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])
            {
                // Jobs can share this instruction; only mutate their own simulator.
                sim->ApplyX(qubits[qi]);
 
                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; 
};
 
} // namespace Circuits
 
#endif // !_RESET_STATE_H_