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);
  }

  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_