tensorcircuit.channels#

Some common noise quantum channels.

class tensorcircuit.channels.KrausList(iterable, name, is_unitary)[source]#

Bases: list

__init__(iterable, name, is_unitary)[source]#

append(object, /)#: Append object to the end of the list.

clear()#: Remove all items from list.

copy()#: Return a shallow copy of the list.

count(value, /)#: Return number of occurrences of value.

extend(iterable, /)#: Extend list by appending elements from the iterable.

index(value, start=0, stop=9223372036854775807, /)#

Return first index of value.

Raises ValueError if the value is not present.

insert(index, object, /)#: Insert object before index.

pop(index=- 1, /)#

Remove and return item at index (default last).

Raises IndexError if list is empty or index is out of range.

remove(value, /)#

Remove first occurrence of value.

Raises ValueError if the value is not present.

reverse()#: Reverse IN PLACE.

sort(*, key=None, reverse=False)#

Sort the list in ascending order and return None.

The sort is in-place (i.e. the list itself is modified) and stable (i.e. the order of two equal elements is maintained).

If a key function is given, apply it once to each list item and sort them, ascending or descending, according to their function values.

The reverse flag can be set to sort in descending order.

tensorcircuit.channels.amplitudedampingchannel(gamma: float, p: float) → Sequence[tensorcircuit.gates.Gate][source]#

Return an amplitude damping channel. Notice: Amplitude damping corrspondings to p = 1.

\[\begin{split}\sqrt{p} \begin{bmatrix} 1 & 0\\ 0 & \sqrt{1-\gamma}\\ \end{bmatrix}\qquad \sqrt{p} \begin{bmatrix} 0 & \sqrt{\gamma}\\ 0 & 0\\ \end{bmatrix}\qquad \sqrt{1-p} \begin{bmatrix} \sqrt{1-\gamma} & 0\\ 0 & 1\\ \end{bmatrix}\qquad \sqrt{1-p} \begin{bmatrix} 0 & 0\\ \sqrt{\gamma} & 0\\ \end{bmatrix}\end{split}\]

Example

>>> cs = amplitudedampingchannel(0.25, 0.3)
>>> tc.channels.single_qubit_kraus_identity_check(cs)

Parameters

gamma (float) – the damping parameter of amplitude ($\gamma$)
p (float) – $p$

Returns

An amplitude damping channel with given $\gamma$ and $p$

Return type

Sequence[Gate]

tensorcircuit.channels.check_rep_transformation(kraus: Sequence[tensorcircuit.gates.Gate], density_matrix: Any, verbose: bool = False)[source]#

Check the convertation between those representations.

Parameters

kraus (Sequence[Gate]) – A sequence of Gate
density_matrix (Matrix) – Initial density matrix
verbose (bool, optional) – Whether print Kraus and new Kraus operators, defaults to False

tensorcircuit.channels.choi_to_kraus(choi: Any, truncation_rules: Optional[Dict[str, Any]] = None) → Any[source]#

Convert the Choi matrix representation to Kraus operator representation.

This can be done by firstly geting eigen-decomposition of Choi-matrix

\[\Lambda = \sum_k \gamma_k \vert \phi_k \rangle \langle \phi_k \vert\]

Then define Kraus operators

\[K_k = \sqrt{\gamma_k} V_k\]

where $\gamma_k\geq0$ and $\phi_k$ is the col-val vectorization of $V_k$ .

Examples

>>> kraus = tc.channels.phasedampingchannel(0.2)
>>> superop = tc.channels.kraus_to_choi(kraus)
>>> kraus_new = tc.channels.choi_to_kraus(superop, truncation_rules={"max_singular_values":3})

Parameters

choi (Matrix) – Choi matrix
truncation_rules (Dictionary) – A dictionary to restrict the calculation of kraus matrices. The restriction can be the number of kraus terms, which is jitable. It can also be the truncattion error, which is not jitable.

Returns

A list of Kraus operators

Return type

Sequence[Matrix]

tensorcircuit.channels.choi_to_super(choi: Any) → Any[source]#

Convert from Choi representation to Superoperator representation.

Parameters: choi (Matrix) – Choi matrix
Returns: Superoperator
Return type: Matrix

tensorcircuit.channels.composedkraus(kraus1: tensorcircuit.channels.KrausList, kraus2: tensorcircuit.channels.KrausList) → tensorcircuit.channels.KrausList[source]#

Compose the noise channels

Parameters

kraus1 (KrausList) – One noise channel
kraus2 (KrausList) – Another noise channel

Returns

Composed nosie channel

Return type

KrausList

tensorcircuit.channels.depolarizingchannel(px: float, py: float, pz: float) → Sequence[tensorcircuit.gates.Gate][source]#

Return a Depolarizing Channel

\[\begin{split}\sqrt{1-p_x-p_y-p_z} \begin{bmatrix} 1 & 0\\ 0 & 1\\ \end{bmatrix}\qquad \sqrt{p_x} \begin{bmatrix} 0 & 1\\ 1 & 0\\ \end{bmatrix}\qquad \sqrt{p_y} \begin{bmatrix} 0 & -1j\\ 1j & 0\\ \end{bmatrix}\qquad \sqrt{p_z} \begin{bmatrix} 1 & 0\\ 0 & -1\\ \end{bmatrix}\end{split}\]

Example

>>> cs = depolarizingchannel(0.1, 0.15, 0.2)
>>> tc.channels.single_qubit_kraus_identity_check(cs)

Parameters

px (float) – $p_x$
py (float) – $p_y$
pz (float) – $p_z$

Returns

Sequences of Gates

Return type

Sequence[Gate]

tensorcircuit.channels.evol_kraus(density_matrix: Any, kraus_list: Sequence[Any]) → Any[source]#

The dynamic evolution according to Kraus operators.

\[\rho' = \sum_{k} K_k \rho K_k^{\dagger}\]

Examples

>>> density_matrix = np.array([[0.5,0.5],[0.5,0.5]])
>>> kraus = tc.channels.phasedampingchannel(0.2)
>>> evol_kraus(density_matrix,kraus)

Parameters

density_matrix (Matrix) – Initial density matrix
kraus_list (Sequence[Matrix]) – A list of Kraus operator

Returns

Final density matrix

Return type

Matrix

tensorcircuit.channels.evol_superop(density_matrix: Any, superop: Any) → Any[source]#

The dynamic evolution according to Superoperator.

Examples

>>> density_matrix = np.array([[0.5,0.5],[0.5,0.5]])
>>> kraus = tc.channels.phasedampingchannel(0.2)
>>> superop = kraus_to_super(kraus)
>>> evol_superop(density_matrix,superop)

Parameters

density_matrix (Matrix) – Initial density matrix
superop (Sequence[Matrix]) – Superoperator

Returns

Final density matrix

Return type

Matrix

tensorcircuit.channels.generaldepolarizingchannel(p: Union[float, Sequence[float]], num_qubits: int = 1) → Sequence[tensorcircuit.gates.Gate][source]#

Return a depolarizing channel. If $p$ is a float number, the one qubit channel is

\[\mathcal{E}(\rho) = (1 - 3p)\rho + p(X\rho X + Y\rho Y + Z\rho Z)\]

Or alternatively

\[\mathcal{E}(\rho) = 4p \frac{I}{2} + (1 - 4p) \rho\]

Note

The definition of p in this method is different from isotropicdepolarizingchannel().

And if $p$ is a sequence, the one qubit channel is

\[\mathcal{E}(\rho) = (1 - \sum_i p_i) \rho + p_1 X\rho X + p_2 Y\rho Y + p_3 \rho Z\]

The logic for two-qubit or more-qubit channel follows similarly.

Example

>>> cs = tc.channels.generaldepolarizingchannel([0.1,0.1,0.1],1)
>>> tc.channels.kraus_identity_check(cs)
>>> cs = tc.channels.generaldepolarizingchannel(0.02,2)
>>> tc.channels.kraus_identity_check(cs)

Parameters

p (Union[float, Sequence]) – parameter for each Pauli channel
num_qubits (int, optional) – number of qubits, defaults 1

Returns

Sequences of Gates

Return type

Sequence[Gate]

tensorcircuit.channels.is_hermitian_matrix(mat: Any, rtol: float = 1e-08, atol: float = 1e-05)[source]#

Test if an array is a Hermitian matrix

Parameters

mat (Matrix) – Matrix
rtol (float, optional) – _description_, defaults to 1e-8
atol (float, optional) – _description_, defaults to 1e-5

Returns

_description_

Return type

_type_

tensorcircuit.channels.isotropicdepolarizingchannel(p: float, num_qubits: int = 1) → Sequence[tensorcircuit.gates.Gate][source]#

Return an isotropic depolarizing channel.

\[\mathcal{E}(\rho) = (1 - p)\rho + p/(4^n-1)\sum_j P_j \rho P_j\]

where $n$ is the number of qubits and $P_j$ are $n$-qubit Pauli strings except $I$. Or alternatively

\[\mathcal{E}(\rho) = \frac{4^n}{4^n-1}p \frac{I}{2} + (1 - \frac{4^n}{4^n-1}p) \rho\]

Note

The definition of p in this method is different from generaldepolarizingchannel().

Example

>>> cs = tc.channels.isotropicdepolarizingchannel(0.30,2)
>>> tc.channels.kraus_identity_check(cs)

Parameters

p (float) – error probability
num_qubits (int, optional) – number of qubits, defaults 1

Returns

Sequences of Gates

Return type

Sequence[Gate]

tensorcircuit.channels.kraus_identity_check(kraus: Sequence[tensorcircuit.gates.Gate]) → None[source]#

Check identity of Kraus operators.

\[\sum_{k}^{} K_k^{\dagger} K_k = I\]

Examples

>>> cs = resetchannel()
>>> tc.channels.kraus_identity_check(cs)

Parameters: kraus (Sequence[Gate]) – List of Kraus operators.

tensorcircuit.channels.kraus_to_choi(kraus_list: Sequence[Any]) → Any[source]#

Convert from Kraus representation to Choi representation.

Parameters: kraus_list (Sequence[Matrix]) – A list Kraus operators
Returns: Choi matrix
Return type: Matrix

tensorcircuit.channels.kraus_to_super(kraus_list: Sequence[Any]) → Any[source]#

Convert Kraus operator representation to Louivile-Superoperator representation.

In the col-vec basis, the evolution of a state $\rho$ in terms of tensor components of superoperator $\varepsilon$ can be expressed as

\[\rho'_{mn} = \sum_{\mu \nu}^{} \varepsilon_{nm,\nu \mu} \rho_{\mu \nu}\]

The superoperator $\varepsilon$ must make the dynamic map from $\rho$ to $\rho'$ to satisfy hermitian-perserving (HP), trace-preserving (TP), and completely positive (CP).

We can construct the superoperator from Kraus operators by

\[\varepsilon = \sum_{k} K_k^{*} \otimes K_k\]

Examples

>>> kraus = resetchannel()
>>> tc.channels.kraus_to_super(kraus)

Parameters: kraus_list (Sequence[Gate]) – A sequence of Gate
Returns: The corresponding Tensor of Superoperator
Return type: Matrix

tensorcircuit.channels.kraus_to_super_gate(kraus_list: Sequence[tensorcircuit.gates.Gate]) → Any[source]#

Convert Kraus operators to one Tensor (as one Super Gate).

\[\sum_{k}^{} K_k \otimes K_k^{*}\]

Parameters: kraus_list (Sequence[Gate]) – A sequence of Gate
Returns: The corresponding Tensor of the list of Kraus operators
Return type: Tensor

tensorcircuit.channels.krausgate_to_krausmatrix(kraus_list: Sequence[tensorcircuit.gates.Gate]) → Sequence[Any][source]#

Convert Kraus of Gate form to Matrix form.

Parameters: kraus_list (Sequence[Gate]) – A list of Kraus
Returns: A list of Kraus operators
Return type: Sequence[Matrix]

tensorcircuit.channels.krausmatrix_to_krausgate(kraus_list: Sequence[Any]) → Sequence[tensorcircuit.gates.Gate][source]#

Convert Kraus of Matrix form to Gate form.

Parameters: kraus_list (Sequence[Matrix]) – A list of Kraus
Returns: A list of Kraus operators
Return type: Sequence[Gate]

tensorcircuit.channels.phasedampingchannel(gamma: float) → Sequence[tensorcircuit.gates.Gate][source]#

Return a phase damping channel with given $\gamma$

\[\begin{split}\begin{bmatrix} 1 & 0\\ 0 & \sqrt{1-\gamma}\\ \end{bmatrix}\qquad \begin{bmatrix} 0 & 0\\ 0 & \sqrt{\gamma}\\ \end{bmatrix}\end{split}\]

Example

>>> cs = phasedampingchannel(0.6)
>>> tc.channels.single_qubit_kraus_identity_check(cs)

Parameters: gamma (float) – The damping parameter of phase ($\gamma$)
Returns: A phase damping channel with given $\gamma$
Return type: Sequence[Gate]

tensorcircuit.channels.resetchannel() → Sequence[tensorcircuit.gates.Gate][source]#

Reset channel

\[\begin{split}\begin{bmatrix} 1 & 0\\ 0 & 0\\ \end{bmatrix}\qquad \begin{bmatrix} 0 & 1\\ 0 & 0\\ \end{bmatrix}\end{split}\]

Example

>>> cs = resetchannel()
>>> tc.channels.single_qubit_kraus_identity_check(cs)

Returns: Reset channel
Return type: Sequence[Gate]

tensorcircuit.channels.reshuffle(op: Any, order: Sequence[int]) → Any[source]#

Reshuffle the dimension index of a matrix.

Parameters

op (Matrix) – Input matrix
order (Tuple) – required order

Returns

Reshuffled matrix

Return type

Matrix

tensorcircuit.channels.single_qubit_kraus_identity_check(kraus: Sequence[tensorcircuit.gates.Gate]) → None#

Check identity of Kraus operators.

\[\sum_{k}^{} K_k^{\dagger} K_k = I\]

Examples

>>> cs = resetchannel()
>>> tc.channels.kraus_identity_check(cs)

Parameters: kraus (Sequence[Gate]) – List of Kraus operators.

tensorcircuit.channels.super_to_choi(superop: Any) → Any[source]#

Convert Louivile-Superoperator representation to Choi representation.

In the col-vec basis, the evolution of a state $\rho$ in terms of Choi matrix $\Lambda$ can be expressed as

\[\rho'_{mn} = \sum_{\mu,\nu}^{} \Lambda_{\mu m,\nu n} \rho_{\mu \nu}\]

The Choi matrix $\Lambda$ must make the dynamic map from $\rho$ to $\rho'$ to satisfy hermitian-perserving (HP), trace-preserving (TP), and completely positive (CP).

Interms of tensor components we have the relationship of Louivile-Superoperator representation and Choi representation

\[\Lambda_{mn,\mu \nu} = \varepsilon_{\nu n,\mu m}\]

Examples

>>> kraus = resetchannel()
>>> superop = tc.channels.kraus_to_super(kraus)
>>> tc.channels.super_to_choi(superop)

Parameters: superop (Matrix) – Superoperator
Returns: Choi matrix
Return type: Matrix

tensorcircuit.channels.super_to_kraus(superop: Any) → Any[source]#

Convert from Superoperator representation to Kraus representation.

Parameters: superop (Matrix) – Superoperator
Returns: A list of Kraus operator
Return type: Matrix

tensorcircuit.channels.thermalrelaxationchannel(t1: float, t2: float, time: float, method: str = 'ByChoi', excitedstatepopulation: float = 0.0) → Sequence[tensorcircuit.gates.Gate][source]#

Return a thermal_relaxation_channel

Example

>>> cs = thermalrelaxationchannel(100,200,100,"AUTO",0.1)
>>> tc.channels.single_qubit_kraus_identity_check(cs)

Parameters

t1 (float) – the T1 relaxation time.
t2 (float) – the T2 dephasing time.
time (str) – gate time
method – method to express error (default: “ByChoi”). When $T1>T2$, choose method “ByKraus” or “ByChoi” for jit. When $T1<T2$,choose method “ByChoi” for jit. Users can also set method as “AUTO” and never mind the relative magnitude of $T1,T2$, which is not jitable.
excitedstatepopulation – the population of state $|1\rangle$ at equilibrium (default: 0)

Returns

A thermal_relaxation_channel

Return type

Sequence[Gate]