Operations.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _CIRCUIT_OPERATIONS_H_
#define _CIRCUIT_OPERATIONS_H_
 
#include "../Simulators/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; }

  virtual bool IsClifford() const { return false; }

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

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_