Parametric quantum channels¶

Definition¶

In addition to QuantumChannelKraus, the qat.quops module contains parametric quantum channels, i.e channels which depend on a parameter $t$. In other words, its Kraus operators are of the form $E_k(t)$.

Predefined parametric quantum channels¶

At the moment, there are two predefined parametric quantum channels : ParametricPureDephasing and ParametricAmplitudeDamping, which correspond to the well-known pure-dephasing and amplitude-damping channels (see e.g Nielsen & Chuang).

In [1]:
import numpy as np
from qat.quops import ParametricAmplitudeDamping, ParametricPureDephasing, QuantumChannelKraus

Such objects are instantiated in the following way:

In [2]:
# Amplitude damping channel with exponential decay (Lindblad approximation, characteristic decay time T_1)
AD_parametric = ParametricAmplitudeDamping(T_1=1.0)

# Pure dephasing channel with exponential decay (Lindblad approximation, characteristic decay time T_phi)
PD_parametric = ParametricPureDephasing(T_phi=1.0)

# Pure dephasing channel with 1/f spectral function
PD_1_over_f = ParametricPureDephasing(spectral_function={"type": "1/f", 
                                                           "intensity": 3e-10,
                                                           "w_c" : 1e-1, 
                                                           "w_ir": 1e-9})

# Pure dephasing channel with ohmic spectral function
PD_ohmic = ParametricPureDephasing(spectral_function={"type": "Ohmic", 
                                                           "intensity": 3e-10,
                                                           "w_c" : 1e-1,
                                                           "w_ir" : 0})

Calling the object with a given parameter (the time during which the channel is applied) returns a QuantumChannelKraus object:

In [3]:
print("type = ",type(AD_parametric(0.5)))
print("type = ",type(PD_parametric(0.5)))
print("type = ",type(PD_1_over_f(0.5)))
print("type = ",type(PD_ohmic(0.5)))

type =  <class 'qat.quops.quantum_channels.QuantumChannelKraus'>
type =  <class 'qat.quops.quantum_channels.QuantumChannelKraus'>
type =  <class 'qat.quops.quantum_channels.QuantumChannelKraus'>
type =  <class 'qat.quops.quantum_channels.QuantumChannelKraus'>

To get the value of the Kraus operators, one can write e.g:

In [4]:
print("Kraus operators = ", AD_parametric(0.5).kraus_operators)

Kraus operators =  [array([[1.        +0.j, 0.        +0.j],
       [0.        +0.j, 0.77880078+0.j]]), array([[0.        +0.j, 0.62727135+0.j],
       [0.        +0.j, 0.        +0.j]])]

Creating one's own parametric quantum channel¶

Creating one's own parametric quantum channel is straightforward, as illustrated in the example below:

In [5]:
class MyCustomParametricQuantumChannel:
    def __init__(self, T_custom):
        self.T_custom = T_custom
    def __call__(self, t):
        p = 1 - np.exp(-t/self.T_custom)
        return QuantumChannelKraus([np.sqrt(p)*np.identity(2), np.sqrt(1-p)*np.array([[0, -1j],[1j, 0]], np.complex_)])
    
custom_chan = MyCustomParametricQuantumChannel(T_custom=2)
print(custom_chan(0.5))

:
[[0.47031821 0.        ]
 [0.         0.47031821]]
[[0.+0.j        0.-0.8824969j]
 [0.+0.8824969j 0.+0.j       ]]
In [ ]: