tensorcircuit.u1circuit¶

Circuit class for U(1) conserving circuits.

class tensorcircuit.u1circuit.U1Circuit(nqubits: int, k: int | None = None, filled: Sequence[int] | None = None, inputs: Any | None = None)[source]¶

Bases: AbstractCircuit

Circuit class for U(1) conserving circuits (particle number conservation). The simulation is performed entirely within the compressed U(1) subspace, enabling efficient simulation of systems where the total number of excitations is preserved.

Note: Supports up to 64 qubits by utilizing 64-bit integer bitmasks for basis state representation.

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, k: int | None = None, filled: Sequence[int] | None = None, inputs: Any | None = None) → None[source]¶

Initialize a U(1) conserving circuit.

Parameters:

nqubits (int) – Number of qubits in the circuit.
k (Optional[int], defaults to None) – Total number of excitations (particles) to preserve. If None, it is inferred from the length of filled.
filled (Optional[Sequence[int]], defaults to None) – Initial indices of qubits that are occupied (|1> state). If provided and inputs is None, the initial state is set to this computational basis state.
inputs (Optional[Any], defaults to None) – Initial state vector already defined in the U(1) subspace. If provided, must have shape (comb(nqubits, k),).

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]]) → 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.

apply_general_gate(gate: Any, *index: int, name: str | None = None, split: Dict[str, Any] | None = None, mpo: bool = False, diagonal: bool = False, ir_dict: Dict[str, Any] | None = None, **kwargs: Any) → None[source]¶

Apply a gate by name. Called by _meta_apply generated methods.

Parameters:

gate – Gate tensor (ignored, dispatch is by name)
index – Qubit indices
name – Gate name (rz, rzz, cz, cphase, swap, iswap)
split – Split configuration (ignored in U1Circuit)
mpo – MPO flag (ignored in U1Circuit)
diagonal – Diagonal flag (ignored in U1Circuit)
ir_dict – QIR dictionary for recording
kwargs – Extra parameters

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]¶

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¶

Measurement on z basis at index qubit based on quantum amplitude (not post-selection). The highlight is that this method can return the measured result as a int Tensor and thus maintained a jittable pipeline.

Example:

>>> c = tc.Circuit(2)
>>> c.H(0)
>>> r = c.cond_measurement(0)
>>> c.conditional_gate(r, [tc.gates.i(), tc.gates.x()], 1)
>>> c.expectation([tc.gates.z(), [0]]), c.expectation([tc.gates.z(), [1]])
# two possible outputs: (1, 1) or (-1, -1)

Note

In terms of DMCircuit, this method returns nothing and the density matrix after this method is kept in mixed state without knowing the measuremet resuslts

Parameters:: index (int) – the qubit for the z-basis measurement
Returns:: 0 or 1 for z measurement on up and down freedom
Return type:: Tensor

cond_measurement(index: int) → Any¶

Example:

>>> c = tc.Circuit(2)
>>> c.H(0)
>>> r = c.cond_measurement(0)
>>> c.conditional_gate(r, [tc.gates.i(), tc.gates.x()], 1)
>>> c.expectation([tc.gates.z(), [0]]), c.expectation([tc.gates.z(), [1]])
# two possible outputs: (1, 1) or (-1, -1)

Note

In terms of DMCircuit, this method returns nothing and the density matrix after this method is kept in mixed state without knowing the measuremet resuslts

Parameters:: index (int) – the qubit for the z-basis measurement
Returns:: 0 or 1 for z measurement on up and down freedom
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.

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

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(subsystem_to_keep: Sequence[int] | None = None, subsystem_to_traceout: Sequence[int] | None = None) → Any[source]¶

Compute the von Neumann entanglement entropy for the specified qubits.

Parameters:

subsystem_to_keep (Sequence[int], optional) – The qubits to keep.
subsystem_to_traceout (Sequence[int], optional) – The qubits to trace out.

Returns:

Entanglement entropy.

Return type:

Tensor

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: Any, **kws: Any) → Any[source]¶

Compute expectation value of operators.

Currently only supports single Z operator via expectation_z. For general operators, please use expectation_ps.

Parameters:: ops – Operator specification
Returns:: Expectation value

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

Compute expectation value of a Pauli string.

Parameters:

x – Qubit indices for X operators
y – Qubit indices for Y operators
z – Qubit indices for Z operators
ps – Alternative Pauli string specification (0=I, 1=X, 2=Y, 3=Z)

Returns:

Expectation value <P>

expectation_z(i: int) → Any[source]¶

Compute expectation value of Z operator on qubit i.

Parameters:: i – Qubit index
Returns:: Expectation value <Z_i>

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) → 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_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, status: Any | None = None) → Tuple[Any, Any][source]¶

Measure specific qubits in the computational basis.

This is a simplified measurement that samples from the full state and returns the values at the specified qubit indices.

Parameters:

index (int) – Qubit indices to measure
with_prob (bool, optional) – If true, return the probability of the outcome
status (Optional[Tensor]) – External randomness tensor, shape [1]

Returns:

Tuple of (measurement outcomes tensor, probability or -1.0)

Return type:

Tuple[Tensor, Any]

measure_instruction(*index: int) → None¶

add a measurement instruction flag, no effect on numerical simulation

Parameters:: index (int) – the corresponding qubits

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']¶

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

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.

prepend(c: AbstractCircuit) → AbstractCircuit¶

prepend circuit c before

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

probability() → Any[source]¶

Get the probability vector over the U(1) conserved basis states.

Returns:: Probability vector of shape [dim] where dim = C(n, k)
Return type:: Tensor

probability_full() → Any[source]¶

Get the probability vector over the full 2^n computational basis.

Returns:: Probability vector of shape [2^nqubits]
Return type:: Tensor

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.

reduced_density_matrix(subsystem_to_keep: Sequence[int] | None = None, subsystem_to_traceout: Sequence[int] | None = None, return_blocks: bool = False) → Any[source]¶

Compute the reduced density matrix for the specified qubits.

Parameters:

subsystem_to_keep (Sequence[int], optional) – The qubits to keep (all others are traced out).
subsystem_to_traceout (Sequence[int], optional) – The qubits to trace out.
return_blocks (bool) – If true, return a list of RDM blocks for each k_A.

Returns:

The reduced density matrix or a list of blocks.

Return type:

Any

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, allow_state: bool = True, format: str | None = None, random_generator: Any | None = None, status: Any | None = None, jittable: bool = True) → Any[source]¶

Sample from the U(1) circuit state.

Parameters:

batch (Optional[int], optional) – Number of samples, defaults to None (single sample)
allow_state (bool, optional) – If true, sample from the state vector directly
format (Optional[str]) – Sample format. Options: - None: returns list of (binary_config_tensor, probability) tuples - “sample_int”: np.array of integer samples - “sample_bin”: list of binary arrays - “count_vector”: count vector over full basis - “count_tuple”: (unique_values, counts) - “count_dict_bin”: {“01..”: count, …} - “count_dict_int”: {int: count, …}
format – alias for the argument format
random_generator (Optional[Any], optional) – Random generator, defaults to None
status (Optional[Tensor]) – External randomness tensor uniformly from [0, 1], shape [batch]
jittable (bool) – Keep full size for jit compatibility, defaults to True

Returns:

Samples in the specified format

Return type:

Any

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

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 state vector in the U(1) conserved subspace.

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}\]

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_dense() → Any[source]¶

Convert the U(1) conserved state to the full 2^n Hilbert space.

Returns a state vector of shape [2^nqubits] where non-zero amplitudes appear only at positions corresponding to basis states with exactly k filled qubits.

Returns:: State vector in full Hilbert space
Return type:: Tensor

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

wavefunction() → Any[source]¶: Return the state vector in the U(1) conserved subspace.

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}\]