Circuit/Factory.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _CIRCUIT_FACTORY_H_
#define _CIRCUIT_FACTORY_H_
 
#include "Circuit.h"
#include "Conditional.h"
#include "Measurements.h"
#include "RandomOp.h"
#include "Reset.h"
 
namespace Circuits {
 
template <typename Time = Types::time_type>
class CircuitFactory {
 public:
  static std::shared_ptr<Circuit<Time>> CreateCircuit(
      const std::vector<std::shared_ptr<IOperation<Time>>> &ops = {}) {
    return std::make_shared<Circuit<Time>>(ops);
  }
 
  static std::shared_ptr<IOperation<Time>> CreateReset(
      const Types::qubits_vector &qubits = {},
      const std::vector<bool> &resetTgts = {}) {
    return std::make_shared<Reset<Time>>(qubits, 0, resetTgts);
  }
 
  static std::shared_ptr<IOperation<Time>> CreateRandom(
      const std::vector<size_t> &bits = {}, size_t seed = 0) {
    return std::make_shared<Random<Time>>(bits, seed);
  }
 
  static const std::shared_ptr<IOperation<Time>> CreateMeasurement(
      const std::vector<std::pair<Types::qubit_t, size_t>> &qs = {}) {
    return std::make_shared<MeasurementOperation<Time>>(qs);
  }
 
  static const std::shared_ptr<IQuantumGate<Time>> CreateGate(
      QuantumGateType type, size_t q1, size_t q2 = 0, size_t q3 = 0,
      double param1 = 0, double param2 = 0, double param3 = 0,
      double param4 = 0) {
    // parameters that do not make sense for a gate are ignored, eg if it's a
    // single qubit gate, q2 and q3 are ignored if it doesn't have a parameter,
    // the parameter is ignored if it has only one, the others are ignored
    // TODO: maybe make specialized variants, as in CreateOneQubitGate,
    // CreateTwoQubitGate, etc
    std::shared_ptr<IQuantumGate<Time>> gate;
 
    switch (type) {
        // one qubit gates
      case QuantumGateType::kPhaseGateType:
        gate = std::make_shared<PhaseGate<Time>>(q1, param1);
        break;
      case QuantumGateType::kXGateType:
        gate = std::make_shared<XGate<Time>>(q1);
        break;
      case QuantumGateType::kYGateType:
        gate = std::make_shared<YGate<Time>>(q1);
        break;
      case QuantumGateType::kZGateType:
        gate = std::make_shared<ZGate<Time>>(q1);
        break;
      case QuantumGateType::kHadamardGateType:
        gate = std::make_shared<HadamardGate<Time>>(q1);
        break;
      case QuantumGateType::kSGateType:
        gate = std::make_shared<SGate<Time>>(q1);
        break;
      case QuantumGateType::kSdgGateType:
        gate = std::make_shared<SdgGate<Time>>(q1);
        break;
      case QuantumGateType::kTGateType:
        gate = std::make_shared<TGate<Time>>(q1);
        break;
      case QuantumGateType::kTdgGateType:
        gate = std::make_shared<TdgGate<Time>>(q1);
        break;
      case QuantumGateType::kSxGateType:
        gate = std::make_shared<SxGate<Time>>(q1);
        break;
      case QuantumGateType::kSxDagGateType:
        gate = std::make_shared<SxDagGate<Time>>(q1);
        break;
      case QuantumGateType::kKGateType:
        gate = std::make_shared<KGate<Time>>(q1);
        break;
      case QuantumGateType::kRxGateType:
        gate = std::make_shared<RxGate<Time>>(q1, param1);
        break;
      case QuantumGateType::kRyGateType:
        gate = std::make_shared<RyGate<Time>>(q1, param1);
        break;
      case QuantumGateType::kRzGateType:
        gate = std::make_shared<RzGate<Time>>(q1, param1);
        break;
      case QuantumGateType::kUGateType:
        gate =
            std::make_shared<UGate<Time>>(q1, param1, param2, param3, param4);
        break;
        // two qubit gates
      case QuantumGateType::kSwapGateType:
        gate = std::make_shared<SwapGate<Time>>(q1, q2);
        break;
      case QuantumGateType::kCXGateType:
        gate = std::make_shared<CXGate<Time>>(q1, q2);
        break;
      case QuantumGateType::kCYGateType:
        gate = std::make_shared<CYGate<Time>>(q1, q2);
        break;
      case QuantumGateType::kCZGateType:
        gate = std::make_shared<CZGate<Time>>(q1, q2);
        break;
      case QuantumGateType::kCPGateType:
        gate = std::make_shared<CPGate<Time>>(q1, q2, param1);
        break;
      case QuantumGateType::kCRxGateType:
        gate = std::make_shared<CRxGate<Time>>(q1, q2, param1);
        break;
      case QuantumGateType::kCRyGateType:
        gate = std::make_shared<CRyGate<Time>>(q1, q2, param1);
        break;
      case QuantumGateType::kCRzGateType:
        gate = std::make_shared<CRzGate<Time>>(q1, q2, param1);
        break;
      case QuantumGateType::kCHGateType:
        gate = std::make_shared<CHGate<Time>>(q1, q2);
        break;
      case QuantumGateType::kCSxGateType:
        gate = std::make_shared<CSxGate<Time>>(q1, q2);
        break;
      case QuantumGateType::kCSxDagGateType:
        gate = std::make_shared<CSxDagGate<Time>>(q1, q2);
        break;
      case QuantumGateType::kCUGateType:
        gate = std::make_shared<CUGate<Time>>(q1, q2, param1, param2, param3,
                                              param4);
        break;
        // three qubit gates
      case QuantumGateType::kCSwapGateType:
        gate = std::make_shared<CSwapGate<Time>>(q1, q2, q3);
        break;
      case QuantumGateType::kCCXGateType:
        gate = std::make_shared<CCXGate<Time>>(q1, q2, q3);
        break;
      default:
        break;
    }
 
    return gate;
  }
 
  static const std::shared_ptr<IOperation<Time>> CreateGateWithVectors(
      QuantumGateType type, const Types::qubits_vector &qubits,
      const std::vector<double> &params = {}) {
    return CreateGate(type, qubits.empty() ? 0 : qubits[0],
                      (qubits.size() < 2) ? 0 : qubits[1],
                      (qubits.size() < 3) ? 0 : qubits[2],
                      params.empty() ? 0. : params[0],
                      (params.size() < 2) ? 0. : params[1],
                      (params.size() < 3) ? 0. : params[2],
                      (params.size() < 4) ? 0. : params[3]);
  }
 
  // maybe this could be refined, have a CreateCondition with the condition
  // type, but for now we only have equality can be done later
 
  static std::shared_ptr<ICondition> CreateEqualCondition(
      const std::vector<size_t> &ind, const std::vector<bool> &b) {
    return std::make_shared<EqualCondition>(ind, b);
  }
 
  // we have only three conditional things, I don't think we need a single
  // factory method for them (with a 'type' parameter)
 
  static std::shared_ptr<IOperation<Time>> CreateConditionalGate(
      const std::shared_ptr<IGateOperation<Time>> &operation,
      const std::shared_ptr<ICondition> &condition) {
    return std::make_shared<ConditionalGate<Time>>(operation, condition);
  }
 
  static std::shared_ptr<IOperation<Time>> CreateSimpleConditionalGate(
      const std::shared_ptr<IGateOperation<Time>> &operation,
      const size_t cbit) {
    const auto eqcond = CreateEqualCondition({cbit}, {true});
    return std::make_shared<ConditionalGate<Time>>(operation, eqcond);
  }
 
  static std::shared_ptr<IOperation<Time>> CreateConditionalMeasurement(
      const std::shared_ptr<MeasurementOperation<Time>> &measurement,
      const std::shared_ptr<ICondition> &condition) {
    return std::make_shared<ConditionalMeasurement<Time>>(measurement,
                                                          condition);
  }
 
  static std::shared_ptr<IOperation<Time>> CreateConditionalRandomGen(
      const std::shared_ptr<Random<Time>> &randomGen,
      const std::shared_ptr<ICondition> &condition) {
    return std::make_shared<ConditionalRandomGen<Time>>(randomGen, condition);
  }
 
  static std::shared_ptr<IOperation<Time>> CreateNoOp() {
    return std::make_shared<NoOperation<Time>>();
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateBellStateCircuit(
      size_t qbit1, size_t qbit2, bool qbit1X = false, bool qbit2X = false) {
    size_t s = 2;
    if (qbit1X) ++s;
    if (qbit2X) ++s;
 
    std::vector<std::shared_ptr<IOperation<Time>>> ops(s);
 
    s = 0;
    if (qbit1X) ops[s++] = CreateGate(QuantumGateType::kXGateType, qbit1);
    if (qbit2X) ops[s++] = CreateGate(QuantumGateType::kXGateType, qbit2);
    ops[s++] = CreateGate(QuantumGateType::kHadamardGateType, qbit1);
    ops[s] = CreateGate(QuantumGateType::kCXGateType, qbit1, qbit2);
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>>
  CreateBellStateDecoderCircuit(size_t qbit1, size_t qbit2) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(2);
 
    ops[0] = CreateGate(QuantumGateType::kCXGateType, qbit1, qbit2);
    ops[1] = CreateGate(QuantumGateType::kHadamardGateType, qbit1);
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateGZHStateCircuit(
      size_t qbit1, size_t qbit2, size_t qbit3) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(3);
 
    ops[0] = CreateGate(QuantumGateType::kHadamardGateType, qbit1);
    ops[1] = CreateGate(QuantumGateType::kCXGateType, qbit1, qbit2);
    ops[2] = CreateGate(QuantumGateType::kCXGateType, qbit2, qbit3);
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>>
  CreateTeleportationCircuit(size_t entqbit1, size_t entqbit2, size_t srcqbit,
                             size_t cbit1, size_t cbit2) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(8);
 
    // EPR pair
    ops[0] = CreateGate(QuantumGateType::kHadamardGateType, entqbit1);
    ops[1] = CreateGate(QuantumGateType::kCXGateType, entqbit1, entqbit2);
 
    // teleportation follows, using the entangled qubits
    ops[2] = CreateGate(QuantumGateType::kCXGateType, srcqbit, entqbit1);
    ops[3] = CreateGate(QuantumGateType::kHadamardGateType, srcqbit);
 
    // measurements
    ops[4] = CreateMeasurement({{srcqbit, cbit1}});
    ops[5] = CreateMeasurement({{entqbit1, cbit2}});
 
    // apply the conditional gates based on the measurements
    const auto xgate = CreateGate(QuantumGateType::kXGateType, entqbit2);
    const auto zgate = CreateGate(QuantumGateType::kZGateType, entqbit2);
 
    ops[6] = CreateSimpleConditionalGate(xgate, cbit2);
    ops[7] = CreateSimpleConditionalGate(zgate, cbit1);
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>>
  CreateStartDistributionCircuit(size_t ctrlQubit, size_t ctrlEntangledQubit,
                                 size_t tgtEntangledQubit,
                                 size_t ctrlEntangledMeasureBit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(5);
    // 1. Entangle qubits for the two hosts
    // auto ops = CreateBellStateCircuit(ctrlEntangledQubit, tgtEntangledQubit);
    ops[0] = CreateGate(QuantumGateType::kHadamardGateType, ctrlEntangledQubit);
    ops[1] = CreateGate(QuantumGateType::kCXGateType, ctrlEntangledQubit,
                        tgtEntangledQubit);
 
    // 2. Now apply cnot from ctrl to entangled qubit on ctrl host
    // ops.emplace_back(std::make_shared<Circuits::CXGate<Time>>(ctrlQubit,
    // ctrlEntangledQubit));
    ops[2] =
        CreateGate(QuantumGateType::kCXGateType, ctrlQubit, ctrlEntangledQubit);
    // 3. Measure the entangled qubit on ctrl host (then the measurement result
    // is sent to the other host)
    const std::vector<std::pair<Types::qubit_t, size_t>> measureOps{
        {ctrlEntangledQubit, ctrlEntangledMeasureBit}};
    // ops.emplace_back(std::make_shared<Circuits::MeasurementOperation<Time>>(measureOps));
    ops[3] = CreateMeasurement(measureOps);
 
    // 4. Send the measurement result to the target host, use the result to
    // apply not on the target entangled qubit
    // ops.emplace_back(std::make_shared<Circuits::ConditionalGate<Time>>(std::make_shared<Circuits::XGate<Time>>(tgtEntangledQubit),
    //  std::make_shared<Circuits::EqualCondition>(std::vector<size_t>{
    // ctrlEntangledMeasureBit }, std::vector<bool>{true})));
    ops[4] = std::make_shared<Circuits::ConditionalGate<Time>>(
        std::make_shared<Circuits::XGate<Time>>(tgtEntangledQubit),
        std::make_shared<Circuits::EqualCondition>(
            std::vector<size_t>{ctrlEntangledMeasureBit},
            std::vector<bool>{true}));
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>>
  CreateEndDistributionCircuit(size_t ctrlQubit, size_t tgtEntangledQubit,
                               size_t tgtEntangledMeasureBit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(3);
 
    ops[0] = std::make_shared<Circuits::HadamardGate<Time>>(tgtEntangledQubit);
    const std::vector<std::pair<Types::qubit_t, size_t>> measureOps{
        {tgtEntangledQubit, tgtEntangledMeasureBit}};
    ops[1] = std::make_shared<Circuits::MeasurementOperation<Time>>(measureOps);
    ops[2] = std::make_shared<Circuits::ConditionalGate<Time>>(
        std::make_shared<Circuits::ZGate<Time>>(ctrlQubit),
        std::make_shared<Circuits::EqualCondition>(
            std::vector<size_t>{tgtEntangledMeasureBit},
            std::vector<bool>{true}));
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateMeasureX(
      size_t qubit, size_t cbit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(2);
    ops[0] = CreateGate(QuantumGateType::kHadamardGateType, qubit);
    ops[1] = CreateMeasurement({{qubit, cbit}});
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateMeasureY(
      size_t qubit, size_t cbit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(3);
    ops[0] = CreateGate(QuantumGateType::kSdgGateType, qubit);
    ops[1] = CreateGate(QuantumGateType::kHadamardGateType, qubit);
    ops[2] = CreateMeasurement({{qubit, cbit}});
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateMeasureZ(
      size_t qubit, size_t cbit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(1);
    ops[0] = CreateMeasurement({{qubit, cbit}});
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateInitZero(
      size_t qubit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(1);
    ops[0] = CreateReset({qubit});
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateInitOne(
      size_t qubit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(2);
    ops[0] = CreateReset({qubit});
    ops[1] = CreateGate(QuantumGateType::kXGateType, qubit);
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateInitPlus(
      size_t qubit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(2);
    ops[0] = CreateReset({qubit});
    ops[1] = CreateGate(QuantumGateType::kHadamardGateType, qubit);
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateInitMinus(
      size_t qubit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(3);
    ops[0] = CreateReset({qubit});
    ops[1] = CreateGate(QuantumGateType::kXGateType, qubit);
    ops[2] = CreateGate(QuantumGateType::kHadamardGateType, qubit);
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateInitPlusI(
      size_t qubit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(3);
    ops[0] = CreateReset({qubit});
    ops[1] = CreateGate(QuantumGateType::kHadamardGateType, qubit);
    ops[2] = CreateGate(QuantumGateType::kSGateType, qubit);
 
    return ops;
  }
 
  static std::vector<std::shared_ptr<IOperation<Time>>> CreateInitMinusI(
      size_t qubit) {
    std::vector<std::shared_ptr<IOperation<Time>>> ops(3);
    ops[0] = CreateReset({qubit});
    ops[1] = CreateGate(QuantumGateType::kHadamardGateType, qubit);
    ops[2] = CreateGate(QuantumGateType::kSdgGateType, qubit);
 
    return ops;
  }
};
}  // namespace Circuits
 
#endif  // !_CIRCUIT_FACTORY_H_