cirq_superstaq.ops

Submodules

Attributes

`AQTICCX`
`AQTITOFFOLI`
`AceCRMinusPlus`
`AceCRPlusMinus`
`BSWAP`
`BSWAP_INV`
`CR`
`CZ3`
`CZ3_INV`
`DD`
`QutritZ0`
`QutritZ1`
`QutritZ2`
`SWAP3`
`ZX`

Classes

`AceCR`	Active Cancellation Echoed Cross Resonance (AceCR) gate, parametrized (e.g., supporting
`BSwapPowGate`	iSWAP-like qutrit entangling gate swapping the "11" and "22" states of two qutrits.
`Barrier`	A temporal boundary restricting circuit compilation and pulse scheduling.
`DDPowGate`	The Dipole-Dipole gate for EeroQ hardware.
`MovementGate`	A gate to represent qubit shuttling.
`ParallelGates`	A single gate combining a collection of concurrent gate(s) acting on different qubits.
`ParallelRGate`	Wrapper class to define a ParallelGate of identical RGate gates.
`PermutationGate`	Extension of cirq.QubitPermutationGate to support qudits of arbitrary dimension.
`QubitSubspaceGate`	Embeds an n-qubit (i.e. SU(2^n)) gate into a given subspace of a higher-dimensional gate.
`QuditSwapGate`	A (non-parametrized) SWAP gate on two qudits of arbitrary dimension.
`QutritCZPowGate`	Generalized CZ gate for pairs of equal-dimension qudits.
`QutritZ0PowGate`	Phase rotation on the ground state of a qutrit.
`QutritZ1PowGate`	Phase rotation on the first excited state of a qutrit.
`QutritZ2PowGate`	Phase rotation on the second excited state of a qutrit.
`RGate`	A single-qubit gate that rotates about an axis in the X-Y plane.
`StrippedCZGate`	The Stripped CZ gate is a regular CZ gate when the rz angle = 0.
`VirtualZPowGate`	Applies a phase rotation between two successive energy levels of a qudit.
`ZXPowGate`	The ZX-parity gate, possibly raised to a power.
`ZZSwapGate`	The ZZ-SWAP gate, which performs the ZZ-interaction followed by a SWAP.

Functions

`approx_eq_mod`(→ bool)	Check if a ~= b (mod period). If either input is an unresolved parameter, returns a == b.
`barrier`(→ cirq.Operation)	Equivalent to https://qiskit.org/documentation/stubs/qiskit.circuit.library.Barrier.html.
`movement_op`(→ cirq.Operation)	Construct a MovementGate operation implementing the given moves.
`parallel_gates_operation`(→ cirq.Operation)	Constructs a parallel gates operation.
`qubit_subspace_op`(→ cirq.Operation)	Embeds a qubit Operation into a given subspace of a higher-dimensional Operation.
`qudit_swap_op`(→ cirq.Operation)	Construct a SWAP gate and apply it to the provided qudits.

Package Contents

class cirq_superstaq.ops.AceCR(rads: str | cirq.TParamVal = np.pi / 2, sandwich_rx_rads: cirq.TParamVal = 0)

Bases: cirq.Gate

Active Cancellation Echoed Cross Resonance (AceCR) gate, parametrized (e.g., supporting polarity switches) and supporting sandwiches.

The typical AceCR in literature is a positive half-CR, then X on “Z side”, then negative half-CR (“Z side” and “X side” refer to the two sides of the underlying ZX interactions).

rads

sandwich_rx_rads = 0

class cirq_superstaq.ops.BSwapPowGate(*, exponent: cirq.value.TParamVal = 1.0, global_shift: float = 0.0)

Bases: cirq.EigenGate, cirq.InterchangeableQubitsGate

iSWAP-like qutrit entangling gate swapping the “11” and “22” states of two qutrits.

property dimension: int

Indicates that this gate acts on qutrits.

Returns:: The integer 3, representing the qudit dimension for qutrits.

class cirq_superstaq.ops.Barrier(num_qubits: int | None = None, qid_shape: tuple[int, Ellipsis] | None = None)

Bases: cirq.ops.IdentityGate, cirq.InterchangeableQubitsGate

A temporal boundary restricting circuit compilation and pulse scheduling.

Otherwise equivalent to the identity gate.

class cirq_superstaq.ops.DDPowGate(*, exponent: cirq.value.TParamVal = 1.0, global_shift: float = 0.0)

Bases: cirq.EigenGate

The Dipole-Dipole gate for EeroQ hardware.

class cirq_superstaq.ops.MovementGate(moves: collections.abc.Mapping[int, int], dimension: int = 2)

Bases: PermutationGate

A gate to represent qubit shuttling.

Mostly just a wrapper for a permutation gate, but doesn’t require destinations for empty sites.

property complete_map: dict[int, int]

A complete (one-to-one and onto) initial-to-final map, including “moves” of empty sites.

Note this is not always unique.

property moves: dict[int, int]

class cirq_superstaq.ops.ParallelGates(*component_gates: cirq.Gate)

Bases: cirq.Gate, cirq.InterchangeableQubitsGate

A single gate combining a collection of concurrent gate(s) acting on different qubits.

qubit_index_to_equivalence_group_key(index: int) → int

Returns a key that differs between qubits.

Does it by different component gates and non-interchangeable qubits in the same component gate.

Parameters:: index – The qubit index.
Returns:: Equivalence group key.

qubit_index_to_gate_and_index(index: int) → tuple[cirq.Gate, int]

Gets gate (and index) for the corresponding index.

Parameters:: index – The index into a particular member of the ParallelGates operation.
Returns:: A tuple of the gate at the given index and the index itself.
Raises:: ValueError – If index is outside bounds of gate index range.

component_gates: tuple[cirq.Gate, Ellipsis] = ()

class cirq_superstaq.ops.ParallelRGate(theta: cirq.TParamVal, phi: cirq.TParamVal, num_copies: int)

Bases: cirq.ParallelGate, cirq.InterchangeableQubitsGate

Wrapper class to define a ParallelGate of identical RGate gates.

property exponent: cirq.TParamVal

The exponent property of ParallelRGate.

Returns:: The sub gate exponent.

property phase_exponent: cirq.TParamVal

The phase_exponent property of each RGate.

Returns:: The phase exponent.

property phi: cirq.TParamVal

The phi property of ParallelRGate, defining orientation (i.e., axis of rotation).

Returns:: The rotation-axis angle phi.

property sub_gate: RGate

The gate that is applied to the specified subspace.

Returns:: The underlying gate used.

property theta: cirq.TParamVal

The theta property of ParallelRGate, angle to rotate about the phi-determined axis.

Returns:: The rotation angle theta.

class cirq_superstaq.ops.PermutationGate(permutation: collections.abc.Sequence[int], dimension: int = 2)

Bases: cirq.QubitPermutationGate

Extension of cirq.QubitPermutationGate to support qudits of arbitrary dimension.

property dimension: int

class cirq_superstaq.ops.QubitSubspaceGate(sub_gate: cirq.Gate, qid_shape: collections.abc.Sequence[int], subspaces: collections.abc.Sequence[tuple[int, int]] | None = None)

Bases: cirq.Gate, cirq.InterchangeableQubitsGate

Embeds an n-qubit (i.e. SU(2^n)) gate into a given subspace of a higher-dimensional gate.

qubit_index_to_equivalence_group_key(index: int) → int

Check for interchangeable qubits.

Any interchangeable qubits in sub_gate will remain interchangeable in this gate if they have the same dimension and subspace.

property qid_shape: tuple[int, Ellipsis]

Specifies the qudit dimension for each of the inputs.

Returns:: The dimensions for the input qudits.

property sub_gate: cirq.Gate

The gate that is applied to the specified subspace.

Returns:: The underlying gate used.

property subspaces: list[tuple[int, int]]

A list of subspace indices acted upon.

For instance, a CX on the 0-1 qubit subspace of two qudits would have subspaces of [(0, 1), (0, 1)]. The same gate acting on the 1-2 subspaces of both qudits would correspond to [(1, 2), (1, 2)].

Returns:: A list of dimensions tuples, specified for each subspace.

class cirq_superstaq.ops.QuditSwapGate(dimension: int)

Bases: cirq.Gate, cirq.InterchangeableQubitsGate

A (non-parametrized) SWAP gate on two qudits of arbitrary dimension.

property dimension: int

The qudit dimension on which this SWAP gate will act.

Returns:: The qudit dimension.

class cirq_superstaq.ops.QutritCZPowGate(*, exponent: cirq.value.TParamVal = 1.0, global_shift: float = 0.0)

Bases: cirq.EigenGate, cirq.InterchangeableQubitsGate

Generalized CZ gate for pairs of equal-dimension qudits.

It is defined by the following unitary:

U = Σ_(i<d,j<d) ω**ij.|i⟩⟨i|.|j⟩⟨j|,

where d is the dimension of the qudits and ω = exp(2πi/d).

Currently written for qutrits (d = 3), but its implementation should work for any dimension.

property dimension: int

Indicates that this gate acts on qutrits.

Returns:: The integer 3, representing the qudit dimension for qutrits.

class cirq_superstaq.ops.QutritZ0PowGate(*, exponent: cirq.value.TParamVal = 1.0, global_shift: float = 0.0)

Bases: _QutritZPowGate

Phase rotation on the ground state of a qutrit.

class cirq_superstaq.ops.QutritZ1PowGate(*, exponent: cirq.value.TParamVal = 1.0, global_shift: float = 0.0)

Bases: _QutritZPowGate

Phase rotation on the first excited state of a qutrit.

class cirq_superstaq.ops.QutritZ2PowGate(*, exponent: cirq.value.TParamVal = 1.0, global_shift: float = 0.0)

Bases: _QutritZPowGate

Phase rotation on the second excited state of a qutrit.

class cirq_superstaq.ops.RGate(theta: cirq.TParamVal, phi: cirq.TParamVal)

Bases: cirq.PhasedXPowGate

A single-qubit gate that rotates about an axis in the X-Y plane.

property phi: cirq.TParamVal

Angle (in radians) defining the axis of rotation in the X-Y plane.

Returns:: The phi rotation angle.

property theta: cirq.TParamVal

Angle (in radians) by which to rotate about the axis given by self.phi.

Returns:: The theta rotation angle.

class cirq_superstaq.ops.StrippedCZGate(rz_rads: cirq.TParamVal = 0)

Bases: cirq.Gate

The Stripped CZ gate is a regular CZ gate when the rz angle = 0.

It is the gate that is actually being performed by Sqale, and it is corrected into a CZ gate by RZ gates afterwards if the rz angle is nonzero.

property rz_rads: cirq.TParamVal

The RZ-rotation angle in radians for the gate.

Returns:: The angle for the RZ rotation.

class cirq_superstaq.ops.VirtualZPowGate(dimension: int = 2, level: int = 1, exponent: cirq.TParamVal = 1.0, global_shift: float = 0.0)

Bases: cirq.EigenGate

Applies a phase rotation between two successive energy levels of a qudit.

property dimension: int

The qudit dimension on which this gate acts.

Returns:: The gate’s dimension.

property level: int

The lowest energy level onto which this gate applies a phase; for example if level=2 a phase of (-1)**exponent will be applied to energy levels [2, …, dimension - 1]. This is equivalent to phase shifting all subsequent single-qudit gates acting in the (1, 2) subspace (assuming all other gates commute with this one).

Returns:: The lowest energy level onto which this gate applies a phase.

class cirq_superstaq.ops.ZXPowGate(*, exponent: cirq.value.TParamVal = 1.0, global_shift: float = 0.0)

Bases: cirq.EigenGate

The ZX-parity gate, possibly raised to a power.

Per arxiv.org/pdf/1904.06560v3 eq. 135, the ZX**t gate implements the following unitary:

\[\begin{split}e^{-\frac{i\pi}{2} t Z \otimes X} = \begin{bmatrix} c & -s & . & . \\ -s & c & . & . \\ . & . & c & s \\ . & . & s & c \\ \end{bmatrix}\end{split}\]

where ‘.’ means ‘0’ and \(c = \cos(\frac{\pi t}{2})\) and \(s = i \sin(\frac{\pi t}{2})\).

class cirq_superstaq.ops.ZZSwapGate(theta: cirq.TParamVal)

Bases: cirq.Gate, cirq.ops.gate_features.InterchangeableQubitsGate

The ZZ-SWAP gate, which performs the ZZ-interaction followed by a SWAP.

ZZ-SWAPs are useful for applications like QAOA or Hamiltonian Simulation, particularly on linear- or low- connectivity devices. See https://arxiv.org/pdf/2004.14970.pdf for an application of ZZ SWAP networks.

The unitary for a ZZ-SWAP gate parametrized by ZZ-interaction angle \(\theta\) is:

\[\begin{split}\begin{bmatrix} 1 & . & . & . \\ . & . & e^{i \theta} & . \\ . & e^{i \theta} & . & . \\ . & . & . & 1 \\ \end{bmatrix}\end{split}\]

where ‘.’ means ‘0’. For \(\theta = 0\), the ZZ-SWAP gate is just an ordinary SWAP.

theta

cirq_superstaq.ops.approx_eq_mod(a: cirq.TParamVal, b: cirq.TParamVal, period: float, atol: float = 1e-08) → bool

Check if a ~= b (mod period). If either input is an unresolved parameter, returns a == b.

Parameters:

a – A Cirq parameter value.
b – A Cirq parameter value.
period – The parameter period (i.e., cycle time).
atol – The absolute tolerance for equality checking.

Returns:

A boolean indicating whether input parameters are approximately equal.

cirq_superstaq.ops.barrier(*qubits: cirq.Qid) → cirq.Operation

Equivalent to https://qiskit.org/documentation/stubs/qiskit.circuit.library.Barrier.html.

Parameters:: qubits – The qubits that the barrier will cover.
Returns:: A barrier cirq.Operation on the provided qubits.

cirq_superstaq.ops.movement_op(moves: collections.abc.Mapping[cirq.Qid, cirq.Qid]) → cirq.Operation

Construct a MovementGate operation implementing the given moves.

Parameters:: moves – A dictionary mapping initial qubit positions to their destinations. For example, moves={q0: q1, q1: q2} indicates a shift of two qubits (initially q0 and q1) by one step (to positions q1 and q2). In this case q2 (absent from moves.keys()) is assumed to be an empty site at the start of the operation, and q0 (absent from moves.values()) will be empty after the move.
Returns:: A MovementGate operation implementing the indicated move.

cirq_superstaq.ops.parallel_gates_operation(*ops: cirq.Operation) → cirq.Operation

Constructs a parallel gates operation.

Given operations acting on disjoint qubits, constructs a single cirq_superstaq.ParallelGates instance and applies it such that each operation’s .gate is applied to its .qubits.

Parameters:

ops – Operations to pack into a single ParallelGates operation.

Returns:

ParallelGates(op.gate, op2.gate, …).on(*op.qubits, *op2.qubits, …)

Raises:

ValueError – If the operation has no .gate attribute.
ValueError – If the operation has tags.

cirq_superstaq.ops.qubit_subspace_op(sub_op: cirq.Operation, qid_shape: collections.abc.Sequence[int], subspaces: collections.abc.Sequence[tuple[int, int]] | None = None) → cirq.Operation

Embeds a qubit Operation into a given subspace of a higher-dimensional Operation.

Uses QubitSubspaceGate.

Parameters:

sub_op – The cirq.Operation to embed.
qid_shape – The dimensions of the subspace.
subspaces – The list of all subspaces.

Returns:

A cirq.Operation embedding a low-dimensional operation.

Raises:

ValueError – If there is no gate specified for the subspace operation.

cirq_superstaq.ops.qudit_swap_op(qudit0: cirq.Qid, qudit1: cirq.Qid) → cirq.Operation

Construct a SWAP gate and apply it to the provided qudits.

If both qudits have dimension 2, uses cirq.SWAP; otherwise uses QuditSwapGate.

Parameters:

qudit0 – The first qudit to swap.
qudit1 – The second qudit to swap.

Returns:

A SWAP gate acting on the provided qudits.

Raises:

ValueError – If the input qudits don’t have the same dimension.

cirq_superstaq.ops.AQTICCX

cirq_superstaq.ops.AQTITOFFOLI

cirq_superstaq.ops.AceCRMinusPlus

cirq_superstaq.ops.AceCRPlusMinus

cirq_superstaq.ops.BSWAP

cirq_superstaq.ops.BSWAP_INV

cirq_superstaq.ops.CR

cirq_superstaq.ops.CZ3

cirq_superstaq.ops.CZ3_INV

cirq_superstaq.ops.DD

cirq_superstaq.ops.QutritZ0

cirq_superstaq.ops.QutritZ1

cirq_superstaq.ops.QutritZ2

cirq_superstaq.ops.SWAP3

cirq_superstaq.ops.ZX