Package evaluation of Qecsim on Julia 1.13.0-DEV.955 (13f6b3b5c0*) started at 2025-08-03T14:48:41.250


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

Installing PkgEval dependencies (TestEnv)...

Set-up completed after 9.52s


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

Installing Qecsim...
   Resolving package versions...
    Updating `~/.julia/environments/v1.13/Project.toml`
  [e6c2bad3] + Qecsim v0.1.0
    Updating `~/.julia/environments/v1.13/Manifest.toml`
  [861a8166] + Combinatorics v1.0.3
  [34da2185] + Compat v4.18.0
  [9a962f9c] + DataAPI v1.16.0
⌅ [864edb3b] + DataStructures v0.18.22
  [ffbed154] + DocStringExtensions v0.9.5
  [92d709cd] + IrrationalConstants v0.2.4
  [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.2
  [21216c6a] + Preferences v1.4.3
  [e6c2bad3] + Qecsim v0.1.0
  [189a3867] + Reexport v1.2.2
  [a2af1166] + SortingAlgorithms v1.2.1
  [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 v0.7.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.13.1+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 3.85s


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

Precompiling PkgEval dependencies...

Precompiling package dependencies...

Precompilation completed after 20.95s


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

     Testing Qecsim
      Status `/tmp/jl_feJDZh/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_feJDZh/Manifest.toml`
  [861a8166] Combinatorics v1.0.3
  [34da2185] Compat v4.18.0
  [9a962f9c] DataAPI v1.16.0
⌅ [864edb3b] DataStructures v0.18.22
  [ffbed154] DocStringExtensions v0.9.5
  [92d709cd] IrrationalConstants v0.2.4
  [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.2
  [21216c6a] Preferences v1.4.3
  [e6c2bad3] Qecsim v0.1.0
  [189a3867] Reexport v1.2.2
  [1bc83da4] SafeTestsets v0.1.0
  [a2af1166] SortingAlgorithms v1.2.1
  [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 v0.7.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.13.1+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(0x84abd715a1f26ad5598716351ed6222b)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.9101760000000061, :time_steps => 1, :n_logical_commutations => [241, 233], :error_weight_total => 1268, :wall_time => 0.570031593, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2536, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 647, :logical_failure_rate => 0.353, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 353, :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(0x8182b93bff4118405d8424bbe1f74fa8)
[ 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.000270907, :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(0x336bbdae0a24dabd53d6be08c0faa531)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.36000000000000004, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 8, :wall_time => 0.000466576, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.16, :measurement_error_probability => 0.0, :error_probability => 0.25, :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.25
│   random_seed = nothing
│   max_runs = nothing
└   max_failures = 2
[ Info: qec_run: rng=Random.MersenneTwister(0x8624f436813446c2858c613181ce25cb)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.2222222222222222, :time_steps => 1, :n_logical_commutations => [1, 2], :error_weight_total => 5, :wall_time => 0.000379796, :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(0x4682a1fa3456391896607c2f1a909748)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.1111111111111112, :time_steps => 1, :n_logical_commutations => [3, 2], :error_weight_total => 9, :wall_time => 0.000480465, :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 => 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.25
│   random_seed = nothing
│   max_runs = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xa0bf0c7d2883a517291148cdfcf6e2a6)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.9594839999999979, :time_steps => 1, :n_logical_commutations => [218, 228], :error_weight_total => 1254, :wall_time => 0.029515201, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2508, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 660, :logical_failure_rate => 0.34, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 340, :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(0xd8f39643fc850f7e954eb498dd14c217)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 1, :wall_time => 0.000199198, :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 => 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(0xef8aa20b2d278ac95d9c902dfd023705)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.64, :time_steps => 1, :n_logical_commutations => [2, 3], :error_weight_total => 14, :wall_time => 0.000405906, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.27999999999999997, :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(0xc243e23a63066b2d82520af9b4c7d72e)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [1, 2], :error_weight_total => 6, :wall_time => 0.000177778, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.6, :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 => 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 = 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(0x8a4c240bdc4ff094412e4b7d9ced13e2)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.1875, :time_steps => 1, :n_logical_commutations => [0, 3], :error_weight_total => 7, :wall_time => 0.000204418, :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.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.047375426, :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.020429289, :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#290"._DuckCode()
│   error_model = Main.var"##App.jl#290"._DuckErrorModel()
│   decoder = Main.var"##App.jl#290"._DuckDecoder()
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xa52509ef9657ace209dfd71006848e04)
[ 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.000492985, :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#290"._DuckCode()
│   error_model = Main.var"##App.jl#290"._DuckErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x3bd04ab9cfccfa186b4d93755b596771)
[ 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.000650924, :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#290"._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(0xa33f5409e420cd8082f141e5bd7e3a63)
[ 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.000903881, :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 => "duck", :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 = Main.var"##App.jl#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x36a74151ee4c054d11f018a733328e2b)
[ 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.000512705, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x21e97e43914c5de42460488b152fa9bd)
[ 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.000239748, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x8159d207e2178f7b0209c9fb0aa40f6b)
[ 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.000194598, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x02b6ab34d0dead7917cf3a50af4cf9c0)
[ 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.000319567, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x7ad62ca2d9cc418f60171871d3c18e9c)
[ 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.000290797, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x8d0675f8a58bbc66245972bd23f48538)
[ 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.000287807, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0xfbf2e44a9dc44bcb966334b865b772f0)
[ 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.080411592, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x9c3913cd3f27ae9d06897f94dcb0d1ba)
[ 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.000305107, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x71b893d0cc48d4343c787c010b97a932)
[ 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.559669996, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x1a2612dc54abeb93ab57f4668ff8d543)
[ 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.591674463, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0xaacb0d8047f4437b3927a2b1aeb45c88)
[ 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.504345379, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x6c9f7259f7a273fb8c0797349ccd0881)
[ 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.080414803, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0xa781e9c0abd10a1c5f441bffd64fac89)
[ 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.613475971, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x8cd0a9ba7423af922907cec1cec5f7b5)
[ 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.253603816, :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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0x387e8dd2dddb0f96ce4a0ef9f131fbf4)
┌ 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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0xf4b676a15c092d2e4adbdc21812e06f5)
┌ 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#290"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#290"._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(0xe378aa876f839b511e8020ef06ed9e96)
┌ 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(0xac34129b49831a8e0efc148e8aab3db9)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.76, :time_steps => 1, :n_logical_commutations => [1, 2], :error_weight_total => 8, :wall_time => 0.000393316, :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 => 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.2
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xec06e8d982f9a901d38f4dca5d9f1ba5)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.76, :time_steps => 1, :n_logical_commutations => [2, 2], :error_weight_total => 8, :wall_time => 0.000262507, :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 => 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.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x72cf572d2b07d053b534d033b0169d11)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.8400000000000002, :time_steps => 1, :n_logical_commutations => [0, 1], :error_weight_total => 4, :wall_time => 0.000482125, :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 => 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(0x1cbf537d572f4732d72615536e75ceff)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.25, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 5, :wall_time => 0.000301318, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.1, :measurement_error_probability => 0.0, :error_probability => 0.2, :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(0xe33b2bfc389ed452cd8d6cc73af47c75)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.44000000000000006, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 4, :wall_time => 0.017089292, :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#290"._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(0x74e91e72bd3e103d012054722117b326)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.5555555555555556, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 5, :wall_time => 0.030807968, :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 => 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#290"._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(0xb0eedbda1ad9926aa53cb689b9443f7d)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.888888888888889, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 5, :wall_time => 0.000277947, :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(0x00e4c29500fb556b62633614f188a4e7)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.25, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 5, :wall_time => 0.000318556, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.1, :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(0x4965c1d3069958656a251e7d570a0e96)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6400000000000001, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 6, :wall_time => 0.000353586, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.12, :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.BitFlipErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x0cfece73a9e54bd93a27ee00bc46e15a)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.4400000000000001, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 4, :wall_time => 0.000478826, :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)
┌ Error: Recovered data: [{"error_weight_pvar":0.4400000000000001},{"time_steps":1},{"n_logical_commutations":[1,1]},{"error_weight_total":4},{"wall_time":0.000478826},{"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":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(0xdae1ebb4c5bba61e418760d89c67621d)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.24, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 4, :wall_time => 0.000514565, :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 => 10, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 0, :n_run => 10)
Test Summary:                              | Pass  Total     Time
Qecsim.jl                                  |  241    241  1m14.4s
  error.jl                                 |    3      3     8.0s
  PauliTools.jl                            |   43     43     9.8s
  Model.jl                                 |   21     21     2.9s
  models/BasicModels.jl                    |   13     13     0.6s
  models/GenericModels/simpleerrormodel.jl |   44     44     8.0s
  models/GenericModels/naivedecoder.jl     |   16     16     2.3s
  App.jl                                   |  101    101    42.8s
     Testing Qecsim tests passed 

Testing completed after 81.81s

PkgEval succeeded after 150.85s