Skip to main contentIBM Quantum Documentation

Quantum Information

qiskit.quantum_info


Operators

Operator(data[, input_dims, output_dims])Matrix operator class
Pauli([data])N-qubit Pauli operator.
Clifford(data[, validate, copy])An N-qubit unitary operator from the Clifford group.
ScalarOp([dims, coeff])Scalar identity operator class.
SparsePauliOp(data[, coeffs, ...])Sparse N-qubit operator in a Pauli basis representation.
CNOTDihedral([data, num_qubits, validate])An N-qubit operator from the CNOT-Dihedral group.
PauliList(data)List of N-qubit Pauli operators.
pauli_basis(num_qubits[, weight])Return the ordered PauliList for the n-qubit Pauli basis.

States

Statevector(data[, dims])Statevector class
DensityMatrix(data[, dims])DensityMatrix class
StabilizerState(data[, validate])StabilizerState class.

Channels

Choi(data[, input_dims, output_dims])Choi-matrix representation of a Quantum Channel.
SuperOp(data[, input_dims, output_dims])Superoperator representation of a quantum channel.
Kraus(data[, input_dims, output_dims])Kraus representation of a quantum channel.
Stinespring(data[, input_dims, output_dims])Stinespring representation of a quantum channel.
Chi(data[, input_dims, output_dims])Pauli basis Chi-matrix representation of a quantum channel.
PTM(data[, input_dims, output_dims])Pauli Transfer Matrix (PTM) representation of a Quantum Channel.

Measures

average_gate_fidelity

qiskit.quantum_info.average_gate_fidelity(channel, target=None, require_cp=True, require_tp=False)GitHub(opens in a new tab)

Return the average gate fidelity of a noisy quantum channel.

The average gate fidelity FaveF_{\text{ave}} is given by

Fave(E,U)=dψψUE(ψ ⁣ψ)Uψ=dFpro(E,U)+1d+1\begin{aligned} F_{\text{ave}}(\mathcal{E}, U) &= \int d\psi \langle\psi|U^\dagger \mathcal{E}(|\psi\rangle\!\langle\psi|)U|\psi\rangle \\ &= \frac{d F_{\text{pro}}(\mathcal{E}, U) + 1}{d + 1} \end{aligned}

where Fpro(E,U)F_{\text{pro}}(\mathcal{E}, U) is the process_fidelity() of the input quantum channel E\mathcal{E} with a target unitary UU, and dd is the dimension of the channel.

Parameters

  • channel (QuantumChannel or Operator) – noisy quantum channel.
  • target (Operator or None) – target unitary operator. If None target is the identity operator [Default: None].
  • require_cp (bool(opens in a new tab)) – check if input and target channels are completely-positive and if non-CP log warning containing negative eigenvalues of Choi-matrix [Default: True].
  • require_tp (bool(opens in a new tab)) – check if input and target channels are trace-preserving and if non-TP log warning containing negative eigenvalues of partial Choi-matrix Trout[E]ITr_{\text{out}}[\mathcal{E}] - I [Default: True].

Returns

The average gate fidelity FaveF_{\text{ave}}.

Return type

float(opens in a new tab)

Raises

QiskitError – if the channel and target do not have the same dimensions, or have different input and output dimensions.

process_fidelity

qiskit.quantum_info.process_fidelity(channel, target=None, require_cp=True, require_tp=True)GitHub(opens in a new tab)

Return the process fidelity of a noisy quantum channel.

The process fidelity Fpro(E,F)F_{\text{pro}}(\mathcal{E}, \mathcal{F}) between two quantum channels E,F\mathcal{E}, \mathcal{F} is given by

Fpro(E,F)=F(ρE,ρF)F_{\text{pro}}(\mathcal{E}, \mathcal{F}) = F(\rho_{\mathcal{E}}, \rho_{\mathcal{F}})

where FF is the state_fidelity(), ρE=ΛE/d\rho_{\mathcal{E}} = \Lambda_{\mathcal{E}} / d is the normalized Choi matrix for the channel E\mathcal{E}, and dd is the input dimension of E\mathcal{E}.

When the target channel is unitary this is equivalent to

Fpro(E,U)=Tr[SUSE]d2F_{\text{pro}}(\mathcal{E}, U) = \frac{Tr[S_U^\dagger S_{\mathcal{E}}]}{d^2}

where SE,SUS_{\mathcal{E}}, S_{U} are the SuperOp matrices for the input quantum channel E\mathcal{E} and target unitary UU respectively, and dd is the input dimension of the channel.

Parameters

  • channel (Operator or QuantumChannel) – input quantum channel.
  • target (Operator or QuantumChannel or None) – target quantum channel. If None target is the identity operator [Default: None].
  • require_cp (bool(opens in a new tab)) – check if input and target channels are completely-positive and if non-CP log warning containing negative eigenvalues of Choi-matrix [Default: True].
  • require_tp (bool(opens in a new tab)) – check if input and target channels are trace-preserving and if non-TP log warning containing negative eigenvalues of partial Choi-matrix Trout[E]ITr_{\text{out}}[\mathcal{E}] - I [Default: True].

Returns

The process fidelity FproF_{\text{pro}}.

Return type

float(opens in a new tab)

Raises

QiskitError – if the channel and target do not have the same dimensions.

gate_error

qiskit.quantum_info.gate_error(channel, target=None, require_cp=True, require_tp=False)GitHub(opens in a new tab)

Return the gate error of a noisy quantum channel.

The gate error EE is given by the average gate infidelity

E(E,U)=1Fave(E,U)E(\mathcal{E}, U) = 1 - F_{\text{ave}}(\mathcal{E}, U)

where Fave(E,U)F_{\text{ave}}(\mathcal{E}, U) is the average_gate_fidelity() of the input quantum channel E\mathcal{E} with a target unitary UU.

Parameters

  • channel (QuantumChannel) – noisy quantum channel.
  • target (Operator or None) – target unitary operator. If None target is the identity operator [Default: None].
  • require_cp (bool(opens in a new tab)) – check if input and target channels are completely-positive and if non-CP log warning containing negative eigenvalues of Choi-matrix [Default: True].
  • require_tp (bool(opens in a new tab)) – check if input and target channels are trace-preserving and if non-TP log warning containing negative eigenvalues of partial Choi-matrix Trout[E]ITr_{\text{out}}[\mathcal{E}] - I [Default: True].

Returns

The average gate error EE.

Return type

float(opens in a new tab)

Raises

QiskitError – if the channel and target do not have the same dimensions, or have different input and output dimensions.

diamond_norm

qiskit.quantum_info.diamond_norm(choi, solver='SCS', **kwargs)GitHub(opens in a new tab)

Return the diamond norm of the input quantum channel object.

This function computes the completely-bounded trace-norm (often referred to as the diamond-norm) of the input quantum channel object using the semidefinite-program from reference [1].

Parameters

  • choi (Choi or QuantumChannel) – a quantum channel object or Choi-matrix array.
  • solver (str(opens in a new tab)) – The solver to use.
  • kwargs – optional arguments to pass to CVXPY solver.

Returns

The completely-bounded trace norm E\|\mathcal{E}\|_{\diamond}.

Return type

float(opens in a new tab)

Raises

QiskitError – if CVXPY package cannot be found.

Additional Information:

The input to this function is typically not a CPTP quantum channel, but rather the difference between two quantum channels ΔE\|\Delta\mathcal{E}\|_\diamond where ΔE=E1E2\Delta\mathcal{E} = \mathcal{E}_1 - \mathcal{E}_2.

Reference:

J. Watrous. “Simpler semidefinite programs for completely bounded norms”, arXiv:1207.5726 [quant-ph] (2012).

Note

This function requires the optional CVXPY package to be installed. Any additional kwargs will be passed to the cvxpy.solve function. See the CVXPY documentation for information on available SDP solvers.

state_fidelity

qiskit.quantum_info.state_fidelity(state1, state2, validate=True)GitHub(opens in a new tab)

Return the state fidelity between two quantum states.

The state fidelity FF for density matrix input states ρ1,ρ2\rho_1, \rho_2 is given by

F(ρ1,ρ2)=Tr[ρ1ρ2ρ1]2.F(\rho_1, \rho_2) = Tr[\sqrt{\sqrt{\rho_1}\rho_2\sqrt{\rho_1}}]^2.

If one of the states is a pure state this simplifies to F(ρ1,ρ2)=ψ1ρ2ψ1F(\rho_1, \rho_2) = \langle\psi_1|\rho_2|\psi_1\rangle, where ρ1=ψ1 ⁣ψ1\rho_1 = |\psi_1\rangle\!\langle\psi_1|.

Parameters

Returns

The state fidelity F(ρ1,ρ2)F(\rho_1, \rho_2).

Return type

float(opens in a new tab)

Raises

QiskitError – if validate=True and the inputs are invalid quantum states.

purity

qiskit.quantum_info.purity(state, validate=True)GitHub(opens in a new tab)

Calculate the purity of a quantum state.

The purity of a density matrix ρ\rho is

Purity(ρ)=Tr[ρ2]\text{Purity}(\rho) = Tr[\rho^2]

Parameters

Returns

the purity Tr[ρ2]Tr[\rho^2].

Return type

float(opens in a new tab)

Raises

QiskitError – if the input isn’t a valid quantum state.

concurrence

qiskit.quantum_info.concurrence(state)GitHub(opens in a new tab)

Calculate the concurrence of a quantum state.

The concurrence of a bipartite Statevector ψ|\psi\rangle is given by

C(ψ)=2(1Tr[ρ02])C(|\psi\rangle) = \sqrt{2(1 - Tr[\rho_0^2])}

where ρ0=Tr1[ψ ⁣ψ]\rho_0 = Tr_1[|\psi\rangle\!\langle\psi|] is the reduced state from by taking the partial_trace() of the input state.

For density matrices the concurrence is only defined for 2-qubit states, it is given by:

C(ρ)=max(0,λ1λ2λ3λ4)C(\rho) = \max(0, \lambda_1 - \lambda_2 - \lambda_3 - \lambda_4)

where λ1λ2λ3λ4\lambda _1 \ge \lambda _2 \ge \lambda _3 \ge \lambda _4 are the ordered eigenvalues of the matrix R=ρ(YY)ρ(YY)ρR=\sqrt{\sqrt{\rho }(Y\otimes Y)\overline{\rho}(Y\otimes Y)\sqrt{\rho}}.

Parameters

state (Statevector orDensityMatrix) – a 2-qubit quantum state.

Returns

The concurrence.

Return type

float(opens in a new tab)

Raises

  • QiskitError – if the input state is not a valid QuantumState.
  • QiskitError – if input is not a bipartite QuantumState.
  • QiskitError – if density matrix input is not a 2-qubit state.

entropy

qiskit.quantum_info.entropy(state, base=2)GitHub(opens in a new tab)

Calculate the von-Neumann entropy of a quantum state.

The entropy SS is given by

S(ρ)=Tr[ρlog(ρ)]S(\rho) = - Tr[\rho \log(\rho)]

Parameters

Returns

The von-Neumann entropy S(rho).

Return type

float(opens in a new tab)

Raises

QiskitError – if the input state is not a valid QuantumState.

entanglement_of_formation

qiskit.quantum_info.entanglement_of_formation(state)GitHub(opens in a new tab)

Calculate the entanglement of formation of quantum state.

The input quantum state must be either a bipartite state vector, or a 2-qubit density matrix.

Parameters

state (Statevector orDensityMatrix) – a 2-qubit quantum state.

Returns

The entanglement of formation.

Return type

float(opens in a new tab)

Raises

  • QiskitError – if the input state is not a valid QuantumState.
  • QiskitError – if input is not a bipartite QuantumState.
  • QiskitError – if density matrix input is not a 2-qubit state.

mutual_information

qiskit.quantum_info.mutual_information(state, base=2)GitHub(opens in a new tab)

Calculate the mutual information of a bipartite state.

The mutual information II is given by:

I(ρAB)=S(ρA)+S(ρB)S(ρAB)I(\rho_{AB}) = S(\rho_A) + S(\rho_B) - S(\rho_{AB})

where ρA=TrB[ρAB],ρB=TrA[ρAB]\rho_A=Tr_B[\rho_{AB}], \rho_B=Tr_A[\rho_{AB}], are the reduced density matrices of the bipartite state ρAB\rho_{AB}.

Parameters

Returns

The mutual information I(ρAB)I(\rho_{AB}).

Return type

float(opens in a new tab)

Raises

  • QiskitError – if the input state is not a valid QuantumState.
  • QiskitError – if input is not a bipartite QuantumState.

Utility Functions

Quaternion(data)A class representing a Quaternion.

partial_trace

qiskit.quantum_info.partial_trace(state, qargs)GitHub(opens in a new tab)

Return reduced density matrix by tracing out part of quantum state.

If all subsystems are traced over this returns the trace() of the input state.

Parameters

Returns

The reduced density matrix.

Return type

DensityMatrix

Raises

QiskitError – if input state is invalid.

schmidt_decomposition

qiskit.quantum_info.schmidt_decomposition(state, qargs)GitHub(opens in a new tab)

Return the Schmidt Decomposition of a pure quantum state.

For an arbitrary bipartite state:

ψAB=i,jcijxiAyjB,|\psi\rangle_{AB} = \sum_{i,j} c_{ij} |x_i\rangle_A \otimes |y_j\rangle_B,

its Schmidt Decomposition is given by the single-index sum over k:

ψAB=kλkukAvkB|\psi\rangle_{AB} = \sum_{k} \lambda_{k} |u_k\rangle_A \otimes |v_k\rangle_B

where ukA|u_k\rangle_A and vkB|v_k\rangle_B are an orthonormal set of vectors in their respective spaces AA and BB, and the Schmidt coefficients λk\lambda_k are positive real values.

Parameters

Returns

list of tuples (s, u, v), where s (float) are the Schmidt coefficients λk\lambda_k, and u (Statevector), v (Statevector) are the Schmidt vectors ukA|u_k\rangle_A, ukB|u_k\rangle_B, respectively.

Return type

list(opens in a new tab)

Raises

  • QiskitError – if Input qargs is not a list of positions of the Input state.
  • QiskitError – if Input qargs is not a proper subset of Input state.
Note

In Qiskit, qubits are ordered using little-endian notation, with the least significant qubits having smaller indices. For example, a four-qubit system is represented as q3q2q1q0|q_3q_2q_1q_0\rangle. Using this convention, setting qargs=[0] will partition the state as q3q2q1Aq0B|q_3q_2q_1\rangle_A\otimes|q_0\rangle_B. Furthermore, qubits will be organized in this notation regardless of the order they are passed. For instance, passing either qargs=[1,2] or qargs=[2,1] will result in partitioning the state as q3q0Aq2q1B|q_3q_0\rangle_A\otimes|q_2q_1\rangle_B.

shannon_entropy

qiskit.quantum_info.shannon_entropy(pvec, base=2)GitHub(opens in a new tab)

Compute the Shannon entropy of a probability vector.

The shannon entropy of a probability vector p=[p0,...,pn1]\vec{p} = [p_0, ..., p_{n-1}] is defined as

H(p)=i=0n1pilogb(pi)H(\vec{p}) = \sum_{i=0}^{n-1} p_i \log_b(p_i)

where bb is the log base and (default 2), and 0logb(0)00 \log_b(0) \equiv 0.

Parameters

  • pvec (array_like) – a probability vector.
  • base (int(opens in a new tab)) – the base of the logarithm [Default: 2].

Returns

The Shannon entropy H(pvec).

Return type

float(opens in a new tab)

commutator

qiskit.quantum_info.commutator(a, b)GitHub(opens in a new tab)

Compute commutator of a and b.

abba.ab - ba.

Parameters

  • a (OperatorTypeT) – Operator a.
  • b (OperatorTypeT) – Operator b.

Returns

The commutator

Return type

OperatorTypeT

anti_commutator

qiskit.quantum_info.anti_commutator(a, b)GitHub(opens in a new tab)

Compute anti-commutator of a and b.

ab+ba.ab + ba.

Parameters

  • a (OperatorTypeT) – Operator a.
  • b (OperatorTypeT) – Operator b.

Returns

The anti-commutator

Return type

OperatorTypeT

double_commutator

qiskit.quantum_info.double_commutator(a, b, c, *, commutator=True)GitHub(opens in a new tab)

Compute symmetric double commutator of a, b and c.

See also Equation (13.6.18) in [1].

If commutator is True, it returns

[[A,B],C]/2+[A,[B,C]]/2=(2ABC+2CBABACCABACBBCA)/2.[[A, B], C]/2 + [A, [B, C]]/2 = (2ABC + 2CBA - BAC - CAB - ACB - BCA)/2.

If commutator is False, it returns

{[A,B],C}/2+{A,[B,C]}/2=(2ABC2CBABAC+CABACB+BCA)/2.\lbrace[A, B], C\rbrace/2 + \lbrace A, [B, C]\rbrace/2 = (2ABC - 2CBA - BAC + CAB - ACB + BCA)/2.

Parameters

  • a (OperatorTypeT) – Operator a.
  • b (OperatorTypeT) – Operator b.
  • c (OperatorTypeT) – Operator c.
  • commutator (bool(opens in a new tab)) – If True compute the double commutator, if False the double anti-commutator.

Returns

The double commutator

Return type

OperatorTypeT

References

[1]: R. McWeeny.

Methods of Molecular Quantum Mechanics. 2nd Edition, Academic Press, 1992. ISBN 0-12-486552-6.


Random

random_statevector

qiskit.quantum_info.random_statevector(dims, seed=None)GitHub(opens in a new tab)

Generator a random Statevector.

The statevector is sampled from the uniform distribution. This is the measure induced by the Haar measure on unitary matrices.

Parameters

Returns

the random statevector.

Return type

Statevector

Reference:

K. Zyczkowski and H. Sommers (2001), “Induced measures in the space of mixed quantum states”, J. Phys. A: Math. Gen. 34 7111(opens in a new tab).

random_density_matrix

qiskit.quantum_info.random_density_matrix(dims, rank=None, method='Hilbert-Schmidt', seed=None)GitHub(opens in a new tab)

Generator a random DensityMatrix.

Parameters

  • dims (int(opens in a new tab) ortuple(opens in a new tab)) – the dimensions of the DensityMatrix.
  • rank (int(opens in a new tab) or None) – Optional, the rank of the density matrix. The default value is full-rank.
  • method (string) – Optional. The method to use. ‘Hilbert-Schmidt’: (Default) sample from the Hilbert-Schmidt metric. ‘Bures’: sample from the Bures metric.
  • seed (int(opens in a new tab) or np.random.Generator) – Optional. Set a fixed seed or generator for RNG.

Returns

the random density matrix.

Return type

DensityMatrix

Raises

QiskitError – if the method is not valid.

random_unitary

qiskit.quantum_info.random_unitary(dims, seed=None)GitHub(opens in a new tab)

Return a random unitary Operator.

The operator is sampled from the unitary Haar measure.

Parameters

Returns

a unitary operator.

Return type

Operator

random_hermitian

qiskit.quantum_info.random_hermitian(dims, traceless=False, seed=None)GitHub(opens in a new tab)

Return a random hermitian Operator.

The operator is sampled from Gaussian Unitary Ensemble.

Parameters

Returns

a Hermitian operator.

Return type

Operator

random_pauli

qiskit.quantum_info.random_pauli(num_qubits, group_phase=False, seed=None)GitHub(opens in a new tab)

Return a random Pauli.

Parameters

Returns

a random Pauli

Return type

Pauli

random_clifford

qiskit.quantum_info.random_clifford(num_qubits, seed=None)GitHub(opens in a new tab)

Return a random Clifford operator.

The Clifford is sampled using the method of Reference [1].

Parameters

Returns

a random Clifford operator.

Return type

Clifford

Reference:

  1. S. Bravyi and D. Maslov, Hadamard-free circuits expose the structure of the Clifford group. arXiv:2003.09412 [quant-ph](opens in a new tab)

random_quantum_channel

qiskit.quantum_info.random_quantum_channel(input_dims=None, output_dims=None, rank=None, seed=None)GitHub(opens in a new tab)

Return a random CPTP quantum channel.

This constructs the Stinespring operator for the quantum channel by sampling a random isometry from the unitary Haar measure.

Parameters

Returns

a quantum channel operator.

Return type

Stinespring

Raises

QiskitError – if rank or dimensions are invalid.

random_cnotdihedral

qiskit.quantum_info.random_cnotdihedral(num_qubits, seed=None)GitHub(opens in a new tab)

Return a random CNOTDihedral element.

Parameters

Returns

a random CNOTDihedral element.

Return type

CNOTDihedral

random_pauli_list

qiskit.quantum_info.random_pauli_list(num_qubits, size=1, seed=None, phase=True)GitHub(opens in a new tab)

Return a random PauliList.

Parameters

Returns

a random PauliList.

Return type

PauliList


Analysis

hellinger_distance

qiskit.quantum_info.hellinger_distance(dist_p, dist_q)GitHub(opens in a new tab)

Computes the Hellinger distance between two counts distributions.

Parameters

Returns

Distance

Return type

float(opens in a new tab)

References

Hellinger Distance @ wikipedia(opens in a new tab)

hellinger_fidelity

qiskit.quantum_info.hellinger_fidelity(dist_p, dist_q)GitHub(opens in a new tab)

Computes the Hellinger fidelity between two counts distributions.

The fidelity is defined as (1H2)2\left(1-H^{2}\right)^{2} where H is the Hellinger distance. This value is bounded in the range [0, 1].

This is equivalent to the standard classical fidelity F(Q,P)=(ipiqi)2F(Q,P)=\left(\sum_{i}\sqrt{p_{i}q_{i}}\right)^{2} that in turn is equal to the quantum state fidelity for diagonal density matrices.

Parameters

Returns

Fidelity

Return type

float(opens in a new tab)

Example

from qiskit import QuantumCircuit
from qiskit.quantum_info.analysis import hellinger_fidelity
from qiskit.providers.basic_provider import BasicSimulator
 
qc = QuantumCircuit(5, 5)
qc.h(2)
qc.cx(2, 1)
qc.cx(2, 3)
qc.cx(3, 4)
qc.cx(1, 0)
qc.measure(range(5), range(5))
 
sim = BasicSimulator()
res1 = sim.run(qc).result()
res2 = sim.run(qc).result()
 
hellinger_fidelity(res1.get_counts(), res2.get_counts())

References

Quantum Fidelity @ wikipedia(opens in a new tab) Hellinger Distance @ wikipedia(opens in a new tab)

Z2Symmetries(symmetries, sq_paulis, sq_list)The $Z_2$ symmetry converter identifies symmetries from the problem hamiltonian and uses them to provide a tapered - more efficient - representation of operators as Paulis for this problem.
Was this page helpful?