Package evaluation of Qecsim on Julia 1.13.0-DEV.1080 (ed57414aec*) started at 2025-09-04T14:26:47.549


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

Installing PkgEval dependencies (TestEnv)...

Set-up completed after 10.11s


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


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

     Testing Qecsim
      Status `/tmp/jl_fY2gwh/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_fY2gwh/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.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 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(0x5c19d6455c57db263a9b128e512e96bd)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.8973560000000054, :time_steps => 1, :n_logical_commutations => [229, 228], :error_weight_total => 1238, :wall_time => 0.382827582, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2476, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 654, :logical_failure_rate => 0.346, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 346, :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(0x07b9dcadf12a8cec5789c294d38a137f)
[ 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.000282608, :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(0x10210eb2c61d0d3b2a8c5633e8f648bd)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6100000000000001, :time_steps => 1, :n_logical_commutations => [0, 2], :error_weight_total => 13, :wall_time => 0.000558007, :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 => 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.25
│   random_seed = nothing
│   max_runs = nothing
└   max_failures = 2
[ Info: qec_run: rng=Random.MersenneTwister(0x9037fa8b47290ddeaf8eb35bcbf9cd89)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.36, :time_steps => 1, :n_logical_commutations => [2, 2], :error_weight_total => 6, :wall_time => 0.000412238, :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(0x7ce9035dded38e1346829f3ca43cf0f6)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.9600000000000002, :time_steps => 1, :n_logical_commutations => [2, 1], :error_weight_total => 6, :wall_time => 0.000384198, :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 => 2, :logical_failure_rate => 0.6, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :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 = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xeed726154a41ac127c3d7fd790958fc4)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.9375999999999972, :time_steps => 1, :n_logical_commutations => [223, 223], :error_weight_total => 1220, :wall_time => 0.020464485, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.244, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 661, :logical_failure_rate => 0.339, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 339, :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(0x8121a7fe02a26fbc160235c19c709509)
[ 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.000153499, :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(0x02666d7002719f32c1e7f2144c3a92bf)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.41, :time_steps => 1, :n_logical_commutations => [3, 2], :error_weight_total => 13, :wall_time => 0.000298779, :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(0xba8f88b1646a78bcb7a7c2b412520b17)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.24, :time_steps => 1, :n_logical_commutations => [2, 1], :error_weight_total => 7, :wall_time => 0.000239899, :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 => 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(0xd53958e1c2b53472e46c491d5458401c)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.8888888888888893, :time_steps => 1, :n_logical_commutations => [1, 3], :error_weight_total => 10, :wall_time => 0.000209779, :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 => 3, :logical_failure_rate => 0.5, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :n_run => 6)
┌ 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.051463735, :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.054544542, :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#146"._DuckCode()
│   error_model = Main.var"##App.jl#146"._DuckErrorModel()
│   decoder = Main.var"##App.jl#146"._DuckDecoder()
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x87d15b9f00107d0a971def4db41c1257)
[ 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.000527448, :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#146"._DuckCode()
│   error_model = Main.var"##App.jl#146"._DuckErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xb905c7186f4ca427a9320627c4f21093)
[ 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.000644247, :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#146"._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(0xbe890379deb43bab8867194384cc0ebf)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.24000000000000005, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 4, :wall_time => 0.000873136, :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 => "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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x0d39112476a5498eb48a618f5848a7b1)
[ 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.000210699, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0xb16d630104c368085cb6e6838ab97c9f)
[ 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.000227559, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x4a15a1076ba99799547b168f1eb89478)
[ 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.000139229, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0xfe79ceaa104ecdb63528e45572ef3f01)
[ 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.000245789, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x2cc64499593e21c751823fdfdc17d3fc)
[ 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.000166779, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x59d78975cd083b58874c2c4aa23fd8cf)
[ 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.00019616, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0xe2324af83570f9bf9ac6094d5ae707df)
[ 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.065196635, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x705648a8fe44613e41a13217f1df2eba)
[ 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.000235699, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x88292c51e7e23b358dbd938bb1336e33)
[ 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.489854819, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x36b2e970a84140f51336868a9c41837a)
[ 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.460507461, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x49e81c54b51204a61636d488e04d6309)
[ 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.368483927, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x2ba3e67aed00eb5fed0a2490b5d2543b)
[ 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.06628817, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0xda0fa3a28a1c6f407ef51dfa3fc91494)
[ 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.594398068, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0xd4c5369b2ed8afa6ee9f2af2c5fce1d4)
[ 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.258582367, :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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0xe0c164dec57d1d62d532ec60206237c6)
┌ 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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0x0137b6037600477f6472ce68b14b0f56)
┌ 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#146"._FixedErrorModel(Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
│   decoder = Main.var"##App.jl#146"._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(0xc8e9daa7735d18b662836f633ce2c4ee)
┌ 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(0xb0799e1035169719c7e32119a6d3776a)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.29, :time_steps => 1, :n_logical_commutations => [0, 1], :error_weight_total => 9, :wall_time => 0.000441768, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.18, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.2
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x4dddae85718625145dc9ccadbcffc7ba)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.2900000000000003, :time_steps => 1, :n_logical_commutations => [2, 1], :error_weight_total => 9, :wall_time => 0.000384059, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.18, :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.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xc4a640bfd2bec9f2ca8ef785813e1f79)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.4400000000000001, :time_steps => 1, :n_logical_commutations => [1, 0], :error_weight_total => 4, :wall_time => 0.000397038, :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(0x0240b087329bae8e7f73d27d736a2bf5)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.48999999999999994, :time_steps => 1, :n_logical_commutations => [1, 2], :error_weight_total => 11, :wall_time => 0.000518477, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.22000000000000003, :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.BitFlipErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xe1a528178f1c442d27e41acec208fd78)
[ 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.019940805, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.1, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
┌ 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#146"._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(0x6d002632735c1f427002c756e1401fd2)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6666666666666666, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 3, :wall_time => 0.031059168, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.19999999999999998, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 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#146"._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(0xd73f921fead9a250238fba2d64a36f70)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.22222222222222224, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 1, :wall_time => 0.000331228, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.06666666666666667, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 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(0x4915ed58cb1cd2a52a17b9b104774588)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.21000000000000002, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 3, :wall_time => 0.000368908, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.06, :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(0x20046bdced928113f78ed7934d9c39e0)
[ 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.000323169, :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(0xd828f0ae5df774beb8651ab46619a709)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.24000000000000005, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 6, :wall_time => 0.000380359, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.12, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 10, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 0, :n_run => 10)
┌ Error: Recovered data: [{"error_weight_pvar":0.24000000000000005},{"time_steps":1},{"n_logical_commutations":[0,0]},{"error_weight_total":6},{"wall_time":0.000380359},{"n_k_d":[5,1,3]},{"error_model":"Bit-flip"},{"physical_error_rate":0.12},{"measurement_error_probability":0.0},{"error_probability":0.1},{"n_success":10},{"logical_failure_rate":0.0},{"custom_totals":null},{"code":"5-qubit"},{"decoder":"Naive"},{"n_fail":0},{"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(0x78ed2aeb42470ac40772f21a5bdae09d)
[ 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.000597877, :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 => 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  1m18.5s
  error.jl                                 |    3      3     6.9s
  PauliTools.jl                            |   43     43    10.0s
  Model.jl                                 |   21     21     4.4s
  models/BasicModels.jl                    |   13     13     0.7s
  models/GenericModels/simpleerrormodel.jl |   44     44     9.4s
  models/GenericModels/naivedecoder.jl     |   16     16     2.8s
  App.jl                                   |  101    101    44.2s
     Testing Qecsim tests passed 

Testing completed after 85.97s

PkgEval succeeded after 145.57s