Package evaluation to test Qecsim on Julia 1.14.0-DEV.1272 (5444ac0564*) started at 2025-11-20T15:27:50.731


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

Installing PkgEval dependencies (TestEnv)...

Set-up completed after 5.85s


################################################################################
# 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.8s


################################################################################
# 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/i9lgt/src/julia-1.11/common.jl:75
│     [2] test_dir_has_project_file
│       @ ~/.julia/packages/TestEnv/i9lgt/src/julia-1.11/common.jl:52 [inlined]
│     [3] maybe_gen_project_override!
│       @ ~/.julia/packages/TestEnv/i9lgt/src/julia-1.11/common.jl:83 [inlined]
│     [4] activate(pkg::String; allow_reresolve::Bool)
│       @ TestEnv ~/.julia/packages/TestEnv/i9lgt/src/julia-1.11/activate_set.jl:12
│     [5] activate(pkg::String)
│       @ TestEnv ~/.julia/packages/TestEnv/i9lgt/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...
   6154.3 ms  ✓ StatsBase
   3490.6 ms  ✓ Qecsim
  2 dependencies successfully precompiled in 10 seconds. 33 already precompiled.

Precompilation completed after 17.02s


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

     Testing Qecsim
      Status `/tmp/jl_TTij8v/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_TTij8v/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(0x8928a19160165866ea3a539bf770a40c)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.8950559999999959, :time_steps => 1, :n_logical_commutations => [222, 224], :error_weight_total => 1212, :wall_time => 0.289944076, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2424, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 670, :logical_failure_rate => 0.33, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 330, :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(0x5bd60b37617c0611c3ebf4f648a9e1ca)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 2, :wall_time => 0.000204048, :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(0xde31ed8bdd11e988c5952c40e0af3b1d)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.21, :time_steps => 1, :n_logical_commutations => [2, 3], :error_weight_total => 13, :wall_time => 0.000242977, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.26, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 6, :logical_failure_rate => 0.4, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 4, :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(0x9f9fb39664f6c34d2bebfa378ce40660)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6666666666666666, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 12, :wall_time => 0.000360967, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.19999999999999998, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 10, :logical_failure_rate => 0.16666666666666666, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 2, :n_run => 12)
┌ 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(0x96e1c7613fe9c06c651f0e1bccbeb827)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.1875, :time_steps => 1, :n_logical_commutations => [2, 1], :error_weight_total => 7, :wall_time => 0.000251988, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.35, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 1, :logical_failure_rate => 0.75, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :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 = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x2fd7cb1ba66672a406bbf48174f9605c)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.9609110000000044, :time_steps => 1, :n_logical_commutations => [222, 232], :error_weight_total => 1283, :wall_time => 0.014782789, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.25660000000000005, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 650, :logical_failure_rate => 0.35, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 350, :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(0x7c552e40a2d3bb6d4795f67a3a64f1dc)
[ 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 => 9.4539e-5, :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(0xf12ab65b901f142d07fd682effd6e44f)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.8099999999999999, :time_steps => 1, :n_logical_commutations => [2, 3], :error_weight_total => 13, :wall_time => 0.000225948, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.26, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 6, :logical_failure_rate => 0.4, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 4, :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(0x43d8f8cadb5ba40f149c82a9301025a8)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.56, :time_steps => 1, :n_logical_commutations => [1, 2], :error_weight_total => 6, :wall_time => 0.000134809, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.24, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 3, :logical_failure_rate => 0.4, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 2, :n_run => 5)
┌ 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(0x4fd15e190e4dba413c9cbe47fac37172)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.9506172839506175, :time_steps => 1, :n_logical_commutations => [2, 2], :error_weight_total => 11, :wall_time => 0.000171559, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.24444444444444446, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 6, :logical_failure_rate => 0.3333333333333333, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :n_run => 9)
┌ 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.026886773, :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.034562749, :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(0x07221a27bc1034fd858a8f49f1e149c8)
[ 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.000340757, :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(0x11504bac70d8f5ca7509ec5415e5e431)
[ 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.000397336, :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(0x808dde548ccf258264b0894d21734741)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.20999999999999996, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 3, :wall_time => 0.000498395, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.06, :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 = 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(0xf9d5d06ccff2d467972305513baf914b)
[ 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.000236878, :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(0xe1bb8f50c7d1f8681bce8df8b980a3f4)
[ 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.000226657, :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(0x78253fb3a12474b1bd26d721b5e66603)
[ 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.000169948, :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(0xf4882ed34b7d1aa23e238e14ab900baa)
[ 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.000289577, :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(0xcd0a185e56c2f5d76aee55ef6a185c09)
[ 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.000206988, :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(0xbc901cf6e0d176d19a38be50ee6e46c5)
[ 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.000170118, :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(0x951a3c20bea3cdc859d7d3dfa5c310a1)
[ 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.074769055, :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(0xb925f6cbefdc45e43b0fecd6342002cf)
[ 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.000286138, :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(0xcbde5204b456f514c353371cff07b7fb)
[ 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.509773391, :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(0xac72a720e8ee65b80fb375a1f22c9322)
[ 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.514900732, :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(0x23808c7475e00dc6696adeb8372cba81)
[ 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.439400695, :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(0x0251b4773a0159797065e190c32f22bf)
[ 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.074941713, :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(0x0f8a4a9d0a20b37b37c1b0b163c54137)
[ 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.567672728, :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(0xa5064e985d44c61f927d52363a329704)
[ 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.239465979, :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(0x86e047e1bc8da5ed9ad99cca4403b236)
┌ 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(0xf1fd766dae0e7ff800466d9e5ada035b)
┌ 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(0x3003045fcfe5cc7c7ff21251a45b25b9)
┌ 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(0x1638c7546cf6666a520a53d4816127ad)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.4, :time_steps => 1, :n_logical_commutations => [1, 2], :error_weight_total => 10, :wall_time => 0.000437035, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2, :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.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.2
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xd27ee4fa4e1ccd409567a1163f3ba7e8)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.49000000000000005, :time_steps => 1, :n_logical_commutations => [7, 4], :error_weight_total => 19, :wall_time => 0.000420316, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.38, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 3, :logical_failure_rate => 0.7, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 7, :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(0x9ea5b9f3514f1ab383073524a13532ea)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.45, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 5, :wall_time => 0.000376926, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :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)
┌ 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(0xda4f07582e08a5b21d53ff55e4d26cbd)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.61, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 7, :wall_time => 0.000369856, :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 => 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(0x2fcee022a8980e0834627db6a8e851e2)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.41, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 3, :wall_time => 0.016372493, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.06, :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(0xc394c7dd5786aec73db673569d2950fb)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.22222222222222224, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 2, :wall_time => 0.025215598, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.13333333333333333, :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(0xc0ad78a45d378ea0be4965c20aed9941)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.5555555555555554, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 5, :wall_time => 0.000234838, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.3333333333333333, :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(0x27d5d8eb599e0e008c30704347131245)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.61, :time_steps => 1, :n_logical_commutations => [0, 2], :error_weight_total => 7, :wall_time => 0.000497536, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.13999999999999999, :measurement_error_probability => 0.0, :error_probability => 0.08, :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.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x31c6954a17c03d650abc7a9ca4863d55)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.16000000000000006, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 2, :wall_time => 0.000380247, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.04, :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(0xc3921423adbabca3ed38a215b040226c)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.41, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 3, :wall_time => 0.000827042, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.06, :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.41},{"time_steps":1},{"n_logical_commutations":[1,1]},{"error_weight_total":3},{"wall_time":0.000827042},{"n_k_d":[5,1,3]},{"error_model":"Bit-flip"},{"physical_error_rate":0.06},{"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(0xb887269d75b942e382ada83905bb3d04)
[ 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.000405906, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.13999999999999999, :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  1m09.8s
  error.jl                                 |    3      3     7.3s
  PauliTools.jl                            |   43     43    10.6s
  Model.jl                                 |   21     21     2.8s
  models/BasicModels.jl                    |   13     13     0.4s
  models/GenericModels/simpleerrormodel.jl |   44     44     7.9s
  models/GenericModels/naivedecoder.jl     |   16     16     2.3s
  App.jl                                   |  101    101    38.5s
     Testing Qecsim tests passed 

Testing completed after 76.24s

PkgEval succeeded after 119.59s