Operations.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _CIRCUIT_OPERATIONS_H_
#define _CIRCUIT_OPERATIONS_H_
 
#include "../../Simulators/Interfaces/Simulator.h"
#include "../../Types.h"
 
namespace Circuits
{
enum class OperationType
{
    kGate,                   
    kMeasurement,            
    kRandomGen,              
    kConditionalGate,        
    kConditionalMeasurement, 
    kConditionalRandomGen,   
    kReset,                  
    kNoOp,                   
    kComposite,              
    kQuantumChannel,         
    kDelay                   
};
 
// simulators keep track of the quantum state, but there are things that are not
// part of it that need keeping around (for example, the result of a
// measurement, or if it's a 'random generation' operation, the generated
// number), so here it is the values in there are needed either for the end
// result or for the next operation (conditional gate, conditional measurement)

class OperationState
{
  public:
    OperationState(size_t numBits = 0)
    {
        AllocateBits(numBits);
    }

    OperationState(const OperationState &other) : bits(other.bits)
    {
    }

    OperationState(OperationState &&other) noexcept : bits(std::move(other.bits))
    {
    }

    OperationState(const std::vector<bool> &b) : bits(b)
    {
    }

    OperationState(std::vector<bool> &&b) : bits(std::move(b))
    {
    }

    OperationState &operator=(const OperationState &other)
    {
        bits = other.bits;
        return *this;
    }

    OperationState &operator=(OperationState &&other) noexcept
    {
        bits.swap(other.bits);
        return *this;
    }

    OperationState &operator=(const std::vector<bool> &b)
    {
        bits = b;
        return *this;
    }

    OperationState &operator=(std::vector<bool> &&b)
    {
        bits.swap(b);
        return *this;
    }

    void AllocateBits(size_t numBits)
    {
        bits.resize(bits.size() + numBits, false);
    }

    void Clear()
    {
        bits.clear();
    }

    size_t GetNumBits() const
    {
        return bits.size();
    }

    bool GetBit(size_t index) const
    {
        if (index > bits.size())
            return false;
 
        return bits[index];
    }

    std::vector<bool> GetBits(const std::vector<size_t> &indices) const
    {
        std::vector<bool> results(indices.size(), false);
 
        for (size_t i = 0; i < indices.size(); ++i)
            if (indices[i] < bits.size())
                results[i] = bits[indices[i]];
 
        return results;
    }

    const std::vector<bool> &GetAllBits() const
    {
        return bits;
    }

    std::vector<bool> GetAllBitsCopy() const
    {
        return bits;
    }

    void SetBit(size_t index, bool value = true)
    {
        if (index > bits.size())
            return;
 
        bits[index] = value;
    }

    void Reset(bool value = false)
    {
        std::fill(bits.begin(), bits.end(), value);
    }

    void SetResultsInOrder(const std::vector<bool> &results)
    {
        const size_t theSize = std::max(bits.size(), results.size());
 
        bits = results;
        bits.resize(theSize, false);
    }

    void SetResults(const std::vector<size_t> &indices, size_t results)
    {
        for (int i = 0; i < static_cast<int>(indices.size()); ++i)
        {
            if (indices[i] < bits.size())
                bits[indices[i]] = results & 1;
            results >>= 1;
        }
    }

    void Swap(OperationState &results)
    {
        bits.swap(results.bits);
    }

    void Remap(const std::unordered_map<Types::qubit_t, Types::qubit_t> &mapping, bool ignoreNotMapped = false, size_t newSize = 0)
    {
        std::vector<bool> newBits(newSize > 0 ? newSize : (ignoreNotMapped ? mapping.size() : bits.size()), false);
 
        for (size_t i = 0; i < bits.size(); ++i)
        {
            const auto it = mapping.find(i);
            if (it != mapping.end())
                newBits[it->second] = bits[i];
            else if (!ignoreNotMapped && i < newBits.size())
                newBits[i] = bits[i];
        }
 
        bits.swap(newBits);
    }

    void RemapWithVector(const std::vector<Types::qubit_t> &mapping, bool ignoreNotMapped = false, size_t newSize = 0)
    {
        std::vector<bool> newBits(newSize > 0 ? newSize : (ignoreNotMapped ? mapping.size() : bits.size()), false);
 
        for (size_t i = 0; i < bits.size(); ++i)
        {
            if (i < mapping.size())
                newBits[mapping.at(i)] = bits[i];
            else if (!ignoreNotMapped && i < newBits.size())
                newBits[i] = bits[i];
        }
 
        bits.swap(newBits);
    }
 
  private:
    std::vector<bool> bits; 
};

template <typename Time = Types::time_type> class IOperation : public std::enable_shared_from_this<IOperation<Time>>
{
  public:
    IOperation(Time delay = 0) : delay(delay){};

    virtual ~IOperation() = default;

    virtual void Execute(const std::shared_ptr<Simulators::ISimulator> &sim, OperationState &state) const = 0;

    virtual OperationType GetType() const
    {
        return OperationType::kNoOp;
    }

    virtual std::shared_ptr<IOperation<Time>> Clone() const = 0;

    virtual 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 = 0;

    virtual bool CanAffectQuantumState() const
    {
        return GetType() == OperationType::kGate || GetType() == OperationType::kQuantumChannel || GetType() == OperationType::kMeasurement ||
               GetType() == OperationType::kConditionalGate || GetType() == OperationType::kConditionalMeasurement || GetType() == OperationType::kReset ||
               GetType() == OperationType::kComposite;
    }

    virtual bool NeedsEntanglementForDistribution() const
    {
        return (GetType() == OperationType::kGate || GetType() == OperationType::kConditionalGate || GetType() == OperationType::kQuantumChannel) &&
               AffectedQubits().size() > 1;
    }

    virtual bool IsConditional() const
    {
        return GetType() == OperationType::kConditionalGate || GetType() == OperationType::kConditionalMeasurement ||
               GetType() == OperationType::kConditionalRandomGen;
    }

    virtual Types::qubits_vector AffectedQubits() const
    {
        return {};
    }

    virtual std::vector<size_t> AffectedBits() const
    {
        return {};
    }

    std::shared_ptr<IOperation<Time>> getptr()
    {
        return std::enable_shared_from_this<IOperation<Time>>::shared_from_this();
    }

    Time GetDelay() const
    {
        return delay;
    }

    virtual void SetDelay(Time d)
    {
        delay = d;
    }

    void SetNoiseless(bool value = true)
    {
        noiseless = value;
    }

    bool IsNoiseless() const
    {
        return noiseless;
    }

    virtual bool IsClifford() const
    {
        return false;
    }

    virtual bool IsBranching() const
    {
        return false;
    }
 
  private:
    Time delay;             
    bool noiseless = false; 
};

template <typename Time = Types::time_type> class NoOperation : public IOperation<Time>
{
  public:
    NoOperation(Time delay = 0) : IOperation<Time>(delay){};

    void Execute(const std::shared_ptr<Simulators::ISimulator> &sim, OperationState &state) const override
    {
    }

    std::shared_ptr<IOperation<Time>> Clone() const override
    {
        return std::make_shared<NoOperation<Time>>(NoOperation<Time>::GetDelay());
    }

    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
    {
        return this->Clone();
    }

    bool IsClifford() const override
    {
        return true;
    }
};

template <typename Time = Types::time_type> class IGateOperation : public IOperation<Time>
{
  public:
    IGateOperation(Time delay = 0) : IOperation<Time>(delay){};

    OperationType GetType() const override
    {
        return OperationType::kGate;
    }

    virtual unsigned int GetNumQubits() const = 0;

    virtual void SetQubit(Types::qubit_t qubit, unsigned long index = 0) = 0;

    virtual Types::qubit_t GetQubit(unsigned int index = 0) const = 0;
};
 
} // namespace Circuits
 
#endif // !_CIRCUIT_OPERATIONS_H_