AbstractDecoder

The abstract type for a decoder.

AbstractDecodingProblem

The abstract type for a decoding problem.

CSSBimatrix

Since the encding process may alter the generators of stabilizer group, we introduce the CSSBimatrix structure to store the information of encoding process. The CSSBimatrix structure contains the following fields

• matrix: The bimatrix representation of the stabilizers.
• Q: The matrix records the Gaussian elimination process, whcih is used to recover the original stabilizers.
• ordering: The ordering of qubits.
• xcodenum: The number of X stabilizers.

CSSErrorPattern(xerror::Vector{Mod2}, zerror::Vector{Mod2})

A CSS error pattern with X and Z errors. Fields:

• xerror::Vector{Mod2}: the X errors
• zerror::Vector{Mod2}: the Z errors

CSSCSSTannerGraph(stgx::SimpleTannerGraph, stgz::SimpleTannerGraph)
CSSTannerGraph(nq::Int, stxs::Vector{Vector{Int}}, stzs::Vector{Vector{Int}})
CSSTannerGraph(sts::Vector{PauliString{N}}) where N
CSSTannerGraph(cqc::CSSQuantumCode)

Two tanner graph for a CSS code, one for X stabilizers and one for Z stabilizers. Fields: stgx: Tanner graph for X stabilizers stgz: Tanner graph for Z stabilizers

ClassicalDecodingProblem(tanner::SimpleTannerGraph, pvec::Vector{Float64})

A classical decoding problem. Fields:

• tanner::SimpleTannerGraph: the Tanner graph
• pvec::Vector{Float64}: the independent probability distributions on each bit

CliffordSimulateResult{N}

The result of simulating a Pauli string by a Clifford circuit.

Fields

• output::PauliString{N}: A mapped Pauli string as the output.
• phase::ComplexF64: The phase factor.
• circuit::ChainBlock: The circuit (simplified, with linear structure).
• history::Vector{PauliString{N}}: The history of Pauli strings, its length is length(circuit)+1.

Code1573

Construct a [[15,7,3]] CSS code instance.

Code422

Construct a [[4,2,2]] CSS code instance.

Code513

Construct a [[5,1,3]] code instance.

Code832

Construct a [[8,3,2]] CSS code instance.

CompiledDecoder

Compile the decoder to specific tanner graph and prior probability distributions.

GeneralDecodingProblem(tanner::SimpleTannerGraph, ptn::TensorNetwork)

A general decoding problem. Fields:

• tanner::SimpleTannerGraph: the Tanner graph
• ptn::TensorNetwork: the probability distributions, qubits are labeled as 1:qubit_num

IPDecoder <: AbstractGeneralDecoder

An integer programming decoder.

IndependentDepolarizingDecodingProblem(tanner::CSSTannerGraph, pvec::IndependentDepolarizingError)

A decoding problem with independent depolarizing error model. Fields:

• tanner::CSSTannerGraph: the Tanner graph
• pvec::IndependentDepolarizingError: the independent probability distributions on each qubit

MatchingDecoder{T<:MatchingSolver} <: AbstractDecoder

A decoder that uses matching algorithm. Fields:

• solver::T: the matching solver

PauliString{N} <: CompositeBlock{2}

A Pauli string is a tensor product of Pauli gates, e.g. XYZ. The matrix representation of a Pauli string is evaluated as

\[A = \bigotimes_{i=1}^N \sigma_{ids[N-i+1]}\]

where ids is the array of integers representing the Pauli gates. Note the order of ids is following the little-endian convention, i.e. the first qubit is the least significant qubit. For example, the Pauli string XYZ has matrix representation Z ⊗ Y ⊗ X.

Fields

• ids::NTuple{N, Int}: the array of integers (1-4) representing the Pauli gates.
  • 1: I ($σ_0$)
  • 2: X ($σ_1$)
  • 3: Y ($σ_2$)
  • 4: Z ($σ_3$)

QCInfo(data_qubits::Vector{Int},ancilla_qubits::Vector{Int},nq::Int)
QCInfo(data_qubits::Vector{Int},nq::Int)

A struct to store the qubit information of a quantum circuit.

Fields

• data_qubits: The data qubit indices.
• ancilla_qubits: The ancilla qubit indices. If not specified, it is set to the complement of data_qubits in 1:nq
• nq: The total number of qubits.

ShorCode

Construct a Shor code instance.

SimpleTannerGraph(nq::Int, ns::Int, q2s::Vector{Vector{Int}}, s2q::Vector{Vector{Int}}, H::Matrix{Mod2})

Tanner graph for a classical linear code. Fields: nq: number of qubits ns: number of stabilizers q2s: a list of lists, q2s[i] is the list of stabilizers that contain qubit i s2q: a list of lists, s2q[i] is the list of qubits that stabilizer i contains H: the parity check matrix

SimpleTannerGraph(nq::Int, sts::Vector{Vector{Int}})

Construct a Tanner graph from a list of stabilizers. Input: nq: number of qubits sts: a list of parity checks, each parity check is a list of bits.

SteaneCode

Construct a Steane code instance.

SurfaceCode(m::Int, n::Int)

Construct a surface code with m rows and n columns.

TNMAP(;optimizer::CodeOptimizer=default_optimizer()) <: AbstractGeneralDecoder

Tensor Network MAP decoder.

Keyword Arguments

• optimizer::CodeOptimizer = TreeSA(): The optimizer to use for optimizing the tensor network contraction order.

TruthTable

The truth table for error correction.

Fields

• table::Dict{Int,Int}: The truth table for error correction.
• num_qubits::Int: The number of qubits.
• num_st::Int: The number of stabilizers.
• d::Int64: The maximum number of errors.

ToricCode(m::Int, n::Int)

Construct a Toric code with m rows and n columns.

annotate_history(res::CliffordSimulateResult{N})

Annotate the history of Pauli strings in the result of clifford_simulate.

Arguments

• res: The result of clifford_simulate.

Returns

• draw: The visualization of the history.

clifford_group(n::Int)

Generate the n-qubit Clifford group.

clifford_network(qc::ChainBlock)

Generate a Clifford network from a quantum circuit.

clifford_simulate(ps::PauliString, qc::ChainBlock)

Map the Pauli string ps by a quantum circuit qc.

Arguments

• ps: The Pauli string.
• qc: The quantum circuit.

Returns

• result: A CliffordSimulateResult records the output Pauli string, the phase factor, the simplified circuit, and the history of Pauli strings.

coherent_error_unitary(u::AbstractMatrix{T}, error_rate::Real; cache::Union{Vector, Nothing} = nothing) where T

Generate the error unitary near the given error rate.

Arguments

• u: The original unitary.
• error_rate: The error rate.
• cache: The vector to store the error rate.

Returns

• q: The errored unitary.

correction_circuit(table::Dict{Int,Int}, num_qubits::Int, num_st::Int, st_pos::AbstractVector{Int}, total_qubits::Int)

Generate the error correction circuit by embedding the truth table into the quantum circuit.

Arguments

• table: The truth table for error correction.
• num_qubits: The number of qubits in the circuit.
• num_st: The number of stabilizers.
• st_pos: The indices of ancilla qubits that measure stabilizers.
• total_qubits: The total number of qubits in the circuit.

Returns

• qc: The error correction circuit.

correction_dict(st::Vector{PauliString{N}}, d::Int64; et="XZ")

Generate the correction dictionary for the given stabilizers.

Arguments

• st: The vector of pauli strings, composing the generator of stabilizer group.
• d: The maximum number of errors.
• et: The type of error to be corrected. It can be "X", "Z", or "XZ". Default is "XZ".

Returns

• table: The correction dictionary, mapping the syndrome to the corresponding error pattern.

correction_pauli_string(qubit_num::Int, syn::Dict{Int, Bool}, prob::Dict{Int, Vector{Float64}})

Generate the error Pauli string in the coding space. To correct the error, we still need to transform it to the physical space.

Arguments

• qubit_num: The number of qubits.
• syn: The syndrome dictionary.
• prob: The inferred error probability of each physical qubit in coding space.

Returns

• ps: The error Pauli string in the coding space.

decode(decoder::AbstractDecoder, problem::AbstractDecodingProblem, syndrome::AbstractSyndrome)

Decode the syndrome using the decoder.

encode_stabilizers(stabilizers::AbstractVector{PauliString{N}}) where N

Generate the encoding circuit for the given stabilizers.

Arguments

• stabilizers: The vector of pauli strings, composing the generator of stabilizer group.

Returns

• qc: The encoding circuit.
• data_qubits: The indices of data qubits.
• bimat: The structure storing the encoding information.

error_pairs(error_rate::T; gates = nothing) where {T <: Real}

Generate the error pairs for the given error rate.

Arguments

• error_rate: The error rate.
• gates: The gates to be errored. If not specified, it is set to [X,Y,Z,H,CCZ,ConstGate.Toffoli,ConstGate.CNOT,ConstGate.CZ]

Returns

• pairs: The error pairs.
• vec: The vector to store the error rate to each gate.

error_quantum_circuit(qc::ChainBlock, error_rate::T ) where {T <: Real}

Generate the error quantum circuit for the given error rate.

Arguments

• qc: The quantum circuit.
• error_rate: The error rate.

Returns

• eqc: The error quantum circuit.

error_quantum_circuit_pair_replace(qc::ChainBlock, error_rate::T ) where {T <: Real}
error_quantum_circuit_pair_replace(qc::ChainBlock, pairs)

Generate the error quantum circuit for the given error rate. The errored gate to the same type of gate is the same.

Arguments

• qc: The quantum circuit.
• error_rate: The error rate.
• pairs: The error gates used to replace the original gates.

Returns

• qcf: The error quantum circuit.
• vec: The vector to store the error rate to each gate.

fidelity_tensornetwork(qc::ChainBlock,qc_info::QCInfo)

Generate the tensor network representation of the quantum circuit fidelity with the given QCInfo, where ancilla qubits are initilized at zero state and partial traced after the circuit. The data qubits are traced out.

Arguments

• qc: The quantum circuit.
• qc_info: The qubit information of the quantum circuit

Returns

• tn: The tensor network representation of the quantum circuit.

get_graph(tanner::SimpleTannerGraph)
get_graph(ctg::CSSTannerGraph)

Get the simple graph of a simple tanner graph or a CSS tanner graph.

inference(measure_outcome::Vector{Int}, code::CSSBimatrix, qc::ChainBlock, p::Vector{Vector{Float64}})

Infer the error probability of each qubit from the measurement outcome of the stabilizers.

Arguments

• measure_outcome: The measurement outcome of the stabilizers, which is either 1 or -1.
• code: The structure storing the encoding information.
• qc: The encoding circuit.
• p: The prior error probability of each physical qubit.

Returns

• ps_ec_phy: The error Pauli string for error correction.

measure_circuit_fault_tol(sts::Vector{PauliString{N}}) where N

Generate the Shor type measurement circuit for fault tolerant measurement.

Arguments

• sts: The vector of Pauli strings, composing the generator of stabilizer group.

Returns

• qc: The measurement circuit.
• st_pos: The ancilla qubit indices that measrue corresponding stabilizers.
• num_qubits: The total number of qubits in the circuit.

measure_circuit_steane(data_qubit::Int, sts::Vector{PauliString{N}};qcen = nothing) where N

Generate the Steane type measurement circuit.

Arguments

• data_qubit: The index of the data qubit.
• sts: The vector of Pauli strings, composing the generator of stabilizer group.
• qcen: The encoding circuit. If nothing, the measurement circuit will not contain the encoder for ancilla qubits.

Returns

• qc: The measurement circuit.
• st_pos: The ancilla qubit indices that measrue corresponding stabilizers.

measure_syndrome!(reg::AbstractRegister, stabilizers::AbstractVector{PauliString{N}}) where N

Measure the given stabilizers.

Arguments

• reg: The quantum register.
• stabilizers: The vector of pauli strings, composing the generator of stabilizer group.

Returns

• measure_outcome: The measurement outcome of the stabilizers, which is either 1 or -1.

pauli_basis(nqubits::Int)

Generate the n-qubit Pauli basis.

pauli_decomposition(m::AbstractMatrix)

Decompose a matrix into the Pauli basis.

pauli_mapping(m::AbstractMatrix)

Convert a linear operator to a matrix in the Pauli basis.

pauli_string_map_iter(ps::PauliString{N}, qc::ChainBlock) where N

Map the Pauli string ps by a quantum circuit qc. Return the mapped Pauli string.

paulistring(n::Int, k::Int, ids::Vector{Int}) -> PauliString

Create a Pauli string with n qubits, where the i-th qubit is k if i is in ids, otherwise 1. k = 1 for I2, 2 for X, 3 for Y, 4 for Z.

perm_of_paulistring(ps::PauliString, operation::Pair{Vector{Int}, <:PermMatrix})

Map the Pauli string ps by a permutation matrix pm. Return the mapped Pauli string and the phase factor.

Arguments

• ps: The Pauli string.
• operation: A pair of the positions to apply the permutation and the permutation matrix.

Returns

• ps: The mapped Pauli string.
• val: The phase factor.

place_qubits(reg0::AbstractRegister, data_qubits::Vector{Int}, num_qubits::Int)

Place the data qubits to the specified position. The other qubits are filled with zero state.

Arguments

• reg0: The data register.
• data_qubits: The indices of data qubits.
• num_qubits: The total number of qubits.

Returns

• reg: The register with data qubits placed at the specified position.

random_error_qubits(qubit_number::Int, em::AbstractErrorModel)

Generate a random error pattern for a given number of qubits and an error model.

simulation_tensornetwork(qc::ChainBlock,qc_info::QCInfo)

Generate the tensor network representation of the quantum circuit with the given QCInfo, where ancilla qubits are initilized at zero state and partial traced after the circuit.

Arguments

• qc: The quantum circuit.
• qc_info: The qubit information of the quantum circuit

Returns

• tn: The tensor network representation of the quantum circuit.
• input_indices: The input indices of the tensor network.
• output_indices: The output indices of the tensor network.

stabilizers(tc::ToricCode)
stabilizers(sc::SurfaceCode)
stabilizers(shor::ShorCode)
stabilizers(steane::SteaneCode)
stabilizers(code832::Code832)

Get the stabilizers of the code instances.

syndrome_extraction(errored_qubits::Vector{Mod2}, H::Matrix{Mod2})
syndrome_extraction(errored_qubits::Vector{Mod2}, tanner::SimpleTannerGraph)
syndrome_extraction(error_patterns::CSSErrorPattern, tanner::CSSTannerGraph)

Extract the syndrome from the error pattern.

syndrome_inference(cl::CliffordNetwork{T}, syn::Dict{Int,Bool}, p::Vector{Vector{Float64}}) where T

Infer the error probability of each qubit from the measurement outcome of the stabilizers.

Arguments

• cl: The Clifford network.
• syn: The syndrome dictionary.
• p: The prior error probability of each physical qubit.

Returns

• pinf: The inferred error probability of each physical qubit in coding space. For errored stabilizers, there are two possibilities: X or Y error. For unerrored stabilizers, there are also two possibilities: no error or Z error. For unmeasured qubits, there are four possibilities: no error, X error, Y error, Z error. Therefore the length of each vector in pinf may be 2 or 4.

to_perm_matrix([::Type{T}, ::Type{Ti}, ]matrix_or_yaoblock; atol=1e-8)

Convert a Clifford gate to its permutation representation.

Arguments

• T: Element type of phase factor.
• Ti: Element type of the permutation matrix.
• m: The matrix representation of the gate.
• atol: The tolerance to zeros in the matrix.

Returns

• pm: The permutation matrix. pm.perm is the permutation vector, pm.vals is the phase factor.

transformed_syndrome_dict(measure_outcome::Vector{Int}, code::CSSBimatrix)

Generate the syndrome dictionary on the transformed stabilizers from the measurement outcome.

Arguments

• measure_outcome: The measurement outcome of the stabilizers, which is either 1 or -1.
• code: The structure storing the encoding information.

Returns

• syn_dict: The syndrome dictionary on the transformed stabilizers. 1 is transformed to 0, -1 is transformed to 1.

multiprocess_run(func, inputs::AbstractVector)

Execute function func on inputs with multiple processing.

Example

Suppose we have a file run.jl with the following contents

using GenericTensorNetworks.SimpleMultiprocessing

results = multiprocess_run(x->x^2, randn(8))

In an terminal, you may run the script with 4 processes by typing

$ julia -p4 run.jl
      From worker 2:	[ Info: running argument -0.17544008350172655 on device 2
      From worker 5:	[ Info: running argument 0.34578117779452555 on device 5
      From worker 3:	[ Info: running argument 2.0312551239727705 on device 3
      From worker 4:	[ Info: running argument -0.7319353419291961 on device 4
      From worker 2:	[ Info: running argument 0.013132180639054629 on device 2
      From worker 3:	[ Info: running argument 0.9960101782201602 on device 3
      From worker 4:	[ Info: running argument -0.5613942832743966 on device 4
      From worker 5:	[ Info: running argument 0.39460402723831134 on device 5