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

    bool IsBranching() const override
    {
        if (!operation)
            return false;
 
        return operation->IsBranching();
    }
 
  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_