QuantumChannelOperation.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _CIRCUIT_QUANTUM_CHANNEL_OPERATION_H_
#define _CIRCUIT_QUANTUM_CHANNEL_OPERATION_H_
 
#include <stdexcept>
#include <unordered_set>
 
#include "Operations.h"
 
namespace Circuits
{

template <typename Time = Types::time_type> class QuantumChannelOperation : public IOperation<Time>
{
  public:
    QuantumChannelOperation(const Types::qubits_vector &targets, const Simulators::QuantumChannel &channel, Time delay = 0)
        : IOperation<Time>(delay), targets_(targets), channel_(channel)
    {
        if (targets_.size() != channel_.GetNumberOfQubits())
            throw std::invalid_argument("The number of channel targets does not match its Kraus operators");
        if (targets_.empty() || targets_.size() > 2)
            throw std::invalid_argument("Maestro circuit channels support only one or two qubits");
 
        std::unordered_set<Types::qubit_t> uniqueTargets;
        for (const Types::qubit_t target : targets_)
            if (!uniqueTargets.insert(target).second)
                throw std::invalid_argument("Quantum-channel target qubits must be distinct");
    }
 
    void Execute(const std::shared_ptr<Simulators::ISimulator> &simulator, OperationState &state) const override
    {
        (void)state;
        simulator->ApplyQuantumChannel(targets_, channel_);
    }
 
    OperationType GetType() const override
    {
        return OperationType::kQuantumChannel;
    }
 
    Types::qubits_vector AffectedQubits() const override
    {
        return targets_;
    }
 
    bool CanAffectQuantumState() const override
    {
        return true;
    }
 
    bool NeedsEntanglementForDistribution() const override
    {
        return targets_.size() > 1;
    }
 
    const Simulators::QuantumChannel &GetChannel() const
    {
        return channel_;
    }
 
    std::shared_ptr<IOperation<Time>> Clone() const override
    {
        return std::make_shared<QuantumChannelOperation<Time>>(targets_, channel_, IOperation<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
    {
        (void)bitsMap;
        Types::qubits_vector remappedTargets = targets_;
        for (Types::qubit_t &target : remappedTargets)
        {
            const auto mapped = qubitsMap.find(target);
            if (mapped != qubitsMap.end())
                target = mapped->second;
        }
        return std::make_shared<QuantumChannelOperation<Time>>(remappedTargets, channel_, IOperation<Time>::GetDelay());
    }
 
  private:
    Types::qubits_vector targets_;
    Simulators::QuantumChannel channel_;
};
 
} // namespace Circuits
 
#endif // _CIRCUIT_QUANTUM_CHANNEL_OPERATION_H_