an assembly language with quantum instructions
Go to file
zkdream.net a7601a6453 P 2024-04-03 08:48:22 +03:00
src P 2024-04-03 08:48:22 +03:00
.gitignore P 2024-04-03 08:48:22 +03:00
build.rs P 2024-04-03 08:48:22 +03:00
Cargo.toml P 2024-04-03 08:48:22 +03:00
LICENSE P 2024-04-03 08:48:22 +03:00
README.md P 2024-04-03 08:48:22 +03:00

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