zk⁷ 2a125ae5f2 | ||
---|---|---|
src | ||
.gitignore | ||
Cargo.toml | ||
LICENSE | ||
README.md | ||
build.rs |
README.md
qbits n
cbits n
qregs n
cregs n
mem n
<code>
The order of the headers is important and should not be changed. The qbits
header specifies the number of
qubits in each quantum register. The cbits
header specifies the number of classical bits in each classical
register. The qregs
header specifies the number of quantum registers. The cregs
header specifies the number
of classical registers. The n
after each header is any integer number. Operands/arguments for all
instructions are delimited by spaces and not commas.
Code execution should always end at a hlt
instruction. If the emulator reaches the end of code but does not
encounter a hlt
instruction, it will end with a "PC out of bounds" error.
Quantum Instructions
The general format for quantum instructions are:
op qn <other arguments>
Where op
is the name/opcode, qn
specifies a specific qubit n
of the currently selected quantum register.
<other arguments>
can include more qubits as arguments, or in the case of some instructions, a rotation expressed
as a rational multiple of pi, in the format [n]pi[/n]
, where n
can be any integer number, and items
in []
are optional. Quantum registers can be selected via the qsel
instruction, which has the general format
qsel qrn
where n
is any non-negative number.
List of currently implemented quantum instructions:
Quantum Gate | Instruction name | Syntax example | Explanation |
---|---|---|---|
Hadamard | h | h q0 |
Applies a Hadamard to qubit 0 |
CNOT | cnot | cnot q0 q1 |
Applies a CNOT to qubit 1 with qubit 0 being the control |
CCNOT/Toffoli | ccnot | ccnot q0 q1 q2 |
Applies a Toffoli to qubit 2 with qubit 0 and qubit 1 being the controls |
Pauli X | x | x q0 |
Applies a Pauli X to qubit 0 |
Pauli Y | y | y q0 |
Applies a Pauli Y to qubit 0 |
Pauli Z | z | z q0 |
Applies a Pauli Z to qubit 0 |
Rx | rx | rx q0 pi/3 |
Rotates the statevector of qubit 0 by pi/3 radians along X axis on bloch sphere |
Ry | ry | ry q0 pi |
Rotates the statevector of qubit 0 by pi radians along Y axis on bloch sphere |
Rz | rz | rz q0 pi/4 |
Rotates the statevector of qubit 0 by pi/4 radians along Z axis on bloch sphere |
U gate | u | u q0 pi pi/3 pi/6 |
Rotates the statevector of qubit 0 by the 3 Euler angles pi, pi/3, pi/6 |
S gate | s | s q0 |
Applies an S gate to qubit 0 |
T gate | t | t q0 |
Applies a T gate to qubit 0 |
S-dagger | sdg | sdg q0 |
Applies a S-dagger or the inverse of S gate to qubit 0 |
T-dagger | tdg | tdg q0 |
Applies a T-dagger or the inverse of T gate to qubit 0 |
Phase gate | p | p q0 pi/3 |
Applies a relative phase of pi/3 radians to qubit 0 |
Controlled Hadamard | ch | ch q0 q1 |
Applies a controlled Hadamard to qubit 1 with qubit 0 being the control |
Controlled Pauli Y | cy | cy q0 q1 |
Applies a controlled Pauli Y to qubit 1 with qubit 0 being the control |
Controlled Pauli Z | cz | cz q0 q1 |
Applies a controlled Pauli Z to qubit 1 with qubit 0 being the control |
Controlled Phase | cp | cp q0 q1 pi/2 |
Applies a controlled Phase gate to qubit 1 of pi/2 radians with qubit 0 being the control |
Swap | swap | swap q0 q1 |
Swaps the state of qubits 0 and 1 |
Square Root NOT | sqrtx | sqrtx q0 |
Applies a sqrt(NOT)/sqrt(X) to qubit 0 |
Square Root Swap | sqrtswp | sqrtswp q0 q1 |
Applies a sqrt(Swap) to qubits 0 and 1, halfway swapping their state |
Controlled Swap | cswap | cswap q0 q1 q2 |
Swaps the state of qubits 1 and 2 with qubit 0 being the control |
Measure | m | m q0 cr1 c3 |
Measures the state of qubit 0 into 3rd bit of classical register 1 |
Note: Remove any measurement operations before running the emulator with --print-state
(or -p
) as the emulator does not ignore them currently when run with that flag set
Classical Instructions
General format for classical instructions are:
op <operands>
Where op
is the name/opcode, operands may include crn
, which specifies a specific classical register n
, or
an immediate literal value (for now non-negative due to not implemented in parser yet) Other than these differences,
they behave basically the same as any other assembly language instructions.
List of currently implemented classical instructions:
Note: The value of a register refers to the value stored in the register. The value of an immediate is the immediate number itself.
Note 2: An operand can either be a register or immediate unless a restriction is specified.
Instruction name | Description |
---|---|
add | op1 = op2 + op3. op1 is always a register. |
sub | op1 = op2 - op3. op1 is always a register. |
mult | op1 = op2 * op3. op1 is always a register. All values are treated unsigned. |
umult | op1 = (op2 * op3) >> (cbits/2). op1 is always a register. All values are treated unsigned. |
div | op1 = op2 / op3. op1 is always a register. Performs integer division. All values are treated unsigned. |
smult | op1 = op2 * op3. op1 is always a register. All values are treated signed. |
sumult | op1 = (op2 * op3) >> (cbits/2). op1 is always a register. All values are treated signed. |
sdiv | op1 = op2 / op3. op1 is always a register. Performs integer division. All values are treated signed. |
not | op1 = ~op2. op1 is always a register. |
and | op1 = op2 & op3. op1 is always a register. |
or | op1 = op2 | op3. op1 is always a register. |
xor | op1 = op2 ^ op3. op1 is always a register. |
nand | op1 = ~(op2 & op3). op1 is always a register. |
nor | op1 = ~(op2 | op3). op1 is always a register. |
xnor | op1 = ~(op2 ^ op3). op1 is always a register. |
Misc. Instructions
These instructions are here because.
Instruction name | Description |
---|---|
qsel | Selects a quantum register so that proceeding quantum instructions act on that qreg. |
cmp | Updates flags based on comparing values in op1 and op2. op1 is always a register. |
jmp | Unconditionally jump to a label. |
jeq | Jump to label if comparison resulted in EQ flag set. |
jne | Jump to label if comparsion did not result in EQ flag set. |
jg | Jump to label if comparison resulted in GREATER flag set. |
jge | Jump to label if comparison resulted in GREATER or EQ flag set. |
jl | Jump to label if comparison resulted in LESSER flag set. |
jle | Jump to label if comparison resulted in LESSER or EQ flag set. |
hlt | Halt the program. |
Examples
This program simulates the \ket{\Phi^+}
bell state:
qbits 2
cbits 2
qregs 1
cregs 1
qsel qr0
h q0
cnot q0 q1
m q0 cr0 c0
m q1 cr0 c1
hlt