Models

Basic stabilizer codes

BasicCode <: StabilizerCode

BasicCode(
    pauli_stabilizers::AbstractVector{<:AbstractString},
    pauli_logical_xs::AbstractVector{<:AbstractString},
    pauli_logical_zs::AbstractVector{<:AbstractString},
    nkd::Tuple{Integer,Integer,Union{Integer,Missing}}=nothing,
    label::AbstractString=nothing
)

Construct a basic code from string representations of stabilizers and logical operators.

Paulis are expressed as strings of capitalized I, X, Y, Z characters, with one character per physical qubit. Logical X and Z operators are in matching order, with one of each for each logical qubit. Optional nkd defaults to n and k evaluated and d missing. Optional label defaults to "Basic [n,k,d]".

Examples

julia> using Qecsim.BasicModels

julia> code = BasicCode(["ZZI", "IZZ"], ["XXX"], ["IIZ"])  # 3-qubit repetition
BasicCode(["ZZI", "IZZ"], ["XXX"], ["IIZ"], (3, 1, missing), "Basic [3,1,missing]")

julia> validate(code)  # no error indicates operators satisfy commutation relations

julia> nkd(code)  # default nkd
(3, 1, missing)

julia> label(code)  # default label
"Basic [3,1,missing]"

FiveQubitCode() -> BasicCode

Construct 5-qubit [5,1,3] code as a BasicCode.

SteaneCode() -> BasicCode

Construct Steane [7,1,3] code as a BasicCode.

Generic error models and decoders compatible with any stabilizer codes.

SimpleErrorModel <: ErrorModel

Abstract supertype for simple IID error models that generate errors based on the number of qubits and a probability distribution.

generate(
    error_model::SimpleErrorModel, code, p::Real, [rng::AbstractRNG=GLOBAL_RNG]
) -> BitVector

Generate a new IID error based on Model.probability_distribution. See also Model.generate.

BitFlipErrorModel <: SimpleErrorModel

IID error model with probability vector: $(p_I, p_X, p_Y p_Z) = (1-p, p, 0, 0)$, where $p$ is the probability of an error on a single-qubit.

BitPhaseFlipErrorModel <: SimpleErrorModel

IID error model with probability vector: $(p_I, p_X, p_Y p_Z) = (1-p, 0, p, 0)$, where $p$ is the probability of an error on a single-qubit.

DepolarizingErrorModel <: SimpleErrorModel

IID error model with probability vector: $(p_I, p_X, p_Y p_Z) = (1-p, p/3, p/3, p/3)$, where $p$ is the probability of an error on a single-qubit.

PhaseFlipErrorModel <: SimpleErrorModel

IID error model with probability vector: $(p_I, p_X, p_Y p_Z) = (1-p, 0, 0, p)$, where $p$ is the probability of an error on a single-qubit.

NaiveDecoder <: Decoder

NaiveDecoder([max_qubits=10])

Construct a naive decoder that iterates through all possible errors, in ascending weight, and resolves to the first error that matches the syndrome.