Gate reference
The standard gates a Qollab circuit is built from: the symbol the Circuit panel draws, the Qiskit call in Python and JS, qubits and parameters, with a page per gate.
Qollab circuits use Qiskit's gate methods, called the same way in Python and JS: qc.h(0) in one, circuit.h(0) in the other. Angles are in radians. The standard gates run on every backend, with two cases that need transpile() first: the built-in simulator for the multi-controlled gates (mcx, mcp) and for Pauli evolution, and the IBM noise models for Pauli evolution. The native gates need a native-gateset backend. The local simulators also take some of Qiskit's rarer gates (iswap, ecr, cswap, rzx), which have no page here.
On an IonQ run the Circuit panel on the Run tab draws the circuit as it was submitted, one box per gate, with a dot on each control wire. Local and IBM noise-model runs show no circuit panel.
Single-qubit gates
| Panel | Gate | Does | Call | Controlled form |
|---|---|---|---|---|
| H | H gate (Hadamard) | Equal superposition of 0 and 1 | h(q) | ch(control, target) |
| X | X gate (NOT) | Flips 0 and 1 | x(q) | cx(control, target) |
| Y | Y gate | Flips 0 and 1, with a phase | y(q) | cy(control, target) |
| Z | Z gate | Flips the sign of 1 | z(q) | cz(control, target) |
| S | S gate | Quarter-turn phase on 1 | s(q) | |
| Sdg | S† gate | Undoes S | sdg(q) | |
| T | T gate | Eighth-turn phase on 1 | t(q) | |
| Tdg | T† gate | Undoes T | tdg(q) | |
| √X | √X gate | Half of an X | sx(q) | csx(control, target) |
| √X† | √X† gate | Undoes √X | sxdg(q) | |
| P(λ) | P gate (phase) | Phase λ on 1 | p(λ, q) | cp(λ, control, target) |
| Rx(θ) | RX gate | Rotation about X by θ | rx(θ, q) | crx(θ, control, target) |
| Ry(θ) | RY gate | Rotation about Y by θ | ry(θ, q) | cry(θ, control, target) |
| Rz(θ) | RZ gate | Rotation about Z by θ | rz(θ, q) | crz(θ, control, target) |
A controlled form applies the gate to the target only when the control is . The panel draws it as the base gate's box with a dot on the control wire.
Two-qubit gates
| Panel | Gate | Does | Call |
|---|---|---|---|
| ● X | CX gate (CNOT) | Flips the target when the control is 1 | cx(control, target) |
| ● Y | CY gate | Y on the target when the control is 1 | cy(control, target) |
| ● Z | CZ gate | Flips the sign of 11 | cz(control, target) |
| ● P(λ) | CP gate | Phase λ on 11 | cp(λ, control, target) |
| Swap | Swap gate | Exchanges two qubits | swap(a, b) |
| Xx(θ) | RXX gate | Rotates the pair about X⊗X by θ | rxx(θ, a, b) |
| Yy(θ) | RYY gate | Rotates the pair about Y⊗Y by θ | ryy(θ, a, b) |
| Zz(θ) | RZZ gate | Phase that depends on whether the pair agrees | rzz(θ, a, b) |
Three or more qubits
| Panel | Gate | Does | Call |
|---|---|---|---|
| ● ● X | CCX gate (Toffoli) | Flips the target when both controls are 1 | ccx(control1, control2, target) |
| ● … X | Multi-controlled X | Flips the target when every control is 1 | mcx([controls], target) |
| ● … P(λ) | Multi-controlled phase | Phase λ when every control and the target are 1 | mcp(λ, [controls], target) |
A multi-controlled gate can carry up to 7 control qubits on IonQ backends; more than that fails at submission with the entry in the Error reference.
Pauli evolution
| Panel | Gate | Does | Call |
|---|---|---|---|
| exp(…)(t) | Pauli evolution | Evolves the qubits under a Hamiltonian for time t | qc.append(PauliEvolutionGate(op, time=t), qubits) |
PauliEvolutionGate is in qiskit.circuit.library. The panel prints the weighted Pauli terms inside exp(…) and the time after them. IonQ backends take the gate as submitted when its terms commute with each other (the gate page covers the option for terms that do not); the built-in simulator and the IBM noise models reject it untranspiled, so run transpile() first there (see Transpilation).
IonQ native gates
Native gates are what IonQ hardware physically executes. They appear in your circuit only when you write a native-gate circuit yourself, which turns IonQ's compiler off; see How your circuit is compiled. They come from qiskit_ionq rather than qiskit, and their angles are in turns (a fraction of a full rotation), not radians.
| Gate | Does | Call | Systems |
|---|---|---|---|
| GPi | Half-turn about an axis at phase φ | qc.append(GPIGate(φ), [q]) | Aria and Forte |
| GPi2 | Quarter-turn about an axis at phase φ | qc.append(GPI2Gate(φ), [q]) | Aria and Forte |
| MS | Entangles the pair by θ, from 0 (identity) to 0.25 (fully, the default) | qc.append(MSGate(φ0, φ1, θ), [a, b]) | Aria |
| ZZ | Phase that depends on whether the pair agrees | qc.append(ZZGate(θ), [a, b]) | Forte |
Related
Stay in the loop.
Get the latest tutorials, demos, and project showcases straight to your inbox. No noise, just the good stuff.
On this page
Gates