Gates¶

Standard gates ¶

In QuantumFlow a gate is a unitary operator acting on a specific collection of qubits. A standard gate (subclasses of StdGate) are gates with a name, with zero or more parameters, acting on a fixed number of qubits.

class quantumflow.StdGate(qubits: Sequence[Qubit], params: Sequence[float | Expr] | None = None)¶

A standard gate. Standard gates have a name, a fixed number of real parameters, and act upon a fixed number of qubits.

e.g. Rx(theta, q0), CNot(q0, q1), Can(tx, ty, tz, q0, q1, q2)

In the argument list, parameters are first, then qubits. Parameters have type Variable (either a concrete floating point number, or a symbolic expression), and qubits have type Qubit (Any hashable python type).

Standard one-qubit gates ¶

class quantumflow.I(q0: Qubit)¶: The 1-qubit identity gate.

\[\begin{split}I() \equiv \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix}\end{split}\]

class quantumflow.X(q0: Qubit)¶: A 1-qubit Pauli-X gate.

\[\begin{split}X() &\equiv \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\end{split}\]

class quantumflow.Y(q0: Qubit)¶

A 1-qubit Pauli-Y gate.

\[\begin{split}Y() &\equiv \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}\end{split}\]

mnemonic: “Minus eye high”.

class quantumflow.Z(q0: Qubit)¶: A 1-qubit Pauli-Z gate.

\[\begin{split}Z() &\equiv \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}\end{split}\]

class quantumflow.H(q0: Qubit)¶: A 1-qubit Hadamard gate.

\[\begin{split}H() \equiv \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}\end{split}\]

class quantumflow.S(q0: Qubit)¶: A 1-qubit phase S gate, equivalent to Z ** (1/2). The square root of the Z gate. Also sometimes denoted as the P gate.

\[\begin{split}S() \equiv \begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix}\end{split}\]

class quantumflow.T(q0: Qubit)¶: A 1-qubit T (pi/8) gate, equivalent to X ** (1/4). The forth root of the Z gate (up to global phase).

\[\begin{split}\begin{pmatrix} 1 & 0 \\ 0 & e^{i \pi / 4} \end{pmatrix}\end{split}\]

class quantumflow.PhaseShift(theta: float | Expr, q0: Qubit)¶: A 1-qubit parametric phase shift gate. Equivalent to Rz up to a global phase.

\[\begin{split}\text{PhaseShift}(\theta) \equiv \begin{pmatrix} 1 & 0 \\ 0 & e^{i \theta} \end{pmatrix}\end{split}\]

class quantumflow.Rx(theta: float | Expr, q0: Qubit)¶

A 1-qubit Pauli-X parametric rotation gate.

\[\begin{split}R_x(\theta) = \begin{bmatrix*}[r] \cos(\half\theta) & -i \sin(\half\theta) \\ -i \sin(\half\theta) & \cos(\half\theta) \end{bmatrix*}\end{split}\]

Parameters:: theta – Angle of rotation in Bloch sphere

class quantumflow.Ry(theta: float | Expr, q0: Qubit)¶

A 1-qubit Pauli-Y parametric rotation gate

\[\begin{split}R_y(\theta) = \begin{bmatrix*}[r] \cos(\half\theta) & -\sin(\half\theta) \\ \sin(\half\theta) & \cos(\half\theta) \end{bmatrix*}\end{split}\]

Parameters:: theta – Angle of rotation in Bloch sphere

class quantumflow.Rz(theta: float | Expr, q0: Qubit)¶

A 1-qubit Pauli-X parametric rotation gate

\[\begin{split}R_z(\theta) = \begin{bmatrix*} e^{-i\half\theta} & 0 \\ 0 & e^{+i\half\theta} \end{bmatrix*}\end{split}\]

Parameters:: theta – Angle of rotation in Bloch sphere

class quantumflow.Ph(phi: float | Expr, q0: Qubit)¶

Apply a global phase shift of exp(i phi).

Since this gate applies a global phase it technically doesn’t need to specify qubits at all. But we instead anchor the gate to 1 specific qubit so that we can keep track of the phase as we manipulate gates, circuits, and DAGCircuits.

We generally don’t actually care about the global phase, since it has no physical meaning, although it does matter when constructing controlled gates.

\[\begin{split}\operatorname{Ph}(\phi) \equiv \begin{pmatrix} e^{i \phi}& 0 \\ 0 & e^{i \phi} \end{pmatrix}\end{split}\]

Standard two-qubit gates ¶

class quantumflow.CZ(q0: Qubit, q1: Qubit)¶

A controlled-Z gate

Equivalent to controlled_gate(Z()) and locally equivalent to Can(1/2, 0, 0)

\[\begin{split}\text{CZ}() = \begin{pmatrix} 1&0&0&0 \\ 0&1&0&0 \\ 0&0&1&0 \\ 0&0&0&-1 \end{pmatrix}\end{split}\]

class quantumflow.CNot(q0: Qubit, q1: Qubit)¶

A controlled-not gate

Equivalent to controlled_gate(X()), and locally equivalent to Can(1/2, 0, 0)

\[\begin{split}\text{CNot}() \equiv \begin{pmatrix} 1&0&0&0 \\ 0&1&0&0 \\ 0&0&0&1 \\ 0&0&1&0 \end{pmatrix}\end{split}\]

class quantumflow.Swap(q0: Qubit, q1: Qubit)¶

A 2-qubit swap gate

Equivalent to Can(1/2, 1/2, 1/2).

\[\begin{split}\text{SWAP}() \equiv \begin{pmatrix} 1&0&0&0 \\ 0&0&1&0 \\ 0&1&0&0 \\ 0&0&0&1 \end{pmatrix}\end{split}\]

class quantumflow.ISwap(q0: Qubit, q1: Qubit)¶

A 2-qubit iSwap gate

Equivalent to Can(-1/2,-1/2,0).

\[\begin{split}\text{ISWAP}() \equiv \begin{pmatrix} 1&0&0&0 \\ 0&0&i&0 \\ 0&i&0&0 \\ 0&0&0&1 \end{pmatrix}\end{split}\]

class quantumflow.CPhase00(theta: float | Expr, q0: Qubit = 0, q1: Qubit = 1)¶: A 2-qubit 00 phase-shift gate

\[\text{CPhase00}(\theta) \equiv \text{diag}(e^{i \theta}, 1, 1, 1)\]

class quantumflow.CPhase01(theta: float | Expr, q0: Qubit = 0, q1: Qubit = 1)¶: A 2-qubit 01 phase-shift gate

\[\text{CPhase01}(\theta) \equiv \text{diag}(1, e^{i \theta}, 1, 1)\]

class quantumflow.CPhase10(theta: float | Expr, q0: Qubit = 0, q1: Qubit = 1)¶: A 2-qubit 10 phase-shift gate

\[\text{CPhase10}(\theta) \equiv \text{diag}(1, 1, e^{i \theta}, 1)\]

class quantumflow.CPhase(theta: float | Expr, q0: Qubit = 0, q1: Qubit = 1)¶: A 2-qubit 11 phase-shift gate

\[\text{CPhase}(\theta) \equiv \text{diag}(1, 1, 1, e^{i \theta})\]

class quantumflow.PSwap(theta: float | Expr, q0: Qubit = 0, q1: Qubit = 1)¶

A 2-qubit parametric-swap gate, as defined by Quil. Interpolates between SWAP (theta=0) and iSWAP (theta=pi/2).

Locally equivalent to CAN(1/2, 1/2, 1/2 - theta/pi)

\[\begin{split}\text{PSwap}(\theta) \equiv \begin{pmatrix} 1&0&0&0 \\ 0&0&e^{i\theta}&0 \\ 0&e^{i\theta}&0&0 \\ 0&0&0&1 \end{pmatrix}\end{split}\]

Standard three-qubit gates ¶

class quantumflow.CCNot(q0: Qubit, q1: Qubit, q2: Qubit)¶

A 3-qubit Toffoli gate. A controlled, controlled-not.

Equivalent to controlled_gate(cnot())

\[\begin{split}\text{CCNot}() \equiv \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \end{pmatrix}\end{split}\]

class quantumflow.CSwap(q0: Qubit, q1: Qubit, q2: Qubit)¶

A 3-qubit Fredkin gate. A controlled swap.

Equivalent to controlled_gate(swap())

\[\begin{split}\text{CSwap}() \equiv \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \end{pmatrix}\end{split}\]

Additional gates ¶

One-qubit gates ¶

class quantumflow.S_H(q0: Qubit)¶: The inverse of the 1-qubit phase S gate, equivalent to Z ** -1/2.

\[\begin{split}\begin{pmatrix} 1 & 0 \\ 0 & -i \end{pmatrix}\end{split}\]

class quantumflow.T_H(q0: Qubit)¶: The inverse (complex conjugate) of the 1-qubit T (pi/8) gate, equivalent to Z ** -1/4.

\[\begin{split}\begin{pmatrix} 1 & 0 \\ 0 & e^{-i \pi / 4} \end{pmatrix}\end{split}\]

class quantumflow.XPow(t: float | Expr, q0: Qubit)¶

Powers of the 1-qubit Pauli-X gate.

\[XPow(t) = X^t = e^{i \pi t/2} R_X(\pi t)\]

Parameters:: t – Number of half turns (quarter cycles) on Block sphere

class quantumflow.YPow(t: float | Expr, q0: Qubit)¶

Powers of the 1-qubit Pauli-Y gate.

The pseudo-Hadamard gate is YPow(3/2), and its inverse is YPow(1/2).

\[YPow(t) = Y^t = e^{i \pi t/2} R_Y(\pi t)\]

Parameters:: t – Number of half turns (quarter cycles) on Block sphere

class quantumflow.ZPow(t: float | Expr, q0: Qubit)¶

Powers of the 1-qubit Pauli-Z gate.

\[ZPow(t) = Z^t = e^{i \pi t/2} R_Z(\pi t)\]

Parameters:: t – Number of half turns (quarter cycles) on Block sphere

class quantumflow.HPow(t: float | Expr, q0: Qubit)¶: Powers of the 1-qubit Hadamard gate.

\[\begin{split}HPow(t) = H^t = e^{i \pi t/2} \begin{pmatrix} \cos(\tfrac{t}{2}) + \tfrac{i}{\sqrt{2}}\sin(\tfrac{t}{2})) & \tfrac{i}{\sqrt{2}} \sin(\tfrac{t}{2}) \\ \tfrac{i}{\sqrt{2}} \sin(\tfrac{t}{2}) & \cos(\tfrac{t}{2}) -\tfrac{i}{\sqrt{2}} \sin(\frac{t}{2}) \end{pmatrix}\end{split}\]

class quantumflow.V(q0: Qubit)¶: Principal square root of the X gate, X-PLUS-90 gate.

class quantumflow.V_H(q0: Qubit)¶: Complex conjugate of the V gate, X-MINUS-90 gate.

class quantumflow.PhasedX(p: float | Expr, q0: Qubit)¶: A phased X gate, equivalent to the circuit ───Z^-p───X───Z^p───

class quantumflow.PhasedXPow(p: float | Expr, t: float | Expr, q0: Qubit)¶

A phased X gate raised to a power.

Equivalent to the circuit ───Z^-p───X^t───Z^p───

Two-qubit gates ¶

class quantumflow.Can(tx: float | Expr, ty: float | Expr, tz: float | Expr, q0: Qubit, q1: Qubit)¶

The canonical 2-qubit gate

The canonical decomposition of 2-qubits gates removes local 1-qubit rotations, and leaves only the non-local interactions.

\[\text{CAN}(t_x, t_y, t_z) \equiv \exp\Big\{-i\frac{\pi}{2}(t_x X\otimes X + t_y Y\otimes Y + t_z Z\otimes Z)\Big\}\]

class quantumflow.XX(t: float | Expr, q0: Qubit, q1: Qubit)¶

A parametric 2-qubit gate generated from an XX interaction,

Equivalent to Can(t, 0, 0).

XX(1/2) is the Mølmer-Sørensen gate.

Ref: Sørensen, A. & Mølmer, K. Quantum computation with ions in thermal motion. Phys. Rev. Lett. 82, 1971–1974 (1999)

Parameters:: t –

class quantumflow.YY(t: float | Expr, q0: Qubit, q1: Qubit)¶

A parametric 2-qubit gate generated from a YY interaction.

Equivalent to Can(0, t, 0), and locally equivalent to Can(t, 0, 0)

Parameters:: t –

class quantumflow.ZZ(t: float | Expr, q0: Qubit, q1: Qubit)¶

A parametric 2-qubit gate generated from a ZZ interaction.

Equivalent to Can(0,0,t), and locally equivalent to Can(t,0,0)

Parameters:: t –

class quantumflow.XY(t: float | Expr, q0: Qubit, q1: Qubit)¶

XY interaction gate.

Powers of the iSWAP gate. Equivalent to Can(t, t, 0).

class quantumflow.Exch(t: float | Expr, q0: Qubit, q1: Qubit)¶

A 2-qubit parametric gate generated from an isotropic exchange interaction.

Equivalent to Can(t,t,t)

class quantumflow.Barenco(phi: float | Expr, alpha: float | Expr, theta: float | Expr, q0: Qubit, q1: Qubit)¶

A universal two-qubit gate:

Ref:: A Universal Two–Bit Gate for Quantum Computation, A. Barenco (1996) https://arxiv.org/pdf/quant-ph/9505016.pdf

class quantumflow.CY(q0: Qubit, q1: Qubit)¶

A controlled-Y gate

Equivalent to controlled_gate(Y()) and locally equivalent to Can(1/2,0,0)

\[\begin{split}\text{CY}() = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & -i \\ 0 & 0 & i & 0 \end{pmatrix}\end{split}\]

class quantumflow.CH(q0: Qubit, q1: Qubit)¶

A controlled-Hadamard gate

Equivalent to controlled_gate(H()) and locally equivalent to Can(1/2, 0, 0)

\[\begin{split}\text{CH}() = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & \tfrac{1}{\sqrt{2}} & \tfrac{1}{\sqrt{2}} \\ 0 & 0 & \tfrac{1}{\sqrt{2}} & -\tfrac{1}{\sqrt{2}} \end{pmatrix}\end{split}\]

class quantumflow.CNotPow(t: float | Expr, q0: Qubit, q1: Qubit)¶

Powers of the CNot gate.

Equivalent to controlled_gate(TX(t)), and locally equivalent to Can(t/2, 0 ,0).

\[\begin{split}\text{CTX}(t) = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & \cos(\frac{\theta}{2}) e^{i\frac{\theta}{2}} & -i \sin(\frac{\theta}{2}) e^{i\frac{\theta}{2}} \\ 0 & 0 & -i \sin(\frac{\theta}{2}) e^{i\frac{\theta}{2}} & \cos(\frac{\theta}{2}) e^{i\frac{\theta}{2}} \end{pmatrix}\end{split}\]

Parameters:

t – turns (powers of the CNot gate, or controlled-powers of X)
q0 – control qubit
q1 – target qubit

class quantumflow.SqrtISwap(q0: Qubit, q1: Qubit)¶

A square root of the iswap gate

Equivalent to Can(-1/4,-1/4,0).

class quantumflow.SqrtISwap_H(q0: Qubit, q1: Qubit)¶

The Hermitian conjugate of the square root iswap gate

Equivalent to Can(1/4, 1/4, 0).

class quantumflow.SqrtSwap(q0: Qubit, q1: Qubit)¶

Square root of the 2-qubit swap gate

Equivalent to Can(1/4, 1/4, 1/4).

class quantumflow.SqrtSwap_H(q0: Qubit, q1: Qubit)¶

The conjugate of the Square root swap gate

Equivalent to Can(-1/4, -1/4, -1/4), and locally equivalent to Can(3/4, 1/4, 1/4)

Three-qubit gates ¶

class quantumflow.CCZ(q0: Qubit, q1: Qubit, q2: Qubit)¶

A controlled, controlled-Z.

Equivalent to controlled_gate(CZ())

\[\begin{split}\text{CSWAP}() \equiv \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & -1 \end{pmatrix}\end{split}\]

class quantumflow.Deutsch(theta: float | Expr, q0: Qubit, q1: Qubit, q2: Qubit)¶

The Deutsch gate, a 3-qubit universal quantum gate.

A controlled-controlled-i*R_x(2*theta) gate. Note that Deutsch(pi/2) is the CCNot gate.

\[\begin{split}\text{Deutsch}(\theta) \equiv \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & i \cos(\theta) & \sin(\theta) \\ 0 & 0 & 0 & 0 & 0 & 0 & \sin(\theta)& i \cos(\theta) \end{pmatrix}\end{split}\]

Ref:

Deutsch, Quantum Computational Networks,
Proc. R. Soc. Lond. A 425, 73 (1989).

class quantumflow.CCiX(q0: Qubit, q1: Qubit, q2: Qubit)¶

A doubly controlled iX gate.

\[\begin{split}\text{CCiX}() \equiv \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & i \\ 0 & 0 & 0 & 0 & 0 & 0 & i & 0 \end{pmatrix}\end{split}\]

Refs:: http://arxiv.org/abs/1210.0974

QASM gates ¶

class quantumflow.U3(theta: float | Expr, phi: float | Expr, lam: float | Expr, q0: Qubit)¶

The U3 single qubit gate from QASM. The U2 gate is the U3 gate with theta=pi/2. The U1 gate has theta=phi=0, which is the same as a PhaseShift gate.

..math::: text{U3}(theta, phi, lambda) = R_z(phi) R_y(theta) R_z(lambda)
Refs:: https://arxiv.org/pdf/1707.03429.pdf (Eq. 2) https://github.com/Qiskit/qiskit-terra/blob/master/qiskit/extensions/standard/u3.py

class quantumflow.U2(phi: float | Expr, lam: float | Expr, q0: Qubit)¶: A ‘single pulse’ 1-qubit gate defined in QASM

class quantumflow.CU3(theta: float | Expr, phi: float | Expr, lam: float | Expr, q0: Qubit, q1: Qubit)¶

The controlled U3 gate, as defined by QASM.

Ref:: https://github.com/Qiskit/qiskit-terra/blob/master/qiskit/extensions/standard/cu3.py

quantumflow.CRZ¶: alias of CRz

quantumflow.RZZ¶: alias of Rzz

Mapping between APIs ¶

Each of the main quantum computing python APIs (QuantumFlow, Cirq, qsikit (QASM), and pyQuil) have different gates available and different naming conventions. The following table maps gate names between these APIs.

Description

QF

Cirq

QASM/qsikit

PyQuil

Pennylane

One qubit gates

Global phase Ph Identity (single qubit) I Pauli-X X Pauli-Y Y Pauli-Z Z Hadamard H X-rotations Rx Y-rotations Ry Z-rotations Rz Sqrt of Z S Sqrt of S T Phase shift Bloch rotations Rn Powers of X Powers of Y Powers of Z Powers of Hadamard Inv. of S S_H Inv. of T T_H Sqrt of X V Inv. sqrt of X V_H Sqrt of Y Inv. sqrt of Y ? ? ? ? I id or iden I ? X x X PauliX Y y Y PauliY Z z Z PauliZ H h H Hadamard rx rx RX RX ry ry RY RY rz rz RZ RZ S s S S T t T T PhaseShift . u1 PHASE PhaseShift . . . . XPow XPowGate . . . YPow YPowGate . . . ZPow ZPowGate . . . HPow HPowGate . . . . sdg . . . tdg . . . . . . . . . . SqrtY . . . . SqrtY_H . . . .

Two qubit gates

Powers of X⊗X XX XXPowGate . . . Powers of Y⊗Y YY YYPowGate . . . Powers of Z⊗Z ZZ ZZPowGate . . . Canonical Can . . . . Controlled-Not CNOT CNOT cx CNOT CNOT Controlled-Z CZ CZ cz CZ CZ Controlled-Y CY . cy . . Controlled-Hadamard CH . ch . . Controlled-V CV . . . . Controlled-inv-V CV_H . . . . Powers of CNOT CXPow CNotPowGate . . . Powers of CY CYPow . . . . Powers of CZ CZPow CZPowGate . . . Swap Swap SWAP swap . SWAP Exchange Exch SwapPowGate (*) . . iSwap ISwap ISWAP . ISWAP . XY (powers of iSwap) XY ISwapPowGate(*) . XY(*) . Givens rotation Givens givens . . . Barenco Barenco . . . . B (Berkeley) B . . . . Sqrt-iSWAP SqrtISwap . . . . Inv. of sqrt-iSWAP SqrtISwap_H . . . . Sqrt-SWAP SqrtSwap . . . . Inv. of sqrt-SWAP SqrtSwap_H . . . . ECP ECP . . . . W (Dual-rail Hadamard) W . . . . Controlled-S CS . . . . Controlled-T CT . . . .

Three qubit gates

Toffoli CCNot CCX ccx CCNOT Toffoli Fredkin CSwap CSWAP cswap CSWAP CSWAP Controlled-Controlled-Z CCZ CCZ . . . Deutsch Deutsch . . . . Powers of CCNOT CCXPow CCXPowGate . . . Powers of CCZ . CCZPowGate . . .

Forest specific gates

Controlled-phase CPhase CZPowGate(*) cu1 CPHASE . Controlled-phase on 00 CPhase00 . . CPHASE00 . Controlled-phase on 01 CPhase01 . . CPHASE01 . Controlled-phase on 10 CPhase10 . . CPHASE10 . Parametric Swap PSwap . . PSWAP .

Cirq specific gates

Fermionic-Simulation FSim FSimGate . . . Phased-X gate PhasedX . . . . Powers of Phased-X gate PhasedXPow PhasedXPowGate . . . Sycamore Sycamore Sycamore . . . Fermionic swap FSwap FSwap . . . Powers of fermionic swap FSwapPow FSwapPow . . .

QASM/qiskit gates

QASM’s U3 gate U3 . u3 . Rot QASM’s U2 gate U2 . u2 . QASM’s controlled-U3 CU3 . cu3 . . QASM’s ZZ-rotations RZZ . rzz . CRot Controlled-RX . . . . CRX Controlled-RY . . . . CRY Controlled-RZ CRZ . crz CRZ ========================== =========== =============== =========== =========== ===========

(*) Modulo differences in parametrization

(**) Cirq defines XX, YY, and ZZ gates, as XX^1, YY^1, ZZ^1 which are direct products of single qubit gates. (e.g. XX(t,0,1) is the same as X(0) X(1) when t=1)

Table Of Contents

Gates¶