# Standard Gates

The Classiq platform provides many standard gates. Some key standard gates are shown here in detail.
All gates are covered in the reference manual.

# Generic imports
from classiq import QArray, QBit, allocate, create_model, qfunc, synthesize, write_qmod


## Single Qubit Gates

An example is given for $$X$$ gate. The gates $$I$$, $$X$$, $$Y$$, $$Z$$, $$H$$, $$T$$ are used in the same way.

### For example: X

Function: X

Arguments:

• target: QBit
from classiq import X

@qfunc
def main():
q = QBit("q")
allocate(1, q)

X(q)

qmod = create_model(main)
write_qmod(qmod, "X")
qprog = synthesize(qmod)


## Single Qubit Rotation Gates

An example is given for $$RZ$$ gate. The gates $$RX$$, $$RY$$, $$RZ$$ are used in the same way except for parameter name.

#### Parameter names for different rotation gates

• RX: theta

• RY: theta

• RZ: phi

### For example: RZ

$\begin{split}RZ(\theta) = \begin{pmatrix} {e^{-i\frac{\theta}{2}}} & 0 \\ 0 & {e^{i\frac{\theta}{2}}} \\ \end{pmatrix}\end{split}$

Function: RZ

Arguments:

• theta: CReal

• target: QBit

from classiq import RZ

@qfunc
def main():
q = QBit("q")
allocate(1, q)

theta = 1.9
RZ(theta, q)

qmod = create_model(main)
write_qmod(qmod, "RZ")
qprog = synthesize(qmod)


### R Gate

Rotation by $$\theta$$ around the $$cos(\phi)X + sin(\phi)Y$$ axis.

$$\begin{split}R(\theta, \phi) = \begin{pmatrix} cos(\frac{\theta}{2}) & -ie^{-i\phi}sin(\frac{\theta}{2}) \ -ie^{i\phi}sin(\frac{\theta}{2}) & cos(\frac{\theta}{2}) \ \end{pmatrix}\end{split}$$

Parameters:

• theta: CReal

• phi: CReal

• target: QBit

from classiq import R

@qfunc
def main():
q = QBit("q")
allocate(1, q)

theta = 1
phi = 2
R(theta, phi, q)

qmod = create_model(main)
write_qmod(qmod, "R")
qprog = synthesize(qmod)


### Phase Gate

Rotation about the Z axis by $$\lambda$$ with global phase of $$\frac{\lambda}{2}$$.

$\begin{split}PHASE(\lambda) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\lambda} \end{pmatrix}\end{split}$

Parameters:

• theta: CReal

• target: QBit

from classiq import PHASE

@qfunc
def main():
q = QBit("q")
allocate(1, q)

theta = 1
PHASE(theta, q)

qmod = create_model(main)
write_qmod(qmod, "PHASE")
qprog = synthesize(qmod)


## Double Qubits Rotation Gates

An example is given for $$RZZ$$ gate. The gates $$RXX$$, $$RYY$$, $$RZZ$$ are used in the same way.

### RZZ Gate

$\begin{split}RZZ(\theta) = \begin{pmatrix} {e^{-i\frac{\theta}{2}}} & 0 & 0 & 0 \\ 0 & {e^{i\frac{\theta}{2}}} & 0 & 0 \\ 0 & 0 & {e^{i\frac{\theta}{2}}} & 0 \\ 0 & 0 & 0 & {e^{-i\frac{\theta}{2}}} \\ \end{pmatrix}\end{split}$

Parameters:

• theta: CReal

• target: QArray[QBit]

from classiq import RZZ

@qfunc
def main():
q = QArray("q")
allocate(2, q)

theta = 1
RZZ(theta, q)

qmod = create_model(main)
write_qmod(qmod, "RZZ")
qprog = synthesize(qmod)


## Controlled Gates

An example is given for $$CX$$ gate. The gates $$CX$$, $$CY$$, $$CZ$$, $$CH$$, $$CSX$$, $$CCX$$ are used in a similar way.

In $$CCX$$ Gate the ctrl_state parameter receives a value suitable for 2 control qubits. for example: "01".

### CX Gate

The Controlled $$X$$ gate.

Applies $$X$$ Gate on the target qubit, based on the state of the control qubit (by default if the controlled state is $$|1\rangle$$).

$\begin{split}CX = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ \end{pmatrix}\end{split}$

Parameters:

• control: QBit

• target: QBit

from classiq import CX

@qfunc
def main():
q_target = QBit("q_t")
allocate(1, q_target)

q_control = QBit("q_c")
allocate(1, q_control)

CX(q_control, q_target)

qmod = create_model(main)
write_qmod(qmod, "CX")
qprog = synthesize(qmod)


## Controlled Rotations

An example is given for $$CRX$$ gate. The gates $$CRX$$, $$CRY$$, $$CRZ$$, CPhase are used in the same way.

### CRX Gate

Controlled rotation around the X axis.

$\begin{split}CRX(\theta) = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & \cos(\frac{\theta}{2}) & -i\sin(\frac{\theta}{2}) \\ 0 & 0 & -i\sin(\frac{\theta}{2}) & \cos(\frac{\theta}{2}) \\ \end{pmatrix}\end{split}$

Parameters:

• theta: CReal

• control: QBit

• target: QBit

from classiq import CRX

@qfunc
def main():
q_target = QBit("q_t")
allocate(1, q_target)

q_control = QBit("q_c")
allocate(1, q_control)

theta = 1
CRX(theta, q_control, q_target)

qmod = create_model(main)
write_qmod(qmod, "CRX")
qprog = synthesize(qmod)


## Swap Gate

Swaps between two qubit states.

$\begin{split}SWAP = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ \end{pmatrix}\end{split}$

Parameters:

• qbit0: QBit

• qbit1: QBit

from classiq import SWAP

@qfunc
def main():
q1 = QBit("q1")
allocate(1, q1)

q2 = QBit("q2")
allocate(1, q2)

SWAP(q1, q2)

qmod = create_model(main)
write_qmod(qmod, "SWAP")
qprog = synthesize(qmod)


## U Gate

The single-qubit gate applies phase and rotation with three Euler angles.

Matrix representation:

$U(\gamma,\phi,\theta,\lambda) = e^{i\gamma}\begin{pmatrix} \cos(\frac{\theta}{2}) & -e^{i\lambda}\sin(\frac{\theta}{2}) \\ e^{i\phi}\sin(\frac{\theta}{2}) & e^{i(\phi+\lambda)}\cos(\frac{\theta}{2}) \\ \end{pmatrix}$

Parameters:

• theta: CReal

• phi: CReal

• lam: CReal

• gam: CReal

• target: QBit

from classiq import U

@qfunc
def main():
q = QBit("q")
allocate(1, q)

theta = 1
phi = 2
lam = 1.5
gam = 1.1
U(theta, phi, lam, gam, q)

qmod = create_model(main)
write_qmod(qmod, "U")
qprog = synthesize(qmod)