Package evaluation to test Qecsim on Julia 1.14.0-DEV.50 (b60d1db399*) started at 2025-11-09T15:34:55.647


################################################################################
# Set-up
#

Installing PkgEval dependencies (TestEnv)...

Set-up completed after 6.51s


################################################################################
# Installation
#

Installing Qecsim...
   Resolving package versions...
    Updating `~/.julia/environments/v1.14/Project.toml`
  [e6c2bad3] + Qecsim v0.1.0
    Updating `~/.julia/environments/v1.14/Manifest.toml`
  [861a8166] + Combinatorics v1.0.3
  [34da2185] + Compat v4.18.1
  [9a962f9c] + DataAPI v1.16.0
⌅ [864edb3b] + DataStructures v0.18.22
  [ffbed154] + DocStringExtensions v0.9.5
  [92d709cd] + IrrationalConstants v0.2.6
⌅ [682c06a0] + JSON v0.21.4
  [2ab3a3ac] + LogExpFunctions v0.3.29
  [e1d29d7a] + Missings v1.2.0
  [bac558e1] + OrderedCollections v1.8.1
  [69de0a69] + Parsers v2.8.3
  [aea7be01] + PrecompileTools v1.3.3
  [21216c6a] + Preferences v1.5.0
  [e6c2bad3] + Qecsim v0.1.0
  [189a3867] + Reexport v1.2.2
  [a2af1166] + SortingAlgorithms v1.2.2
  [10745b16] + Statistics v1.11.1
  [82ae8749] + StatsAPI v1.7.1
⌅ [2913bbd2] + StatsBase v0.33.21
  [56f22d72] + Artifacts v1.11.0
  [2a0f44e3] + Base64 v1.11.0
  [ade2ca70] + Dates v1.11.0
  [b77e0a4c] + InteractiveUtils v1.11.0
  [ac6e5ff7] + JuliaSyntaxHighlighting v1.12.0
  [8f399da3] + Libdl v1.11.0
  [37e2e46d] + LinearAlgebra v1.13.0
  [d6f4376e] + Markdown v1.11.0
  [a63ad114] + Mmap v1.11.0
  [de0858da] + Printf v1.11.0
  [9a3f8284] + Random v1.11.0
  [ea8e919c] + SHA v1.0.0
  [9e88b42a] + Serialization v1.11.0
  [2f01184e] + SparseArrays v1.13.0
  [f489334b] + StyledStrings v1.11.0
  [fa267f1f] + TOML v1.0.3
  [cf7118a7] + UUIDs v1.11.0
  [4ec0a83e] + Unicode v1.11.0
  [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1
  [4536629a] + OpenBLAS_jll v0.3.29+0
  [bea87d4a] + SuiteSparse_jll v7.10.1+0
  [8e850b90] + libblastrampoline_jll v5.15.0+0
        Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m`

Installation completed after 2.87s


################################################################################
# Precompilation
#

Precompiling PkgEval dependencies...

┌ Error: Failed to use TestEnv.jl; test dependencies will not be precompiled
│   exception =
│    UndefVarError: `project_rel_path` not defined in `TestEnv`
│    Suggestion: this global was defined as `Pkg.Operations.project_rel_path` but not assigned a value.
│    Stacktrace:
│     [1] get_test_dir(ctx::Pkg.Types.Context, pkgspec::PackageSpec)
│       @ TestEnv ~/.julia/packages/TestEnv/nGMfF/src/julia-1.11/common.jl:75
│     [2] test_dir_has_project_file
│       @ ~/.julia/packages/TestEnv/nGMfF/src/julia-1.11/common.jl:52 [inlined]
│     [3] maybe_gen_project_override!
│       @ ~/.julia/packages/TestEnv/nGMfF/src/julia-1.11/common.jl:83 [inlined]
│     [4] activate(pkg::String; allow_reresolve::Bool)
│       @ TestEnv ~/.julia/packages/TestEnv/nGMfF/src/julia-1.11/activate_set.jl:12
│     [5] activate(pkg::String)
│       @ TestEnv ~/.julia/packages/TestEnv/nGMfF/src/julia-1.11/activate_set.jl:9
│     [6] top-level scope
│       @ /PkgEval.jl/scripts/precompile.jl:24
│     [7] include(mod::Module, _path::String)
│       @ Base ./Base.jl:309
│     [8] exec_options(opts::Base.JLOptions)
│       @ Base ./client.jl:344
│     [9] _start()
│       @ Base ./client.jl:577
└ @ Main /PkgEval.jl/scripts/precompile.jl:26
Precompiling package dependencies...
Precompiling packages...
   3136.2 ms  ✓ Qecsim
  1 dependency successfully precompiled in 9 seconds. 34 already precompiled.

Precompilation completed after 12.35s


################################################################################
# Testing
#

     Testing Qecsim
      Status `/tmp/jl_Sk40tL/Project.toml`
  [861a8166] Combinatorics v1.0.3
⌅ [682c06a0] JSON v0.21.4
  [e6c2bad3] Qecsim v0.1.0
  [189a3867] Reexport v1.2.2
  [1bc83da4] SafeTestsets v0.1.0
  [10745b16] Statistics v1.11.1
⌅ [2913bbd2] StatsBase v0.33.21
  [37e2e46d] LinearAlgebra v1.13.0
  [9a3f8284] Random v1.11.0
  [8dfed614] Test v1.11.0
      Status `/tmp/jl_Sk40tL/Manifest.toml`
  [861a8166] Combinatorics v1.0.3
  [34da2185] Compat v4.18.1
  [9a962f9c] DataAPI v1.16.0
⌅ [864edb3b] DataStructures v0.18.22
  [ffbed154] DocStringExtensions v0.9.5
  [92d709cd] IrrationalConstants v0.2.6
⌅ [682c06a0] JSON v0.21.4
  [2ab3a3ac] LogExpFunctions v0.3.29
  [e1d29d7a] Missings v1.2.0
  [bac558e1] OrderedCollections v1.8.1
  [69de0a69] Parsers v2.8.3
  [aea7be01] PrecompileTools v1.3.3
  [21216c6a] Preferences v1.5.0
  [e6c2bad3] Qecsim v0.1.0
  [189a3867] Reexport v1.2.2
  [1bc83da4] SafeTestsets v0.1.0
  [a2af1166] SortingAlgorithms v1.2.2
  [10745b16] Statistics v1.11.1
  [82ae8749] StatsAPI v1.7.1
⌅ [2913bbd2] StatsBase v0.33.21
  [56f22d72] Artifacts v1.11.0
  [2a0f44e3] Base64 v1.11.0
  [ade2ca70] Dates v1.11.0
  [b77e0a4c] InteractiveUtils v1.11.0
  [ac6e5ff7] JuliaSyntaxHighlighting v1.12.0
  [8f399da3] Libdl v1.11.0
  [37e2e46d] LinearAlgebra v1.13.0
  [56ddb016] Logging v1.11.0
  [d6f4376e] Markdown v1.11.0
  [a63ad114] Mmap v1.11.0
  [de0858da] Printf v1.11.0
  [9a3f8284] Random v1.11.0
  [ea8e919c] SHA v1.0.0
  [9e88b42a] Serialization v1.11.0
  [2f01184e] SparseArrays v1.13.0
  [f489334b] StyledStrings v1.11.0
  [fa267f1f] TOML v1.0.3
  [8dfed614] Test v1.11.0
  [cf7118a7] UUIDs v1.11.0
  [4ec0a83e] Unicode v1.11.0
  [e66e0078] CompilerSupportLibraries_jll v1.3.0+1
  [4536629a] OpenBLAS_jll v0.3.29+0
  [bea87d4a] SuiteSparse_jll v7.10.1+0
  [8e850b90] libblastrampoline_jll v5.15.0+0
        Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading.
     Testing Running tests...
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xc6d0e547c202d7c5fd05a91f776fccef)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.9186710000000042, :time_steps => 1, :n_logical_commutations => [248, 266], :error_weight_total => 1323, :wall_time => 0.335607025, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2646, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 632, :logical_failure_rate => 0.368, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 368, :n_run => 1000)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 1
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x702be51a7b509d4c1130b1bbfed3b041)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 0, :wall_time => 0.000184648, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 1, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 0, :n_run => 1)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x784dbec2373aaa8c400800aab71fb613)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.64, :time_steps => 1, :n_logical_commutations => [3, 5], :error_weight_total => 16, :wall_time => 0.000325627, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.32, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 4, :logical_failure_rate => 0.6, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 6, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = nothing
└   max_failures = 2
[ Info: qec_run: rng=Random.MersenneTwister(0xd9dbb4d405d702e293553a9ab6a70979)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.2222222222222222, :time_steps => 1, :n_logical_commutations => [2, 0], :error_weight_total => 5, :wall_time => 0.000311267, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.3333333333333333, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 1, :logical_failure_rate => 0.6666666666666666, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 2, :n_run => 3)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 10
└   max_failures = 3
[ Info: qec_run: rng=Random.MersenneTwister(0x0935a69e8f9dc7df4800e6b4ff8d7dfb)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.234375, :time_steps => 1, :n_logical_commutations => [0, 3], :error_weight_total => 11, :wall_time => 0.000362937, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.275, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 5, :logical_failure_rate => 0.375, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :n_run => 8)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xb2021e426f0572ec71ad9f66e361e47b)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.9224639999999955, :time_steps => 1, :n_logical_commutations => [241, 237], :error_weight_total => 1256, :wall_time => 0.015319753, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2512, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 640, :logical_failure_rate => 0.36, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 360, :n_run => 1000)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 1
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x405f32b79e25480a0e98e95078c7ce32)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [0, 1], :error_weight_total => 2, :wall_time => 0.000165279, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.4, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 1)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xf12a68f53b626087605e829e526ff7b7)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6, :time_steps => 1, :n_logical_commutations => [2, 2], :error_weight_total => 10, :wall_time => 0.000264177, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 7, :logical_failure_rate => 0.3, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = nothing
└   max_failures = 2
[ Info: qec_run: rng=Random.MersenneTwister(0x1a08728be3463ac05b5b31acd9acd382)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.0, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 4, :wall_time => 0.000154969, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 2, :logical_failure_rate => 0.5, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 2, :n_run => 4)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 10
└   max_failures = 3
[ Info: qec_run: rng=Random.MersenneTwister(0xea1ac5cfc4a79f4905add5c78207d71e)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.24489795918367346, :time_steps => 1, :n_logical_commutations => [1, 3], :error_weight_total => 10, :wall_time => 0.000235627, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2857142857142857, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 4, :logical_failure_rate => 0.42857142857142855, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :n_run => 7)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = 13
│   max_runs = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(13)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.4977440000000004, :time_steps => 1, :n_logical_commutations => [60, 63], :error_weight_total => 516, :wall_time => 0.03658954, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.1032, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 908, :logical_failure_rate => 0.092, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 92, :n_run => 1000)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = 13
│   max_runs = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(13)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.4977440000000004, :time_steps => 1, :n_logical_commutations => [60, 63], :error_weight_total => 516, :wall_time => 0.036414862, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.1032, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 908, :logical_failure_rate => 0.092, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 92, :n_run => 1000)
┌ Info: qec_run: starting
│   code = Main.var"##App.jl#147"._DuckCode()
│   error_model = Main.var"##App.jl#147"._DuckErrorModel()
│   decoder = Main.var"##App.jl#147"._DuckDecoder()
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xd8f8a03221c49ce91655360f13bc91a2)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 0, :wall_time => 0.000397866, :n_k_d => (5, 1, 3), :error_model => "duck", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 10, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "duck", :decoder => "duck", :n_fail => 0, :n_run => 10)
┌ Info: qec_run: starting
│   code = Main.var"##App.jl#147"._DuckCode()
│   error_model = Main.var"##App.jl#147"._DuckErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xf128c43b8b4d300bd91bf9622a74d05f)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 0, :wall_time => 0.000432136, :n_k_d => (5, 1, 3), :error_model => "duck", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 10, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "duck", :decoder => "Naive", :n_fail => 0, :n_run => 10)
┌ Info: qec_run: starting
│   code = Main.var"##App.jl#147"._DuckCode()
│   error_model = Qecsim.GenericModels.BitFlipErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xc36b13c0f6b87516beba9c4cbe5474d2)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.5600000000000002, :time_steps => 1, :n_logical_commutations => [2, 1], :error_weight_total => 8, :wall_time => 0.000725483, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.16, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 8, :logical_failure_rate => 0.2, :custom_totals => nothing, :code => "duck", :decoder => "Naive", :n_fail => 2, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Nothing}(nothing, Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], nothing, nothing))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 1
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x1fa32d10b1f812e12037d2ef332a0961)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 0, :wall_time => 0.000251988, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 1, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "fixed", :n_fail => 0, :n_run => 1)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Nothing}(nothing, Bool[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], nothing, nothing))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 2
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x802d31fd21ed419a183942a5dbad234f)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [0, 2], :error_weight_total => 0, :wall_time => 0.000253288, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "fixed", :n_fail => 2, :n_run => 2)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Nothing}(nothing, Bool[0, 0, 0, 0, 0, 1, 1, 1, 1, 1], nothing, nothing))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 3
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xb7d80e56496e0fd2a19f5416f18e6770)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [3, 0], :error_weight_total => 0, :wall_time => 0.000211298, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "fixed", :n_fail => 3, :n_run => 3)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Nothing}(false, Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], nothing, nothing))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 4
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x06ecc44090c9005e9a7f5d778efe253c)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 0, :wall_time => 0.000321027, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "fixed", :n_fail => 4, :n_run => 4)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Nothing}(nothing, Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], Bool[1, 1], nothing))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 5
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x9e690a2e4320f431d1c22d9429cefb9c)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [5, 5], :error_weight_total => 0, :wall_time => 0.000210228, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 5, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "fixed", :n_fail => 0, :n_run => 5)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Nothing}(false, Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], Bool[1, 1], nothing))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 6
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xb8157242655e699424666e835c6942e1)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [6, 6], :error_weight_total => 0, :wall_time => 0.000203488, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "fixed", :n_fail => 6, :n_run => 6)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Nothing}(false, nothing, nothing, nothing))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 7
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xead0a465b78096bacfc9c20516deab4b)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 0, :wall_time => 0.077744897, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "fixed", :n_fail => 7, :n_run => 7)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Nothing}(false, nothing, Bool[1, 1], nothing))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 8
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x55ab0b60e4c8f711e5a276f58c9eb7ca)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [8, 8], :error_weight_total => 0, :wall_time => 0.000216158, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "fixed", :n_fail => 8, :n_run => 8)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Vector{Int64}}(false, nothing, nothing, [1, 1]))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 9
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x499385935a5ae13a1b7b61fd89e9ac95)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 0, :wall_time => 0.368828567, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => [9, 9], :code => "5-qubit", :decoder => "fixed", :n_fail => 9, :n_run => 9)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Vector{Float64}}(false, nothing, nothing, [1.0, 1.0]))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x3f7f2c5ed8b64f2e6e91f20bf42ea5df)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 0, :wall_time => 0.527048477, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => [10.0, 10.0], :code => "5-qubit", :decoder => "fixed", :n_fail => 10, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._FixedDecoder(Qecsim.Model.DecodeResult{Vector{Rational{Int64}}}(false, nothing, nothing, Rational{Int64}[1//2, 1//3]))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 11
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xe75ad721c51d1a05a05cb5f35d52a143)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 0, :wall_time => 0.447727794, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 0, :logical_failure_rate => 1.0, :custom_totals => Rational{Int64}[11//2, 11//3], :code => "5-qubit", :decoder => "fixed", :n_fail => 11, :n_run => 11)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._CycleDecoder(Base.Iterators.Stateful{Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Int64}}}}, Union{Nothing, Tuple{Qecsim.Model.DecodeResult{Vector{Int64}}, Int64}}}(Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Int64}}}}(Qecsim.Model.DecodeResult{Vector{Int64}}[Qecsim.Model.DecodeResult{Vector{Int64}}(false, nothing, nothing, [1, 1]), Qecsim.Model.DecodeResult{Vector{Int64}}(true, nothing, nothing, [2, 3])]), (Qecsim.Model.DecodeResult{Vector{Int64}}(false, nothing, nothing, [1, 1]), 2)))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 12
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x4ebd6a657d435fd3ee537465e66dded1)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 0, :wall_time => 0.081567921, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 6, :logical_failure_rate => 0.5, :custom_totals => [18, 24], :code => "5-qubit", :decoder => "cycle", :n_fail => 6, :n_run => 12)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._CycleDecoder(Base.Iterators.Stateful{Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Any}}}}, Union{Nothing, Tuple{Qecsim.Model.DecodeResult{Vector{Any}}, Int64}}}(Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Any}}}}(Qecsim.Model.DecodeResult{Vector{Any}}[Qecsim.Model.DecodeResult{Vector{Any}}(false, nothing, nothing, Any[1, [1.0]]), Qecsim.Model.DecodeResult{Vector{Any}}(true, nothing, nothing, Any[2, [3.0]])]), (Qecsim.Model.DecodeResult{Vector{Any}}(false, nothing, nothing, Any[1, [1.0]]), 2)))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 2
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xf6edcee7ebd4be70fddd5f8abf2ffc3d)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 0, :wall_time => 0.62615149, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 1, :logical_failure_rate => 0.5, :custom_totals => Any[3, [1.0, 3.0]], :code => "5-qubit", :decoder => "cycle", :n_fail => 1, :n_run => 2)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._CycleDecoder(Base.Iterators.Stateful{Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Any}}}}, Union{Nothing, Tuple{Qecsim.Model.DecodeResult{Vector{Any}}, Int64}}}(Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Any}}}}(Qecsim.Model.DecodeResult{Vector{Any}}[Qecsim.Model.DecodeResult{Vector{Any}}(false, nothing, nothing, Any[1, [1 2]]), Qecsim.Model.DecodeResult{Vector{Any}}(true, nothing, nothing, Any[2, [3 4]])]), (Qecsim.Model.DecodeResult{Vector{Any}}(false, nothing, nothing, Any[1, [1 2]]), 2)))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 2
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x9fdde7dc3656e7965f802d2b26128e9c)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 0, :wall_time => 0.259569331, :n_k_d => (5, 1, 3), :error_model => "fixed", :physical_error_rate => 0.0, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 1, :logical_failure_rate => 0.5, :custom_totals => Any[3, [1 2; 3 4]], :code => "5-qubit", :decoder => "cycle", :n_fail => 1, :n_run => 2)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._CycleDecoder(Base.Iterators.Stateful{Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Nothing}}}, Union{Nothing, Tuple{Qecsim.Model.DecodeResult{Nothing}, Int64}}}(Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Nothing}}}(Qecsim.Model.DecodeResult{Nothing}[Qecsim.Model.DecodeResult{Nothing}(true, nothing, nothing, nothing), Qecsim.Model.DecodeResult{Nothing}(true, nothing, Bool[1, 0], nothing)]), (Qecsim.Model.DecodeResult{Nothing}(true, nothing, nothing, nothing), 2)))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 5
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x92c16b7f35ecd72c77a8dc1f8da5eb6f)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._CycleDecoder(Base.Iterators.Stateful{Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Nothing}}}, Union{Nothing, Tuple{Qecsim.Model.DecodeResult{Nothing}, Int64}}}(Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Nothing}}}(Qecsim.Model.DecodeResult{Nothing}[Qecsim.Model.DecodeResult{Nothing}(true, nothing, Bool[1, 1, 0], nothing), Qecsim.Model.DecodeResult{Nothing}(true, nothing, Bool[1, 0], nothing)]), (Qecsim.Model.DecodeResult{Nothing}(true, nothing, Bool[1, 1, 0], nothing), 2)))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 5
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x247defa8cadc106b36fbcba477aed9d5)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Main.var"##App.jl#147"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#147"._CycleDecoder(Base.Iterators.Stateful{Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult}}, Union{Nothing, Tuple{Qecsim.Model.DecodeResult, Int64}}}(Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult}}(Qecsim.Model.DecodeResult[Qecsim.Model.DecodeResult{Vector{Int64}}(true, nothing, nothing, [1, 0]), Qecsim.Model.DecodeResult{Vector{Float64}}(true, nothing, nothing, [1.1, 0.1])]), (Qecsim.Model.DecodeResult{Vector{Int64}}(true, nothing, nothing, [1, 0]), 2)))
│   p = 0.1
│   random_seed = nothing
│   max_runs = 5
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x479ae03de62975168e7df083872c522c)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.2
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x927644983b5b0cd24df0f5dcf59192bf)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.8099999999999998, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 7, :wall_time => 0.000415766, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.13999999999999999, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.2
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x7895dfd411d588388c7df93e70dae475)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.36000000000000004, :time_steps => 1, :n_logical_commutations => [0, 1], :error_weight_total => 8, :wall_time => 0.000420086, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.16, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x9f4cfe3039eb872bf4f4e0498842b653)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.5599999999999999, :time_steps => 1, :n_logical_commutations => [1, 2], :error_weight_total => 8, :wall_time => 0.000503075, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.16, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 8, :logical_failure_rate => 0.2, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 2, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.2
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x5c99e5014a20f7ef6bea21413f90545e)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6400000000000001, :time_steps => 1, :n_logical_commutations => [2, 0], :error_weight_total => 6, :wall_time => 0.000398866, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.12, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 8, :logical_failure_rate => 0.2, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 2, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.BitFlipErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xeaa8dd648ed887bd0999a472227c64e4)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.4400000000000001, :time_steps => 1, :n_logical_commutations => [1, 0], :error_weight_total => 4, :wall_time => 0.014577361, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.08, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Main.var"##App.jl#147"._CycleDecoder(Base.Iterators.Stateful{Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Any}}}}, Union{Nothing, Tuple{Qecsim.Model.DecodeResult{Vector{Any}}, Int64}}}(Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Any}}}}(Qecsim.Model.DecodeResult{Vector{Any}}[Qecsim.Model.DecodeResult{Vector{Any}}(false, nothing, nothing, Any[1, [1]]), Qecsim.Model.DecodeResult{Vector{Any}}(true, nothing, nothing, Any[2, [3]])]), (Qecsim.Model.DecodeResult{Vector{Any}}(false, nothing, nothing, Any[1, [1]]), 2)))
│   p = 0.2
│   random_seed = nothing
│   max_runs = 3
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xbd838be19e5b611a1f2acf9972195f7b)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.22222222222222224, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 1, :wall_time => 0.029225261, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.06666666666666667, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 1, :logical_failure_rate => 0.6666666666666666, :custom_totals => Any[4, [1, 3, 1]], :code => "5-qubit", :decoder => "cycle", :n_fail => 2, :n_run => 3)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Main.var"##App.jl#147"._CycleDecoder(Base.Iterators.Stateful{Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Any}}}}, Union{Nothing, Tuple{Qecsim.Model.DecodeResult{Vector{Any}}, Int64}}}(Base.Iterators.Cycle{Vector{Qecsim.Model.DecodeResult{Vector{Any}}}}(Qecsim.Model.DecodeResult{Vector{Any}}[Qecsim.Model.DecodeResult{Vector{Any}}(false, nothing, nothing, Any[1, [1]]), Qecsim.Model.DecodeResult{Vector{Any}}(true, nothing, nothing, Any[2, [3]])]), (Qecsim.Model.DecodeResult{Vector{Any}}(true, nothing, nothing, Any[2, [3]]), 3)))
│   p = 0.2
│   random_seed = nothing
│   max_runs = 3
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xedae6183545cf3c7a82d1e988cb8e541)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6666666666666666, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 3, :wall_time => 0.000279308, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.19999999999999998, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 2, :logical_failure_rate => 0.3333333333333333, :custom_totals => Any[5, [3, 1, 3]], :code => "5-qubit", :decoder => "cycle", :n_fail => 1, :n_run => 3)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.08
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x21fae944a022e65adc286f930149f201)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.16000000000000003, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 2, :wall_time => 0.000263918, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.04, :measurement_error_probability => 0.0, :error_probability => 0.08, :n_success => 10, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 0, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x42e5374759b1efa75e8b6349b9179fb7)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.24000000000000005, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 4, :wall_time => 0.000238838, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.08, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 10, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 0, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.BitFlipErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xd90ae6cd8a88a7ed39f283e6303d7171)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.44000000000000006, :time_steps => 1, :n_logical_commutations => [1, 0], :error_weight_total => 6, :wall_time => 0.000453345, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.12, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
┌ Error: Recovered data: [{"error_weight_pvar":0.44000000000000006},{"time_steps":1},{"n_logical_commutations":[1,0]},{"error_weight_total":6},{"wall_time":0.000453345},{"n_k_d":[5,1,3]},{"error_model":"Bit-flip"},{"physical_error_rate":0.12},{"measurement_error_probability":0.0},{"error_probability":0.1},{"n_success":9},{"logical_failure_rate":0.1},{"custom_totals":null},{"code":"5-qubit"},{"decoder":"Naive"},{"n_fail":1},{"n_run":10}]
└ @ Qecsim.App ~/.julia/packages/Qecsim/e9K2S/src/App.jl:423
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.BitFlipErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xed95f45475c2a67951a999a5efb13976)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.45, :time_steps => 1, :n_logical_commutations => [1, 0], :error_weight_total => 5, :wall_time => 0.000360626, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.1, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
Test Summary:                              | Pass  Total     Time
Qecsim.jl                                  |  241    241  1m10.6s
  error.jl                                 |    3      3     8.9s
  PauliTools.jl                            |   43     43    10.2s
  Model.jl                                 |   21     21     2.5s
  models/BasicModels.jl                    |   13     13     0.4s
  models/GenericModels/simpleerrormodel.jl |   44     44     8.3s
  models/GenericModels/naivedecoder.jl     |   16     16     2.5s
  App.jl                                   |  101    101    37.7s
     Testing Qecsim tests passed 

Testing completed after 78.73s

PkgEval succeeded after 150.81s