Quantum Registers

Constructing quantum states

A quantum register is a quantum state or a batch of quantum states. Qubits in a Yao register can be active or inactive. Only active qubits are visible to quantum operators, which enables applying quantum operators on a subset of qubits. For example, Suppose we want to run a quantum Fourier transformation circuit of size 4 on qubits (1, 3, 5, 7) with the focus! function, we first set these qubits to active qubits the rest to inactive, then we apply the circuit on the active qubits, and finally we switch back to the original configuration with the relax! function.

Yao provides two types of quantum registers ArrayReg and BatchedArrayReg. Both use matrices as the storage. For example, for a quantum register with $a$ active qubits, $r$ remaining qubits and batch size $b$, the storage is as follows.

The first dimension of size $2^a$ is for active qubits, only this subset of qubits are allowed to interact with quantum operators. Since we reshaped the state vector into a matrix, applying a quantum operator can be conceptually represented as a matrix-matrix multiplication.

Various quantum states can be created with the following functions.

julia> using Yao
julia> reg = ArrayReg([0, 1, -1+0.0im, 0])  # a unnormalized Bell state |01⟩ - |10⟩ArrayReg{2, ComplexF64, Array...}
    active qubits: 2/2
    nlevel: 2
julia> statevec(reg)  # a quantum state is represented as a vector4-element Vector{ComplexF64}:
  0.0 + 0.0im
  1.0 + 0.0im
 -1.0 + 0.0im
  0.0 + 0.0im
julia> print_table(reg)00 ₍₂₎   0.0 + 0.0im
01 ₍₂₎   1.0 + 0.0im
10 ₍₂₎   -1.0 + 0.0im
11 ₍₂₎   0.0 + 0.0im

julia> reg_zero = zero_state(3)  # create a zero state |000⟩ArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> print_table(reg_zero)000 ₍₂₎   1.0 + 0.0im
001 ₍₂₎   0.0 + 0.0im
010 ₍₂₎   0.0 + 0.0im
011 ₍₂₎   0.0 + 0.0im
100 ₍₂₎   0.0 + 0.0im
101 ₍₂₎   0.0 + 0.0im
110 ₍₂₎   0.0 + 0.0im
111 ₍₂₎   0.0 + 0.0im

julia> reg_rand = rand_state(ComplexF32, 3)  # a random stateArrayReg{2, ComplexF32, Array...}
    active qubits: 3/3
    nlevel: 2

julia> reg_uniform = uniform_state(ComplexF32, 3)  # a uniform stateArrayReg{2, ComplexF32, Array...}
    active qubits: 3/3
    nlevel: 2
julia> print_table(reg_uniform)000 ₍₂₎   0.35355f0 + 0.0f0im
001 ₍₂₎   0.35355f0 + 0.0f0im
010 ₍₂₎   0.35355f0 + 0.0f0im
011 ₍₂₎   0.35355f0 + 0.0f0im
100 ₍₂₎   0.35355f0 + 0.0f0im
101 ₍₂₎   0.35355f0 + 0.0f0im
110 ₍₂₎   0.35355f0 + 0.0f0im
111 ₍₂₎   0.35355f0 + 0.0f0im

julia> reg_prod = product_state(bit"110")  # a product stateArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> bit"110"[3]  # the bit string is in little-endian format1
julia> print_table(reg_prod)000 ₍₂₎   0.0 + 0.0im
001 ₍₂₎   0.0 + 0.0im
010 ₍₂₎   0.0 + 0.0im
011 ₍₂₎   0.0 + 0.0im
100 ₍₂₎   0.0 + 0.0im
101 ₍₂₎   0.0 + 0.0im
110 ₍₂₎   1.0 + 0.0im
111 ₍₂₎   0.0 + 0.0im

julia> reg_ghz = ghz_state(3)  # a GHZ stateArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> print_table(reg_ghz)000 ₍₂₎   0.70711 - 0.0im
001 ₍₂₎   0.0 + 0.0im
010 ₍₂₎   0.0 + 0.0im
011 ₍₂₎   0.0 + 0.0im
100 ₍₂₎   0.0 + 0.0im
101 ₍₂₎   0.0 + 0.0im
110 ₍₂₎   0.0 + 0.0im
111 ₍₂₎   0.70711 - 0.0im
julia> von_neumann_entropy(reg_ghz, (1, 3)) / log(2) # entanglement entropy between qubits (1, 3) and (2,)1.0000000000000229

julia> reg_rand3 = rand_state(3, nlevel=3)  # a random qutrit stateArrayReg{3, ComplexF64, Array...}
    active qudits: 3/3
    nlevel: 3
julia> reg_prod3 = product_state(dit"120;3")  # a qudit product state, what follows ";" symbol denotes the number of levelsArrayReg{3, ComplexF64, Array...}
    active qudits: 3/3
    nlevel: 3
julia> print_table(reg_prod3)000 ₍₃₎   0.0 + 0.0im
001 ₍₃₎   0.0 + 0.0im
002 ₍₃₎   0.0 + 0.0im
010 ₍₃₎   0.0 + 0.0im
011 ₍₃₎   0.0 + 0.0im
012 ₍₃₎   0.0 + 0.0im
020 ₍₃₎   0.0 + 0.0im
021 ₍₃₎   0.0 + 0.0im
022 ₍₃₎   0.0 + 0.0im
100 ₍₃₎   0.0 + 0.0im
101 ₍₃₎   0.0 + 0.0im
102 ₍₃₎   0.0 + 0.0im
110 ₍₃₎   0.0 + 0.0im
111 ₍₃₎   0.0 + 0.0im
112 ₍₃₎   0.0 + 0.0im
120 ₍₃₎   1.0 + 0.0im
121 ₍₃₎   0.0 + 0.0im
122 ₍₃₎   0.0 + 0.0im
200 ₍₃₎   0.0 + 0.0im
201 ₍₃₎   0.0 + 0.0im
202 ₍₃₎   0.0 + 0.0im
210 ₍₃₎   0.0 + 0.0im
211 ₍₃₎   0.0 + 0.0im
212 ₍₃₎   0.0 + 0.0im
220 ₍₃₎   0.0 + 0.0im
221 ₍₃₎   0.0 + 0.0im
222 ₍₃₎   0.0 + 0.0im

julia> reg_batch = rand_state(3; nbatch=2)  # a batch of 2 random qubit statesBatchedArrayReg{2, ComplexF64, Transpose...}
    active qubits: 3/3
    nlevel: 2
    nbatch: 2
julia> print_table(reg_batch)000 ₍₂₎   -0.00131 - 0.2684im; 0.16813 + 0.14023im
001 ₍₂₎   0.30648 - 0.29432im; 0.03173 - 0.23842im
010 ₍₂₎   0.12485 - 0.09021im; -0.64855 + 0.18629im
011 ₍₂₎   0.13148 - 0.35264im; 0.16267 - 0.47im
100 ₍₂₎   0.16153 + 0.35565im; 0.02691 + 0.33801im
101 ₍₂₎   -0.20673 - 0.41949im; 0.06515 + 0.05127im
110 ₍₂₎   0.2543 - 0.1087im; 0.16238 + 0.15649im
111 ₍₂₎   -0.17558 + 0.3216im; 0.05642 - 0.12514im
julia> reg_view = viewbatch(reg_batch, 1)  # view the first state in the batchArrayReg{2, ComplexF64, SubArray...}
    active qubits: 3/3
    nlevel: 2
julia> print_table(reg_view)000 ₍₂₎   -0.00131 - 0.2684im
001 ₍₂₎   0.30648 - 0.29432im
010 ₍₂₎   0.12485 - 0.09021im
011 ₍₂₎   0.13148 - 0.35264im
100 ₍₂₎   0.16153 + 0.35565im
101 ₍₂₎   -0.20673 - 0.41949im
110 ₍₂₎   0.2543 - 0.1087im
111 ₍₂₎   -0.17558 + 0.3216im

julia> reg = rand_state(3; nlevel=4, nbatch=2)BatchedArrayReg{4, ComplexF64, Transpose...}
    active qudits: 3/3
    nlevel: 4
    nbatch: 2
julia> nqudits(reg)  # the total number of qudits3
julia> nactive(reg)  # the number of active qubits3
julia> nremain(reg)  # the number of remaining qubits0
julia> nbatch(reg)  # the batch size2
julia> nlevel(reg)  # the number of levels of each qudit4
julia> basis(reg)  # the basis of the register000 ₍₄₎:333 ₍₄₎
julia> focus!(reg, 1:2)  # set on the first two qubits as activeBatchedArrayReg{4, ComplexF64, Transpose...}
    active qudits: 2/3
    nlevel: 4
    nbatch: 2
julia> nactive(reg)  # the number of active qubits2
julia> basis(reg)  # the basis of the register00 ₍₄₎:33 ₍₄₎
julia> relax!(reg)  # set all qubits as activeBatchedArrayReg{4, ComplexF64, Transpose...}
    active qudits: 3/3
    nlevel: 4
    nbatch: 2
julia> nactive(reg)  # the number of active qubits3
julia> reorder!(reg, (3,1,2))  # reorder the qubitsBatchedArrayReg{4, ComplexF64, Transpose...}
    active qudits: 3/3
    nlevel: 4
    nbatch: 2
julia> reg1 = product_state(bit"111");
julia> reg2 = ghz_state(3);
julia> fidelity(reg1, reg2)  # the fidelity between two states0.7071067811865476
julia> tracedist(reg1, reg2)  # the trace distance between two states0.7071067811865477

Arithmetic operations

The list of arithmetic operations for ArrayReg include

+
-
*
/ (scalar)
adjoint

julia> reg1 = rand_state(3)ArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> reg2 = rand_state(3)ArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> reg3 = reg1 + reg2  # additionArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> normalize!(reg3)  # normalize the stateArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> isnormalized(reg3)  # check if the state is normalizedtrue
julia> reg1 - reg2  # subtractionArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> reg1 * 2  # scalar multiplicationArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> reg1 / 2  # scalar divisionArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> reg1'  # adjointAdjointRegister{2, ArrayReg{2, ComplexF64, Matrix{ComplexF64}}}(ArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2)
julia> reg1' * reg1  # inner product1.0 + 0.0im

Register operations

julia> reg0 = rand_state(3)ArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> append_qudits!(reg0, 2)  # append 2 qubitsArrayReg{2, ComplexF64, Array...}
    active qubits: 5/5
    nlevel: 2
julia> insert_qudits!(reg0, 2, 2)  # insert 2 qubits at the 2nd positionArrayReg{2, ComplexF64, Array...}
    active qubits: 7/7
    nlevel: 2

Comparing with using matrix multiplication for quantum simulation, using specialized instructions are much faster and memory efficient. These instructions are specified with the instruct! function.

julia> reg = zero_state(2)ArrayReg{2, ComplexF64, Array...}
    active qubits: 2/2
    nlevel: 2
julia> instruct!(reg, Val(:H), (1,))  # apply a Hadamard gate on the first qubitArrayReg{2, ComplexF64, Array...}
    active qubits: 2/2
    nlevel: 2
julia> print_table(reg)00 ₍₂₎   0.70711 + 0.0im
01 ₍₂₎   0.70711 + 0.0im
10 ₍₂₎   0.0 + 0.0im
11 ₍₂₎   0.0 + 0.0im

Measurement

We use the measure! function returns the measurement outcome and collapses the state after the measurement. We also have some "cheating" version measure that does not collapse states to facilitate classical simulation.

julia> measure!(reg0, 1)  # measure the qubit, the state collapses0 ₍₂₎
julia> measure!(reg0)  # measure all qubits0010000 ₍₂₎
julia> measure(reg0, 3)  # measure the qubit at location 3, the state does not collapse (hacky)1-element Vector{DitStr{2, 1, Int64}}:
 0 ₍₂₎
julia> reorder!(reg0, 7:-1:1)  # reorder the qubitsArrayReg{2, ComplexF64, Array...}
    active qubits: 7/7
    nlevel: 2
julia> measure!(reg0)0000100 ₍₂₎
julia> invorder!(reg0)  # reverse the order of qubitsArrayReg{2, ComplexF64, Array...}
    active qubits: 7/7
    nlevel: 2
julia> measure!(reg0)0010000 ₍₂₎
julia> measure!(RemoveMeasured(), reg0, 2:4)  # remove the measured qubits000 ₍₂₎
julia> reg0ArrayReg{2, ComplexF64, Array...}
    active qubits: 4/4
    nlevel: 2
julia> reg1 = ghz_state(3)ArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> select!(reg1, bit"111")  # post-select the |111⟩ stateArrayReg{2, ComplexF64, Array...}
    active qubits: 0/0
    nlevel: 2
julia> isnormalized(reg1)  # check if the state is normalizedfalse

Density matrices

julia> reg = rand_state(3)ArrayReg{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> rho = density_matrix(reg)  # the density matrix of the stateDensityMatrix{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> rand_density_matrix(3)  # a random density matrixDensityMatrix{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> completely_mixed_state(3)  # a completely mixed stateDensityMatrix{2, ComplexF64, Array...}
    active qubits: 3/3
    nlevel: 2
julia> partial_tr(rho, 1)  # partial trace on the first qubitDensityMatrix{2, ComplexF64, Array...}
    active qubits: 2/2
    nlevel: 2
julia> purify(rho)  # purify the stateArrayReg{2, ComplexF64, Array...}
    active qubits: 3/6
    nlevel: 2
julia> von_neumann_entropy(rho)  # von Neumann entropy5.624513604281401e-14
julia> mutual_information(rho, 1, 2)  # mutual information between qubits 1 and 20.2659095304711605

API

The constructors and functions for quantum registers are listed below.

YaoAPI.AbstractRegister — Type

AbstractRegister{D}

Abstract type for quantum registers. Type parameter D is the number of levels in each qudit. For qubits, D = 2.

Required methods

Optional methods