tensorcircuit.stabilizercircuit¶

Stabilizer circuit simulator using Stim backend

class tensorcircuit.stabilizercircuit.StabilizerCircuit(nqubits: int, inputs: Any = None, tableau_inputs: Any = None)[source]¶

Bases: AbstractCircuit

Quantum circuit simulator for stabilizer circuits using Stim backend. Supports Clifford operations and measurements.

ANY(*index: int, **vars: Any) → None¶

Apply ANY gate with parameters on the circuit. See tensorcircuit.gates.any_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

CMZ(*index: int, **vars: Any) → None¶

Apply cmz gate on the circuit using hyperedge support for digonal gates. See tensorcircuit.gates.cmz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

CNOT(*index: int, **kws: Any) → None¶

Apply CNOT gate on the circuit. See tensorcircuit.gates.cnot_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

CPHASE(*index: int, **vars: Any) → None¶

Apply CPHASE gate with parameters on the circuit. See tensorcircuit.gates.cphase_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

CR(*index: int, **vars: Any) → None¶

Apply CR gate with parameters on the circuit. See tensorcircuit.gates.cr_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

CRX(*index: int, **vars: Any) → None¶

Apply CRX gate with parameters on the circuit. See tensorcircuit.gates.crx_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

CRY(*index: int, **vars: Any) → None¶

Apply CRY gate with parameters on the circuit. See tensorcircuit.gates.cry_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

CRZ(*index: int, **vars: Any) → None¶

Apply CRZ gate with parameters on the circuit. See tensorcircuit.gates.crz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

CU(*index: int, **vars: Any) → None¶

Apply CU gate with parameters on the circuit. See tensorcircuit.gates.cu_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

CY(*index: int, **kws: Any) → None¶

Apply CY gate on the circuit. See tensorcircuit.gates.cy_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.-1.j\\ 0.+0.j & 0.+0.j & 0.+1.j & 0.+0.j \end{bmatrix}\end{split}\]

CZ(*index: int, **kws: Any) → None¶

Apply CZ gate on the circuit. See tensorcircuit.gates.cz_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & -1.+0.j \end{bmatrix}\end{split}\]

DIAGONAL(*index: int, **vars: Any) → None¶

Apply diagonal gate on the circuit using hyperedge support for digonal gates. See tensorcircuit.gates.diagonal_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

EXP(*index: int, **vars: Any) → None¶

Apply EXP gate with parameters on the circuit. See tensorcircuit.gates.exp_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

EXP1(*index: int, **vars: Any) → None¶

Apply EXP1 gate with parameters on the circuit. See tensorcircuit.gates.exp1_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

FREDKIN(*index: int, **kws: Any) → None¶

Apply FREDKIN gate on the circuit. See tensorcircuit.gates.fredkin_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

H(*index: int, **kws: Any) → None¶

Apply H gate on the circuit. See tensorcircuit.gates.h_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.70710677+0.j & 0.70710677+0.j\\ 0.70710677+0.j & -0.70710677+0.j \end{bmatrix}\end{split}\]

I(*index: int, **kws: Any) → None¶

Apply I gate on the circuit. See tensorcircuit.gates.i_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

ISWAP(*index: int, **vars: Any) → None¶

Apply ISWAP gate with parameters on the circuit. See tensorcircuit.gates.iswap_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

MPO(*index: int, **vars: Any) → None¶

Apply mpo gate in MPO format on the circuit. See tensorcircuit.gates.mpo_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

MULTICONTROL(*index: int, **vars: Any) → None¶

Apply multicontrol gate in MPO format on the circuit. See tensorcircuit.gates.multicontrol_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

ORX(*index: int, **vars: Any) → None¶

Apply ORX gate with parameters on the circuit. See tensorcircuit.gates.orx_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

ORY(*index: int, **vars: Any) → None¶

Apply ORY gate with parameters on the circuit. See tensorcircuit.gates.ory_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

ORZ(*index: int, **vars: Any) → None¶

Apply ORZ gate with parameters on the circuit. See tensorcircuit.gates.orz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

OX(*index: int, **kws: Any) → None¶

Apply OX gate on the circuit. See tensorcircuit.gates.ox_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

OY(*index: int, **kws: Any) → None¶

Apply OY gate on the circuit. See tensorcircuit.gates.oy_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.+0.j & 0.-1.j & 0.+0.j & 0.+0.j\\ 0.+1.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

OZ(*index: int, **kws: Any) → None¶

Apply OZ gate on the circuit. See tensorcircuit.gates.oz_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & -1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

PHASE(*index: int, **vars: Any) → None¶

Apply PHASE gate with parameters on the circuit. See tensorcircuit.gates.phase_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

R(*index: int, **vars: Any) → None¶

Apply R gate with parameters on the circuit. See tensorcircuit.gates.r_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

RX(*index: int, **vars: Any) → None¶

Apply RX gate with parameters on the circuit. See tensorcircuit.gates.rx_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

RXX(*index: int, **vars: Any) → None¶

Apply RXX gate with parameters on the circuit. See tensorcircuit.gates.rxx_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

RY(*index: int, **vars: Any) → None¶

Apply RY gate with parameters on the circuit. See tensorcircuit.gates.ry_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

RYY(*index: int, **vars: Any) → None¶

Apply RYY gate with parameters on the circuit. See tensorcircuit.gates.ryy_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

RZ(*index: int, **vars: Any) → None¶

Apply RZ gate with parameters on the circuit. See tensorcircuit.gates.rz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

RZM(*index: int, **vars: Any) → None¶

Apply rzm gate on the circuit using hyperedge support for digonal gates. See tensorcircuit.gates.rzm_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

RZZ(*index: int, **vars: Any) → None¶

Apply RZZ gate with parameters on the circuit. See tensorcircuit.gates.rzz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

S(*index: int, **kws: Any) → None¶

Apply S gate on the circuit. See tensorcircuit.gates.s_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+1.j \end{bmatrix}\end{split}\]

SD(*index: int, **kws: Any) → None¶

Apply SD gate on the circuit. See tensorcircuit.gates.sd_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & 0.-1.j \end{bmatrix}\end{split}\]

SU4(*index: int, **vars: Any) → None¶

Apply SU4 gate with parameters on the circuit. See tensorcircuit.gates.su4_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

SWAP(*index: int, **kws: Any) → None¶

Apply SWAP gate on the circuit. See tensorcircuit.gates.swap_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

T(*index: int, **kws: Any) → None¶

Apply T gate on the circuit. See tensorcircuit.gates.t_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1. & +0.j & 0. & +0.j\\ 0. & +0.j & 0.70710677+0.70710677j \end{bmatrix}\end{split}\]

TD(*index: int, **kws: Any) → None¶

Apply TD gate on the circuit. See tensorcircuit.gates.td_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1. & +0.j & 0. & +0.j\\ 0. & +0.j & 0.70710677-0.70710677j \end{bmatrix}\end{split}\]

TOFFOLI(*index: int, **kws: Any) → None¶

Apply TOFFOLI gate on the circuit. See tensorcircuit.gates.toffoli_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

U(*index: int, **vars: Any) → None¶

Apply U gate with parameters on the circuit. See tensorcircuit.gates.u_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

WROOT(*index: int, **kws: Any) → None¶

Apply WROOT gate on the circuit. See tensorcircuit.gates.wroot_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.70710677+0.j & -0.5 & -0.5j\\ 0.5 & -0.5j & 0.70710677+0.j \end{bmatrix}\end{split}\]

X(*index: int, **kws: Any) → None¶

Apply X gate on the circuit. See tensorcircuit.gates.x_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.+0.j & 1.+0.j\\ 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

Y(*index: int, **kws: Any) → None¶

Apply Y gate on the circuit. See tensorcircuit.gates.y_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.+0.j & 0.-1.j\\ 0.+1.j & 0.+0.j \end{bmatrix}\end{split}\]

Z(*index: int, **kws: Any) → None¶

Apply Z gate on the circuit. See tensorcircuit.gates.z_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & -1.+0.j \end{bmatrix}\end{split}\]

__init__(nqubits: int, inputs: Any = None, tableau_inputs: Any = None) → None[source]¶

StabilizerCircuit class based on stim package

Parameters:

nqubits (int) – Number of qubits
inputs (Tensor, optional) – initial state by stabilizers, defaults to None
tableau_inputs (Tensor, optional) – initial state by inverse tableau, defaults to None

any(*index: int, **vars: Any) → None¶

Apply ANY gate with parameters on the circuit. See tensorcircuit.gates.any_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

append(c: AbstractCircuit, indices: List[int] | None = None) → AbstractCircuit¶

append circuit c before

Example:

>>> c1 = tc.Circuit(2)
>>> c1.H(0)
>>> c1.H(1)
>>> c2 = tc.Circuit(2)
>>> c2.cnot(0, 1)
>>> c1.append(c2)
<tensorcircuit.circuit.Circuit object at 0x7f8402968970>
>>> c1.draw()
    ┌───┐
q_0:┤ H ├──■──
    ├───┤┌─┴─┐
q_1:┤ H ├┤ X ├
    └───┘└───┘

Parameters:

c (BaseCircuit) – The other circuit to be appended
indices (Optional[List[int]], optional) – the qubit indices to which c is appended on. Defaults to None, which means plain concatenation.

Returns:

The composed circuit

Return type:

BaseCircuit

append_from_qir(qir: List[Dict[str, Any]], allow_channel: bool = False) → None¶

Apply the ciurict in form of quantum intermediate representation after the current cirucit.

Example:

>>> c = tc.Circuit(3)
>>> c.H(0)
>>> c.to_qir()
[{'gatef': h, 'gate': Gate(...), 'index': (0,), 'name': 'h', 'split': None, 'mpo': False}]
>>> c2 = tc.Circuit(3)
>>> c2.CNOT(0, 1)
>>> c2.to_qir()
[{'gatef': cnot, 'gate': Gate(...), 'index': (0, 1), 'name': 'cnot', 'split': None, 'mpo': False}]
>>> c.append_from_qir(c2.to_qir())
>>> c.to_qir()
[{'gatef': h, 'gate': Gate(...), 'index': (0,), 'name': 'h', 'split': None, 'mpo': False},
 {'gatef': cnot, 'gate': Gate(...), 'index': (0, 1), 'name': 'cnot', 'split': None, 'mpo': False}]

Parameters:

qir (List[Dict[str, Any]]) – The quantum intermediate representation.
allow_channel (bool, optional) – whether to allow channel in the qir, defaults to False

apply(gate: Any, *index: int, name: str | None = None, **kws: Any) → None¶

Apply a Clifford gate to the circuit.

Parameters:

gate (Any) – Gate to apply (must be Clifford)
index (int) – Qubit indices to apply the gate to
name (Optional[str], optional) – Name of the gate operation, defaults to None

Raises:

ValueError – If non-Clifford gate is applied

apply_general_gate(gate: Any, *index: int, name: str | None = None, **kws: Any) → None[source]¶

Apply a Clifford gate to the circuit.

Parameters:

gate (Any) – Gate to apply (must be Clifford)
index (int) – Qubit indices to apply the gate to
name (Optional[str], optional) – Name of the gate operation, defaults to None

Raises:

ValueError – If non-Clifford gate is applied

static apply_general_gate_delayed(gatef: Callable[[], Gate], name: str | None = None, mpo: bool = False) → Callable[[...], None]¶

static apply_general_variable_gate_delayed(gatef: Callable[[...], Any], name: str | None = None, mpo: bool = False, diagonal: bool = False) → Callable[[...], None]¶

barrier_instruction(*index: List[int]) → None¶

add a barrier instruction flag, no effect on numerical simulation

Parameters:: index (List[int]) – the corresponding qubits

ccnot(*index: int, **kws: Any) → None¶

Apply TOFFOLI gate on the circuit. See tensorcircuit.gates.toffoli_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

ccx(*index: int, **kws: Any) → None¶

Apply TOFFOLI gate on the circuit. See tensorcircuit.gates.toffoli_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

circuit_param: Dict[str, Any]¶

clifford_gates = ['h', 'x', 'y', 'z', 'cnot', 'cz', 'swap', 's', 'sd']¶

cmz(*index: int, **vars: Any) → None¶

Apply cmz gate on the circuit using hyperedge support for digonal gates. See tensorcircuit.gates.cmz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

cnot(*index: int, **kws: Any) → None¶

Apply CNOT gate on the circuit. See tensorcircuit.gates.cnot_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

cond_measure(index: int) → Any¶

Measure a single qubit in the Z basis and collapse the state.

Parameters:: index (int) – The index of the qubit to measure.
Returns:: The measurement result (0 or 1).
Return type:: Tensor

cond_measure_many(*index: int) → Any[source]¶

Measure multiple qubits in the Z basis and collapse the state.

Parameters:: index (int) – The indices of the qubits to measure.
Returns:: A tensor containing the measurement results.
Return type:: Tensor

cond_measurement(index: int) → Any[source]¶

Measure a single qubit in the Z basis and collapse the state.

Parameters:: index (int) – The index of the qubit to measure.
Returns:: The measurement result (0 or 1).
Return type:: Tensor

conditional_gate(which: Any, kraus: Sequence[Gate], *index: int) → None¶

Apply which-th gate from kraus list, i.e. apply kraus[which]

Parameters:

which (Tensor) – Tensor of shape [] and dtype int
kraus (Sequence[Gate]) – A list of gate in the form of tc.gate or Tensor
index (int) – the qubit lines the gate applied on

copy() → AbstractCircuit¶

cphase(*index: int, **vars: Any) → None¶

Apply CPHASE gate with parameters on the circuit. See tensorcircuit.gates.cphase_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

cr(*index: int, **vars: Any) → None¶

Apply CR gate with parameters on the circuit. See tensorcircuit.gates.cr_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

crx(*index: int, **vars: Any) → None¶

Apply CRX gate with parameters on the circuit. See tensorcircuit.gates.crx_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

cry(*index: int, **vars: Any) → None¶

Apply CRY gate with parameters on the circuit. See tensorcircuit.gates.cry_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

crz(*index: int, **vars: Any) → None¶

Apply CRZ gate with parameters on the circuit. See tensorcircuit.gates.crz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

cswap(*index: int, **kws: Any) → None¶

Apply FREDKIN gate on the circuit. See tensorcircuit.gates.fredkin_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

cu(*index: int, **vars: Any) → None¶

Apply CU gate with parameters on the circuit. See tensorcircuit.gates.cu_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

current_circuit() → Circuit[source]¶: Return the current stim circuit representation of the circuit.

current_inverse_tableau() → Tableau[source]¶: Return the current inverse tableau of the circuit.

current_simulator() → TableauSimulator[source]¶: Return the current simulator of the circuit.

current_tableau() → Tableau[source]¶: Return the current tableau of the circuit.

cx(*index: int, **kws: Any) → None¶

Apply CNOT gate on the circuit. See tensorcircuit.gates.cnot_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

cy(*index: int, **kws: Any) → None¶

Apply CY gate on the circuit. See tensorcircuit.gates.cy_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.-1.j\\ 0.+0.j & 0.+0.j & 0.+1.j & 0.+0.j \end{bmatrix}\end{split}\]

cz(*index: int, **kws: Any) → None¶

Apply CZ gate on the circuit. See tensorcircuit.gates.cz_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

depolarizing(*index: int, p: float) → None[source]¶

Apply depolarizing noise to a qubit.

Parameters:

index (int) – Index of the qubit to apply noise to
p (float) – Noise parameter (probability of depolarizing)

depolarizing2_instruction(q1: int, q2: int, p: float, **kws: Any) → None¶: add a 2-qubit depolarizing instruction flag, no effect on numerical simulation

depolarizing_instruction(q: int, px: float | None = None, py: float | None = None, pz: float | None = None, **kws: Any) → None¶: add a depolarizing instruction flag, no effect on numerical simulation

detector_instruction(lookback_indices: Sequence[int], coords: Sequence[float] | None = None, **kws: Any) → None¶

add a detector instruction flag, no effect on numerical simulation

Parameters:: lookback_indices (Sequence[int]) – the corresponding measurement record indices

diaggates = ['diagonal', 'rzm', 'cmz']¶

diagonal(*index: int, **vars: Any) → None¶

Apply diagonal gate on the circuit using hyperedge support for digonal gates. See tensorcircuit.gates.diagonal_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

draw(**kws: Any) → Any¶

Visualise the circuit. This method recevies the keywords as same as qiskit.circuit.QuantumCircuit.draw. More details can be found here: https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.draw.html. Interesting kws options include: ``idle_wires``(bool)

Example:

>>> c = tc.Circuit(3)
>>> c.H(1)
>>> c.X(2)
>>> c.CNOT(0, 1)
>>> c.draw(output='text')
q_0: ───────■──
     ┌───┐┌─┴─┐
q_1: ┤ H ├┤ X ├
     ├───┤└───┘
q_2: ┤ X ├─────
     └───┘

entanglement_entropy(cut: Sequence[int]) → float[source]¶

Calculate the entanglement entropy for a subset of qubits using stabilizer formalism.

Parameters:: cut (Sequence[int]) – Indices of qubits to calculate entanglement entropy for
Returns:: Entanglement entropy
Return type:: float

exp(*index: int, **vars: Any) → None¶

Apply EXP gate with parameters on the circuit. See tensorcircuit.gates.exp_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

exp1(*index: int, **vars: Any) → None¶

Apply EXP1 gate with parameters on the circuit. See tensorcircuit.gates.exp1_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

expectation(*ops: Tuple[Node, List[int]], reuse: bool = True, noise_conf: Any | None = None, nmc: int = 1000, status: Any | None = None, **kws: Any) → Any¶

expectation_ps(x: Sequence[int] | None = None, y: Sequence[int] | None = None, z: Sequence[int] | None = None, **kws: Any) → Any[source]¶

Compute exact expectation value of Pauli string using stim’s direct calculation.

Parameters:

x (Optional[Sequence[int]], optional) – Indices for Pauli X measurements
y (Optional[Sequence[int]], optional) – Indices for Pauli Y measurements
z (Optional[Sequence[int]], optional) – Indices for Pauli Z measurements

Returns:

Expectation value

Return type:

float

expps(x: Sequence[int] | None = None, y: Sequence[int] | None = None, z: Sequence[int] | None = None, **kws: Any) → Any¶

Compute exact expectation value of Pauli string using stim’s direct calculation.

Parameters:

x (Optional[Sequence[int]], optional) – Indices for Pauli X measurements
y (Optional[Sequence[int]], optional) – Indices for Pauli Y measurements
z (Optional[Sequence[int]], optional) – Indices for Pauli Z measurements

Returns:

Expectation value

Return type:

float

fredkin(*index: int, **kws: Any) → None¶

Apply FREDKIN gate on the circuit. See tensorcircuit.gates.fredkin_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

classmethod from_cirq(qc: Any, n: int | None = None, inputs: List[float] | None = None, circuit_params: Dict[str, Any] | None = None) → AbstractCircuit¶

Import Cirq Circuit object as a tc.Circuit object.

Example:

>>> import cirq
>>> c = cirq.Circuit()
>>> q = cirq.LineQubit.range(3)
>>> c.append(cirq.H(q[0]))
>>> c.append(cirq.CNOT(q[0], q[1]))
>>> tc_c = tc.Circuit.from_cirq(c)

Parameters:

qc (cirq.Circuit) – Cirq Circuit object
n (int) – The number of qubits for the circuit
inputs (Optional[List[float]], optional) – possible input wavefunction for tc.Circuit, defaults to None
circuit_params (Optional[Dict[str, Any]]) – kwargs given in Circuit.__init__ construction function, default to None.

Returns:

The same circuit but as tensorcircuit object

Return type:

Circuit

classmethod from_json(jsonstr: str, circuit_params: Dict[str, Any] | None = None) → AbstractCircuit¶

load json str as a Circuit

Parameters:

jsonstr (str) – _description_
circuit_params (Optional[Dict[str, Any]], optional) – Extra circuit parameters in the format of __init__, defaults to None

Returns:

_description_

Return type:

AbstractCircuit

classmethod from_json_file(file: str, circuit_params: Dict[str, Any] | None = None) → AbstractCircuit¶

load json file and convert it to a circuit

Parameters:

file (str) – filename
circuit_params (Optional[Dict[str, Any]], optional) – _description_, defaults to None

Returns:

_description_

Return type:

AbstractCircuit

classmethod from_openqasm(qasmstr: str, circuit_params: Dict[str, Any] | None = None, keep_measure_order: bool = False) → AbstractCircuit¶

classmethod from_openqasm_file(file: str, circuit_params: Dict[str, Any] | None = None, keep_measure_order: bool = False) → AbstractCircuit¶

classmethod from_qir(qir: List[Dict[str, Any]], circuit_params: Dict[str, Any] | None = None, allow_channel: bool = False) → AbstractCircuit¶

Restore the circuit from the quantum intermediate representation.

Example:

>>> c = tc.Circuit(3)
>>> c.H(0)
>>> c.rx(1, theta=tc.array_to_tensor(0.7))
>>> c.exp1(0, 1, unitary=tc.gates._zz_matrix, theta=tc.array_to_tensor(-0.2), split=split)
>>> len(c)
7
>>> c.expectation((tc.gates.z(), [1]))
array(0.764842+0.j, dtype=complex64)
>>> qirs = c.to_qir()
>>>
>>> c = tc.Circuit.from_qir(qirs, circuit_params={"nqubits": 3})
>>> len(c._nodes)
7
>>> c.expectation((tc.gates.z(), [1]))
array(0.764842+0.j, dtype=complex64)

Parameters:

qir (List[Dict[str, Any]]) – The quantum intermediate representation of a circuit.
circuit_params (Optional[Dict[str, Any]]) – Extra circuit parameters.

Returns:

The circuit have same gates in the qir.

Return type:

Circuit

Import Qiskit QuantumCircuit object as a tc.Circuit object.

Example:

>>> from qiskit import QuantumCircuit
>>> qisc = QuantumCircuit(3)
>>> qisc.h(2)
>>> qisc.cswap(1, 2, 0)
>>> qisc.swap(0, 1)
>>> c = tc.Circuit.from_qiskit(qisc)

Parameters:

qc (QuantumCircuit in Qiskit) – Qiskit Circuit object
n (int) – The number of qubits for the circuit
inputs (Optional[List[float]], optional) – possible input wavefunction for tc.Circuit, defaults to None
circuit_params (Optional[Dict[str, Any]]) – kwargs given in Circuit.__init__ construction function, default to None.
binding_params (Optional[Union[Sequence[float], Dict[Any, float]]]) – (variational) parameters for the circuit. Could be either a sequence or dictionary depending on the type of parameters in the Qiskit circuit. For ParameterVectorElement use sequence. For Parameter use dictionary

Returns:

The same circuit but as tensorcircuit object

Return type:

Circuit

classmethod from_qsim_file(file: str, circuit_params: Dict[str, Any] | None = None) → AbstractCircuit¶

gate_aliases = [['cnot', 'cx'], ['fredkin', 'cswap'], ['toffoli', 'ccnot'], ['toffoli', 'ccx'], ['any', 'unitary'], ['sd', 'sdg'], ['td', 'tdg']]¶

gate_count(gate_list: str | Sequence[str] | None = None) → int¶

count the gate number of the circuit

Example:

>>> c = tc.Circuit(3)
>>> c.h(0)
>>> c.multicontrol(0, 1, 2, ctrl=[0, 1], unitary=tc.gates._x_matrix)
>>> c.toffolli(1, 2, 0)
>>> c.gate_count()
3
>>> c.gate_count(["multicontrol", "toffoli"])
2

Parameters:: gate_list (Optional[Sequence[str]], optional) – gate name or gate name list to be counted, defaults to None (counting all gates)
Returns:: the total number of all gates or gates in the gate_list
Return type:: int

gate_count_by_condition(cond_func: Callable[[Dict[str, Any]], bool]) → int¶

count the number of gates that satisfy certain condition

Example:

>>> c = tc.Circuit(3)
>>> c.x(0)
>>> c.h(0)
>>> c.multicontrol(0, 1, 2, ctrl=[0, 1], unitary=tc.gates._x_matrix)
>>> c.gate_count_by_condition(lambda qir: qir["index"] == (0, ))
2
>>> c.gate_count_by_condition(lambda qir: qir["mpo"])
1

Parameters:: cond_func (Callable[[Dict[str, Any]], bool]) – the condition for counting the gate
Returns:: the total number of all gates which satisfy the condition
Return type:: int

gate_map = {'cnot': 'CNOT', 'cz': 'CZ', 'h': 'H', 's': 'S', 'sd': 'S_DAG', 'swap': 'SWAP', 'x': 'X', 'y': 'Y', 'z': 'Z'}¶

gate_summary() → Dict[str, int]¶

return the summary dictionary on gate type - gate count pair

Returns:: the gate count dict by gate type
Return type:: Dict[str, int]

get_positional_logical_mapping() → Dict[int, int]¶

Get positional logical mapping dict based on measure instruction. This function is useful when we only measure part of the qubits in the circuit, to process the count result from partial measurement, we must be aware of the mapping, i.e. for each position in the count bitstring, what is the corresponding qubits (logical) defined on the circuit

Returns:: positional_logical_mapping
Return type:: Dict[int, int]

h(*index: int, **kws: Any) → None¶

Apply H gate on the circuit. See tensorcircuit.gates.h_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.70710677+0.j & 0.70710677+0.j\\ 0.70710677+0.j & -0.70710677+0.j \end{bmatrix}\end{split}\]

i(*index: int, **kws: Any) → None¶

Apply I gate on the circuit. See tensorcircuit.gates.i_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

initial_mapping(logical_physical_mapping: Dict[int, int], n: int | None = None, circuit_params: Dict[str, Any] | None = None) → AbstractCircuit¶

generate a new circuit with the qubit mapping given by logical_physical_mapping

Parameters:

logical_physical_mapping (Dict[int, int]) – how to map logical qubits to the physical qubits on the new circuit
n (Optional[int], optional) – number of qubit of the new circuit, can be different from the original one, defaults to None
circuit_params (Optional[Dict[str, Any]], optional) – _description_, defaults to None

Returns:

_description_

Return type:

AbstractCircuit

inputs: Any¶

inverse(circuit_params: Dict[str, Any] | None = None) → AbstractCircuit¶

inverse the circuit, return a new inversed circuit

EXAMPLE:

>>> c = tc.Circuit(2)
>>> c.H(0)
>>> c.rzz(1, 2, theta=0.8)
>>> c1 = c.inverse()

Parameters:: circuit_params (Optional[Dict[str, Any]], optional) – keywords dict for initialization the new circuit, defaults to None
Returns:: the inversed circuit
Return type:: Circuit

is_mps: bool¶

iswap(*index: int, **vars: Any) → None¶

Apply ISWAP gate with parameters on the circuit. See tensorcircuit.gates.iswap_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

measure(*index: int, with_prob: bool = False) → Any[source]¶

Measure qubits in the Z basis.

Parameters:

index (int) – Indices of the qubits to measure.
with_prob (bool, optional) – If True, returns the theoretical probability of the measurement outcome. defaults to False

Returns:

A tensor containing the measurement results. If with_prob is True, a tuple containing the results and the probability is returned.

Return type:

Tensor

measure_instruction(*index: int) → None¶

add a measurement instruction flag, no effect on numerical simulation

Parameters:: index (int) – the corresponding qubits

mid_measure(index: int, keep: int = 0) → Any¶

Perform a mid-measurement operation on a qubit on z direction. The post-selection cannot be recorded in stim.Circuit

Parameters:

index (int) – Index of the qubit to measure
keep (int, optional) – State of qubits to keep after measurement, defaults to 0 (up)

Returns:

Result of the mid-measurement operation

Return type:

Tensor

mid_measurement(index: int, keep: int = 0) → Any[source]¶

Perform a mid-measurement operation on a qubit on z direction. The post-selection cannot be recorded in stim.Circuit

Parameters:

index (int) – Index of the qubit to measure
keep (int, optional) – State of qubits to keep after measurement, defaults to 0 (up)

Returns:

Result of the mid-measurement operation

Return type:

Tensor

mpo(*index: int, **vars: Any) → None¶

Apply mpo gate in MPO format on the circuit. See tensorcircuit.gates.mpo_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

mpogates = ['multicontrol', 'mpo']¶

mr_instruction(q: int, p: float = 0.0, **kws: Any) → None¶

add a measure-reset instruction flag, no effect on numerical simulation

Parameters:: q (int) – the corresponding qubit

multicontrol(*index: int, **vars: Any) → None¶

Apply multicontrol gate in MPO format on the circuit. See tensorcircuit.gates.multicontrol_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

orx(*index: int, **vars: Any) → None¶

Apply ORX gate with parameters on the circuit. See tensorcircuit.gates.orx_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

ory(*index: int, **vars: Any) → None¶

Apply ORY gate with parameters on the circuit. See tensorcircuit.gates.ory_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

orz(*index: int, **vars: Any) → None¶

Apply ORZ gate with parameters on the circuit. See tensorcircuit.gates.orz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

ox(*index: int, **kws: Any) → None¶

Apply OX gate on the circuit. See tensorcircuit.gates.ox_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

oy(*index: int, **kws: Any) → None¶

Apply OY gate on the circuit. See tensorcircuit.gates.oy_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.+0.j & 0.-1.j & 0.+0.j & 0.+0.j\\ 0.+1.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

oz(*index: int, **kws: Any) → None¶

Apply OZ gate on the circuit. See tensorcircuit.gates.oz_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

pauli2_instruction(q1: int, q2: int, **kws: Any) → None¶: add a 2-qubit pauli instruction flag, no effect on numerical simulation

pauli_instruction(q: int, px: float | None = None, py: float | None = None, pz: float | None = None, **kws: Any) → None¶: add a pauli instruction flag, no effect on numerical simulation

phase(*index: int, **vars: Any) → None¶

Apply PHASE gate with parameters on the circuit. See tensorcircuit.gates.phase_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

post_select(index: int, keep: int = 0) → Any¶

Perform a mid-measurement operation on a qubit on z direction. The post-selection cannot be recorded in stim.Circuit

Parameters:

index (int) – Index of the qubit to measure
keep (int, optional) – State of qubits to keep after measurement, defaults to 0 (up)

Returns:

Result of the mid-measurement operation

Return type:

Tensor

post_selection(index: int, keep: int = 0) → Any¶

Perform a mid-measurement operation on a qubit on z direction. The post-selection cannot be recorded in stim.Circuit

Parameters:

index (int) – Index of the qubit to measure
keep (int, optional) – State of qubits to keep after measurement, defaults to 0 (up)

Returns:

Result of the mid-measurement operation

Return type:

Tensor

prepend(c: AbstractCircuit) → AbstractCircuit¶

prepend circuit c before

Parameters:: c (BaseCircuit) – The other circuit to be prepended
Returns:: The composed circuit
Return type:: BaseCircuit

r(*index: int, **vars: Any) → None¶

Apply R gate with parameters on the circuit. See tensorcircuit.gates.r_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

random_gate(*index: int, recorded: bool = False) → None[source]¶

Apply a random Clifford gate to the circuit. This operation will not record in qir

Parameters:

index (int) – Qubit indices to apply the gate to
recorded (bool, optional) – Whether the gate is recorded in stim.Circuit, defaults to False

reset_instruction(*index: int) → None¶

add a reset instruction flag, no effect on numerical simulation

Parameters:: index (int) – the corresponding qubits

rx(*index: int, **vars: Any) → None¶

Apply RX gate with parameters on the circuit. See tensorcircuit.gates.rx_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

rxx(*index: int, **vars: Any) → None¶

Apply RXX gate with parameters on the circuit. See tensorcircuit.gates.rxx_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

ry(*index: int, **vars: Any) → None¶

Apply RY gate with parameters on the circuit. See tensorcircuit.gates.ry_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

ryy(*index: int, **vars: Any) → None¶

Apply RYY gate with parameters on the circuit. See tensorcircuit.gates.ryy_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

rz(*index: int, **vars: Any) → None¶

Apply RZ gate with parameters on the circuit. See tensorcircuit.gates.rz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

rzm(*index: int, **vars: Any) → None¶

Apply rzm gate on the circuit using hyperedge support for digonal gates. See tensorcircuit.gates.rzm_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

rzz(*index: int, **vars: Any) → None¶

Apply RZZ gate with parameters on the circuit. See tensorcircuit.gates.rzz_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

s(*index: int, **kws: Any) → None¶

Apply S gate on the circuit. See tensorcircuit.gates.s_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & 0.+1.j \end{bmatrix}\end{split}\]

sample(batch: int | None = None, **kws: Any) → Any[source]¶

Sample measurements from the circuit.

Parameters:: batch (Optional[int], optional) – Number of samples to take, defaults to None (single sample)
Returns:: Measurement results
Return type:: Tensor

sample_detector() → Any¶: placeholder for sample detector results

sample_expectation_ps(x: Sequence[int] | None = None, y: Sequence[int] | None = None, z: Sequence[int] | None = None, shots: int | None = None, **kws: Any) → float[source]¶

Compute expectation value of Pauli string measurements.

Parameters:

x (Optional[Sequence[int]], optional) – Indices for Pauli X measurements, defaults to None
y (Optional[Sequence[int]], optional) – Indices for Pauli Y measurements, defaults to None
z (Optional[Sequence[int]], optional) – Indices for Pauli Z measurements, defaults to None
shots (Optional[int], optional) – Number of measurement shots, defaults to None

Returns:

Expectation value

Return type:

float

sd(*index: int, **kws: Any) → None¶

Apply SD gate on the circuit. See tensorcircuit.gates.sd_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & 0.-1.j \end{bmatrix}\end{split}\]

sdg(*index: int, **kws: Any) → None¶

Apply SD gate on the circuit. See tensorcircuit.gates.sd_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & 0.-1.j \end{bmatrix}\end{split}\]

select_gate(which: Any, kraus: Sequence[Gate], *index: int) → None¶

Apply which-th gate from kraus list, i.e. apply kraus[which]

Parameters:

which (Tensor) – Tensor of shape [] and dtype int
kraus (Sequence[Gate]) – A list of gate in the form of tc.gate or Tensor
index (int) – the qubit lines the gate applied on

sexpps(x: Sequence[int] | None = None, y: Sequence[int] | None = None, z: Sequence[int] | None = None, shots: int | None = None, **kws: Any) → float¶

Compute expectation value of Pauli string measurements.

Parameters:

x (Optional[Sequence[int]], optional) – Indices for Pauli X measurements, defaults to None
y (Optional[Sequence[int]], optional) – Indices for Pauli Y measurements, defaults to None
z (Optional[Sequence[int]], optional) – Indices for Pauli Z measurements, defaults to None
shots (Optional[int], optional) – Number of measurement shots, defaults to None

Returns:

Expectation value

Return type:

float

sgates = ['i', 'x', 'y', 'z', 'h', 't', 's', 'td', 'sd', 'wroot', 'cnot', 'cz', 'swap', 'cy', 'ox', 'oy', 'oz', 'toffoli', 'fredkin']¶

static standardize_gate(name: str) → str¶

standardize the gate name to tc common gate sets

Parameters:: name (str) – non-standard gate name
Returns:: the standard gate name
Return type:: str

state() → Any[source]¶: Return the wavefunction of the circuit. Note that the state can have smaller qubit count if no gate is applied on later qubits

su4(*index: int, **vars: Any) → None¶

Apply SU4 gate with parameters on the circuit. See tensorcircuit.gates.su4_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

swap(*index: int, **kws: Any) → None¶

Apply SWAP gate on the circuit. See tensorcircuit.gates.swap_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \end{bmatrix}\end{split}\]

t(*index: int, **kws: Any) → None¶

Apply T gate on the circuit. See tensorcircuit.gates.t_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1. & +0.j & 0. & +0.j\\ 0. & +0.j & 0.70710677+0.70710677j \end{bmatrix}\end{split}\]

tableau_gate(*index: int, tableau: Any, recorded: bool = False) → None[source]¶

Apply a gate indicated by tableau to the circuit. This operation will not record in qir

Parameters:

index (int) – Qubit indices to apply the gate to
tableau (Any) – stim.Tableau representation of the gate
recorded (bool, optional) – Whether the gate is recorded in stim.Circuit, defaults to False

td(*index: int, **kws: Any) → None¶

Apply TD gate on the circuit. See tensorcircuit.gates.td_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1. & +0.j & 0. & +0.j\\ 0. & +0.j & 0.70710677-0.70710677j \end{bmatrix}\end{split}\]

tdg(*index: int, **kws: Any) → None¶

Apply TD gate on the circuit. See tensorcircuit.gates.td_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1. & +0.j & 0. & +0.j\\ 0. & +0.j & 0.70710677-0.70710677j \end{bmatrix}\end{split}\]

tex(**kws: Any) → str¶

Generate latex string based on quantikz latex package

Returns:: Latex string that can be directly compiled via, e.g. latexit
Return type:: str

to_cirq(enable_instruction: bool = False) → Any¶

Translate tc.Circuit to a cirq circuit object.

Parameters:: enable_instruction (bool, defaults to False) – whether also export measurement and reset instructions
Returns:: A cirq circuit of this circuit.

to_json(file: str | None = None, simplified: bool = False) → Any¶

circuit dumps to json

Parameters:

file (Optional[str], optional) – file str to dump the json to, defaults to None, return the json str
simplified (bool) – If False, keep all info for each gate, defaults to be False. If True, suitable for IO since less information is required

Returns:

None if dumps to file otherwise the json str

Return type:

Any

to_openqasm(**kws: Any) → str¶

transform circuit to openqasm via qiskit circuit, see https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.qasm.html for usage on possible options for kws

Returns:: circuit representation in openqasm format
Return type:: str

to_openqasm_file(file: str, **kws: Any) → None¶

save the circuit to openqasm file

Parameters:: file (str) – the file path to save the circuit

to_qir() → List[Dict[str, Any]]¶

Return the quantum intermediate representation of the circuit.

Example:

>>> c = tc.Circuit(2)
>>> c.CNOT(0, 1)
>>> c.to_qir()
[{'gatef': cnot, 'gate': Gate(
    name: 'cnot',
    tensor:
        array([[[[1.+0.j, 0.+0.j],
                [0.+0.j, 0.+0.j]],

                [[0.+0.j, 1.+0.j],
                [0.+0.j, 0.+0.j]]],


            [[[0.+0.j, 0.+0.j],
                [0.+0.j, 1.+0.j]],

                [[0.+0.j, 0.+0.j],
                [1.+0.j, 0.+0.j]]]], dtype=complex64),
    edges: [
        Edge(Dangling Edge)[0],
        Edge(Dangling Edge)[1],
        Edge('cnot'[2] -> 'qb-1'[0] ),
        Edge('cnot'[3] -> 'qb-2'[0] )
    ]), 'index': (0, 1), 'name': 'cnot', 'split': None, 'mpo': False}]

Returns:: The quantum intermediate representation of the circuit.
Return type:: List[Dict[str, Any]]

to_qiskit(enable_instruction: bool = False, enable_inputs: bool = False) → Any¶

Translate tc.Circuit to a qiskit QuantumCircuit object.

Parameters:

enable_instruction (bool, defaults to False) – whether also export measurement and reset instructions
enable_inputs (bool, defaults to False) – whether also export the inputs

Returns:

A qiskit object of this circuit.

toffoli(*index: int, **kws: Any) → None¶

Apply TOFFOLI gate on the circuit. See tensorcircuit.gates.toffoli_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

u(*index: int, **vars: Any) → None¶

Apply U gate with parameters on the circuit. See tensorcircuit.gates.u_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

unitary(*index: int, **vars: Any) → None¶

Apply ANY gate with parameters on the circuit. See tensorcircuit.gates.any_gate().

Parameters:

index (int.) – Qubit number that the gate applies on.
vars (float.) – Parameters for the gate.

vgates = ['r', 'cr', 'u', 'cu', 'rx', 'ry', 'rz', 'phase', 'rxx', 'ryy', 'rzz', 'cphase', 'crx', 'cry', 'crz', 'orx', 'ory', 'orz', 'iswap', 'any', 'exp', 'exp1', 'su4']¶

vis_tex(**kws: Any) → str¶

Generate latex string based on quantikz latex package

Returns:: Latex string that can be directly compiled via, e.g. latexit
Return type:: str

wroot(*index: int, **kws: Any) → None¶

Apply WROOT gate on the circuit. See tensorcircuit.gates.wroot_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.70710677+0.j & -0.5 & -0.5j\\ 0.5 & -0.5j & 0.70710677+0.j \end{bmatrix}\end{split}\]

x(*index: int, **kws: Any) → None¶

Apply X gate on the circuit. See tensorcircuit.gates.x_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.+0.j & 1.+0.j\\ 1.+0.j & 0.+0.j \end{bmatrix}\end{split}\]

y(*index: int, **kws: Any) → None¶

Apply Y gate on the circuit. See tensorcircuit.gates.y_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 0.+0.j & 0.-1.j\\ 0.+1.j & 0.+0.j \end{bmatrix}\end{split}\]

z(*index: int, **kws: Any) → None¶

Apply Z gate on the circuit. See tensorcircuit.gates.z_gate().

Parameters:

index (int.) –

Qubit number that the gate applies on. The matrix for the gate is

\[\begin{split}\begin{bmatrix} 1.+0.j & 0.+0.j\\ 0.+0.j & -1.+0.j \end{bmatrix}\end{split}\]