Reset.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _RESET_STATE_H_
#define _RESET_STATE_H_
 
#include "QuantumGates.h"
 
namespace Circuits {

template <typename Time = Types::time_type>
class Reset : public IOperation<Time> {
 public:
  Reset(const Types::qubits_vector &qubits = {}, Time delay = 0,
        const std::vector<bool> &resetTargets = {})
      : IOperation<Time>(delay), qubits(qubits), resetTargets(resetTargets) {}

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    // Use the simulator's native ApplyReset which correctly handles
    // per-backend measurement+flip (critical for MPS re-canonicalization).
    sim->ApplyReset(qubits);
 
    // If any reset targets specify |1⟩ instead of the default |0⟩,
    // apply X to flip those qubits.
    for (size_t qi = 0; qi < resetTargets.size() && qi < qubits.size(); ++qi) {
      if (resetTargets[qi]) {
        xgate.SetQubit(qubits[qi]);
        xgate.Execute(sim, state);
 
        if (sim->SupportsMPSSwapOptimization()) {
          const auto counter = sim->GetGatesCounter();
          if (counter > 0)
            sim->SetGatesCounter(counter - 1);
        }
      }
    }
  }

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

  void SetQubits(const Types::qubits_vector &qs,
                 const std::vector<bool> &resetTgts = {}) {
    qubits = qs;
    resetTargets = resetTgts;
  }

  const Types::qubits_vector &GetQubits() const { return qubits; }

  const std::vector<bool> &GetResetTargets() const { return resetTargets; }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<Reset<Time>>(
        GetQubits(), IOperation<Time>::GetDelay(), GetResetTargets());
  }

  Types::qubits_vector AffectedQubits() const override { return qubits; }

  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 {
    auto newOp = this->Clone();
 
    for (size_t i = 0; i < qubits.size(); ++i) {
      const auto qubitit = qubitsMap.find(qubits[i]);
      if (qubitit != qubitsMap.end())
        std::static_pointer_cast<Reset<Time>>(newOp)->SetQubit(i,
                                                               qubitit->second);
    }
 
    return newOp;
  }

  bool IsClifford() const override { return true; }
 
 protected:
  void SetQubit(size_t index, Types::qubit_t qubit) {
    if (index < qubits.size()) qubits[index] = qubit;
  }
 
 private:
  Types::qubits_vector qubits;    
  std::vector<bool> resetTargets; 
  mutable XGate<Time> xgate;      
};
 
}  // namespace Circuits
 
#endif  // !_RESET_STATE_H_