pytket.circuit_library

The circuit_library module is a collection of methods for generating small circuits, mostly of the form of representing one gate in terms of others (as used, for example, within the AutoRebase() pass).

They can be split into a few rough categories:

• Decompositions of multi-qubit gates into other multi-qubit gates (permitting any single-qubit gates), some of which may trade approximation error in the decomposition for reduced gate costs;

• Decompositions of single-qubit gates into universal gatesets, intended to be run after decomposing all multi-qubit gates;

• Constant circuits of 1-3 gates.

Parameters of the gate to be decomposed are passed as method arguments.

Exact multi-qubit gate decompositions

pytket.circuit_library.BRIDGE_using_CX_0() → pytket.circuit.Circuit

Equivalent to BRIDGE, using four CX, first CX has control on qubit 0

pytket.circuit_library.BRIDGE_using_CX_1() → pytket.circuit.Circuit

Equivalent to BRIDGE, using four CX, first CX has control on qubit 1

pytket.circuit_library.CX_using_TK2() → pytket.circuit.Circuit

Equivalent to CX, using a TK2 and single-qubit gates

pytket.circuit_library.TK2_using_CX(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Given expressions α, β and γ, return circuit equivalent to TK2(α, β, γ) using up to 3 CX and single-qubit gates.

The decomposition minimizes the number of CX gates.

pytket.circuit_library.TK2_using_CX_and_swap(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Given expressions α, β and γ, return circuit equivalent to TK2(α, β, γ), up to a wire swap that is encoded in the implicit qubit permutation of the Circuit, using up to 3 CX and single-qubit gates.

The decomposition minimizes the number of CX gates.

pytket.circuit_library.TK2_using_3xCX(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Given expressions α, β and γ, return circuit equivalent to TK2(α, β, γ) using 3 CX and single-qubit gates.

Prefer using _TK2_using_CX unless you wish to explicitly use 3 CX or if α, β and γ are not normalised to the Weyl chamber.

pytket.circuit_library.CX_using_flipped_CX() → pytket.circuit.Circuit

Equivalent to CX[0,1], using a CX[1,0] and four H gates

pytket.circuit_library.CX_using_ECR() → pytket.circuit.Circuit

Equivalent to CX, using only ECR, Rx and U3 gates

pytket.circuit_library.CX_using_ZZMax() → pytket.circuit.Circuit

Equivalent to CX, using only ZZMax, Rx and Rz gates

pytket.circuit_library.CX_using_ISWAPMax() → pytket.circuit.Circuit

Equivalent to CX, using only ISWAPMax and single-qubit gates

pytket.circuit_library.CX_using_ISWAPMax_and_swap() → pytket.circuit.Circuit

Equivalent to CX, using only ISWAPMax and single-qubit gates, up to a wire swap that is encoded in the implicit qubit permutation of the Circuit

pytket.circuit_library.CX_using_ZZPhase() → pytket.circuit.Circuit

Equivalent to CX, using only ZZPhase, Rx and Rz gates

pytket.circuit_library.CX_using_XXPhase_0() → pytket.circuit.Circuit

Equivalent to CX, using only XXPhase, Rx, Ry and Rz gates

pytket.circuit_library.CX_using_XXPhase_1() → pytket.circuit.Circuit

Equivalent to CX, using only XXPhase, Rx, Ry and Rz gates

pytket.circuit_library.CX_using_AAMS() → pytket.circuit.Circuit

Equivalent to CX, using AAMS, GPI and GPI2 gates

pytket.circuit_library.SWAP_using_CX_0() → pytket.circuit.Circuit

Equivalent to SWAP, using three CX, outer CX have control on qubit 0

pytket.circuit_library.SWAP_using_CX_1() → pytket.circuit.Circuit

Equivalent to SWAP, using three CX, outer CX have control on qubit 1

pytket.circuit_library.CZ_using_CX() → pytket.circuit.Circuit

Equivalent to CZ, using CX and single-qubit gates

pytket.circuit_library.CY_using_CX() → pytket.circuit.Circuit

Equivalent to CY, using CX and single-qubit gates

pytket.circuit_library.CH_using_CX() → pytket.circuit.Circuit

Equivalent to CH, using CX and single-qubit gates

pytket.circuit_library.CV_using_CX() → pytket.circuit.Circuit

Equivalent to CV, using CX and single-qubit gates

pytket.circuit_library.CVdg_using_CX() → pytket.circuit.Circuit

Equivalent to CVdg, using CX and single-qubit gates

pytket.circuit_library.CSX_using_CX() → pytket.circuit.Circuit

Equivalent to CSX, using CX and single-qubit gates

pytket.circuit_library.CSXdg_using_CX() → pytket.circuit.Circuit

Equivalent to CSXdg, using CX and single-qubit gates

pytket.circuit_library.CS_using_CX() → pytket.circuit.Circuit

Equivalent to CS, using CX and single-qubit gates

pytket.circuit_library.CSdg_using_CX() → pytket.circuit.Circuit

Equivalent to CSdg, using CX and single-qubit gates

pytket.circuit_library.CSWAP_using_CX() → pytket.circuit.Circuit

Equivalent to CSWAP, using CX and single-qubit gates

pytket.circuit_library.ECR_using_CX() → pytket.circuit.Circuit

Equivalent to ECR, using CX, Rx and U3 gates

pytket.circuit_library.ZZMax_using_CX() → pytket.circuit.Circuit

Equivalent to ZZMax, using CX, Rz and U3 gates

pytket.circuit_library.CRz_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CRz, using a TK2 and TK1 gates

pytket.circuit_library.CRz_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CRz, using CX and Rz gates

pytket.circuit_library.CRx_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CRx, using a TK2 and TK1 gates

pytket.circuit_library.CRx_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CRx, using CX, H and Rx gates

pytket.circuit_library.CRy_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CRy, using a TK2 and TK1 gates

pytket.circuit_library.CRy_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CRy, using CX and Ry gates

pytket.circuit_library.CU1_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CU1, using a TK2 and TK1 gates

pytket.circuit_library.CU1_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CU1, using CX and U1 gates

pytket.circuit_library.CU3_using_CX(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to CU1, using CX, U1 and U3 gates

pytket.circuit_library.ISWAP_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to ISWAP, using a TK2 gate

pytket.circuit_library.ISWAP_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to ISWAP, using CX, U3 and Rz gates

pytket.circuit_library.ISWAPMax_using_TK2() → pytket.circuit.Circuit

Equivalent to ISWAPMax, using a TK2 gate

pytket.circuit_library.ISWAPMax_using_CX() → pytket.circuit.Circuit

Equivalent to ISWAPMax, using CX, U3 and Rz gates

pytket.circuit_library.XXPhase_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to XXPhase, using a TK2 gate

pytket.circuit_library.XXPhase_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to XXPhase, using CX and U3 gates

pytket.circuit_library.XXPhase_using_AAMS(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to XXPhase, using AAMS gates

pytket.circuit_library.YYPhase_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to YYPhase, using a TK2 gate

pytket.circuit_library.YYPhase_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to YYPhase, using two CX gates and one Ry, one Sdg and one S gate.

pytket.circuit_library.YYPhase_using_AAMS(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to YYPhase, using AAMS gates

pytket.circuit_library.ZZPhase_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to ZZPhase, using a TK2 gate

pytket.circuit_library.ZZPhase_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to ZZPhase, using CX and Rz gates

pytket.circuit_library.ZZPhase_using_AAMS(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to ZZPhase, using AAMS, GPI and GPI2 gates

pytket.circuit_library.XXPhase3_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to XXPhase3, using three TK2 gates

pytket.circuit_library.XXPhase3_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to 3-qubit MS interaction, using CX and U3 gates

pytket.circuit_library.ESWAP_using_TK2(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to ESWAP, using a TK2 and (Clifford) TK1 gates

pytket.circuit_library.ESWAP_using_CX(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to ESWAP, using CX, X, S, Ry and U1 gates

pytket.circuit_library.FSim_using_TK2(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to FSim, using a TK2 and TK1 gates

pytket.circuit_library.FSim_using_CX(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to Fsim, using CX, X, S, U1 and U3 gates

pytket.circuit_library.PhasedISWAP_using_TK2(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to PhasedISWAP, using a TK2 and Rz gates

pytket.circuit_library.PhasedISWAP_using_CX(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to PhasedISWAP, using CX, U3 and Rz gates

pytket.circuit_library.TK2_using_ZZPhase(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to TK2, using 3 ZZPhase gates

pytket.circuit_library.TK2_using_ZZPhase_and_swap(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to TK2, up to a wire swap that is encoded in the implicit qubit permutation of the Circuit, using up to 3 ZZPhase gates.

pytket.circuit_library.TK2_using_TK2_or_swap(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Either the exact TK2, or a wire swap encoded in the implicit qubit permutation of the Circuit and single qubit gates.

pytket.circuit_library.TK2_using_TK2(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A circuit of a single TK2 gate with given parameters

pytket.circuit_library.TK2_using_ZZMax(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to TK2, using up to 3 ZZMax gates.

pytket.circuit_library.TK2_using_ZZMax_and_swap(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to TK2, up to a wire swap that is encoded in the implicit qubit permutation of the Circuit, using up to 3 ZZMax gates.

pytket.circuit_library.TK2_using_ISWAPMax(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to TK2, using only ISWAPMax and single-qubit gates.

pytket.circuit_library.TK2_using_ISWAPMax_and_swap(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to TK2, using only ISWAPMax and single-qubit gates, up to a wire swap that is encoded in the implicit qubit permutation of the Circuit.

pytket.circuit_library.TK2_using_AAMS(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to TK2, using AAMS, GPI and GPI2 gates

pytket.circuit_library.CCX_modulo_phase_shift() → pytket.circuit.Circuit

Equivalent to CCX up to phase shift, using three CX. Warning: this is not equivalent to CCX up to global phase so cannot be used as a direct substitution except when the phase reversal can be cancelled. Its unitary representation is like CCX but with a -1 at the (5,5) position.

pytket.circuit_library.CCX_normal_decomp() → pytket.circuit.Circuit

Equivalent to CCX, using 6 CX

pytket.circuit_library.C3X_normal_decomp() → pytket.circuit.Circuit

Equivalent to CCCX, using 14 CX

pytket.circuit_library.C4X_normal_decomp() → pytket.circuit.Circuit

Equivalent to CCCCX, using 36 CX

pytket.circuit_library.CnX_vchain_decomp(n: int, zeroed_ancillas: bool = True) → pytket.circuit.Circuit

CnX decomposition from https://arxiv.org/abs/1906.01734/1508.03273.

Parameters:

• n – Number of control qubits

• zeroed_ancillas – If True, the gate will be implemented assuming that all ancilla qubits start in state \(\ket{0}\). If False, ancilla qubits may be initialized in any state, at the cost of higher CX-count.

Returns:

Circuit with control qubits at indices \(0, \ldots, n-1\), target qubit \(n\), and ancilla qubits \(n+1, \ldots, n + \lfloor(n-1)/2\rfloor\).

pytket.circuit_library.ladder_down() → pytket.circuit.Circuit

CX[0,1]; CX[2,0]; CCX[0,1,2]

pytket.circuit_library.ladder_down_2() → pytket.circuit.Circuit

CX[0,1]; X[0]; X[2]; CCX[0,1,2]

pytket.circuit_library.ladder_up() → pytket.circuit.Circuit

CCX[0,1,2]; CX[2,0]; CX[2,1]

Approximate multi-qubit gate decompositions

pytket.circuit_library.approx_TK2_using_1xCX() → pytket.circuit.Circuit

Best approximation of TK2 using 1 CX gate and single-qubit gates, using squared trace fidelity metric. No parameter is required for this approximation. The returned circuit will be equivalent to TK2(0.5, 0, 0).

pytket.circuit_library.approx_TK2_using_2xCX(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Best approximation of TK2 using 2 CX gates and single-qubit gates, using squared trace fidelity metric. Given expressions α and β, with 0.5 ≥ α ≥ β ≥ 0, return a circuit equivalent to TK2(α, β, 0).

pytket.circuit_library.approx_TK2_using_1xZZPhase(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Approximate equivalent to TK2, using 1 ZZPhase gate and single-qubit gates. Only requires the first angle of the TK2 gate.

pytket.circuit_library.approx_TK2_using_2xZZPhase(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Approximate equivalent to TK2, using 2 ZZPhase gates and single-qubit gates. Only requires the first two angles of the TK2 gate.

Single-qubit gate decompositions

pytket.circuit_library.NPhasedX_using_PhasedX(arg0: int, arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Unwrap NPhasedX, into number_of_qubits PhasedX gates

pytket.circuit_library.TK2_using_normalised_TK2(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

TK2(a, b, c)-equivalent circuit, using a single normalised TK2 and single-qb gates

pytket.circuit_library.TK1_to_PhasedXRz(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A tk1 equivalent circuit given tk1 parameters in terms of PhasedX, Rz

pytket.circuit_library.TK1_to_RzRx(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A tk1 equivalent circuit given tk1 parameters in terms of Rz, Rx

pytket.circuit_library.TK1_to_RxRy(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A tk1 equivalent circuit given tk1 parameters in terms of Rx, Ry

pytket.circuit_library.TK1_to_RzH(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A tk1 equivalent circuit given tk1 parameters in terms of Rz, H

pytket.circuit_library.TK1_to_RzSX(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A tk1 equivalent circuit given tk1 parameters in terms of Rz, Sx

pytket.circuit_library.TK1_to_RzXSX(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A tk1 equivalent circuit given tk1 parameters in terms of Rz, X, Sx

pytket.circuit_library.TK1_to_TK1(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A circuit of a single tk1 gate with given parameters

pytket.circuit_library.TK1_to_U3(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

A tk1 equivalent circuit given tk1 parameters in terms of U3 and global phase

pytket.circuit_library.Rx_using_GPI(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to Rx, using GPI and GPI2 gates

pytket.circuit_library.Ry_using_GPI(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to Ry, using GPI and GPI2 gates

pytket.circuit_library.Rz_using_GPI(arg: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to Rz, using GPI gates

pytket.circuit_library.TK1_using_GPI(arg0: Union[sympy.Expr, float], arg1: Union[sympy.Expr, float], arg2: Union[sympy.Expr, float], /) → pytket.circuit.Circuit

Equivalent to TK1, using GPI and GPI2 gates

Constant circuits

pytket.circuit_library.X() → pytket.circuit.Circuit

Just an X gate

pytket.circuit_library.CX() → pytket.circuit.Circuit

Just a CX[0,1] gate

pytket.circuit_library.CCX() → pytket.circuit.Circuit

Just a CCX[0,1,2] gate

pytket.circuit_library.X1_CX() → pytket.circuit.Circuit

X[1]; CX[0,1]

pytket.circuit_library.Z0_CX() → pytket.circuit.Circuit

Z[0]; CX[0,1]

pytket.circuit_library.BRIDGE() → pytket.circuit.Circuit

Just a BRIDGE[0,1,2] gate

pytket.circuit_library.H_CZ_H() → pytket.circuit.Circuit

H[1]; CZ[0,1]; H[1]

pytket.circuit_library.CX_VS_CX_reduced() → pytket.circuit.Circuit

CX-reduced form of CX/V,S/CX

pytket.circuit_library.CX_V_CX_reduced() → pytket.circuit.Circuit

CX-reduced form of CX/V,-/CX

pytket.circuit_library.CX_S_CX_reduced() → pytket.circuit.Circuit

CX-reduced form of CX/-,S/CX (= ZZMax)

pytket.circuit_library.CX_V_S_XC_reduced() → pytket.circuit.Circuit

CX-reduced form of CX/V,-/S,-/XC

pytket.circuit_library.CX_S_V_XC_reduced() → pytket.circuit.Circuit

CX-reduced form of CX/-,S/-,V/XC

pytket.circuit_library.CX_XC_reduced() → pytket.circuit.Circuit

CX-reduced form of CX/XC