Conditional.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _CONDITIONAL_H_
#define _CONDITIONAL_H_
 
#include "Measurements.h"
#include "QuantumGates.h"
#include "RandomOp.h"
 
namespace Circuits {
 
class ICondition : public std::enable_shared_from_this<ICondition> {
 public:
  ICondition(const std::vector<size_t> &ind) : indices(ind) {}
 
  virtual ~ICondition() = default;
 
  virtual bool IsConditionMet(OperationState &state) const = 0;
 
  const std::vector<size_t> &GetBitsIndices() const { return indices; }
 
  void SetBitsIndices(const std::vector<size_t> &ind) { indices = ind; }
 
  virtual std::shared_ptr<ICondition> Clone() const = 0;
 
  virtual std::shared_ptr<ICondition> Remap(
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &bitsMap = {})
      const = 0;
 
  std::shared_ptr<ICondition> getptr() {
    return std::enable_shared_from_this<ICondition>::shared_from_this();
  }
 
 private:
  std::vector<size_t>
      indices; 
};
 
class EqualCondition : public ICondition {
 public:
  EqualCondition(const std::vector<size_t> &ind, const std::vector<bool> &b)
      : ICondition(ind), bits(b) {}
 
  bool IsConditionMet(OperationState &state) const override {
    return state.GetBits(GetBitsIndices()) == GetAllBits();
  }
 
  const std::vector<bool> &GetAllBits() const { return bits; }
 
  void SetBits(const std::vector<bool> &b) { bits = b; }
 
  std::shared_ptr<ICondition> Clone() const override {
    return std::make_shared<EqualCondition>(GetBitsIndices(), GetAllBits());
  }
 
  std::shared_ptr<ICondition> Remap(
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &bitsMap = {})
      const override {
    auto newCond = this->Clone();
 
    auto newBits = newCond->GetBitsIndices();
    for (size_t i = 0; i < newBits.size(); ++i) {
      const auto bitit = bitsMap.find(newBits[i]);
      if (bitit != bitsMap.end()) newBits[i] = bitit->second;
      // else throw std::invalid_argument("Conditional operation: bit not found
      // in the map, couldn't remap.");
    }
    newCond->SetBitsIndices(newBits);
 
    return newCond;
  }
 
 private:
  std::vector<bool> bits; 
};
 
template <typename Time = Types::time_type>
class IConditionalOperation : public IOperation<Time> {
 public:
  IConditionalOperation(const std::shared_ptr<IOperation<Time>> &operation,
                        const std::shared_ptr<ICondition> &condition,
                        Time delay = 0)
      : IOperation<Time>(delay), operation(operation), condition(condition) {}
 
  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    if (!condition || !operation) return;
 
    if (condition->IsConditionMet(state))
      operation->Execute(sim, state);
    else if (sim)
      sim->IncrementGatesCounter();
  }
 
  void SetOperation(const std::shared_ptr<IOperation<Time>> &op) {
    if (!op) return;
    // the reason why 'recursive' conditional gates are not allowed (as in
    // conditional-conditional-...-gate) is because of the distribution for the
    // network execution would work fine as long as it's 'local'
    else if ((op->GetType() == OperationType::kGate &&
              this->GetType() != OperationType::kConditionalGate) ||
             (op->GetType() == OperationType::kMeasurement &&
              this->GetType() != OperationType::kConditionalMeasurement) ||
             (op->GetType() == OperationType::kRandomGen &&
              this->GetType() != OperationType::kConditionalRandomGen))
      return;
 
    operation = op;
  }
 
  std::shared_ptr<IOperation<Time>> GetOperation() const { return operation; }
 
  void SetCondition(const std::shared_ptr<ICondition> &cond) {
    condition = cond;
  }
 
  std::shared_ptr<ICondition> GetCondition() const { return condition; }
 
  std::vector<size_t> AffectedBits() const override {
    if (!condition) return {};
 
    return condition->GetBitsIndices();
  }
 
  Types::qubits_vector AffectedQubits() const override {
    if (!operation) return {};
 
    return operation->AffectedQubits();
  }
 
  std::shared_ptr<IOperation<Time>> Remap(
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &qubitsMap,
      const std::unordered_map<Types::qubit_t, Types::qubit_t> &bitsMap = {})
      const override {
    const auto condOp =
        std::static_pointer_cast<IConditionalOperation<Time>>(this->Clone());
 
    condOp->SetCondition(condOp->GetCondition()->Remap(bitsMap));
    condOp->SetOperation(condOp->GetOperation()->Remap(qubitsMap, bitsMap));
 
    return condOp;
  }
 
  bool IsClifford() const override {
    if (!operation) return true;
 
    return operation->IsClifford();
  }
 
 private:
  std::shared_ptr<IOperation<Time>>
      operation; 
  std::shared_ptr<ICondition> condition; 
};
 
template <typename Time = Types::time_type>
class ConditionalGate : public IConditionalOperation<Time> {
 public:
  ConditionalGate(const std::shared_ptr<IGateOperation<Time>> &operation,
                  const std::shared_ptr<ICondition> &condition, Time delay = 0)
      : IConditionalOperation<Time>(operation, condition, delay) {}
 
  OperationType GetType() const override {
    return OperationType::kConditionalGate;
  }
 
  std::shared_ptr<IOperation<Time>> Clone() const override {
    const auto gate = std::static_pointer_cast<IGateOperation<Time>>(
        IConditionalOperation<Time>::GetOperation()->Clone());
    const auto cond = std::static_pointer_cast<ICondition>(
        IConditionalOperation<Time>::GetCondition()->Clone());
 
    return std::make_shared<ConditionalGate<Time>>(
        gate, cond, IOperation<Time>::GetDelay());
  }
};
 
template <typename Time = Types::time_type>
class ConditionalMeasurement : public IConditionalOperation<Time> {
 public:
  ConditionalMeasurement(
      const std::shared_ptr<MeasurementOperation<Time>> &operation,
      const std::shared_ptr<ICondition> &condition, Time delay = 0)
      : IConditionalOperation<Time>(operation, condition, delay) {}
 
  OperationType GetType() const override {
    return OperationType::kConditionalMeasurement;
  }
 
  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<ConditionalMeasurement<Time>>(
        std::static_pointer_cast<MeasurementOperation<Time>>(
            IConditionalOperation<Time>::GetOperation()->Clone()),
        std::static_pointer_cast<ICondition>(
            IConditionalOperation<Time>::GetCondition()->Clone()),
        IOperation<Time>::GetDelay());
  }
};
 
template <typename Time = Types::time_type>
class ConditionalRandomGen : public IConditionalOperation<Time> {
 public:
  ConditionalRandomGen(const std::shared_ptr<Random<Time>> &operation,
                       const std::shared_ptr<ICondition> &condition,
                       Time delay = 0)
      : IConditionalOperation<Time>(operation, condition, delay) {}
 
  OperationType GetType() const override {
    return OperationType::kConditionalRandomGen;
  }
 
  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<ConditionalRandomGen<Time>>(
        std::static_pointer_cast<Random<Time>>(
            IConditionalOperation<Time>::GetOperation()->Clone()),
        std::static_pointer_cast<ICondition>(
            IConditionalOperation<Time>::GetCondition()->Clone()),
        IOperation<Time>::GetDelay());
  }
 
  Types::qubits_vector AffectedQubits() const override { return {}; }
};
 
}  // namespace Circuits
 
#endif  // !_CONDITIONAL_H_