Package evaluation of Qecsim on Julia 1.13.0-DEV.1191 (63a270f4d4*) started at 2025-09-23T07:17:19.406


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

Installing PkgEval dependencies (TestEnv)...

Set-up completed after 8.82s


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


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

Precompiling PkgEval dependencies...

Precompiling package dependencies...

Precompilation completed after 22.32s


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

     Testing Qecsim
      Status `/tmp/jl_WoY5vZ/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_WoY5vZ/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(0xdf34a5edd8a7ba570b20c9b380b33955)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.9386560000000052, :time_steps => 1, :n_logical_commutations => [207, 213], :error_weight_total => 1188, :wall_time => 0.470394046, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2376, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 685, :logical_failure_rate => 0.315, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 315, :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(0x157bc5b859f5b3106c90ccd212e375e3)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.0, :time_steps => 1, :n_logical_commutations => [1, 0], :error_weight_total => 2, :wall_time => 0.000249677, :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(0xa8fe7c8d1a1e98cfb417e9002e0c04e4)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 1.01, :time_steps => 1, :n_logical_commutations => [4, 3], :error_weight_total => 13, :wall_time => 0.000364997, :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 => 5, :logical_failure_rate => 0.5, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 5, :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(0xf00b0575634df36ffc6c9c2b37aa65fe)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 2.6666666666666665, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 6, :wall_time => 0.000306658, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.39999999999999997, :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(0xaf6171b20e2f3853d447150c72485aee)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6875, :time_steps => 1, :n_logical_commutations => [2, 1], :error_weight_total => 9, :wall_time => 0.000367017, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.45, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 1, :logical_failure_rate => 0.75, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :n_run => 4)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x86f17d7da2ecea306958898b2f2fb04b)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.8745590000000038, :time_steps => 1, :n_logical_commutations => [222, 213], :error_weight_total => 1229, :wall_time => 0.024155493, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.24580000000000002, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 665, :logical_failure_rate => 0.335, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 335, :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(0xc06ff90449cb66b32dfe263cdf2353bb)
[ 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.000201589, :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(0x2e0565901b1137c45370f1ec24085db9)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.8100000000000002, :time_steps => 1, :n_logical_commutations => [4, 4], :error_weight_total => 13, :wall_time => 0.000396426, :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(0x329586be1d28d1a372a298eea44d23a0)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.609375, :time_steps => 1, :n_logical_commutations => [2, 1], :error_weight_total => 7, :wall_time => 0.000337177, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.175, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 6, :logical_failure_rate => 0.25, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 2, :n_run => 8)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.25
│   random_seed = nothing
│   max_runs = 10
└   max_failures = 3
[ Info: qec_run: rng=Random.MersenneTwister(0x9a80800c429ece5735e3c8475a44bb56)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.6938775510204082, :time_steps => 1, :n_logical_commutations => [3, 1], :error_weight_total => 8, :wall_time => 0.000269168, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.2285714285714286, :measurement_error_probability => 0.0, :error_probability => 0.25, :n_success => 4, :logical_failure_rate => 0.42857142857142855, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 3, :n_run => 7)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = 13
│   max_runs = 1000
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(13)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.4977440000000004, :time_steps => 1, :n_logical_commutations => [60, 63], :error_weight_total => 516, :wall_time => 0.042325287, :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.01873464, :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(0x2ec0957d5061480a8b147a3259c685c2)
[ 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.000473976, :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(0x8c563c0438a3258b9200ba997c1665ff)
[ 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.000508895, :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(0x2d3d975736098a18f05e556a1bd06bde)
[ 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.000674494, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :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 => "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(0xabedd705641cece142842ec14009109b)
[ 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.000237008, :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(0xfd0f718b064a9f09c44d83c49a2757fc)
[ 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.000204549, :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(0xe492ab1d04f37e4c31cf689e26349a12)
[ 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.000186898, :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(0x45fa2d45c2501d5b351fc40200963733)
[ 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.000287448, :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(0xca03c26128a8bf98225292f0096f8ff0)
[ 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.000196378, :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(0x6e7320990fbf92d470601d593ad3e602)
[ 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.000208818, :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(0x44f6910b777c7dbf21a9b5cc9f8ef747)
[ 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.312988066, :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(0x5394d8b0450f5509c8ad684a3c34bce6)
[ 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.000266378, :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(0xef8fdb1adbb1573b13be7f8d8cd38770)
[ 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.498497394, :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(0xb6aa6368530b3e4ec389b22ef880430a)
[ 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.493072261, :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(0xebcb94dd0f28044690a2cc4a6c84b84a)
[ 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.403017324, :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(0x5912e6e894d01b54d0df84c432e15dc6)
[ 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.075474332, :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(0xd2181a25555f9a1dd08fbf35be7e2e77)
[ 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.566030054, :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(0x0158d5c39b9613e805d01edaec2e7c60)
[ 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.238446985, :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(0xa9bb7bb5fd8e119409c0b8fd131cd338)
┌ 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(0xde6e8b390a7a7312f651dfbaf1587191)
┌ 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(0x789839f002aef341eab2f9c2c8e801a5)
┌ 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(0x6c1ca245e0f62f2547a200ad528ea8d6)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.76, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 12, :wall_time => 0.000377927, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.24, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 8, :logical_failure_rate => 0.2, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 2, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.2
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xcd1495be9c7abd780be4f0be31eb4acb)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.45, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 5, :wall_time => 0.000319247, :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 => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xc0f7735ed80d4fc0798662052ceb0920)
[ 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.000342847, :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.DepolarizingErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.2
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x72c7973e744ac732a66983b550d98af0)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.44000000000000006, :time_steps => 1, :n_logical_commutations => [0, 1], :error_weight_total => 4, :wall_time => 0.000300807, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.08, :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.BitFlipErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0xcdbe2a3973744584ad59884e2cb90b30)
[ 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.016593948, :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#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(0x0938be17c63ffc2ccb7f87f55ee00223)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.22222222222222224, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 2, :wall_time => 0.028134118, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.13333333333333333, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 1, :logical_failure_rate => 0.6666666666666666, :custom_totals => Any[4, [1, 3, 1]], :code => "5-qubit", :decoder => "cycle", :n_fail => 2, :n_run => 3)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.DepolarizingErrorModel()
│   decoder = Main.var"##App.jl#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(0xb156312dddb700534732f364012c0468)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.22222222222222224, :time_steps => 1, :n_logical_commutations => nothing, :error_weight_total => 2, :wall_time => 0.000273358, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.13333333333333333, :measurement_error_probability => 0.0, :error_probability => 0.2, :n_success => 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(0x34a70ef2290d5a8b969803163e437569)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.20999999999999996, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 3, :wall_time => 0.000390666, :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(0x2e7a4cc0ab2d39143c548db7aebb67c3)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.41, :time_steps => 1, :n_logical_commutations => [1, 1], :error_weight_total => 3, :wall_time => 0.000262837, :n_k_d => (5, 1, 3), :error_model => "Depolarizing", :physical_error_rate => 0.06, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 9, :logical_failure_rate => 0.1, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 1, :n_run => 10)
┌ Info: qec_run: starting
│   code = Qecsim.BasicModels.BasicCode(["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], ["XXXXX"], ["ZZZZZ"], (5, 1, 3), "5-qubit")
│   error_model = Qecsim.GenericModels.BitFlipErrorModel()
│   decoder = Qecsim.GenericModels.NaiveDecoder(10)
│   p = 0.1
│   random_seed = nothing
│   max_runs = 10
└   max_failures = nothing
[ Info: qec_run: rng=Random.MersenneTwister(0x101f6307ace6fd9096cb38c29c0cf66c)
[ 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.000365467, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.06, :measurement_error_probability => 0.0, :error_probability => 0.1, :n_success => 10, :logical_failure_rate => 0.0, :custom_totals => nothing, :code => "5-qubit", :decoder => "Naive", :n_fail => 0, :n_run => 10)
┌ Error: Recovered data: [{"error_weight_pvar":0.21000000000000002},{"time_steps":1},{"n_logical_commutations":[0,0]},{"error_weight_total":3},{"wall_time":0.000365467},{"n_k_d":[5,1,3]},{"error_model":"Bit-flip"},{"physical_error_rate":0.06},{"measurement_error_probability":0.0},{"error_probability":0.1},{"n_success":10},{"logical_failure_rate":0.0},{"custom_totals":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(0x6d18d1814828641bcb86d39d9da73f5d)
[ Info: qec_run: complete: data=Dict{Symbol, Any}(:error_weight_pvar => 0.09000000000000001, :time_steps => 1, :n_logical_commutations => [0, 0], :error_weight_total => 1, :wall_time => 0.000323027, :n_k_d => (5, 1, 3), :error_model => "Bit-flip", :physical_error_rate => 0.02, :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  1m13.9s
  error.jl                                 |    3      3     7.3s
  PauliTools.jl                            |   43     43    11.0s
  Model.jl                                 |   21     21     4.0s
  models/BasicModels.jl                    |   13     13     0.5s
  models/GenericModels/simpleerrormodel.jl |   44     44     8.2s
  models/GenericModels/naivedecoder.jl     |   16     16     2.3s
  App.jl                                   |  101    101    40.5s
     Testing Qecsim tests passed 

Testing completed after 81.81s

PkgEval succeeded after 135.73s