From 80335672ed8eefd3d02a6e9415045e0ba65ae9db Mon Sep 17 00:00:00 2001 From: Transaction Science Date: Sun, 4 Oct 2026 17:33:48 -0400 Subject: [PATCH] wai-quantum 0.3.29: the architecture around the code, priced, and the 2025 factoring machine re-run quantum_arch prices what has cut projected fault-tolerant cost since 2023 without a better qubit: - Yoked storage (arXiv:2312.04522): plain, row-yoked and grid-yoked patches, cold and hot, under the published path-counting fits (SI1000, uniform, and the refit used by arXiv:2505.15917). The layout search matches the source's own footprint tool on all 915 layouts it produces (three fit sets, 61 targets, five storage kinds): distance, block shape, check period and qubits per logical qubit. - Whole-block storage plans: copies of one shape plus one remainder block, capped at the block sizes the fits were drawn from. - Magic-state cultivation (arXiv:2409.17595), read off the published end-to-end curves (Apache-2.0 data), interpolated log-linearly; refuses unsimulated noise strengths. - 8T-to-CCZ factories and a clock set by the slowest of lattice surgery, the CCZ supply and the control loop; it says which one binds. - The factoring workload of arXiv:2505.15917: its operation tallies, logical qubits and Toffoli counts. Under the source's counting rule the counts match its reference implementation to its rounding of half operations, for every tabulated key size (1024 to 8192 bits). Re-running the 2048-bit estimate reproduces its 897,864 qubits from its layout and its 429.03 qubits per cold logical qubit from its fit. It also finds six places where the source disagrees with itself: - its tallies at its stated durations give 10.62 h per shot, not 12.07 h; - its hot-storage count (131) sits below its own peak formula (152); - its reference counting code prices a 6-bit phaseup at 0.25 Toffolis, not 8 (+1.7%); - loop 4's table swaps additions and lookups relative to its code; - its 30,000 qubit-rounds per 10^-7 T state is 22,600 in the data behind the figure; - 1280 cold qubits need seven whole blocks (582,624 qubits), not 550,400. With every correction the machine is 958,480 qubits and 4.3 days: the conclusion holds. CLI: wai-quantum arch factoring|storage|cultivate [--json]. Example: arch_factoring. Pinned bit for bit natively and under wasm32-wasip2; CLI output byte-identical across the two. Co-Authored-By: Claude Opus 5.5 --- wai/wai-quantum-serve/Cargo.lock | 2 +- wai/wai-quantum/Cargo.lock | 2 +- wai/wai-quantum/Cargo.toml | 11 +- wai/wai-quantum/README.md | 27 + wai/wai-quantum/examples/arch_factoring.rs | 28 + wai/wai-quantum/src/lib.rs | 6 +- wai/wai-quantum/src/quantum_arch.rs | 1357 +++++++++++++++++ wai/wai-quantum/src/repro.rs | 28 +- wai/wai-quantum/tests/bit_identity.rs | 47 +- .../tests/data/yoked_footprint_oracle.csv | 916 +++++++++++ wai/wai-rs/Cargo.lock | 2 +- wai/wai-rs/Cargo.toml | 4 + wai/wai-rs/src/bin/wai_quantum.rs | 82 + wai/wai-rs/src/lib.rs | 3 + wai/wai-web/Cargo.lock | 2 +- 15 files changed, 2495 insertions(+), 22 deletions(-) create mode 100644 wai/wai-quantum/examples/arch_factoring.rs create mode 100644 wai/wai-quantum/src/quantum_arch.rs create mode 100644 wai/wai-quantum/tests/data/yoked_footprint_oracle.csv diff --git a/wai/wai-quantum-serve/Cargo.lock b/wai/wai-quantum-serve/Cargo.lock index dfd94bbcb..8ce676bc5 100644 --- a/wai/wai-quantum-serve/Cargo.lock +++ b/wai/wai-quantum-serve/Cargo.lock @@ -589,7 +589,7 @@ dependencies = [ [[package]] name = "wai-quantum" -version = "0.3.28" +version = "0.3.29" dependencies = [ "blake3", "ed25519-dalek", diff --git a/wai/wai-quantum/Cargo.lock b/wai/wai-quantum/Cargo.lock index 47acef1df..22101dd04 100644 --- a/wai/wai-quantum/Cargo.lock +++ b/wai/wai-quantum/Cargo.lock @@ -415,7 +415,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "wai-quantum" -version = "0.3.28" +version = "0.3.29" dependencies = [ "blake3", "ed25519-dalek", diff --git a/wai/wai-quantum/Cargo.toml b/wai/wai-quantum/Cargo.toml index ba231cd9c..2b032b640 100644 --- a/wai/wai-quantum/Cargo.toml +++ b/wai/wai-quantum/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "wai-quantum" -version = "0.3.28" +version = "0.3.29" edition = "2024" rust-version = "1.97" license = "Apache-2.0" @@ -65,6 +65,9 @@ quantum_gbs = [] # The dense state vector at any angle: gate fusion, diagonal fast paths, threads, # the same bits everywhere. quantum_sv = [] +# Architecture-level estimation: yoked storage, magic-state cultivation, CCZ +# factories and reaction-limited time, assembled into whole-machine estimates. +quantum_arch = [] # Mixed states and the observables that distinguish quantum theory from a classical # account: density matrices, the partial trace, exact Pauli expectations, CHSH. quantum_info = ["quantum"] @@ -104,13 +107,17 @@ quantum_phasor_meter = ["_signing"] # Everything. full = [ - "quantum", "quantum_toolchain", "quantum_mps", "quantum_stabilizer", "quantum_pauli", "quantum_spd", "quantum_spd_receipt", "quantum_bptn", "quantum_resource", "quantum_resource_receipt", "quantum_frame", "quantum_tn", "quantum_gbs", "quantum_sv", "quantum_qir", "quantum_info", "quantum_qudit", "quantum_comm", "quantum_source", "quantum_channel", + "quantum", "quantum_toolchain", "quantum_mps", "quantum_stabilizer", "quantum_pauli", "quantum_spd", "quantum_spd_receipt", "quantum_bptn", "quantum_resource", "quantum_resource_receipt", "quantum_frame", "quantum_tn", "quantum_gbs", "quantum_sv", "quantum_arch", "quantum_qir", "quantum_info", "quantum_qudit", "quantum_comm", "quantum_source", "quantum_channel", "quantum_receipt", "quantum_ops", "quantum_cal", "quantum_mitigate", "quantum_qec", "quantum_control", "quantum_noise", "quantum_compile", "quantum_atom", "quantum_qbom", "quantum_vml", "quantum_phasor", "quantum_qfhrr", "quantum_kernel", "quantum_qdata", "quantum_phasor_meter", ] +[[example]] +name = "arch_factoring" +required-features = ["quantum_arch"] + [[example]] name = "sv_run" required-features = ["quantum_sv"] diff --git a/wai/wai-quantum/README.md b/wai/wai-quantum/README.md index 031959f77..4b984f261 100644 --- a/wai/wai-quantum/README.md +++ b/wai/wai-quantum/README.md @@ -64,6 +64,7 @@ never creates information. | `quantum_bptn` | **tensor-network states on the hardware graph**: simple-update evolution with belief-propagation environments and re-gauging, the device's couplings applied a layer at a time in parallel (bit-identical to one at a time). Exact on trees; on the 127-qubit lattice it gives the exactly computed 5-step magnetization to 4e-7 at bond dimension 32 — an independent check on sparse Pauli dynamics, whose errors it does not share | | `quantum_resource` | **fault-tolerant resource estimation**: from a program's logical counts (qubits, T, Toffoli and rotation gates, measurements) to code distance, T-state factories found by exhaustive search, physical qubits and runtime, on six reference qubits and three codes, with the qubits-versus-time frontier. Reproduces the published worked examples to their printed precision | | `quantum_resource_receipt` | a signed, energy-accounted receipt over an estimate, re-checkable bit for bit on any machine | +| `quantum_arch` | **architecture-level estimation**: yoked surface-code storage (row and grid parity checks over patches, hot and cold), magic-state cultivation read off the published simulation curves, CCZ factories, and a clock set by whichever is slowest of lattice surgery, the magic-state supply and the control loop. Assembles whole-machine estimates; its storage search matches the source's footprint tool layout for layout | | `quantum_receipt` | signed, energy-accounted receipt over a reconstruction | | `quantum_ops` | the operations/attestation layer | | `quantum_cal`, `quantum_control`, `quantum_noise` | calibration, filter-function robust control, DD noise spectroscopy, Cycle-Benchmarking noise learning | @@ -152,6 +153,32 @@ search limits, to the bit). Re-running it anywhere must reproduce every figure, down to each factory round, and the bytes are the same natively and as a WASI component. +## Architecture + +```sh +wai-quantum arch factoring --bits 2048 # the whole machine, region by region +wai-quantum arch storage --target 1e-15 # cheapest plain, row- and grid-yoked layouts +wai-quantum arch cultivate --p 1e-3 --target 1e-7 +``` + +Most of the recent fall in projected fault-tolerant cost comes from the +architecture around the code, not from better qubits. Idle qubits sit in yoked +storage (arXiv:2312.04522). T states are cultivated inside one patch rather +than distilled (arXiv:2409.17595). The clock runs at the pace of the slowest of +lattice surgery, the magic-state supply and the control loop. `quantum_arch` +prices each of these. + +It re-runs the 2025 estimate that 2048-bit factoring takes under a week on +under a million noisy qubits (arXiv:2505.15917). +- **Reproduced.** Its 897,864 physical qubits, its storage density of + 429.03 qubits per logical qubit, and its Toffoli counts for every tabulated + key size, each to the reference implementation's own rounding. +- **Corrected.** Re-running it surfaced six places where the source disagrees + with itself, each documented in the module. Its hot-storage count is below + its own peak formula. Its cold storage assumes fractional blocks. Its + printed runtime is 14% above its own tallies. With every correction applied, + the machine needs 958,480 qubits and 4.3 days. The conclusion holds. + ## Error correction at circuit level An error-correction experiment is a noisy Clifford circuit, its detectors and diff --git a/wai/wai-quantum/examples/arch_factoring.rs b/wai/wai-quantum/examples/arch_factoring.rs new file mode 100644 index 000000000..836b428e3 --- /dev/null +++ b/wai/wai-quantum/examples/arch_factoring.rs @@ -0,0 +1,28 @@ +//! Re-run a published factoring estimate on a whole machine, and print every +//! region, the clock and the totals. +//! +//! ```text +//! cargo run --release --example arch_factoring --features quantum_arch -- [BITS] +//! ``` +use wai_quantum::quantum_arch::{factoring_estimate, FactoringParams, Machine, PhaseupCount}; + +fn main() { + let bits: u32 = std::env::args().nth(1).map_or(2048, |a| a.parse().expect("modulus bits")); + let params = FactoringParams::published(bits).expect("one of 1024, 1536, 2048, 3072, 4096, 6144, 8192"); + let machine = Machine::published(); + let e = factoring_estimate(¶ms, &machine).expect("estimate"); + println!("modulus bits {bits}"); + println!("logical qubits {} cold + {} hot (peak {})", e.cold_logical, e.hot_logical, params.peak_logical_qubits()); + println!("hot distance {}", e.hot_distance); + for (b, k) in &e.cold.blocks { + println!("cold block {k} × {}×{} grid at d={} ({} logical, {:.2} qubits each)", b.rows - 1, b.cols - 1, b.distance, b.logical, b.qubits_per_logical()); + } + println!("physical qubits {} cold + {} hot + {} compute = {}", e.cold_qubits, e.hot_qubits, e.compute_qubits, e.physical_qubits()); + println!("T state d1={} error {:.2e} at {:.0} qubit·rounds", e.t_state.d1, e.t_state.error, e.t_state.volume); + println!("CCZ {:.1} rounds per factory, error {:.1e}", e.ccz_rounds, e.ccz_error); + println!("clock step {:.1} µs ({:?}-bound)", e.timing.step_us(), e.timing.bound()); + println!("toffolis per shot {:.4e} (source rule {:.4e}, as stated {:.4e})", e.toffolis_per_shot, params.toffolis_per_shot_source_rule(PhaseupCount::AsCoded), params.toffolis_per_shot_source_rule(PhaseupCount::AsStated)); + println!("hours per shot {:.3} at the clock, {:.3} at whole milliseconds", e.hours_per_shot, e.hours_per_shot_rounded); + println!("shots {:.3} expected, survival {:.4}", e.expected_shots, e.shot_survival); + println!("days {:.3}", e.days); +} diff --git a/wai/wai-quantum/src/lib.rs b/wai/wai-quantum/src/lib.rs index a30de7c50..772ac7e41 100644 --- a/wai/wai-quantum/src/lib.rs +++ b/wai/wai-quantum/src/lib.rs @@ -35,7 +35,8 @@ pub mod gates; feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", - feature = "quantum_sv" + feature = "quantum_sv", + feature = "quantum_arch" ))] mod repro; @@ -99,6 +100,9 @@ pub mod quantum_resource; #[cfg(feature = "quantum_resource_receipt")] pub mod quantum_resource_receipt; +#[cfg(feature = "quantum_arch")] +pub mod quantum_arch; + #[cfg(feature = "quantum_frame")] pub mod quantum_frame; diff --git a/wai/wai-quantum/src/quantum_arch.rs b/wai/wai-quantum/src/quantum_arch.rs new file mode 100644 index 000000000..bd9009557 --- /dev/null +++ b/wai/wai-quantum/src/quantum_arch.rs @@ -0,0 +1,1357 @@ +//! Architecture-level ESTIMATION — `wai.quantum.arch`. +//! +//! Since 2023 the projected cost of a fault-tolerant computation has fallen by +//! an order of magnitude without a better qubit. The savings come from the +//! architecture around the code: +//! +//! - **Yoked storage** (arXiv:2312.04522). Idle logical qubits sit in +//! surface-code patches bound together by row (and column) parity checks. +//! This takes about a third of the qubits of plain patches at the same +//! error. +//! - **Magic-state cultivation** (arXiv:2409.17595). A T state is grown inside +//! one patch and kept only if every check passes, instead of being distilled +//! from fifteen. +//! - **Reaction-limited scheduling.** A step runs at the pace of the slowest of +//! three things: lattice surgery, the magic-state supply, or the classical +//! control loop. +//! +//! This module prices all three and assembles them into a whole-machine +//! estimate. As in the planar estimator (`quantum_resource`), every number is a +//! deterministic function of its inputs: `+ − × ÷` and in-crate logarithms, +//! with the same bits on every machine. +//! +//! # Storage +//! +//! A patch of distance `d` covers `2(d+1)²` physical qubits; the margin leaves +//! room for lattice surgery. Storage errors follow path-counting fits. Each +//! fit gives the logical error per patch per round: +//! +//! ```text +//! p = r^(a−1) · n^(b−1) / (C · Λ^d) +//! ``` +//! +//! Here `r` is the number of rounds between yoke checks and `n` the number of +//! patches per yoked block. The exponents are `(a, b) = (1, 1)` for plain +//! patches, `(2, 2)` for row yokes and `(4, 2)` for grid yokes. This is +//! multiplied by `n / k` to give the error per *logical* qubit per round. +//! +//! - **Cold storage.** Blocks share one hallway that walks through them to +//! measure the yokes. A row-yoked block of `g` groups is checked every +//! `(8g + 2)·d` rounds. A `w × w` grid block is checked every `(25w + 4)·d` +//! rounds and stores `w² − 4w + 2` logical qubits in `(w+1)²` patches. +//! - **Hot storage.** Every patch faces an access hallway. Row yokes are +//! checked every `50d` rounds. +//! +//! The search for the cheapest layout per logical qubit is held to the source's +//! own footprint tool. There are three fit sets ([`StorageModel::si1000`], +//! [`StorageModel::uniform`], [`StorageModel::uniform_refit`]). For each, the +//! layout is checked at 61 targets from 10⁻¹⁸ to 10⁻³, for plain, row-yoked +//! and grid-yoked storage, cold and hot. Every distance, block shape and +//! qubit count is identical. +//! +//! # Magic states +//! +//! [`cultivate`] reads the cheapest T state meeting an error target off the +//! cultivation curves. Those curves come from the published end-to-end +//! simulations: 10⁹–10¹² shots per point, released under Apache-2.0. A curve +//! gives the expected qubit·rounds per kept state (retries included) at each +//! postselection cutoff, for injection distance 3 or 5 and noise 5·10⁻⁴, +//! 10⁻³ or 2·10⁻³. +//! +//! The simulations swap the T gate for an S gate, so they can run on a +//! stabilizer simulator. As the source does, the error is then doubled to +//! stand in for T. +//! +//! [`CczFactory`] turns eight T states into one CCZ state, with output error +//! `28·p_T²` (arXiv:1212.5069). The factory is a 3 × 4 block of patches running +//! six layers of temporally encoded lattice surgery. +//! +//! # Time +//! +//! [`Timing`] sets the clock. A step takes the longest of three times: +//! - the lattice-surgery period, `d` rounds; +//! - the CCZ supply period, rounds per CCZ divided by the number of factories; +//! - the reaction time of the control system. +//! +//! [`Timing::bound`] says which of the three binds. +//! +//! On that clock: +//! - an `n`-bit addition consumes `n − 1` CCZ states and then uncomputes, for +//! `2(n−1)` steps; +//! - a lookup over `w` address bits takes `2ʷ − 1` steps; +//! - a phaseup takes half a lookup. +//! +//! # The 2025 factoring estimate, re-run +//! +//! arXiv:2505.15917 estimates that a 2048-bit RSA modulus can be factored in +//! under a week on under a million noisy qubits. Its assumptions are: +//! - a square grid; +//! - a uniform error rate of 10⁻³; +//! - a 1 µs cycle; +//! - a 10 µs reaction time. +//! +//! [`FactoringParams`] carries its algorithm parameters. [`factoring_estimate`] +//! re-runs the whole estimate from them. +//! +//! **Reproduced.** +//! - **Physical qubits.** The total of 897,864 is reproduced exactly from the +//! source's layout: +//! - 1280 cold logical qubits at 430 qubits each; +//! - 131 hot patches at distance 25; +//! - a 7 × 18 compute region holding six factories. +//! - **Cold-storage density.** The 430 is the published fit evaluated. Grid +//! blocks 16 patches wide at distance 11 give 429.03 qubits per logical +//! qubit at 10⁻¹⁵ per round. +//! - **Logical counts.** The source's Toffoli count, `6.5·10⁹` per factoring, +//! and its 1399 logical qubits follow from its operation tallies under its +//! counting rule. +//! +//! **Where the source disagrees with itself.** Re-running it surfaced six +//! places. None of them moves the conclusion: under a million qubits and under +//! a week. +//! - **Runtime per shot.** The source's tallies, at its stated durations (2 ms +//! per addition and per lookup, 1 ms per phaseup), give 10.62 h per shot. +//! It prints 12.07 h, so its own estimate is conservative by 14%. +//! - **Hot storage.** The layout keeps 131 logical qubits hot, but the source +//! gives three other counts. +//! - Its peak formula `m + 3f + 2ℓ + len m` evaluates to 1432 at loop 4, +//! which is 152 hot. +//! - The text prints 1409 beside that formula. +//! - Its table gives 1399, which is 119 hot. +//! +//! At 152 hot the machine takes 926,256 physical qubits, still under a +//! million. +//! - **Phaseup Toffolis.** The source's reference counting code has an exponent +//! sign slip. It evaluates a phaseup with a 6-bit address to 0.25 Toffolis; +//! the text says 8. Counting as the text states adds 1.7% to the total. +//! - **Loop 4.** The table lists 1.5 additions and 2.5 lookups per iteration. +//! The reference code performs 2.5 additions and 1.5 lookups. Both take +//! 2 ms, so the runtime is unchanged. +//! - **Cultivation.** The source reads 30,000 qubit·rounds for a 10⁻⁷ T state +//! off a figure. The data behind that figure give about 22,600. This makes +//! the factory estimate conservative as well. +//! - **Block granularity.** 1280 logical qubits do not fill whole 194-qubit +//! grid blocks. Seven whole blocks cost 582,624 physical qubits, not +//! 550,400. +//! +//! [`factoring_estimate`] applies every correction. It finds 958,480 physical +//! qubits: +//! - seven cold grid blocks, 582,624; +//! - 152 hot patches, 205,504; +//! - the compute region, 170,352. +//! +//! At the clock, with each operation rounded up to a whole millisecond, a shot +//! takes 10.58 h. A factoring takes 4.3 days, shots lost to logical errors +//! included. +//! +//! # Honest boundaries +//! +//! - **Fits are fits.** The storage formulas are path-counting extrapolations +//! from simulations at one noise strength, 10⁻³. Their authors call them +//! conservative. Outside that regime they are guesses. +//! - **Cultivation is tabulated, not modelled.** Only the three simulated noise +//! strengths are supported; [`cultivate`] refuses any other. Between +//! tabulated cutoffs the volume is interpolated log-linearly. Points backed +//! by few failures (see [`CultivationPoint::failures`]) are uncertain by a +//! factor of a few. +//! - **The factoring workload is the source's.** The operation tallies and the +//! deviation rate come from it, and are reproduced, not re-derived. The +//! residue-system search behind them is a conjecture of the source +//! (its Assumption 1). +//! - **Lattice surgery is priced, not routed.** Operation times are lower +//! bounds from the CCZ count and the layer count. There is no placement or +//! routing. + +use crate::repro::{exp, ln}; + +/// Physical qubits a distance-`d` patch covers, with room for lattice surgery: +/// `2(d+1)²`. +pub fn patch_qubits(d: u32) -> u64 { + 2 * u64::from(d + 1) * u64::from(d + 1) +} + +/// A path-counting fit for the logical error of stored patches. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct StorageFit { + /// The error suppression factor `Λ` per unit of distance. + pub suppression: f64, + /// The divisor `C`. + pub divisor: f64, + /// `a`: the error grows as `r^(a−1)` in the rounds between yoke checks. + pub round_exponent: u32, + /// `b`: the error grows as `n^(b−1)` in the patches per block. + pub patch_exponent: u32, +} + +impl StorageFit { + /// Logical error per patch per round at distance `d`, with `rounds` + /// between yoke checks and `patches` per block. + pub fn per_patch_round(&self, d: u32, rounds: u64, patches: u64) -> f64 { + let mut scale = self.divisor; + for _ in 0..d { + scale *= self.suppression; + } + let mut x = 1.0; + for _ in 1..self.round_exponent { + x *= rounds as f64; + } + for _ in 1..self.patch_exponent { + x *= patches as f64; + } + x / scale + } + + /// The plain-patch fit equivalent to a threshold model + /// `P(d) = a·(p/p*)^((d+1)/2)` per round, at physical error `p`. For + /// example, the fit `quantum_match` measures from its own memory + /// experiments. + pub fn flat_from_threshold(prefactor: f64, threshold: f64, p: f64) -> StorageFit { + let ratio_sqrt = exp(0.5 * ln(p / threshold)); + StorageFit { + suppression: 1.0 / ratio_sqrt, + divisor: 1.0 / (prefactor * ratio_sqrt), + round_exponent: 1, + patch_exponent: 1, + } + } +} + +/// Fits for plain, row-yoked and grid-yoked patches. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct StorageModel { + pub flat: StorageFit, + pub rows: StorageFit, + pub grid: StorageFit, +} + +const fn fit(suppression: f64, divisor: f64, round_exponent: u32, patch_exponent: u32) -> StorageFit { + StorageFit { suppression, divisor, round_exponent, patch_exponent } +} + +impl StorageModel { + /// arXiv:2312.04522, main text. SI1000 circuit noise at `p = 10⁻³`, fitted + /// to one significant figure. + pub fn si1000() -> StorageModel { + StorageModel { flat: fit(3.0, 20.0, 1, 1), rows: fit(8.0, 500.0, 2, 2), grid: fit(50.0, 200_000.0, 4, 2) } + } + + /// arXiv:2312.04522, supplementary note 1. Uniform depolarizing circuit + /// noise at `p = 10⁻³`, fitted to one significant figure. + pub fn uniform() -> StorageModel { + StorageModel { flat: fit(4.0, 10.0, 1, 1), rows: fit(10.0, 2000.0, 2, 2), grid: fit(200.0, 20_000.0, 4, 2) } + } + + /// The uniform-noise fits refitted to one and a half significant figures, + /// as used by arXiv:2505.15917 (its storage figure). More pessimistic than + /// [`StorageModel::uniform`]. + pub fn uniform_refit() -> StorageModel { + StorageModel { flat: fit(3.5, 40.0, 1, 1), rows: fit(15.0, 100.0, 2, 2), grid: fit(150.0, 50_000.0, 4, 2) } + } +} + +/// Where a block sits: cold (dense, shared check hallway) or hot (every patch +/// faces an access hallway). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Storage { + Cold, + Hot, +} + +/// How a block's patches are bound together. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Yoke { + /// Plain patches. + None, + /// One parity check along each row of patches (distance-2 outer code). + Rows, + /// Parity checks along rows and columns of a square (distance-4 outer + /// code). Cold storage only. + Grid, +} + +/// A stored block: its shape, its distance and how well it keeps. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct StorageBlock { + pub storage: Storage, + pub yoke: Yoke, + /// Patch distance. + pub distance: u32, + /// The distance a plain patch would need for the same target; sets the + /// height of hot-storage access hallways. + pub hallway_distance: u32, + /// Patches per yoked group (a row), or `w²` for a grid. + pub patches_per_group: u32, + /// Groups (rows) in the block. + pub groups: u32, + /// Footprint, in patches, including hallways and workspace. + pub rows: u32, + pub cols: u32, + /// Logical qubits the block stores. + pub logical: u32, + /// Rounds between yoke checks. + pub rounds_between_checks: u64, + /// Logical error per logical qubit per round. + pub error_per_logical_round: f64, +} + +impl StorageBlock { + /// Physical qubits the block covers. A hot block's access hallways are + /// `d0 + 1` patches tall, where `d0` is the plain-patch distance. + pub fn physical_qubits(&self) -> u64 { + let patch = patch_qubits(self.distance); + match self.storage { + Storage::Cold => patch * u64::from(self.rows) * u64::from(self.cols), + Storage::Hot => { + let hallways = u64::from(self.groups.div_ceil(2)); + let code_rows = u64::from(self.rows) - hallways; + let hallway_patch = 2 * u64::from(self.distance + 1) * u64::from(self.hallway_distance + 1); + patch * code_rows * u64::from(self.cols) + hallway_patch * hallways * u64::from(self.cols) + } + } + } + + /// Physical qubits per stored logical qubit. + pub fn qubits_per_logical(&self) -> f64 { + self.physical_qubits() as f64 / f64::from(self.logical) + } +} + +const MAX_DISTANCE: u32 = 200; + +/// The smallest plain-patch distance (at least 3) whose per-round error meets +/// `target`; `None` past distance 200. +pub fn flat_distance(model: &StorageModel, target: f64) -> Option { + (3..=MAX_DISTANCE).find(|&d| model.flat.per_patch_round(d, 1, 1) <= target) +} + +/// A rectangular block: `groups` rows of `patches_per_group` patches, plain or +/// row-yoked, at the smallest distance meeting `target` per logical qubit per +/// round. A row-yoked group must have an even number of patches, two of which +/// hold the yokes. `None` if no distance up to 200 meets the target, or the +/// shape stores nothing. +pub fn rectangular_block(model: &StorageModel, storage: Storage, yoke: Yoke, patches_per_group: u32, groups: u32, target: f64) -> Option { + let yokes = match yoke { + Yoke::None => 0, + Yoke::Rows => 2, + Yoke::Grid => return None, + }; + if groups == 0 || (yokes > 0 && patches_per_group % 2 == 1) || patches_per_group <= yokes { + return None; + } + let fit = if yokes == 0 { &model.flat } else { &model.rows }; + let per_group = patches_per_group - yokes; + let mut d = 3; + let (rounds, error) = loop { + let rounds = match storage { + Storage::Hot => 50 * u64::from(d), + Storage::Cold => (u64::from(groups) * 8 + 2) * u64::from(d), + }; + let error = fit.per_patch_round(d, rounds, u64::from(patches_per_group)) * f64::from(patches_per_group) / f64::from(per_group); + if error <= target { + break (rounds, error); + } + if d >= MAX_DISTANCE { + return None; + } + d += 1; + }; + let (mut rows, mut cols) = (groups, patches_per_group); + match storage { + Storage::Hot => { + cols += 1; + rows += groups.div_ceil(2); + } + Storage::Cold => { + if yokes > 0 { + rows += 1; + } + } + } + Some(StorageBlock { + storage, + yoke, + distance: d, + hallway_distance: flat_distance(model, target)?, + patches_per_group, + groups, + rows, + cols, + logical: per_group * groups, + rounds_between_checks: rounds, + error_per_logical_round: error, + }) +} + +/// A cold `w × w` grid-yoked block (`w` a positive multiple of 4), at the +/// smallest distance meeting `target` per logical qubit per round. It stores +/// `w² − 4w + 2` logical qubits in `(w+1)²` patches (one row and one column of +/// workspace). +pub fn grid_block(model: &StorageModel, width: u32, target: f64) -> Option { + if width == 0 || !width.is_multiple_of(4) { + return None; + } + let patches = width * width; + let logical = patches - 4 * width + 2; + let mut d = 3; + let (rounds, error) = loop { + let rounds = u64::from(d) * u64::from(width) * 25 + u64::from(d) * 4; + let error = model.grid.per_patch_round(d, rounds, u64::from(patches)) * f64::from(patches) / f64::from(logical); + if error <= target { + break (rounds, error); + } + if d >= MAX_DISTANCE { + return None; + } + d += 1; + }; + Some(StorageBlock { + storage: Storage::Cold, + yoke: Yoke::Grid, + distance: d, + hallway_distance: flat_distance(model, target)?, + patches_per_group: patches, + groups: 1, + rows: width + 1, + cols: width + 1, + logical, + rounds_between_checks: rounds, + error_per_logical_round: error, + }) +} + +/// The cheapest block per logical qubit storing at most `max_logical` logical +/// qubits. Rectangular blocks try 4 to 200 patches per group and every group +/// count. Grid blocks try every width that fits. The first minimum wins, in +/// order of patches per group and then groups (or width). +pub fn best_block(model: &StorageModel, storage: Storage, yoke: Yoke, target: f64, max_logical: u32) -> Option { + let mut best: Option<(f64, StorageBlock)> = None; + let mut consider = |b: StorageBlock| { + let rate = b.qubits_per_logical(); + if best.as_ref().is_none_or(|(r, _)| rate < *r) { + best = Some((rate, b)); + } + }; + match yoke { + Yoke::Grid => { + if storage == Storage::Hot { + return None; + } + let mut w = 4; + while w * w - 4 * w + 2 <= max_logical { + if let Some(b) = grid_block(model, w, target) { + consider(b); + } + w += 4; + } + } + Yoke::None | Yoke::Rows => { + let yokes = if yoke == Yoke::Rows { 2 } else { 0 }; + for n in 4..=200u32 { + if n <= yokes { + continue; + } + let per_group = n - yokes; + for groups in 1..=max_logical.div_ceil(per_group) { + if per_group * groups > max_logical { + continue; + } + if let Some(b) = rectangular_block(model, storage, yoke, n, groups, target) { + consider(b); + } + } + } + } + } + best.map(|(_, b)| b) +} + +/// How a number of logical qubits is stored: whole blocks. +#[derive(Clone, Debug, PartialEq)] +pub struct StoragePlan { + /// The blocks, with how many of each. + pub blocks: Vec<(StorageBlock, u64)>, + /// Logical qubits asked for. + pub logical: u64, +} + +impl StoragePlan { + pub fn physical_qubits(&self) -> u64 { + self.blocks.iter().map(|(b, k)| b.physical_qubits() * k).sum() + } + /// Logical qubits the blocks can hold (at least [`StoragePlan::logical`]). + pub fn capacity(&self) -> u64 { + self.blocks.iter().map(|(b, k)| u64::from(b.logical) * k).sum() + } +} + +/// Store `logical` qubits in whole cold blocks of one kind of yoke. A plan is +/// copies of one block shape, plus at most one block of another shape for the +/// remainder. Every pair of shapes holding at most `max_block` logical qubits +/// is tried, and the plan with the fewest physical qubits is kept. The shapes +/// are grid widths from 4, and rectangles of up to 200 patches per group and +/// 16 groups. +/// +/// The fits were drawn from blocks of up to 256 patches. The source's own +/// layouts cap a block at 250 logical qubits. Larger blocks extrapolate the +/// fits, and they look cheaper than they have been shown to be. +pub fn store(model: &StorageModel, yoke: Yoke, target: f64, logical: u64, max_block: u32) -> Option { + if logical == 0 { + return Some(StoragePlan { blocks: Vec::new(), logical }); + } + let mut shapes: Vec = Vec::new(); + match yoke { + Yoke::Grid => { + let mut w = 4; + while w * w - 4 * w + 2 <= max_block { + shapes.extend(grid_block(model, w, target)); + w += 4; + } + } + Yoke::None | Yoke::Rows => { + for n in 4..=200u32 { + for groups in 1..=16 { + shapes.extend(rectangular_block(model, Storage::Cold, yoke, n, groups, target).filter(|b| b.logical <= max_block)); + } + } + } + } + let mut best: Option<(u64, StoragePlan)> = None; + let mut consider = |blocks: Vec<(StorageBlock, u64)>| { + let plan = StoragePlan { blocks, logical }; + let cost = plan.physical_qubits(); + if best.as_ref().is_none_or(|(c, _)| cost < *c) { + best = Some((cost, plan)); + } + }; + for main in &shapes { + let cap = u64::from(main.logical); + consider(vec![(*main, logical.div_ceil(cap))]); + for rest in &shapes { + let rest_cap = u64::from(rest.logical); + let copies = logical.saturating_sub(rest_cap).div_ceil(cap); + let mut blocks = vec![(*rest, 1)]; + if copies > 0 { + blocks.insert(0, (*main, copies)); + } + consider(blocks); + } + } + best.map(|(_, plan)| plan) +} + +/// One point on a published cultivation curve: a postselection cutoff, with +/// what it keeps and what it costs. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct CultivationPoint { + /// Injection (colour-code) distance, 3 or 5. + pub d1: u32, + /// Uniform circuit noise strength. + pub p: f64, + /// Kept shots and failures among them, as simulated. + pub kept: u64, + pub failures: u64, + /// Expected qubit·rounds per kept state, retries included. + pub volume: f64, +} + +impl CultivationPoint { + /// Logical error of a kept T state: twice the simulated S-state rate. + pub fn error(&self) -> f64 { + 2.0 * self.failures as f64 / self.kept as f64 + } +} + +/// `(d1, p, kept, failures, qubit·rounds)`. These are the representative +/// cutoffs of the end-to-end cultivation simulations of arXiv:2409.17595 +/// (data: doi:10.5281/zenodo.13777072, Apache-2.0). Each curve escapes into a +/// distance-15 surface code. The volumes are the source's own: the circuit's +/// growth-weighted qubit·rounds divided by the keep rate. The error falls +/// down each curve as the volume rises. +#[rustfmt::skip] +const CULTIVATION: [(u32, f64, u64, u64, u32); 78] = [ + (3, 5e-4, 507_113_042, 76, 4434), (3, 5e-4, 567_320_249, 112, 3963), (3, 5e-4, 630_762_204, 260, 3564), + (3, 5e-4, 702_651_030, 4541, 3200), + (3, 1e-3, 225_419_907, 299, 8071), (3, 1e-3, 257_427_648, 383, 7067), (3, 1e-3, 289_504_256, 486, 6284), + (3, 1e-3, 326_502_293, 677, 5572), (3, 1e-3, 367_643_011, 1251, 4948), (3, 1e-3, 423_967_169, 6213, 4291), + (3, 1e-3, 471_154_637, 15137, 3861), (3, 1e-3, 524_756_158, 169_010, 3467), + (3, 2e-3, 32_114_403, 400, 37284), (3, 2e-3, 40_189_645, 555, 29793), (3, 2e-3, 44_762_157, 671, 26749), + (3, 2e-3, 53_846_749, 921, 22236), (3, 2e-3, 64_036_036, 1342, 18698), (3, 2e-3, 73_311_524, 1827, 16332), + (3, 2e-3, 82_408_196, 2507, 14530), (3, 2e-3, 92_020_117, 3438, 13012), (3, 2e-3, 107_411_997, 5695, 11147), + (3, 2e-3, 124_485_101, 11808, 9618), (3, 2e-3, 144_091_705, 20247, 8310), (3, 2e-3, 165_174_154, 33151, 7249), + (3, 2e-3, 187_192_142, 58772, 6396), (3, 2e-3, 208_384_384, 107_491, 5746), (3, 2e-3, 237_794_538, 258_511, 5035), + (3, 2e-3, 264_661_056, 825_206, 4524), + (5, 5e-4, 92_480_789_479, 2, 18963), (5, 5e-4, 119_289_578_411, 3, 14702), (5, 5e-4, 133_864_311_235, 4, 13101), + (5, 5e-4, 149_019_473_596, 16, 11769), (5, 5e-4, 168_245_418_061, 42, 10424), (5, 5e-4, 190_063_821_114, 101, 9227), + (5, 5e-4, 213_505_407_573, 1225, 8214), (5, 5e-4, 237_773_048_111, 3798, 7376), + (5, 1e-3, 5_072_794_335, 2, 127_164), (5, 1e-3, 6_326_363_510, 3, 101_967), (5, 1e-3, 7_316_858_650, 5, 88163), + (5, 1e-3, 8_528_845_303, 7, 75635), (5, 1e-3, 11_303_894_346, 12, 57067), (5, 1e-3, 12_580_794_262, 17, 51275), + (5, 1e-3, 14_509_395_372, 43, 44459), (5, 1e-3, 17_056_858_658, 85, 37819), (5, 1e-3, 19_856_355_181, 130, 32487), + (5, 1e-3, 22_392_999_123, 361, 28807), (5, 1e-3, 24_893_295_331, 855, 25914), (5, 1e-3, 27_896_134_842, 1269, 23124), + (5, 1e-3, 31_155_995_215, 2210, 20705), (5, 1e-3, 34_799_549_714, 3586, 18537), (5, 1e-3, 38_815_144_303, 5781, 16619), + (5, 1e-3, 43_978_628_618, 15089, 14668), (5, 1e-3, 49_076_765_044, 88245, 13144), + (5, 2e-3, 19_158_113, 1, 2_657_934), (5, 2e-3, 26_331_515, 2, 1_933_842), (5, 2e-3, 31_195_093, 3, 1_632_340), + (5, 2e-3, 37_354_668, 6, 1_363_176), (5, 2e-3, 43_645_077, 10, 1_166_706), (5, 2e-3, 50_852_147, 13, 1_001_354), + (5, 2e-3, 58_670_182, 18, 867_919), (5, 2e-3, 65_338_141, 27, 779_346), (5, 2e-3, 73_001_601, 36, 697_533), + (5, 2e-3, 86_267_386, 63, 590_269), (5, 2e-3, 111_432_443, 95, 456_967), (5, 2e-3, 130_018_899, 134, 391_643), + (5, 2e-3, 156_035_212, 195, 326_343), (5, 2e-3, 186_603_798, 300, 272_883), (5, 2e-3, 217_837_248, 492, 233_757), + (5, 2e-3, 247_509_021, 780, 205_734), (5, 2e-3, 286_129_637, 1187, 177_965), (5, 2e-3, 338_075_961, 1890, 150_620), + (5, 2e-3, 389_809_192, 3249, 130_631), (5, 2e-3, 438_097_321, 5457, 116_232), (5, 2e-3, 499_133_825, 10420, 102_019), + (5, 2e-3, 555_534_346, 19226, 91661), (5, 2e-3, 628_514_709, 51577, 81018), (5, 2e-3, 700_358_340, 175_735, 72707), + (5, 2e-3, 778_533_166, 1_971_026, 65406), +]; + +/// Every tabulated cultivation point, ordered by `(d1, p)` and then by rising +/// error. +pub fn cultivation_points() -> Vec { + CULTIVATION + .iter() + .map(|&(d1, p, kept, failures, volume)| CultivationPoint { d1, p, kept, failures, volume: f64::from(volume) }) + .collect() +} + +/// A cultivated T state: its error, its expected cost and how it was grown. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct CultivatedT { + pub error: f64, + /// Expected qubit·rounds per kept state. + pub volume: f64, + pub d1: u32, +} + +/// The cheapest cultivated T state with error at most `target` at noise `p`. +/// The volume is interpolated log-linearly in `(ln error, ln volume)` between +/// the tabulated cutoffs that bracket the target. `None` if `p` is not one of +/// the simulated strengths (5·10⁻⁴, 10⁻³, 2·10⁻³) or no curve reaches the +/// target. +pub fn cultivate(p: f64, target: f64) -> Option { + let points = cultivation_points(); + let mut best: Option = None; + for d1 in [3, 5] { + let curve: Vec<&CultivationPoint> = points.iter().filter(|q| q.d1 == d1 && q.p == p).collect(); + let Some(first) = curve.first() else { continue }; + if first.error() > target { + continue; + } + // Points rise in error and fall in volume. Take the last point at or + // below the target, and interpolate towards the next one up. + let k = curve.iter().rposition(|q| q.error() <= target).unwrap_or(0); + let lo = curve[k]; + let found = match curve.get(k + 1) { + Some(hi) if target > lo.error() => { + let t = (ln(target) - ln(lo.error())) / (ln(hi.error()) - ln(lo.error())); + CultivatedT { error: target, volume: exp(ln(lo.volume) + t * (ln(hi.volume) - ln(lo.volume))), d1 } + } + _ => CultivatedT { error: lo.error(), volume: lo.volume, d1 }, + }; + if best.is_none_or(|b| found.volume < b.volume) { + best = Some(found); + } + } + best +} + +/// A CCZ factory fed by cultivated T states: `t_states` T states in, one CCZ +/// state out. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct CczFactory { + /// Footprint, in patches. + pub width: u32, + pub height: u32, + /// Layers of lattice surgery per CCZ state. + pub layers: u32, + /// Rounds per layer, as a fraction of `d` (2/3 with temporally encoded + /// lattice surgery). + pub layer_fraction: f64, + /// T states consumed per CCZ state. + pub t_states: u32, + /// Output error is `suppression · p_T²`. + pub suppression: f64, +} + +impl CczFactory { + /// 8T-to-CCZ distillation (arXiv:1212.5069), in a 3 × 4 patch layout + /// (arXiv:2409.17595, figure 24) of six temporally encoded layers. + pub fn eight_t() -> CczFactory { + CczFactory { width: 4, height: 3, layers: 6, layer_fraction: 2.0 / 3.0, t_states: 8, suppression: 28.0 } + } + + /// Physical qubits at patch distance `d`. + pub fn physical_qubits(&self, d: u32) -> u64 { + u64::from(self.width * self.height) * patch_qubits(d) + } + + /// Rounds per CCZ state. The T states are cultivated inside the + /// footprint, each costing `t_volume` qubit·rounds. The lattice surgery + /// follows. + pub fn rounds_per_ccz(&self, d: u32, t_volume: f64) -> f64 { + let cultivation = f64::from(self.t_states) * t_volume / self.physical_qubits(d) as f64; + cultivation + f64::from(self.layers) * self.layer_fraction * f64::from(d) + } + + /// Error of a CCZ state built from T states of error `t_error`. + pub fn error(&self, t_error: f64) -> f64 { + self.suppression * t_error * t_error + } +} + +/// What sets the pace of a step. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Bound { + /// Lattice surgery: `d` rounds per step. + Surgery, + /// The CCZ supply. + MagicStates, + /// The classical control loop. + Reaction, +} + +/// The machine's clock. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Timing { + /// Surface-code cycle, µs. + pub cycle_us: f64, + /// Control-system reaction time, µs. + pub reaction_us: f64, + /// Patch distance in the compute region. + pub distance: u32, + /// Rounds per CCZ state per factory. + pub ccz_rounds: f64, + pub factories: u32, +} + +impl Timing { + /// One lattice-surgery step: `d` cycles. + pub fn surgery_us(&self) -> f64 { + f64::from(self.distance) * self.cycle_us + } + /// Time between CCZ states from all factories together. + pub fn ccz_period_us(&self) -> f64 { + self.ccz_rounds * self.cycle_us / f64::from(self.factories) + } + /// A step: the slowest of surgery, CCZ supply and reaction. + pub fn step_us(&self) -> f64 { + self.surgery_us().max(self.ccz_period_us()).max(self.reaction_us) + } + /// Which of the three sets [`Timing::step_us`] (surgery on a tie). + pub fn bound(&self) -> Bound { + let step = self.step_us(); + if self.surgery_us() == step { + Bound::Surgery + } else if self.ccz_period_us() == step { + Bound::MagicStates + } else { + Bound::Reaction + } + } + /// An `n`-bit addition: `n − 1` CCZ states, then an uncompute of the same + /// length. + pub fn add_us(&self, n: u32) -> f64 { + 2.0 * f64::from(n.saturating_sub(1)) * self.step_us() + } + /// A table lookup over `w` address bits: `2ʷ − 1` layers, enough for its + /// `2ʷ − w − 1` CCZ states. + pub fn lookup_us(&self, w: u32) -> f64 { + ((1u64 << w) - 1) as f64 * self.step_us() + } + /// A phaseup over `w` address bits: at most half a lookup. + pub fn phaseup_us(&self, w: u32) -> f64 { + self.lookup_us(w) / 2.0 + } +} + +/// The parameters of the approximate-residue factoring algorithm of +/// arXiv:2505.15917 (its table 4). +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct FactoringParams { + /// Bits in the modulus. + pub n: u32, + /// Ekerå–Håstad parameter. + pub s: u32, + /// Bits per prime of the residue system. + pub prime_bits: u32, + /// Window sizes of loops 1, 3 and 4. + pub w1: u32, + pub w3: u32, + pub w4: u32, + /// Bits of the truncated accumulator. + pub accumulator_bits: u32, + /// Shot failure rate from the approximation (simulated by the source). + pub deviant: f64, +} + +impl FactoringParams { + /// The source's highlighted parameters for `n` ∈ {1024, 1536, 2048, 3072, + /// 4096, 6144, 8192}. + pub fn published(n: u32) -> Option { + let (s, prime_bits, w1, w3, w4, accumulator_bits, deviant) = match n { + 1024 => (8, 18, 6, 3, 6, 28, 0.0287), + 1536 => (8, 21, 6, 3, 5, 31, 0.0183), + 2048 => (8, 21, 6, 3, 5, 33, 0.0125), + 3072 => (8, 21, 6, 3, 5, 35, 0.0091), + 4096 => (8, 24, 6, 3, 5, 36, 0.0080), + 6144 => (8, 24, 6, 3, 5, 39, 0.0042), + 8192 => (8, 24, 6, 3, 5, 40, 0.0040), + _ => return None, + }; + Some(FactoringParams { n, s, prime_bits, w1, w3, w4, accumulator_bits, deviant }) + } + + /// Input qubits `m = ⌈n(1/2 + 1/(2s))⌉ + ⌈n/(2s)⌉`. + pub fn input_qubits(&self) -> u64 { + let n = u64::from(self.n); + let s = u64::from(self.s); + (n * (s + 1)).div_ceil(2 * s) + n.div_ceil(2 * s) + } + + /// Primes in the residue system: enough `ℓ`-bit primes to cover `n` bits + /// per multiplication, `|P| = ⌈n·⌈m/w₁⌉/ℓ⌉`. + pub fn primes(&self) -> u64 { + (u64::from(self.n) * self.input_qubits().div_ceil(u64::from(self.w1))).div_ceil(u64::from(self.prime_bits)) + } + + /// Expected shots per factoring: `(s+1)/(1 − P_deviant)/0.99`. + pub fn expected_shots(&self) -> f64 { + f64::from(self.s + 1) / (1.0 - self.deviant) / 0.99 + } + + /// The operation tallies of one shot. + pub fn tallies(&self) -> Vec { + let p = self.primes(); + let m = self.input_qubits(); + let len_m = u64::from(64 - m.leading_zeros()); + let (l, f) = (u64::from(self.prime_bits), u64::from(self.accumulator_bits)); + let win1 = m.div_ceil(u64::from(self.w1)); + let win3 = l.div_ceil(u64::from(self.w3)); + let win4 = l.div_ceil(u64::from(self.w4)); + let (w1, w3, w4) = (self.w1, self.w3, self.w4); + let sub = |name, family, iterations: u64, halves: [u64; 3], add_bits, lookup_bits, phaseup_bits| Subroutine { + name, + family, + iterations, + half_adds: halves[0], + half_lookups: halves[1], + half_phaseups: halves[2], + add_bits: add_bits as u32, + lookup_bits, + phaseup_bits, + }; + vec![ + sub("loop1", 1, (p + 1) * win1, [2, 2, 0], l + len_m, w1, 0), + sub("loop2", 2, p * len_m, [4, 0, 0], l + len_m, 0, 0), + sub("loop3 startup", 3, p, [0, 2, 0], 0, 2 * w3, 0), + sub("loop3 body", 3, p * (win3 - 2) * win3, [4, 2, 0], l + 1, 2 * w3, 0), + sub("loop4", 4, p * win4, [5, 3, 2], f + 1, w4, w4), + sub("unloop3 body", 5, p * (win3 - 2) * 2 * win3, [5, 3, 2], l + 1, 2 * w3, 2 * w3), + sub("unloop3 cleanup", 5, p, [0, 0, 2], 0, 0, 2 * w3), + sub("unloop2", 6, p * len_m, [4, 0, 0], l + len_m, 0, 0), + ] + } + + /// Peak logical qubits by the source's qubit tally (its table 5): loop 4 + /// holds `m + 3f + 2ℓ + len m`. + pub fn peak_logical_qubits(&self) -> u64 { + let m = self.input_qubits(); + let len_m = u64::from(64 - m.leading_zeros()); + m + 3 * u64::from(self.accumulator_bits) + 2 * u64::from(self.prime_bits) + len_m + } + + /// Logical qubits by the source's reference code (its table 4 column): + /// `m + (ℓ + len m) + ℓ + f + max(ℓ, f, ℓ + len m)`. + pub fn table_logical_qubits(&self) -> u64 { + let m = self.input_qubits(); + let len_m = u64::from(64 - m.leading_zeros()); + let (l, f) = (u64::from(self.prime_bits), u64::from(self.accumulator_bits)); + m + (l + len_m) + l + f + l.max(f).max(l + len_m) + } + + /// Toffolis per shot, operation by operation: + /// - an `n`-bit addition is `n − 1`; + /// - a lookup over `w` bits is `2ʷ − w − 1`; + /// - a phaseup over `w` bits is `⌈√(2ʷ)⌉`, so 8 at 6 bits, as the source's + /// text states. + pub fn toffolis_per_shot(&self) -> f64 { + self.tallies() + .iter() + .map(|s| { + let add = f64::from(s.add_bits.saturating_sub(1)); + let lookup = ((1u64 << s.lookup_bits) - u64::from(s.lookup_bits) - 1) as f64; + let phaseup = isqrt_ceil(1u64 << s.phaseup_bits) as f64; + s.adds() * add + s.lookups() * lookup + s.phaseups() * phaseup + }) + .sum() + } + + /// Toffolis per shot by the source's reference counting rule, the rule + /// behind its published count: + /// - every operation in a subroutine is priced at that subroutine's + /// largest size; + /// - an addition costs its full register width; + /// - a lookup over `N` entries costs `N − bitlen(N) − 1`. + /// + /// The rule prices a phaseup over `N` entries at + /// `2^(⌊N₁/2⌋−N₁−1) + 2^(⌊N₂/2⌋−N₂−1)`, a quarter of a Toffoli at 6 address + /// bits. [`PhaseupCount::AsStated`] substitutes the text's `⌈√N⌉`. + pub fn toffolis_per_shot_source_rule(&self, phaseups: PhaseupCount) -> f64 { + let tallies = self.tallies(); + (1..=6) + .map(|family| { + let rows: Vec<&Subroutine> = tallies.iter().filter(|s| s.family == family).collect(); + let add_bits = rows.iter().map(|s| s.add_bits).max().unwrap_or(0); + let lookup_bits = rows.iter().filter(|s| s.half_lookups > 0).map(|s| s.lookup_bits).max().unwrap_or(0); + let phaseup_bits = rows.iter().filter(|s| s.half_phaseups > 0).map(|s| s.phaseup_bits).max().unwrap_or(0); + let (adds, lookups, flips) = rows.iter().fold((0.0, 0.0, 0.0), |(a, l, p), s| (a + s.adds(), l + s.lookups(), p + s.phaseups())); + let mut total = adds * f64::from(add_bits); + if lookups > 0.0 { + let big_n = 1u64 << lookup_bits; + total += lookups * (big_n - u64::from(64 - big_n.leading_zeros()) - 1) as f64; + } + if flips > 0.0 { + total += flips + * match phaseups { + PhaseupCount::AsCoded => { + let bits = 64 - (1u64 << phaseup_bits).leading_zeros() as i32; + let (n1, n2) = (bits / 2, bits - bits / 2); + pow2(n1 / 2 - n1 - 1) + pow2(n2 / 2 - n2 - 1) + } + PhaseupCount::AsStated => isqrt_ceil(1u64 << phaseup_bits) as f64, + }; + } + total + }) + .sum() + } +} + +/// How the source rule prices a phaseup. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum PhaseupCount { + /// As the reference counting code evaluates it: a quarter of a Toffoli at + /// 6 address bits. + AsCoded, + /// As the text states: `⌈√N⌉`, so 8 at 6 address bits. + AsStated, +} + +fn pow2(e: i32) -> f64 { + let mut x = 1.0; + for _ in 0..e.unsigned_abs() { + x = if e < 0 { x / 2.0 } else { x * 2.0 }; + } + x +} + +fn isqrt_ceil(x: u64) -> u64 { + let mut r = (x as f64).sqrt() as u64; + while r * r > x { + r -= 1; + } + while r * r < x { + r += 1; + } + r +} + +/// One subroutine of the factoring algorithm: how often it runs and what each +/// iteration does. Operation counts are kept in halves, because loop 4 and +/// unloop 3 average two and a half additions per iteration. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Subroutine { + pub name: &'static str, + /// Which of the six loops it belongs to (1 to 6: loop 1, 2, 3, 4, + /// unloop 3, unloop 2). + pub family: u32, + pub iterations: u64, + pub half_adds: u64, + pub half_lookups: u64, + pub half_phaseups: u64, + /// Largest addition, in bits. + pub add_bits: u32, + /// Largest lookup and phaseup, in address bits. + pub lookup_bits: u32, + pub phaseup_bits: u32, +} + +impl Subroutine { + pub fn adds(&self) -> f64 { + (self.iterations * self.half_adds) as f64 / 2.0 + } + pub fn lookups(&self) -> f64 { + (self.iterations * self.half_lookups) as f64 / 2.0 + } + pub fn phaseups(&self) -> f64 { + (self.iterations * self.half_phaseups) as f64 / 2.0 + } +} + +/// The physical assumptions of a whole-machine estimate. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Machine { + /// Uniform circuit noise strength. + pub p: f64, + pub cycle_us: f64, + pub reaction_us: f64, + pub storage: StorageModel, + /// Target logical error per logical qubit per round, for every stored + /// qubit. + pub target: f64, + pub factory: CczFactory, + pub factories: u32, + /// Columns of lattice-surgery workspace beside the factories. + pub workspace_cols: u32, + /// Error target for each T state fed to a factory. + pub t_target: f64, + /// Largest cold block, in logical qubits (see [`store`]). + pub max_block: u32, +} + +impl Machine { + /// The source's machine: + /// - `p = 10⁻³`, a 1 µs cycle and a 10 µs reaction time; + /// - refitted storage at 10⁻¹⁵ per logical qubit per round; + /// - six 8T-to-CCZ factories with three columns of workspace; + /// - 10⁻⁷ T states. + pub fn published() -> Machine { + Machine { + p: 1e-3, + cycle_us: 1.0, + reaction_us: 10.0, + storage: StorageModel::uniform_refit(), + target: 1e-15, + factory: CczFactory::eight_t(), + factories: 6, + workspace_cols: 3, + t_target: 1e-7, + max_block: 250, + } + } +} + +/// A whole-machine estimate of the factoring algorithm. +#[derive(Clone, Debug, PartialEq)] +pub struct FactoringEstimate { + pub params: FactoringParams, + /// Logical qubits: the input register stays cold, the rest is hot. + pub cold_logical: u64, + pub hot_logical: u64, + /// Hot-patch distance and the cold storage plan. + pub hot_distance: u32, + pub cold: StoragePlan, + /// Physical qubits in each region. + pub cold_qubits: u64, + pub hot_qubits: u64, + pub compute_qubits: u64, + /// The T state each factory consumes, and its CCZ output error. + pub t_state: CultivatedT, + pub ccz_error: f64, + /// Rounds per CCZ per factory. + pub ccz_rounds: f64, + pub timing: Timing, + /// Hours per shot at the clock's lower bound. + pub hours_per_shot: f64, + /// Hours per shot with every operation rounded up to a whole millisecond, + /// the source's allowance for moving qubits in and out. + pub hours_per_shot_rounded: f64, + /// Expected shots, the chance a shot has no logical error, and expected + /// days per factoring (shots lost to logical errors included, at the + /// rounded durations). + pub expected_shots: f64, + pub shot_survival: f64, + pub days: f64, + pub toffolis_per_shot: f64, +} + +impl FactoringEstimate { + pub fn physical_qubits(&self) -> u64 { + self.cold_qubits + self.hot_qubits + self.compute_qubits + } +} + +/// Why a whole-machine estimate could not be made. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ArchError { + /// No plain-patch distance up to 200 meets the storage target. + Distance, + /// No yoked layout meets the storage target. + Storage, + /// No cultivation curve at this noise strength reaches the T target. + Cultivation, +} + +impl core::fmt::Display for ArchError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str(match self { + ArchError::Distance => "no patch distance up to 200 meets the storage target", + ArchError::Storage => "no yoked storage layout meets the storage target", + ArchError::Cultivation => "no cultivation curve at this noise strength reaches the T target", + }) + } +} + +impl std::error::Error for ArchError {} + +/// Re-run the factoring estimate on `machine`. +/// +/// - **Cold storage.** The `m` input qubits sit in whole grid-yoked blocks, +/// via [`store`]. +/// - **Hot storage.** The rest of the peak sits in plain patches. +/// - **Compute region.** `factories` factories are stacked beside the +/// workspace columns. +/// - **Time.** Every operation in the tallies runs on the [`Timing`] clock, +/// which is set by the cultivated T states. +/// - **Survival.** A shot survives when no stored logical qubit fails for its +/// whole duration. +pub fn factoring_estimate(params: &FactoringParams, machine: &Machine) -> Result { + let d = flat_distance(&machine.storage, machine.target).ok_or(ArchError::Distance)?; + let cold_logical = params.input_qubits(); + let hot_logical = params.peak_logical_qubits() - cold_logical; + let cold = store(&machine.storage, Yoke::Grid, machine.target, cold_logical, machine.max_block).ok_or(ArchError::Storage)?; + let t_state = cultivate(machine.p, machine.t_target).ok_or(ArchError::Cultivation)?; + let ccz_rounds = machine.factory.rounds_per_ccz(d, t_state.volume); + let timing = Timing { cycle_us: machine.cycle_us, reaction_us: machine.reaction_us, distance: d, ccz_rounds, factories: machine.factories }; + let whole_ms = |us: f64| (us / 1000.0).ceil() * 1000.0; + let (mut micros, mut micros_rounded) = (0.0, 0.0); + for s in params.tallies() { + let ops = [(s.adds(), timing.add_us(s.add_bits)), (s.lookups(), timing.lookup_us(s.lookup_bits)), (s.phaseups(), timing.phaseup_us(s.phaseup_bits))]; + for (count, us) in ops { + micros += count * us; + micros_rounded += count * whole_ms(us); + } + } + let compute_patches = u64::from((machine.factory.width + machine.workspace_cols) * machine.factory.height * machine.factories); + let (cold_qubits, hot_qubits, compute_qubits) = (cold.physical_qubits(), hot_logical * patch_qubits(d), compute_patches * patch_qubits(d)); + let stored = (cold_logical + hot_logical + compute_patches) as f64; + let rounds = micros_rounded / machine.cycle_us; + let shot_survival = exp(-(stored * rounds * machine.target)); + let expected_shots = params.expected_shots(); + let (hours_per_shot, hours_per_shot_rounded) = (micros / 3.6e9, micros_rounded / 3.6e9); + Ok(FactoringEstimate { + params: *params, + cold_logical, + hot_logical, + hot_distance: d, + cold, + cold_qubits, + hot_qubits, + compute_qubits, + t_state, + ccz_error: machine.factory.error(t_state.error), + ccz_rounds, + timing, + hours_per_shot, + hours_per_shot_rounded, + expected_shots, + shot_survival, + days: hours_per_shot_rounded * expected_shots / shot_survival / 24.0, + toffolis_per_shot: params.toffolis_per_shot(), + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn rsa() -> FactoringParams { + FactoringParams::published(2048).unwrap() + } + + #[test] + fn refitted_storage_gives_the_published_densities() { + let m = StorageModel::uniform_refit(); + assert_eq!(flat_distance(&m, 1e-15), Some(25)); + assert_eq!(patch_qubits(25), 1352); + let g = grid_block(&m, 16, 1e-15).unwrap(); + assert_eq!((g.distance, g.logical, g.rows, g.cols), (11, 194, 17, 17)); + assert_eq!(g.physical_qubits(), 83_232); + assert!((g.qubits_per_logical() - 429.03).abs() < 0.01, "{}", g.qubits_per_logical()); + // Its stated rounding: 430 per logical qubit. + assert_eq!(1280 * 430 + 131 * 1352 + 7 * 18 * 1352, 897_864); + } + + #[test] + fn uniform_grids_reach_the_supplements_density() { + // Supplementary note 1: about 350 physical qubits per logical qubit + // at about 10⁻¹² per round. + let g = best_block(&StorageModel::uniform(), Storage::Cold, Yoke::Grid, 1e-12, 250).unwrap(); + assert!((340.0..370.0).contains(&g.qubits_per_logical()), "{}", g.qubits_per_logical()); + } + + #[test] + fn the_layout_search_matches_the_source_tool_everywhere() { + let data = include_str!("../tests/data/yoked_footprint_oracle.csv"); + let mut checked = 0; + for line in data.lines().skip(1) { + let f: Vec<&str> = line.split(',').collect(); + let model = match f[0] { + "si1000" => StorageModel::si1000(), + "uniform" => StorageModel::uniform(), + "uniform_refit" => StorageModel::uniform_refit(), + other => panic!("{other}"), + }; + let storage = if f[1] == "hot" { Storage::Hot } else { Storage::Cold }; + let target: f64 = f[3].parse().unwrap(); + let got = match f[2] { + "0" => best_block(&model, storage, Yoke::None, target, 250), + "2" => best_block(&model, storage, Yoke::Rows, target, 250), + "64" => grid_block(&model, 16, target), + other => panic!("{other}"), + } + .unwrap_or_else(|| panic!("no layout for {line}")); + let want: Vec = f[4..11].iter().map(|x| x.parse().unwrap()).collect(); + let have = [got.distance, got.groups, got.patches_per_group, got.rows, got.cols, got.logical].map(u64::from); + assert_eq!(&have[..], &want[..6], "{line}"); + assert_eq!(got.rounds_between_checks, want[6], "{line}"); + // The tool leaves the hallway distance unset for grids, which + // have no hallways. + if f[11] != "None" { + assert_eq!(got.hallway_distance.to_string(), f[11], "{line}"); + } + let rate: f64 = f[12].parse().unwrap(); + assert_eq!(got.qubits_per_logical(), rate, "{line}"); + let lerp: f64 = f[13].parse().unwrap(); + assert!((got.error_per_logical_round / lerp - 1.0).abs() < 1e-12, "{line}"); + checked += 1; + } + assert_eq!(checked, 915); + } + + #[test] + fn whole_blocks_cost_more_than_the_rate_suggests() { + let m = StorageModel::uniform_refit(); + let plan = store(&m, Yoke::Grid, 1e-15, 1280, 250).unwrap(); + assert!(plan.capacity() >= 1280); + let widths: Vec<(u32, u64)> = plan.blocks.iter().map(|(b, k)| (b.rows - 1, *k)).collect(); + assert_eq!(widths, vec![(16, 7)]); + assert_eq!(plan.physical_qubits(), 582_624); + // Past the simulated block sizes the fits promise more: a 32-wide grid + // at 410 qubits per logical qubit. + let wide = store(&m, Yoke::Grid, 1e-15, 1280, 1000).unwrap(); + assert!(wide.physical_qubits() < 1280 * 430); + assert!(wide.blocks.iter().any(|(b, _)| b.rows - 1 == 32)); + } + + #[test] + fn cultivation_reads_the_published_curves() { + let t = cultivate(1e-3, 1e-7).unwrap(); + assert_eq!(t.d1, 5); + assert!((22_000.0..23_200.0).contains(&t.volume), "{}", t.volume); + // Well above the distance-5 curve's reach, distance 3 is cheaper. + let cheap = cultivate(1e-3, 1e-4).unwrap(); + assert_eq!(cheap.d1, 3); + // Below every curve: nothing. + assert_eq!(cultivate(1e-3, 1e-12), None); + // Unsimulated noise: refused. + assert_eq!(cultivate(7e-4, 1e-6), None); + // Each curve rises in error as it falls in volume. + let pts = cultivation_points(); + for w in pts.windows(2) { + if (w[0].d1, w[0].p) == (w[1].d1, w[1].p) { + assert!(w[1].error() > w[0].error() && w[1].volume < w[0].volume); + } + } + } + + #[test] + fn the_factory_and_clock_reproduce_the_sources_arithmetic() { + let f = CczFactory::eight_t(); + assert_eq!(f.physical_qubits(25), 16_224); + // 8 × 30,000 / 16,224 + 6 × (2/3) × 25 = 114.79 rounds ("114.7"). + assert!((f.rounds_per_ccz(25, 30_000.0) - 114.79).abs() < 0.01); + assert!(f.error(1e-7) < 1e-12); + // Rounded up to 150 for slack: six factories match the 25 µs surgery + // period. + let t = Timing { cycle_us: 1.0, reaction_us: 10.0, distance: 25, ccz_rounds: 150.0, factories: 6 }; + assert_eq!((t.surgery_us(), t.ccz_period_us(), t.step_us()), (25.0, 25.0, 25.0)); + assert_eq!(t.bound(), Bound::Surgery); + assert_eq!(t.add_us(33), 1600.0); + assert_eq!(t.lookup_us(6), 1575.0); + let slow = Timing { reaction_us: 40.0, ..t }; + assert_eq!(slow.bound(), Bound::Reaction); + let starved = Timing { factories: 2, ..t }; + assert_eq!(starved.bound(), Bound::MagicStates); + } + + #[test] + fn the_logical_counts_reproduce_the_published_table() { + let p = rsa(); + assert_eq!(p.input_qubits(), 1280); + assert_eq!(p.primes(), 20_871); + assert_eq!(p.table_logical_qubits(), 1399); + assert_eq!(p.peak_logical_qubits(), 1432); + // The published count: 6.5·10⁹ Toffolis per factoring. + let per_shot = p.toffolis_per_shot_source_rule(PhaseupCount::AsCoded); + let published = per_shot * f64::from(p.s + 1) / (1.0 - p.deviant); + assert!((6.45e9..6.55e9).contains(&published), "{published:e}"); + // The reference tally rounds loop 4's half operations to integers; held + // in halves here, it is 29.5 Toffolis lower. + assert_eq!(per_shot, 712_920_014.5); + // Every published row. The reference implementation's counts and keep + // rates (its simulated `1 − P_deviant`, printed rounded in the table) + // agree to its rounding of half operations. + for (n, keep, tofs, qubits) in [ + (1024, 0.971_311_569_213_867_2, 1_083_979_446.0, 742), + (1536, 0.981_724_202_632_904, 3_117_105_798.0, 1074), + (2048, 0.987_522_467_970_848_1, 6_497_351_306.0, 1399), + (3072, 0.990_862_101_316_452, 18_500_632_076.0, 2043), + (4096, 0.992_021_542_042_493_8, 40_261_413_896.0, 2692), + (6144, 0.995_758_056_640_625, 119_251_229_120.0, 3978), + (8192, 0.996_010_778_006_166_2, 266_770_779_692.0, 5261), + ] { + let q = FactoringParams::published(n).unwrap(); + assert_eq!(q.table_logical_qubits(), qubits, "n={n}"); + assert!((1.0 - q.deviant - keep).abs() < 5e-5, "n={n}"); + let t = q.toffolis_per_shot_source_rule(PhaseupCount::AsCoded) * f64::from(q.s + 1) / keep; + assert!((t / tofs - 1.0).abs() < 1e-7, "n={n}: {t} vs {tofs}"); + } + } + + #[test] + fn the_phaseup_rule_undercounts() { + let p = rsa(); + let coded = p.toffolis_per_shot_source_rule(PhaseupCount::AsCoded); + let stated = p.toffolis_per_shot_source_rule(PhaseupCount::AsStated); + // 1,481,841 six-bit phaseups at 8 rather than 0.25, and 104,355 + // five-bit ones at 6. + assert_eq!(stated - coded, 1_481_841.0 * 7.75 + 104_355.0 * 5.75); + assert!((0.016..0.018).contains(&(stated / coded - 1.0)), "{}", stated / coded - 1.0); + // Counted operation by operation, at full sizes, the total lands + // between the two. + let own = p.toffolis_per_shot(); + assert!(own < stated, "{own} {stated}"); + } + + #[test] + fn the_stated_durations_give_ten_point_six_hours_not_twelve() { + // 2 ms per addition and per lookup, 1 ms per phaseup. + let ms: f64 = rsa().tallies().iter().map(|s| 2.0 * (s.adds() + s.lookups()) + s.phaseups()).sum(); + let hours = ms / 3.6e6; + assert!((hours - 10.621).abs() < 0.001, "{hours}"); + assert!(hours < 12.07 / 1.13); + } + + #[test] + fn the_whole_machine_stays_under_a_million_qubits_and_a_week() { + let e = factoring_estimate(&rsa(), &Machine::published()).unwrap(); + assert_eq!(e.hot_distance, 25); + assert_eq!(e.hot_logical, 152); + assert_eq!(e.compute_qubits, 170_352); + assert_eq!(e.cold_qubits, 582_624); + assert_eq!(e.physical_qubits(), 958_480); + assert!(e.physical_qubits() < 1_000_000); + assert_eq!(e.t_state.d1, 5); + assert!(e.ccz_error < 1e-12); + assert_eq!(e.timing.bound(), Bound::Surgery); + assert!(e.days < 7.0, "{}", e.days); + // At the source's own hot count the total is 926,256 rather than 897,864. + assert_eq!(1280 * 430 + 152 * 1352 + 7 * 18 * 1352, 926_256); + } + + #[test] + fn a_measured_fit_converts_to_a_storage_fit() { + // a = 0.023, p* = 0.01 at p = 10⁻³: Λ = √10 and C = 1/(a·√0.1). + let f = StorageFit::flat_from_threshold(0.023, 0.01, 1e-3); + assert!((f.suppression - 10f64.sqrt()).abs() < 1e-12); + assert!((f.per_patch_round(9, 1, 1) - 0.023 * 1e-5).abs() < 1e-18); + let m = StorageModel { flat: f, ..StorageModel::uniform_refit() }; + assert_eq!(flat_distance(&m, 1e-15), Some(26)); + } +} diff --git a/wai/wai-quantum/src/repro.rs b/wai/wai-quantum/src/repro.rs index 6836204df..f740492b5 100644 --- a/wai/wai-quantum/src/repro.rs +++ b/wai/wai-quantum/src/repro.rs @@ -34,28 +34,28 @@ pub use trig::sin_cos; // Natural logarithm // --------------------------------------------------------------------------- -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LN2_HI: f64 = 6.931_471_803_691_238_164_90e-1; -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LN2_LO: f64 = 1.908_214_929_270_587_700_02e-10; -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LG1: f64 = 6.666_666_666_666_735_130e-1; -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LG2: f64 = 3.999_999_999_940_941_908e-1; -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LG3: f64 = 2.857_142_874_366_239_149e-1; -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LG4: f64 = 2.222_219_843_214_978_396e-1; -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LG5: f64 = 1.818_357_216_161_805_012e-1; -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LG6: f64 = 1.531_383_769_920_937_332e-1; -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const LG7: f64 = 1.479_819_860_511_658_591e-1; /// The natural logarithm, within an ulp of the true value: `−∞` at zero, NaN /// below it. -#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] pub fn ln(x: f64) -> f64 { let mut bits = x.to_bits(); let mut hx = (bits >> 32) as u32; @@ -99,7 +99,7 @@ pub fn ln(x: f64) -> f64 { // Exponential // --------------------------------------------------------------------------- -#[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] const EXP_P: [f64; 5] = [ 1.666_666_666_666_660_190_37e-1, -2.777_777_777_701_559_338_42e-3, @@ -111,7 +111,7 @@ const EXP_P: [f64; 5] = [ /// `eˣ`, bit-identical on every IEEE-754 platform: fdlibm's algorithm /// (reduction by `ln 2` in two parts, a rational approximation on /// `[−ln2/2, ln2/2]`), using only `+ − × ÷`. Within an ulp of the true value. -#[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] +#[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] pub fn exp(x: f64) -> f64 { const LN2_HI_E: f64 = 6.931_471_803_691_238_164_90e-1; const LN2_LO_E: f64 = 1.908_214_929_270_587_700_02e-10; @@ -312,7 +312,7 @@ mod tests { #[allow(unused_imports)] use super::*; - #[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] + #[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] #[test] fn exp_is_within_an_ulp_of_the_platform() { let mut s = 0x9e37_79b9_7f4a_7c15u64; @@ -355,7 +355,7 @@ mod tests { }) } - #[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))] + #[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))] #[test] fn ln_is_within_an_ulp_of_the_platform() { for x in inputs().filter(|&x| x > 0.0) { diff --git a/wai/wai-quantum/tests/bit_identity.rs b/wai/wai-quantum/tests/bit_identity.rs index 4c9455c68..5f2f4064a 100644 --- a/wai/wai-quantum/tests/bit_identity.rs +++ b/wai/wai-quantum/tests/bit_identity.rs @@ -19,7 +19,8 @@ feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", - feature = "quantum_sv" + feature = "quantum_sv", + feature = "quantum_arch" ))] use wai_quantum::*; @@ -294,3 +295,47 @@ fn dense_state_vector() { assert_eq!(digest(&v), 0xd0df_e437_5b28_903f); } + +/// Storage layouts under every fit set, cultivation interpolation (in-crate +/// `ln` and `exp`), the threshold-to-storage conversion, and the whole factoring +/// machine at three key sizes. +#[test] +fn architecture_estimates() { + use quantum_arch::*; + let mut v = Vec::new(); + for model in [StorageModel::si1000(), StorageModel::uniform(), StorageModel::uniform_refit()] { + for target in [1e-9, 3.7e-13, 1e-15] { + for b in [ + best_block(&model, Storage::Cold, Yoke::Rows, target, 250), + best_block(&model, Storage::Hot, Yoke::Rows, target, 250), + grid_block(&model, 16, target), + ] + .into_iter() + .flatten() + { + v.push(f64::from(b.distance)); + v.push(b.qubits_per_logical()); + v.push(b.error_per_logical_round); + } + } + } + for (p, t) in [(5e-4, 3.3e-9), (1e-3, 1e-7), (1e-3, 4.4e-6), (2e-3, 2.2e-5)] { + let c = cultivate(p, t).unwrap(); + v.push(c.volume); + v.push(c.error); + } + let f = StorageFit::flat_from_threshold(0.023, 0.0100, 1e-3); + v.push(f.suppression); + v.push(f.per_patch_round(17, 1, 1)); + for bits in [1024, 2048, 4096] { + let e = factoring_estimate(&FactoringParams::published(bits).unwrap(), &Machine::published()).unwrap(); + v.push(e.physical_qubits() as f64); + v.push(e.ccz_rounds); + v.push(e.hours_per_shot); + v.push(e.hours_per_shot_rounded); + v.push(e.shot_survival); + v.push(e.days); + v.push(e.toffolis_per_shot); + } + assert_eq!(digest(&v), 0xd166_b4c6_c731_7a52); +} diff --git a/wai/wai-quantum/tests/data/yoked_footprint_oracle.csv b/wai/wai-quantum/tests/data/yoked_footprint_oracle.csv new file mode 100644 index 000000000..f9a649d16 --- /dev/null +++ b/wai/wai-quantum/tests/data/yoked_footprint_oracle.csv @@ -0,0 +1,916 @@ +set,storage,yokes,target,d,groups,ppg,rows,cols,logical,r,d0,rate,lerp +si1000,cold,0,1e-18,35,1,4,1,4,4,350,35,2592.0,9.9936949580635e-19 +si1000,cold,0,1.778279410038923e-18,35,1,4,1,4,4,350,35,2592.0,9.9936949580635e-19 +si1000,cold,0,3.1622776601683795e-18,34,1,4,1,4,4,340,34,2450.0,2.99810848741905e-18 +si1000,cold,0,5.623413251903491e-18,34,1,4,1,4,4,340,34,2450.0,2.99810848741905e-18 +si1000,cold,0,1e-17,33,1,4,1,4,4,330,33,2312.0,8.994325462257151e-18 +si1000,cold,0,1.7782794100389228e-17,33,1,4,1,4,4,330,33,2312.0,8.994325462257151e-18 +si1000,cold,0,3.1622776601683796e-17,32,1,4,1,4,4,320,32,2178.0,2.698297638677145e-17 +si1000,cold,0,5.62341325190349e-17,32,1,4,1,4,4,320,32,2178.0,2.698297638677145e-17 +si1000,cold,0,1e-16,31,1,4,1,4,4,310,31,2048.0,8.094892916031435e-17 +si1000,cold,0,1.7782794100389228e-16,31,1,4,1,4,4,310,31,2048.0,8.094892916031435e-17 +si1000,cold,0,3.1622776601683793e-16,30,1,4,1,4,4,300,30,1922.0,2.4284678748094307e-16 +si1000,cold,0,5.623413251903491e-16,30,1,4,1,4,4,300,30,1922.0,2.4284678748094307e-16 +si1000,cold,0,1e-15,29,1,4,1,4,4,290,29,1800.0,7.285403624428292e-16 +si1000,cold,0,1.7782794100389227e-15,29,1,4,1,4,4,290,29,1800.0,7.285403624428292e-16 +si1000,cold,0,3.1622776601683794e-15,28,1,4,1,4,4,280,28,1682.0,2.1856210873284874e-15 +si1000,cold,0,5.6234132519034904e-15,28,1,4,1,4,4,280,28,1682.0,2.1856210873284874e-15 +si1000,cold,0,1e-14,27,1,4,1,4,4,270,27,1568.0,6.556863261985463e-15 +si1000,cold,0,1.7782794100389227e-14,27,1,4,1,4,4,270,27,1568.0,6.556863261985463e-15 +si1000,cold,0,3.1622776601683796e-14,26,1,4,1,4,4,260,26,1458.0,1.9670589785956387e-14 +si1000,cold,0,5.6234132519034906e-14,26,1,4,1,4,4,260,26,1458.0,1.9670589785956387e-14 +si1000,cold,0,1e-13,25,1,4,1,4,4,250,25,1352.0,5.901176935786916e-14 +si1000,cold,0,1.7782794100389227e-13,24,1,4,1,4,4,240,24,1250.0,1.770353080736075e-13 +si1000,cold,0,3.162277660168379e-13,24,1,4,1,4,4,240,24,1250.0,1.770353080736075e-13 +si1000,cold,0,5.62341325190349e-13,23,1,4,1,4,4,230,23,1152.0,5.311059242208225e-13 +si1000,cold,0,1e-12,23,1,4,1,4,4,230,23,1152.0,5.311059242208225e-13 +si1000,cold,0,1.7782794100389228e-12,22,1,4,1,4,4,220,22,1058.0,1.5933177726624674e-12 +si1000,cold,0,3.1622776601683794e-12,22,1,4,1,4,4,220,22,1058.0,1.5933177726624674e-12 +si1000,cold,0,5.6234132519034904e-12,21,1,4,1,4,4,210,21,968.0,4.779953317987403e-12 +si1000,cold,0,1e-11,21,1,4,1,4,4,210,21,968.0,4.779953317987403e-12 +si1000,cold,0,1.7782794100389227e-11,20,1,4,1,4,4,200,20,882.0,1.4339859953962207e-11 +si1000,cold,0,3.1622776601683794e-11,20,1,4,1,4,4,200,20,882.0,1.4339859953962207e-11 +si1000,cold,0,5.6234132519034906e-11,19,1,4,1,4,4,190,19,800.0,4.3019579861886616e-11 +si1000,cold,0,1e-10,19,1,4,1,4,4,190,19,800.0,4.3019579861886616e-11 +si1000,cold,0,1.778279410038923e-10,18,1,4,1,4,4,180,18,722.0,1.2905873958565984e-10 +si1000,cold,0,3.1622776601683795e-10,18,1,4,1,4,4,180,18,722.0,1.2905873958565984e-10 +si1000,cold,0,5.623413251903491e-10,17,1,4,1,4,4,170,17,648.0,3.871762187569796e-10 +si1000,cold,0,1e-09,17,1,4,1,4,4,170,17,648.0,3.871762187569796e-10 +si1000,cold,0,1.7782794100389228e-09,16,1,4,1,4,4,160,16,578.0,1.1615286562709387e-09 +si1000,cold,0,3.1622776601683795e-09,16,1,4,1,4,4,160,16,578.0,1.1615286562709387e-09 +si1000,cold,0,5.623413251903491e-09,15,1,4,1,4,4,150,15,512.0,3.4845859688128162e-09 +si1000,cold,0,1e-08,15,1,4,1,4,4,150,15,512.0,3.4845859688128162e-09 +si1000,cold,0,1.7782794100389228e-08,14,1,4,1,4,4,140,14,450.0,1.0453757906438449e-08 +si1000,cold,0,3.162277660168379e-08,13,1,4,1,4,4,130,13,392.0,3.1361273719315344e-08 +si1000,cold,0,5.6234132519034905e-08,13,1,4,1,4,4,130,13,392.0,3.1361273719315344e-08 +si1000,cold,0,1e-07,12,1,4,1,4,4,120,12,338.0,9.408382115794604e-08 +si1000,cold,0,1.7782794100389227e-07,12,1,4,1,4,4,120,12,338.0,9.408382115794604e-08 +si1000,cold,0,3.162277660168379e-07,11,1,4,1,4,4,110,11,288.0,2.822514634738381e-07 +si1000,cold,0,5.62341325190349e-07,11,1,4,1,4,4,110,11,288.0,2.822514634738381e-07 +si1000,cold,0,1e-06,10,1,4,1,4,4,100,10,242.0,8.467543904215143e-07 +si1000,cold,0,1.778279410038923e-06,10,1,4,1,4,4,100,10,242.0,8.467543904215143e-07 +si1000,cold,0,3.162277660168379e-06,9,1,4,1,4,4,90,9,200.0,2.5402631712645428e-06 +si1000,cold,0,5.623413251903491e-06,9,1,4,1,4,4,90,9,200.0,2.5402631712645428e-06 +si1000,cold,0,1e-05,8,1,4,1,4,4,80,8,162.0,7.6207895137936296e-06 +si1000,cold,0,1.778279410038923e-05,8,1,4,1,4,4,80,8,162.0,7.6207895137936296e-06 +si1000,cold,0,3.1622776601683795e-05,7,1,4,1,4,4,70,7,128.0,2.2862368541380887e-05 +si1000,cold,0,5.623413251903491e-05,7,1,4,1,4,4,70,7,128.0,2.2862368541380887e-05 +si1000,cold,0,0.0001,6,1,4,1,4,4,60,6,98.0,6.858710562414265e-05 +si1000,cold,0,0.00017782794100389227,6,1,4,1,4,4,60,6,98.0,6.858710562414265e-05 +si1000,cold,0,0.00031622776601683794,5,1,4,1,4,4,50,5,72.0,0.000205761316872428 +si1000,cold,0,0.0005623413251903491,5,1,4,1,4,4,50,5,72.0,0.000205761316872428 +si1000,cold,0,0.001,4,1,4,1,4,4,40,4,50.0,0.0006172839506172839 +si1000,cold,2,1e-18,22,9,20,10,20,162,1628,35,1306.1728395061727,9.80600631559112e-19 +si1000,cold,2,1.778279410038923e-18,22,11,24,12,24,242,1980,35,1259.107438016529,1.4051260155412135e-18 +si1000,cold,2,3.1622776601683795e-18,22,11,24,12,24,242,1980,34,1259.107438016529,1.4051260155412135e-18 +si1000,cold,2,5.623413251903491e-18,21,6,22,7,22,120,1050,34,1242.2666666666667,5.509915440571334e-18 +si1000,cold,2,1e-17,21,11,22,12,22,220,1890,33,1161.6,9.917847793028402e-18 +si1000,cold,2,1.7782794100389228e-17,21,11,24,12,24,242,1890,33,1152.0,1.0730053209587449e-17 +si1000,cold,2,3.1622776601683796e-17,21,11,24,12,24,242,1890,32,1152.0,1.0730053209587449e-17 +si1000,cold,2,5.62341325190349e-17,20,8,22,9,22,160,1320,32,1091.475,5.5414006716603137e-17 +si1000,cold,2,1e-16,20,11,24,12,24,242,1800,31,1049.6528925619834,8.175278635876152e-17 +si1000,cold,2,1.7782794100389228e-16,20,11,24,12,24,242,1800,31,1049.6528925619834,8.175278635876152e-17 +si1000,cold,2,3.1622776601683793e-16,19,7,18,8,18,112,1102,30,1028.5714285714287,3.0968977382528356e-16 +si1000,cold,2,5.623413251903491e-16,19,9,26,10,26,216,1406,30,962.9629629629629,5.495927786943374e-16 +si1000,cold,2,1e-15,19,11,24,12,24,242,1710,29,952.0661157024794,6.213211763265875e-16 +si1000,cold,2,1.7782794100389227e-15,19,11,24,12,24,242,1710,29,952.0661157024794,6.213211763265875e-16 +si1000,cold,2,3.1622776601683794e-15,18,7,24,8,24,154,1044,28,900.1558441558442,3.0346634296372278e-15 +si1000,cold,2,5.6234132519034904e-15,18,11,24,12,24,242,1620,28,859.2396694214876,4.708960494264664e-15 +si1000,cold,2,1e-14,18,11,24,12,24,242,1620,27,859.2396694214876,4.708960494264664e-15 +si1000,cold,2,1.7782794100389227e-14,17,7,18,8,18,112,986,27,833.1428571428571,1.773381441694255e-14 +si1000,cold,2,3.1622776601683796e-14,17,9,26,10,26,216,1258,26,780.0,3.1471418064181e-14 +si1000,cold,2,5.6234132519034906e-14,17,11,24,12,24,242,1530,26,771.1735537190083,3.5578812623333014e-14 +si1000,cold,2,1e-13,17,11,24,12,24,242,1530,25,771.1735537190083,3.5578812623333014e-14 +si1000,cold,2,1.7782794100389227e-13,16,7,24,8,24,154,928,24,720.6233766233767,1.7263863066380675e-13 +si1000,cold,2,3.162277660168379e-13,16,11,24,12,24,242,1440,24,687.8677685950413,2.678875303403898e-13 +si1000,cold,2,5.62341325190349e-13,16,11,24,12,24,242,1440,23,687.8677685950413,2.678875303403898e-13 +si1000,cold,2,1e-12,15,6,20,7,20,108,750,23,663.7037037037037,9.473903143468003e-13 +si1000,cold,2,1.7782794100389228e-12,15,9,26,10,26,216,1110,22,616.2962962962963,1.7772094906831626e-12 +si1000,cold,2,3.1622776601683794e-12,15,11,24,12,24,242,1350,22,609.3223140495868,2.0091564775529236e-12 +si1000,cold,2,5.6234132519034904e-12,14,5,18,6,18,80,588,21,607.5,5.414676707005128e-12 +si1000,cold,2,1e-11,14,7,24,8,24,154,812,21,561.038961038961,9.667763317173176e-12 +si1000,cold,2,1.7782794100389227e-11,14,11,24,12,24,242,1260,20,535.5371900826447,1.500170169906183e-11 +si1000,cold,2,3.1622776601683794e-11,14,11,24,12,24,242,1260,20,535.5371900826447,1.500170169906183e-11 +si1000,cold,2,5.6234132519034906e-11,13,7,18,8,18,112,754,19,504.0,5.554647941607982e-11 +si1000,cold,2,1e-10,13,9,26,10,26,216,962,19,471.85185185185185,9.857588641655941e-11 +si1000,cold,2,1.778279410038923e-10,13,11,24,12,24,242,1170,18,466.5123966942149,1.1144121262160213e-10 +si1000,cold,2,3.1622776601683795e-10,12,5,18,6,18,80,504,18,456.3,2.9703369364142417e-10 +si1000,cold,2,5.623413251903491e-10,12,8,22,9,22,160,792,17,418.275,5.578156560659408e-10 +si1000,cold,2,1e-09,12,11,24,12,24,242,1080,17,402.24793388429754,8.229504932056774e-10 +si1000,cold,2,1.7782794100389228e-09,12,11,24,12,24,242,1080,16,402.24793388429754,8.229504932056774e-10 +si1000,cold,2,3.1622776601683795e-09,11,6,22,7,22,120,550,16,369.6,3.0989758670330053e-09 +si1000,cold,2,5.623413251903491e-09,11,11,22,12,22,220,990,15,345.6,5.578156560659409e-09 +si1000,cold,2,1e-08,11,11,24,12,24,242,990,15,342.74380165289256,6.0349702835082995e-09 +si1000,cold,2,1.7782794100389228e-08,10,7,14,8,14,84,580,14,322.6666666666667,1.7645458380381265e-08 +si1000,cold,2,3.162277660168379e-08,10,9,20,10,20,162,740,13,298.7654320987654,3.063016467624241e-08 +si1000,cold,2,5.6234132519034905e-08,10,11,24,12,24,242,900,13,288.0,4.389069297096946e-08 +si1000,cold,2,1e-07,9,6,12,7,12,60,450,12,280.0,9.655952453613282e-08 +si1000,cold,2,1.7782794100389227e-07,9,7,20,8,20,126,522,12,253.96825396825398,1.7285346984863283e-07 +si1000,cold,2,3.162277660168379e-07,9,11,24,12,24,242,810,11,238.01652892561984,3.160129893909801e-07 +si1000,cold,2,5.62341325190349e-07,8,4,14,5,14,48,272,11,236.25,5.29607137044271e-07 +si1000,cold,2,1e-06,8,6,18,7,18,96,400,10,212.625,9.65595245361328e-07 +si1000,cold,2,1.778279410038923e-06,8,8,26,9,26,192,528,10,197.4375,1.7728805541992187e-06 +si1000,cold,2,3.162277660168379e-06,8,11,24,12,24,242,720,9,192.79338842975207,2.2472034801136364e-06 +si1000,cold,2,5.623413251903491e-06,7,6,14,7,14,72,350,9,174.22222222222223,5.45183817545573e-06 +si1000,cold,2,1e-05,7,8,20,9,20,144,462,8,160.0,9.791056315104167e-06 +si1000,cold,2,1.778279410038923e-05,7,11,24,12,24,242,630,8,152.3305785123967,1.5730424360795456e-05 +si1000,cold,2,3.1622776601683795e-05,6,5,14,6,14,60,252,7,137.2,3.1402587890625004e-05 +si1000,cold,2,5.623413251903491e-05,6,6,22,7,22,120,300,7,125.76666666666667,5.5389404296875e-05 +si1000,cold,2,0.0001,6,11,22,12,22,220,540,6,117.6,9.970092773437501e-05 +si1000,cold,2,0.00017782794100389227,5,4,14,5,14,48,170,6,105.0,0.0001694742838541667 +si1000,cold,2,0.00031622776601683794,5,6,18,7,18,96,250,5,94.5,0.000308990478515625 +si1000,cold,2,0.0005623413251903491,5,10,20,11,20,180,410,5,88.0,0.0005560980902777779 +si1000,cold,2,0.001,4,4,12,5,12,40,136,4,75.0,0.0009562500000000001 +si1000,cold,64,1e-18,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19 +si1000,cold,64,1.778279410038923e-18,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19 +si1000,cold,64,3.1622776601683795e-18,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19 +si1000,cold,64,5.623413251903491e-18,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19 +si1000,cold,64,1e-17,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19 +si1000,cold,64,1.7782794100389228e-17,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17 +si1000,cold,64,3.1622776601683796e-17,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17 +si1000,cold,64,5.62341325190349e-17,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17 +si1000,cold,64,1e-16,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17 +si1000,cold,64,1.7782794100389228e-16,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17 +si1000,cold,64,3.1622776601683793e-16,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17 +si1000,cold,64,5.623413251903491e-16,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16 +si1000,cold,64,1e-15,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16 +si1000,cold,64,1.7782794100389227e-15,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16 +si1000,cold,64,3.1622776601683794e-15,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16 +si1000,cold,64,5.6234132519034904e-15,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16 +si1000,cold,64,1e-14,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16 +si1000,cold,64,1.7782794100389227e-14,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16 +si1000,cold,64,3.1622776601683796e-14,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14 +si1000,cold,64,5.6234132519034906e-14,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14 +si1000,cold,64,1e-13,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14 +si1000,cold,64,1.7782794100389227e-13,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14 +si1000,cold,64,3.162277660168379e-13,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14 +si1000,cold,64,5.62341325190349e-13,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14 +si1000,cold,64,1e-12,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13 +si1000,cold,64,1.7782794100389228e-12,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13 +si1000,cold,64,3.1622776601683794e-12,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13 +si1000,cold,64,5.6234132519034904e-12,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13 +si1000,cold,64,1e-11,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13 +si1000,cold,64,1.7782794100389227e-11,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13 +si1000,cold,64,3.1622776601683794e-11,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11 +si1000,cold,64,5.6234132519034906e-11,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11 +si1000,cold,64,1e-10,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11 +si1000,cold,64,1.778279410038923e-10,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11 +si1000,cold,64,3.1622776601683795e-10,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11 +si1000,cold,64,5.623413251903491e-10,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11 +si1000,cold,64,1e-09,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11 +si1000,cold,64,1.7782794100389228e-09,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09 +si1000,cold,64,3.1622776601683795e-09,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09 +si1000,cold,64,5.623413251903491e-09,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09 +si1000,cold,64,1e-08,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09 +si1000,cold,64,1.7782794100389228e-08,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09 +si1000,cold,64,3.162277660168379e-08,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09 +si1000,cold,64,5.6234132519034905e-08,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08 +si1000,cold,64,1e-07,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08 +si1000,cold,64,1.7782794100389227e-07,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08 +si1000,cold,64,3.162277660168379e-07,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08 +si1000,cold,64,5.62341325190349e-07,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08 +si1000,cold,64,1e-06,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08 +si1000,cold,64,1.778279410038923e-06,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06 +si1000,cold,64,3.162277660168379e-06,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06 +si1000,cold,64,5.623413251903491e-06,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06 +si1000,cold,64,1e-05,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06 +si1000,cold,64,1.778279410038923e-05,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06 +si1000,cold,64,3.1622776601683795e-05,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06 +si1000,cold,64,5.623413251903491e-05,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05 +si1000,cold,64,0.0001,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05 +si1000,cold,64,0.00017782794100389227,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05 +si1000,cold,64,0.00031622776601683794,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05 +si1000,cold,64,0.0005623413251903491,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05 +si1000,cold,64,0.001,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05 +si1000,hot,0,1e-18,35,2,125,3,126,250,1750,35,3919.104,9.9936949580635e-19 +si1000,hot,0,1.778279410038923e-18,35,2,125,3,126,250,1750,35,3919.104,9.9936949580635e-19 +si1000,hot,0,3.1622776601683795e-18,34,2,125,3,126,250,1700,34,3704.4,2.99810848741905e-18 +si1000,hot,0,5.623413251903491e-18,34,2,125,3,126,250,1700,34,3704.4,2.99810848741905e-18 +si1000,hot,0,1e-17,33,2,125,3,126,250,1650,33,3495.744,8.994325462257151e-18 +si1000,hot,0,1.7782794100389228e-17,33,2,125,3,126,250,1650,33,3495.744,8.994325462257151e-18 +si1000,hot,0,3.1622776601683796e-17,32,2,125,3,126,250,1600,32,3293.136,2.698297638677145e-17 +si1000,hot,0,5.62341325190349e-17,32,2,125,3,126,250,1600,32,3293.136,2.698297638677145e-17 +si1000,hot,0,1e-16,31,2,125,3,126,250,1550,31,3096.576,8.094892916031435e-17 +si1000,hot,0,1.7782794100389228e-16,31,2,125,3,126,250,1550,31,3096.576,8.094892916031435e-17 +si1000,hot,0,3.1622776601683793e-16,30,2,125,3,126,250,1500,30,2906.064,2.4284678748094307e-16 +si1000,hot,0,5.623413251903491e-16,30,2,125,3,126,250,1500,30,2906.064,2.4284678748094307e-16 +si1000,hot,0,1e-15,29,2,125,3,126,250,1450,29,2721.6,7.285403624428292e-16 +si1000,hot,0,1.7782794100389227e-15,29,2,125,3,126,250,1450,29,2721.6,7.285403624428292e-16 +si1000,hot,0,3.1622776601683794e-15,28,2,125,3,126,250,1400,28,2543.184,2.1856210873284874e-15 +si1000,hot,0,5.6234132519034904e-15,28,2,125,3,126,250,1400,28,2543.184,2.1856210873284874e-15 +si1000,hot,0,1e-14,27,2,125,3,126,250,1350,27,2370.816,6.556863261985463e-15 +si1000,hot,0,1.7782794100389227e-14,27,2,125,3,126,250,1350,27,2370.816,6.556863261985463e-15 +si1000,hot,0,3.1622776601683796e-14,26,2,125,3,126,250,1300,26,2204.496,1.9670589785956387e-14 +si1000,hot,0,5.6234132519034906e-14,26,2,125,3,126,250,1300,26,2204.496,1.9670589785956387e-14 +si1000,hot,0,1e-13,25,2,125,3,126,250,1250,25,2044.224,5.901176935786916e-14 +si1000,hot,0,1.7782794100389227e-13,24,2,125,3,126,250,1200,24,1890.0,1.770353080736075e-13 +si1000,hot,0,3.162277660168379e-13,24,2,125,3,126,250,1200,24,1890.0,1.770353080736075e-13 +si1000,hot,0,5.62341325190349e-13,23,2,125,3,126,250,1150,23,1741.824,5.311059242208225e-13 +si1000,hot,0,1e-12,23,2,125,3,126,250,1150,23,1741.824,5.311059242208225e-13 +si1000,hot,0,1.7782794100389228e-12,22,2,125,3,126,250,1100,22,1599.696,1.5933177726624674e-12 +si1000,hot,0,3.1622776601683794e-12,22,2,125,3,126,250,1100,22,1599.696,1.5933177726624674e-12 +si1000,hot,0,5.6234132519034904e-12,21,2,125,3,126,250,1050,21,1463.616,4.779953317987403e-12 +si1000,hot,0,1e-11,21,2,125,3,126,250,1050,21,1463.616,4.779953317987403e-12 +si1000,hot,0,1.7782794100389227e-11,20,2,125,3,126,250,1000,20,1333.584,1.4339859953962207e-11 +si1000,hot,0,3.1622776601683794e-11,20,2,125,3,126,250,1000,20,1333.584,1.4339859953962207e-11 +si1000,hot,0,5.6234132519034906e-11,19,2,125,3,126,250,950,19,1209.6,4.3019579861886616e-11 +si1000,hot,0,1e-10,19,2,125,3,126,250,950,19,1209.6,4.3019579861886616e-11 +si1000,hot,0,1.778279410038923e-10,18,2,125,3,126,250,900,18,1091.664,1.2905873958565984e-10 +si1000,hot,0,3.1622776601683795e-10,18,2,125,3,126,250,900,18,1091.664,1.2905873958565984e-10 +si1000,hot,0,5.623413251903491e-10,17,2,125,3,126,250,850,17,979.776,3.871762187569796e-10 +si1000,hot,0,1e-09,17,2,125,3,126,250,850,17,979.776,3.871762187569796e-10 +si1000,hot,0,1.7782794100389228e-09,16,2,125,3,126,250,800,16,873.936,1.1615286562709387e-09 +si1000,hot,0,3.1622776601683795e-09,16,2,125,3,126,250,800,16,873.936,1.1615286562709387e-09 +si1000,hot,0,5.623413251903491e-09,15,2,125,3,126,250,750,15,774.144,3.4845859688128162e-09 +si1000,hot,0,1e-08,15,2,125,3,126,250,750,15,774.144,3.4845859688128162e-09 +si1000,hot,0,1.7782794100389228e-08,14,2,125,3,126,250,700,14,680.4,1.0453757906438449e-08 +si1000,hot,0,3.162277660168379e-08,13,2,125,3,126,250,650,13,592.704,3.1361273719315344e-08 +si1000,hot,0,5.6234132519034905e-08,13,2,125,3,126,250,650,13,592.704,3.1361273719315344e-08 +si1000,hot,0,1e-07,12,2,125,3,126,250,600,12,511.056,9.408382115794604e-08 +si1000,hot,0,1.7782794100389227e-07,12,2,125,3,126,250,600,12,511.056,9.408382115794604e-08 +si1000,hot,0,3.162277660168379e-07,11,2,125,3,126,250,550,11,435.456,2.822514634738381e-07 +si1000,hot,0,5.62341325190349e-07,11,2,125,3,126,250,550,11,435.456,2.822514634738381e-07 +si1000,hot,0,1e-06,10,2,125,3,126,250,500,10,365.904,8.467543904215143e-07 +si1000,hot,0,1.778279410038923e-06,10,2,125,3,126,250,500,10,365.904,8.467543904215143e-07 +si1000,hot,0,3.162277660168379e-06,9,2,125,3,126,250,450,9,302.4,2.5402631712645428e-06 +si1000,hot,0,5.623413251903491e-06,9,2,125,3,126,250,450,9,302.4,2.5402631712645428e-06 +si1000,hot,0,1e-05,8,2,125,3,126,250,400,8,244.944,7.6207895137936296e-06 +si1000,hot,0,1.778279410038923e-05,8,2,125,3,126,250,400,8,244.944,7.6207895137936296e-06 +si1000,hot,0,3.1622776601683795e-05,7,2,125,3,126,250,350,7,193.536,2.2862368541380887e-05 +si1000,hot,0,5.623413251903491e-05,7,2,125,3,126,250,350,7,193.536,2.2862368541380887e-05 +si1000,hot,0,0.0001,6,2,125,3,126,250,300,6,148.176,6.858710562414265e-05 +si1000,hot,0,0.00017782794100389227,6,2,125,3,126,250,300,6,148.176,6.858710562414265e-05 +si1000,hot,0,0.00031622776601683794,5,2,125,3,126,250,250,5,108.864,0.000205761316872428 +si1000,hot,0,0.0005623413251903491,5,2,125,3,126,250,250,5,108.864,0.000205761316872428 +si1000,hot,0,0.001,4,2,125,3,126,250,200,4,75.6,0.0006172839506172839 +si1000,hot,2,1e-18,23,2,126,3,127,248,1150,35,2064.7741935483873,4.988586881032472e-19 +si1000,hot,2,1.778279410038923e-18,22,2,56,3,57,108,1100,35,1990.7777777777778,1.7315110250953687e-18 +si1000,hot,2,3.1622776601683795e-18,22,2,104,3,105,204,1100,34,1917.7941176470588,3.1616185704322395e-18 +si1000,hot,2,5.623413251903491e-18,22,2,126,3,127,248,1100,34,1908.0725806451612,3.817353439398761e-18 +si1000,hot,2,1e-17,21,2,40,3,41,76,1050,33,1851.4736842105262,9.586629735661302e-18 +si1000,hot,2,1.7782794100389228e-17,21,2,76,3,77,148,1050,33,1785.5675675675675,1.7771538745108342e-17 +si1000,hot,2,3.1622776601683796e-17,21,2,126,3,127,248,1050,32,1734.983870967742,2.915069899177236e-17 +si1000,hot,2,5.62341325190349e-17,21,2,126,3,127,248,1050,32,1734.983870967742,2.915069899177236e-17 +si1000,hot,2,1e-16,20,2,54,3,55,104,1000,31,1643.6538461538462,9.727795492208403e-17 +si1000,hot,2,1.7782794100389228e-16,20,2,100,3,101,196,1000,31,1601.5714285714287,1.7701259958947012e-16 +si1000,hot,2,3.1622776601683793e-16,20,2,126,3,127,248,1000,30,1570.0887096774193,2.22100563746837e-16 +si1000,hot,2,5.623413251903491e-16,19,2,40,3,41,76,950,30,1532.1052631578948,5.551115123125783e-16 +si1000,hot,2,1e-15,19,2,72,3,73,140,950,29,1460.0,9.76361848513209e-16 +si1000,hot,2,1.7782794100389227e-15,19,2,126,3,127,248,950,29,1433.8709677419354,1.6879642844759612e-15 +si1000,hot,2,3.1622776601683794e-15,19,2,126,3,127,248,950,28,1413.3870967741937,1.6879642844759612e-15 +si1000,hot,2,5.6234132519034904e-15,18,2,54,3,55,104,900,28,1346.4423076923076,5.603210203512041e-15 +si1000,hot,2,1e-14,18,2,98,3,99,192,900,27,1293.1875,9.996170557968753e-15 +si1000,hot,2,1.7782794100389227e-14,18,2,126,3,127,248,900,27,1284.3387096774193,1.2792992471817812e-14 +si1000,hot,2,3.1622776601683796e-14,17,2,38,3,39,72,850,26,1228.5,3.028194978722038e-14 +si1000,hot,2,5.6234132519034906e-14,17,2,72,3,73,140,850,26,1182.6,5.590956269380902e-14 +si1000,hot,2,1e-13,17,2,126,3,127,248,850,25,1143.0,9.665816534262346e-14 +si1000,hot,2,1.7782794100389227e-13,16,2,28,3,29,52,800,24,1118.7307692307693,1.7140477071874416e-13 +si1000,hot,2,3.162277660168379e-13,16,2,52,3,53,100,800,24,1063.18,3.0740920919924977e-13 +si1000,hot,2,5.62341325190349e-13,16,2,96,3,97,188,800,23,1017.468085106383,5.573073917246879e-13 +si1000,hot,2,1e-12,16,2,126,3,127,248,800,23,1009.8548387096774,7.277791272856356e-13 +si1000,hot,2,1.7782794100389228e-12,15,2,38,3,39,72,750,22,953.3333333333334,1.7100395173959746e-12 +si1000,hot,2,3.1622776601683794e-12,15,2,72,3,73,140,750,22,917.7142857142857,3.1572458932974506e-12 +si1000,hot,2,5.6234132519034904e-12,15,2,126,3,127,248,750,21,884.9032258064516,5.458343454642266e-12 +si1000,hot,2,1e-11,14,2,28,3,29,52,700,21,870.0,9.598667160249673e-12 +si1000,hot,2,1.7782794100389227e-11,14,2,52,3,53,100,700,20,810.9,1.721491571515799e-11 +si1000,hot,2,3.1622776601683794e-11,14,2,96,3,97,188,700,20,789.4148936170212,3.1209213936582525e-11 +si1000,hot,2,5.6234132519034906e-11,14,2,126,3,127,248,700,19,768.1451612903226,4.075563112799559e-11 +si1000,hot,2,1e-10,13,2,40,3,41,76,650,19,725.0526315789474,9.956573577303635e-11 +si1000,hot,2,1.778279410038923e-10,13,2,72,3,73,140,650,18,686.2,1.7512190554823194e-10 +si1000,hot,2,3.1622776601683795e-10,13,2,126,3,127,248,650,18,673.9193548387096,3.0275611695082437e-10 +si1000,hot,2,5.623413251903491e-10,12,2,30,3,31,56,600,17,633.2857142857143,5.612881588084357e-10 +si1000,hot,2,1e-09,12,2,54,3,55,104,600,17,605.0,9.792319570596403e-10 +si1000,hot,2,1.7782794100389228e-09,12,2,98,3,99,192,600,16,576.46875,1.7469574231654403e-09 +si1000,hot,2,3.1622776601683795e-09,11,2,22,3,23,40,550,16,565.8,3.0989758670330053e-09 +si1000,hot,2,5.623413251903491e-09,11,2,40,3,41,76,550,15,517.8947368421053,5.3918675372475066e-09 +si1000,hot,2,1e-08,11,2,76,3,77,148,550,15,499.4594594594595,9.995356604859635e-09 +si1000,hot,2,1.7782794100389228e-08,11,2,126,3,127,248,550,14,479.3225806451613,1.6395408179490798e-08 +si1000,hot,2,3.162277660168379e-08,10,2,30,3,31,56,500,13,438.42857142857144,2.9935368469783234e-08 +si1000,hot,2,5.6234132519034905e-08,10,2,58,3,59,112,500,13,417.2142857142857,5.594587751797268e-08 +si1000,hot,2,1e-07,10,2,104,3,105,204,500,12,396.3235294117647,9.87567153631472e-08 +si1000,hot,2,1.7782794100389227e-07,9,2,24,3,25,44,450,12,375.0,1.7556277188387783e-07 +si1000,hot,2,3.162277660168379e-07,9,2,44,3,45,84,450,11,342.85714285714283,3.0909265790666854e-07 +si1000,hot,2,5.62341325190349e-07,9,2,80,3,81,156,450,11,332.3076923076923,5.501967210036057e-07 +si1000,hot,2,1e-06,8,2,18,3,19,32,400,10,309.9375,9.65595245361328e-07 +si1000,hot,2,1.778279410038923e-06,8,2,34,3,35,64,400,10,285.46875,1.7225742340087892e-06 +si1000,hot,2,3.162277660168379e-06,8,2,64,3,65,124,400,9,264.19354838709677,3.150201612903226e-06 +si1000,hot,2,5.623413251903491e-06,8,2,114,3,115,224,400,9,258.75,5.533014025006975e-06 +si1000,hot,2,1e-05,7,2,26,3,27,48,350,8,225.0,9.401639302571615e-06 +si1000,hot,2,1.778279410038923e-05,7,2,50,3,51,96,350,8,212.5,1.7384688059488933e-05 +si1000,hot,2,3.1622776601683795e-05,7,2,92,3,93,180,350,7,198.4,3.139071994357639e-05 +si1000,hot,2,5.623413251903491e-05,6,2,22,3,23,40,300,7,177.1,5.5389404296875e-05 +si1000,hot,2,0.0001,6,2,40,3,41,76,300,6,158.60526315789474,9.637129934210526e-05 +si1000,hot,2,0.00017782794100389227,6,2,74,3,75,144,300,6,153.125,0.0001740773518880208 +si1000,hot,2,0.00031622776601683794,5,2,18,3,19,32,250,5,128.25,0.000308990478515625 +si1000,hot,2,0.0005623413251903491,5,2,34,3,35,64,250,5,118.125,0.0005512237548828125 +si1000,hot,2,0.001,5,2,62,3,63,120,250,4,107.1,0.0009775797526041668 +uniform,cold,0,1e-18,29,1,4,1,4,4,290,29,1800.0,3.4694469519536144e-19 +uniform,cold,0,1.778279410038923e-18,28,1,4,1,4,4,280,28,1682.0,1.3877787807814458e-18 +uniform,cold,0,3.1622776601683795e-18,28,1,4,1,4,4,280,28,1682.0,1.3877787807814458e-18 +uniform,cold,0,5.623413251903491e-18,27,1,4,1,4,4,270,27,1568.0,5.551115123125783e-18 +uniform,cold,0,1e-17,27,1,4,1,4,4,270,27,1568.0,5.551115123125783e-18 +uniform,cold,0,1.7782794100389228e-17,27,1,4,1,4,4,270,27,1568.0,5.551115123125783e-18 +uniform,cold,0,3.1622776601683796e-17,26,1,4,1,4,4,260,26,1458.0,2.2204460492503132e-17 +uniform,cold,0,5.62341325190349e-17,26,1,4,1,4,4,260,26,1458.0,2.2204460492503132e-17 +uniform,cold,0,1e-16,25,1,4,1,4,4,250,25,1352.0,8.881784197001253e-17 +uniform,cold,0,1.7782794100389228e-16,25,1,4,1,4,4,250,25,1352.0,8.881784197001253e-17 +uniform,cold,0,3.1622776601683793e-16,25,1,4,1,4,4,250,25,1352.0,8.881784197001253e-17 +uniform,cold,0,5.623413251903491e-16,24,1,4,1,4,4,240,24,1250.0,3.552713678800501e-16 +uniform,cold,0,1e-15,24,1,4,1,4,4,240,24,1250.0,3.552713678800501e-16 +uniform,cold,0,1.7782794100389227e-15,23,1,4,1,4,4,230,23,1152.0,1.4210854715202005e-15 +uniform,cold,0,3.1622776601683794e-15,23,1,4,1,4,4,230,23,1152.0,1.4210854715202005e-15 +uniform,cold,0,5.6234132519034904e-15,23,1,4,1,4,4,230,23,1152.0,1.4210854715202005e-15 +uniform,cold,0,1e-14,22,1,4,1,4,4,220,22,1058.0,5.684341886080802e-15 +uniform,cold,0,1.7782794100389227e-14,22,1,4,1,4,4,220,22,1058.0,5.684341886080802e-15 +uniform,cold,0,3.1622776601683796e-14,21,1,4,1,4,4,210,21,968.0,2.2737367544323207e-14 +uniform,cold,0,5.6234132519034906e-14,21,1,4,1,4,4,210,21,968.0,2.2737367544323207e-14 +uniform,cold,0,1e-13,20,1,4,1,4,4,200,20,882.0,9.094947017729283e-14 +uniform,cold,0,1.7782794100389227e-13,20,1,4,1,4,4,200,20,882.0,9.094947017729283e-14 +uniform,cold,0,3.162277660168379e-13,20,1,4,1,4,4,200,20,882.0,9.094947017729283e-14 +uniform,cold,0,5.62341325190349e-13,19,1,4,1,4,4,190,19,800.0,3.637978807091713e-13 +uniform,cold,0,1e-12,19,1,4,1,4,4,190,19,800.0,3.637978807091713e-13 +uniform,cold,0,1.7782794100389228e-12,18,1,4,1,4,4,180,18,722.0,1.4551915228366853e-12 +uniform,cold,0,3.1622776601683794e-12,18,1,4,1,4,4,180,18,722.0,1.4551915228366853e-12 +uniform,cold,0,5.6234132519034904e-12,18,1,4,1,4,4,180,18,722.0,1.4551915228366853e-12 +uniform,cold,0,1e-11,17,1,4,1,4,4,170,17,648.0,5.820766091346741e-12 +uniform,cold,0,1.7782794100389227e-11,17,1,4,1,4,4,170,17,648.0,5.820766091346741e-12 +uniform,cold,0,3.1622776601683794e-11,16,1,4,1,4,4,160,16,578.0,2.3283064365386964e-11 +uniform,cold,0,5.6234132519034906e-11,16,1,4,1,4,4,160,16,578.0,2.3283064365386964e-11 +uniform,cold,0,1e-10,15,1,4,1,4,4,150,15,512.0,9.313225746154786e-11 +uniform,cold,0,1.778279410038923e-10,15,1,4,1,4,4,150,15,512.0,9.313225746154786e-11 +uniform,cold,0,3.1622776601683795e-10,15,1,4,1,4,4,150,15,512.0,9.313225746154786e-11 +uniform,cold,0,5.623413251903491e-10,14,1,4,1,4,4,140,14,450.0,3.7252902984619143e-10 +uniform,cold,0,1e-09,14,1,4,1,4,4,140,14,450.0,3.7252902984619143e-10 +uniform,cold,0,1.7782794100389228e-09,13,1,4,1,4,4,130,13,392.0,1.4901161193847657e-09 +uniform,cold,0,3.1622776601683795e-09,13,1,4,1,4,4,130,13,392.0,1.4901161193847657e-09 +uniform,cold,0,5.623413251903491e-09,13,1,4,1,4,4,130,13,392.0,1.4901161193847657e-09 +uniform,cold,0,1e-08,12,1,4,1,4,4,120,12,338.0,5.960464477539063e-09 +uniform,cold,0,1.7782794100389228e-08,12,1,4,1,4,4,120,12,338.0,5.960464477539063e-09 +uniform,cold,0,3.162277660168379e-08,11,1,4,1,4,4,110,11,288.0,2.384185791015625e-08 +uniform,cold,0,5.6234132519034905e-08,11,1,4,1,4,4,110,11,288.0,2.384185791015625e-08 +uniform,cold,0,1e-07,10,1,4,1,4,4,100,10,242.0,9.5367431640625e-08 +uniform,cold,0,1.7782794100389227e-07,10,1,4,1,4,4,100,10,242.0,9.5367431640625e-08 +uniform,cold,0,3.162277660168379e-07,10,1,4,1,4,4,100,10,242.0,9.5367431640625e-08 +uniform,cold,0,5.62341325190349e-07,9,1,4,1,4,4,90,9,200.0,3.814697265625e-07 +uniform,cold,0,1e-06,9,1,4,1,4,4,90,9,200.0,3.814697265625e-07 +uniform,cold,0,1.778279410038923e-06,8,1,4,1,4,4,80,8,162.0,1.52587890625e-06 +uniform,cold,0,3.162277660168379e-06,8,1,4,1,4,4,80,8,162.0,1.52587890625e-06 +uniform,cold,0,5.623413251903491e-06,8,1,4,1,4,4,80,8,162.0,1.52587890625e-06 +uniform,cold,0,1e-05,7,1,4,1,4,4,70,7,128.0,6.103515625e-06 +uniform,cold,0,1.778279410038923e-05,7,1,4,1,4,4,70,7,128.0,6.103515625e-06 +uniform,cold,0,3.1622776601683795e-05,6,1,4,1,4,4,60,6,98.0,2.44140625e-05 +uniform,cold,0,5.623413251903491e-05,6,1,4,1,4,4,60,6,98.0,2.44140625e-05 +uniform,cold,0,0.0001,5,1,4,1,4,4,50,5,72.0,9.765625e-05 +uniform,cold,0,0.00017782794100389227,5,1,4,1,4,4,50,5,72.0,9.765625e-05 +uniform,cold,0,0.00031622776601683794,5,1,4,1,4,4,50,5,72.0,9.765625e-05 +uniform,cold,0,0.0005623413251903491,4,1,4,1,4,4,40,4,50.0,0.000390625 +uniform,cold,0,0.001,4,1,4,1,4,4,40,4,50.0,0.000390625 +uniform,cold,2,1e-18,20,11,24,12,24,242,1800,29,1049.6528925619834,2.356363636363636e-19 +uniform,cold,2,1.778279410038923e-18,19,8,26,9,26,192,1254,28,975.0,1.76605e-18 +uniform,cold,2,3.1622776601683795e-18,19,11,24,12,24,242,1710,28,952.0661157024794,2.2385454545454543e-18 +uniform,cold,2,5.623413251903491e-18,19,11,24,12,24,242,1710,27,952.0661157024794,2.2385454545454543e-18 +uniform,cold,2,1e-17,18,6,20,7,20,108,900,27,935.925925925926,1e-17 +uniform,cold,2,1.7782794100389228e-17,18,9,24,10,24,198,1332,27,875.1515151515151,1.743709090909091e-17 +uniform,cold,2,3.1622776601683796e-17,18,11,24,12,24,242,1620,26,859.2396694214876,2.1207272727272726e-17 +uniform,cold,2,5.62341325190349e-17,18,11,24,12,24,242,1620,26,859.2396694214876,2.1207272727272726e-17 +uniform,cold,2,1e-16,17,7,18,8,18,112,986,25,833.1428571428571,9.983250000000002e-17 +uniform,cold,2,1.7782794100389228e-16,17,9,26,10,26,216,1258,25,780.0,1.7716833333333334e-16 +uniform,cold,2,3.1622776601683793e-16,17,11,24,12,24,242,1530,25,771.1735537190083,2.0029090909090908e-16 +uniform,cold,2,5.623413251903491e-16,17,11,24,12,24,242,1530,24,771.1735537190083,2.0029090909090908e-16 +uniform,cold,2,1e-15,16,6,22,7,22,120,800,24,741.7666666666667,9.68e-16 +uniform,cold,2,1.7782794100389227e-15,16,11,22,12,22,220,1440,23,693.6,1.7424e-15 +uniform,cold,2,3.1622776601683794e-15,16,11,24,12,24,242,1440,23,687.8677685950413,1.885090909090909e-15 +uniform,cold,2,5.6234132519034904e-15,16,11,24,12,24,242,1440,23,687.8677685950413,1.885090909090909e-15 +uniform,cold,2,1e-14,15,7,20,8,20,126,870,22,650.1587301587301,9.666666666666667e-15 +uniform,cold,2,1.7782794100389227e-14,15,11,24,12,24,242,1350,22,609.3223140495868,1.767272727272727e-14 +uniform,cold,2,3.1622776601683796e-14,15,11,24,12,24,242,1350,21,609.3223140495868,1.767272727272727e-14 +uniform,cold,2,5.6234132519034906e-14,15,11,24,12,24,242,1350,21,609.3223140495868,1.767272727272727e-14 +uniform,cold,2,1e-13,14,7,22,8,22,140,812,20,565.7142857142857,9.825200000000003e-14 +uniform,cold,2,1.7782794100389227e-13,14,11,24,12,24,242,1260,20,535.5371900826447,1.6494545454545455e-13 +uniform,cold,2,3.162277660168379e-13,14,11,24,12,24,242,1260,20,535.5371900826447,1.6494545454545455e-13 +uniform,cold,2,5.62341325190349e-13,13,5,18,6,18,80,546,19,529.2,5.52825e-13 +uniform,cold,2,1e-12,13,7,24,8,24,154,754,19,488.72727272727275,9.870545454545453e-13 +uniform,cold,2,1.7782794100389228e-12,13,11,24,12,24,242,1170,18,466.5123966942149,1.5316363636363636e-12 +uniform,cold,2,3.1622776601683794e-12,13,11,24,12,24,242,1170,18,466.5123966942149,1.5316363636363636e-12 +uniform,cold,2,5.6234132519034904e-12,12,6,16,7,16,84,600,18,450.6666666666667,5.485714285714286e-12 +uniform,cold,2,1e-11,12,9,20,10,20,162,888,17,417.28395061728395,9.866666666666669e-12 +uniform,cold,2,1.7782794100389227e-11,12,11,24,12,24,242,1080,17,402.24793388429754,1.4138181818181817e-11 +uniform,cold,2,3.1622776601683794e-11,12,11,24,12,24,242,1080,16,402.24793388429754,1.4138181818181817e-11 +uniform,cold,2,5.6234132519034906e-11,11,6,18,7,18,96,550,16,378.0,5.56875e-11 +uniform,cold,2,1e-10,11,9,22,10,22,180,814,15,352.0,9.849400000000002e-11 +uniform,cold,2,1.778279410038923e-10,11,11,24,12,24,242,990,15,342.74380165289256,1.2959999999999997e-10 +uniform,cold,2,3.1622776601683795e-10,11,11,24,12,24,242,990,15,342.74380165289256,1.2959999999999997e-10 +uniform,cold,2,5.623413251903491e-10,10,6,20,7,20,108,500,14,313.7037037037037,5.555555555555556e-10 +uniform,cold,2,1e-09,10,10,22,11,22,200,820,14,292.82,9.922000000000002e-10 +uniform,cold,2,1.7782794100389228e-09,10,11,24,12,24,242,900,13,288.0,1.1781818181818181e-09 +uniform,cold,2,3.1622776601683795e-09,9,5,14,6,14,60,378,13,280.0,3.0869999999999998e-09 +uniform,cold,2,5.623413251903491e-09,9,6,22,7,22,120,450,13,256.6666666666667,5.445e-09 +uniform,cold,2,1e-08,9,11,22,12,22,220,810,12,240.0,9.801000000000001e-09 +uniform,cold,2,1.7782794100389228e-08,9,11,24,12,24,242,810,12,238.01652892561984,1.0603636363636363e-08 +uniform,cold,2,3.162277660168379e-08,8,5,16,6,16,70,336,11,222.17142857142858,3.072e-08 +uniform,cold,2,5.6234132519034905e-08,8,7,22,8,22,140,464,11,203.65714285714284,5.614400000000001e-08 +uniform,cold,2,1e-07,8,11,24,12,24,242,720,10,192.79338842975207,9.425454545454546e-08 +uniform,cold,2,1.7782794100389227e-07,7,4,12,5,12,40,238,10,192.0,1.7135999999999997e-07 +uniform,cold,2,3.162277660168379e-07,7,5,18,6,18,80,294,10,172.8,2.9767499999999997e-07 +uniform,cold,2,5.62341325190349e-07,7,8,22,9,22,160,462,9,158.4,5.5902e-07 +uniform,cold,2,1e-06,7,11,24,12,24,242,630,9,152.3305785123967,8.247272727272726e-07 +uniform,cold,2,1.778279410038923e-06,6,4,14,5,14,48,204,8,142.91666666666666,1.6659999999999998e-06 +uniform,cold,2,3.162277660168379e-06,6,6,18,7,18,96,300,8,128.625,3.0374999999999993e-06 +uniform,cold,2,5.623413251903491e-06,6,8,26,9,26,192,396,8,119.4375,5.576999999999999e-06 +uniform,cold,2,1e-05,5,3,12,4,12,30,130,7,115.2,9.36e-06 +uniform,cold,2,1.778279410038923e-05,5,5,14,6,14,60,210,7,100.8,1.7150000000000004e-05 +uniform,cold,2,3.1622776601683795e-05,5,6,22,7,22,120,250,6,92.4,3.0250000000000003e-05 +uniform,cold,2,5.623413251903491e-05,5,9,28,10,28,234,370,6,86.15384615384616,5.578461538461538e-05 +uniform,cold,2,0.0001,4,4,12,5,12,40,136,5,75.0,9.792e-05 +uniform,cold,2,0.00017782794100389227,4,5,18,6,18,80,168,5,67.5,0.00017010000000000001 +uniform,cold,2,0.00031622776601683794,4,7,24,8,24,154,232,5,62.33766233766234,0.00030370909090909095 +uniform,cold,2,0.0005623413251903491,3,3,12,4,12,30,78,4,51.2,0.0005616 +uniform,cold,2,0.001,3,4,16,5,16,56,102,4,45.714285714285715,0.0009325714285714285 +uniform,cold,64,1e-18,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19 +uniform,cold,64,1.778279410038923e-18,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19 +uniform,cold,64,3.1622776601683795e-18,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19 +uniform,cold,64,5.623413251903491e-18,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19 +uniform,cold,64,1e-17,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19 +uniform,cold,64,1.7782794100389228e-17,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19 +uniform,cold,64,3.1622776601683796e-17,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19 +uniform,cold,64,5.62341325190349e-17,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19 +uniform,cold,64,1e-16,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,1.7782794100389228e-16,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,3.1622776601683793e-16,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,5.623413251903491e-16,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,1e-15,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,1.7782794100389227e-15,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,3.1622776601683794e-15,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,5.6234132519034904e-15,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,1e-14,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17 +uniform,cold,64,1.7782794100389227e-14,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14 +uniform,cold,64,3.1622776601683796e-14,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14 +uniform,cold,64,5.6234132519034906e-14,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14 +uniform,cold,64,1e-13,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14 +uniform,cold,64,1.7782794100389227e-13,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14 +uniform,cold,64,3.162277660168379e-13,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14 +uniform,cold,64,5.62341325190349e-13,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14 +uniform,cold,64,1e-12,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14 +uniform,cold,64,1.7782794100389228e-12,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,3.1622776601683794e-12,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,5.6234132519034904e-12,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,1e-11,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,1.7782794100389227e-11,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,3.1622776601683794e-11,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,5.6234132519034906e-11,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,1e-10,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,1.778279410038923e-10,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12 +uniform,cold,64,3.1622776601683795e-10,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10 +uniform,cold,64,5.623413251903491e-10,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10 +uniform,cold,64,1e-09,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10 +uniform,cold,64,1.7782794100389228e-09,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10 +uniform,cold,64,3.1622776601683795e-09,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10 +uniform,cold,64,5.623413251903491e-09,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10 +uniform,cold,64,1e-08,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10 +uniform,cold,64,1.7782794100389228e-08,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10 +uniform,cold,64,3.162277660168379e-08,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,5.6234132519034905e-08,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,1e-07,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,1.7782794100389227e-07,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,3.162277660168379e-07,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,5.62341325190349e-07,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,1e-06,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,1.778279410038923e-06,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,3.162277660168379e-06,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08 +uniform,cold,64,5.623413251903491e-06,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06 +uniform,cold,64,1e-05,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06 +uniform,cold,64,1.778279410038923e-05,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06 +uniform,cold,64,3.1622776601683795e-05,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06 +uniform,cold,64,5.623413251903491e-05,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06 +uniform,cold,64,0.0001,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06 +uniform,cold,64,0.00017782794100389227,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06 +uniform,cold,64,0.00031622776601683794,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06 +uniform,cold,64,0.0005623413251903491,5,1,256,17,17,194,2020,None,107.25773195876289,0.0004350631851546392 +uniform,cold,64,0.001,5,1,256,17,17,194,2020,None,107.25773195876289,0.0004350631851546392 +uniform,hot,0,1e-18,29,2,125,3,126,250,1450,29,2721.6,3.4694469519536144e-19 +uniform,hot,0,1.778279410038923e-18,28,2,125,3,126,250,1400,28,2543.184,1.3877787807814458e-18 +uniform,hot,0,3.1622776601683795e-18,28,2,125,3,126,250,1400,28,2543.184,1.3877787807814458e-18 +uniform,hot,0,5.623413251903491e-18,27,2,125,3,126,250,1350,27,2370.816,5.551115123125783e-18 +uniform,hot,0,1e-17,27,2,125,3,126,250,1350,27,2370.816,5.551115123125783e-18 +uniform,hot,0,1.7782794100389228e-17,27,2,125,3,126,250,1350,27,2370.816,5.551115123125783e-18 +uniform,hot,0,3.1622776601683796e-17,26,2,125,3,126,250,1300,26,2204.496,2.2204460492503132e-17 +uniform,hot,0,5.62341325190349e-17,26,2,125,3,126,250,1300,26,2204.496,2.2204460492503132e-17 +uniform,hot,0,1e-16,25,2,125,3,126,250,1250,25,2044.224,8.881784197001253e-17 +uniform,hot,0,1.7782794100389228e-16,25,2,125,3,126,250,1250,25,2044.224,8.881784197001253e-17 +uniform,hot,0,3.1622776601683793e-16,25,2,125,3,126,250,1250,25,2044.224,8.881784197001253e-17 +uniform,hot,0,5.623413251903491e-16,24,2,125,3,126,250,1200,24,1890.0,3.552713678800501e-16 +uniform,hot,0,1e-15,24,2,125,3,126,250,1200,24,1890.0,3.552713678800501e-16 +uniform,hot,0,1.7782794100389227e-15,23,2,125,3,126,250,1150,23,1741.824,1.4210854715202005e-15 +uniform,hot,0,3.1622776601683794e-15,23,2,125,3,126,250,1150,23,1741.824,1.4210854715202005e-15 +uniform,hot,0,5.6234132519034904e-15,23,2,125,3,126,250,1150,23,1741.824,1.4210854715202005e-15 +uniform,hot,0,1e-14,22,2,125,3,126,250,1100,22,1599.696,5.684341886080802e-15 +uniform,hot,0,1.7782794100389227e-14,22,2,125,3,126,250,1100,22,1599.696,5.684341886080802e-15 +uniform,hot,0,3.1622776601683796e-14,21,2,125,3,126,250,1050,21,1463.616,2.2737367544323207e-14 +uniform,hot,0,5.6234132519034906e-14,21,2,125,3,126,250,1050,21,1463.616,2.2737367544323207e-14 +uniform,hot,0,1e-13,20,2,125,3,126,250,1000,20,1333.584,9.094947017729283e-14 +uniform,hot,0,1.7782794100389227e-13,20,2,125,3,126,250,1000,20,1333.584,9.094947017729283e-14 +uniform,hot,0,3.162277660168379e-13,20,2,125,3,126,250,1000,20,1333.584,9.094947017729283e-14 +uniform,hot,0,5.62341325190349e-13,19,2,125,3,126,250,950,19,1209.6,3.637978807091713e-13 +uniform,hot,0,1e-12,19,2,125,3,126,250,950,19,1209.6,3.637978807091713e-13 +uniform,hot,0,1.7782794100389228e-12,18,2,125,3,126,250,900,18,1091.664,1.4551915228366853e-12 +uniform,hot,0,3.1622776601683794e-12,18,2,125,3,126,250,900,18,1091.664,1.4551915228366853e-12 +uniform,hot,0,5.6234132519034904e-12,18,2,125,3,126,250,900,18,1091.664,1.4551915228366853e-12 +uniform,hot,0,1e-11,17,2,125,3,126,250,850,17,979.776,5.820766091346741e-12 +uniform,hot,0,1.7782794100389227e-11,17,2,125,3,126,250,850,17,979.776,5.820766091346741e-12 +uniform,hot,0,3.1622776601683794e-11,16,2,125,3,126,250,800,16,873.936,2.3283064365386964e-11 +uniform,hot,0,5.6234132519034906e-11,16,2,125,3,126,250,800,16,873.936,2.3283064365386964e-11 +uniform,hot,0,1e-10,15,2,125,3,126,250,750,15,774.144,9.313225746154786e-11 +uniform,hot,0,1.778279410038923e-10,15,2,125,3,126,250,750,15,774.144,9.313225746154786e-11 +uniform,hot,0,3.1622776601683795e-10,15,2,125,3,126,250,750,15,774.144,9.313225746154786e-11 +uniform,hot,0,5.623413251903491e-10,14,2,125,3,126,250,700,14,680.4,3.7252902984619143e-10 +uniform,hot,0,1e-09,14,2,125,3,126,250,700,14,680.4,3.7252902984619143e-10 +uniform,hot,0,1.7782794100389228e-09,13,2,125,3,126,250,650,13,592.704,1.4901161193847657e-09 +uniform,hot,0,3.1622776601683795e-09,13,2,125,3,126,250,650,13,592.704,1.4901161193847657e-09 +uniform,hot,0,5.623413251903491e-09,13,2,125,3,126,250,650,13,592.704,1.4901161193847657e-09 +uniform,hot,0,1e-08,12,2,125,3,126,250,600,12,511.056,5.960464477539063e-09 +uniform,hot,0,1.7782794100389228e-08,12,2,125,3,126,250,600,12,511.056,5.960464477539063e-09 +uniform,hot,0,3.162277660168379e-08,11,2,125,3,126,250,550,11,435.456,2.384185791015625e-08 +uniform,hot,0,5.6234132519034905e-08,11,2,125,3,126,250,550,11,435.456,2.384185791015625e-08 +uniform,hot,0,1e-07,10,2,125,3,126,250,500,10,365.904,9.5367431640625e-08 +uniform,hot,0,1.7782794100389227e-07,10,2,125,3,126,250,500,10,365.904,9.5367431640625e-08 +uniform,hot,0,3.162277660168379e-07,10,2,125,3,126,250,500,10,365.904,9.5367431640625e-08 +uniform,hot,0,5.62341325190349e-07,9,2,125,3,126,250,450,9,302.4,3.814697265625e-07 +uniform,hot,0,1e-06,9,2,125,3,126,250,450,9,302.4,3.814697265625e-07 +uniform,hot,0,1.778279410038923e-06,8,2,125,3,126,250,400,8,244.944,1.52587890625e-06 +uniform,hot,0,3.162277660168379e-06,8,2,125,3,126,250,400,8,244.944,1.52587890625e-06 +uniform,hot,0,5.623413251903491e-06,8,2,125,3,126,250,400,8,244.944,1.52587890625e-06 +uniform,hot,0,1e-05,7,2,125,3,126,250,350,7,193.536,6.103515625e-06 +uniform,hot,0,1.778279410038923e-05,7,2,125,3,126,250,350,7,193.536,6.103515625e-06 +uniform,hot,0,3.1622776601683795e-05,6,2,125,3,126,250,300,6,148.176,2.44140625e-05 +uniform,hot,0,5.623413251903491e-05,6,2,125,3,126,250,300,6,148.176,2.44140625e-05 +uniform,hot,0,0.0001,5,2,125,3,126,250,250,5,108.864,9.765625e-05 +uniform,hot,0,0.00017782794100389227,5,2,125,3,126,250,250,5,108.864,9.765625e-05 +uniform,hot,0,0.00031622776601683794,5,2,125,3,126,250,250,5,108.864,9.765625e-05 +uniform,hot,0,0.0005623413251903491,4,2,125,3,126,250,200,4,75.6,0.000390625 +uniform,hot,0,0.001,4,2,125,3,126,250,200,4,75.6,0.000390625 +uniform,hot,2,1e-18,20,2,126,3,127,248,1000,29,1548.5806451612902,6.401612903225806e-19 +uniform,hot,2,1.778279410038923e-18,19,2,34,3,35,64,950,28,1509.375,1.7159374999999998e-18 +uniform,hot,2,3.1622776601683795e-18,19,2,64,3,65,124,950,28,1446.774193548387,3.138064516129032e-18 +uniform,hot,2,5.623413251903491e-18,19,2,116,3,117,228,950,27,1395.7894736842106,5.606666666666666e-18 +uniform,hot,2,1e-17,19,2,126,3,127,248,950,27,1392.9032258064517,6.0815322580645154e-18 +uniform,hot,2,1.7782794100389228e-17,18,2,36,3,37,68,900,27,1364.6470588235295,1.715294117647059e-17 +uniform,hot,2,3.1622776601683796e-17,18,2,68,3,69,132,900,26,1291.1363636363637,3.152727272727273e-17 +uniform,hot,2,5.62341325190349e-17,18,2,122,3,123,240,900,26,1265.875,5.5815e-17 +uniform,hot,2,1e-16,18,2,126,3,127,248,900,25,1245.4193548387098,5.761451612903226e-17 +uniform,hot,2,1.7782794100389228e-16,17,2,38,3,39,72,850,25,1209.0,1.7047222222222224e-16 +uniform,hot,2,3.1622776601683793e-16,17,2,72,3,73,140,850,25,1163.8285714285714,3.1474285714285717e-16 +uniform,hot,2,5.623413251903491e-16,17,2,126,3,127,248,850,24,1124.5645161290322,5.441370967741936e-16 +uniform,hot,2,1e-15,17,2,126,3,127,248,850,24,1124.5645161290322,5.441370967741936e-16 +uniform,hot,2,1.7782794100389227e-15,16,2,42,3,43,80,800,23,1059.95,1.7639999999999999e-15 +uniform,hot,2,3.1622776601683794e-15,16,2,76,3,77,148,800,23,1025.972972972973,3.122162162162162e-15 +uniform,hot,2,5.6234132519034904e-15,16,2,126,3,127,248,800,23,1009.8548387096774,5.121290322580645e-15 +uniform,hot,2,1e-14,16,2,126,3,127,248,800,22,992.4435483870968,5.121290322580645e-15 +uniform,hot,2,1.7782794100389227e-14,15,2,44,3,45,84,750,22,942.8571428571429,1.728571428571429e-14 +uniform,hot,2,3.1622776601683796e-14,15,2,82,3,83,160,750,21,896.4,3.151875e-14 +uniform,hot,2,5.6234132519034906e-14,15,2,126,3,127,248,750,21,884.9032258064516,4.801209677419355e-14 +uniform,hot,2,1e-13,14,2,26,3,27,48,700,20,860.625,9.858333333333333e-14 +uniform,hot,2,1.7782794100389227e-13,14,2,48,3,49,92,700,20,814.8913043478261,1.7530434782608694e-13 +uniform,hot,2,3.162277660168379e-13,14,2,88,3,89,172,700,20,791.6860465116279,3.1516279069767445e-13 +uniform,hot,2,5.62341325190349e-13,14,2,126,3,127,248,700,19,768.1451612903226,4.4811290322580643e-13 +uniform,hot,2,1e-12,13,2,28,3,29,52,650,19,749.5384615384615,9.799999999999999e-13 +uniform,hot,2,1.7782794100389228e-12,13,2,52,3,53,100,650,18,697.48,1.7576000000000001e-12 +uniform,hot,2,3.1622776601683794e-12,13,2,94,3,95,184,650,18,679.4565217391304,3.1214130434782615e-12 +uniform,hot,2,5.6234132519034904e-12,13,2,126,3,127,248,650,18,673.9193548387096,4.161048387096774e-12 +uniform,hot,2,1e-11,12,2,30,3,31,56,600,17,633.2857142857143,9.642857142857143e-12 +uniform,hot,2,1.7782794100389227e-11,12,2,56,3,57,108,600,17,603.7777777777778,1.7422222222222223e-11 +uniform,hot,2,3.1622776601683794e-11,12,2,102,3,103,200,600,16,575.77,3.1212000000000006e-11 +uniform,hot,2,5.6234132519034906e-11,12,2,126,3,127,248,600,16,572.5241935483871,3.840967741935484e-11 +uniform,hot,2,1e-10,11,2,34,3,35,64,550,15,525.0,9.934375000000001e-11 +uniform,hot,2,1.778279410038923e-10,11,2,62,3,63,120,550,15,504.0,1.7618333333333335e-10 +uniform,hot,2,3.1622776601683795e-10,11,2,112,3,113,220,550,15,493.09090909090907,3.136e-10 +uniform,hot,2,5.623413251903491e-10,10,2,20,3,21,36,500,14,474.8333333333333,5.555555555555556e-10 +uniform,hot,2,1e-09,10,2,36,3,37,68,500,14,442.9117647058824,9.529411764705881e-10 +uniform,hot,2,1.7782794100389228e-09,10,2,68,3,69,132,500,13,414.0,1.7515151515151516e-09 +uniform,hot,2,3.1622776601683795e-09,10,2,124,3,125,244,500,13,405.73770491803276,3.1508196721311478e-09 +uniform,hot,2,5.623413251903491e-09,9,2,22,3,23,40,450,13,391.0,5.445e-09 +uniform,hot,2,1e-08,9,2,42,3,43,80,450,12,354.75,9.9225e-09 +uniform,hot,2,1.7782794100389228e-08,9,2,76,3,77,148,450,12,343.3783783783784,1.7562162162162162e-08 +uniform,hot,2,3.162277660168379e-08,9,2,126,3,127,248,450,11,327.741935483871,2.8807258064516128e-08 +uniform,hot,2,5.6234132519034905e-08,8,2,24,3,25,44,400,11,306.8181818181818,5.236363636363637e-08 +uniform,hot,2,1e-07,8,2,46,3,47,88,400,10,278.79545454545456,9.618181818181819e-08 +uniform,hot,2,1.7782794100389227e-07,8,2,86,3,87,168,400,10,270.32142857142856,1.760952380952381e-07 +uniform,hot,2,3.162277660168379e-07,8,2,126,3,127,248,400,10,267.31451612903226,2.560645161290323e-07 +uniform,hot,2,5.62341325190349e-07,7,2,28,3,29,52,350,9,232.0,5.276923076923076e-07 +uniform,hot,2,1e-06,7,2,54,3,55,104,350,9,220.0,9.813461538461538e-07 +uniform,hot,2,1.778279410038923e-06,7,2,98,3,99,192,350,8,206.25,1.7507291666666663e-06 +uniform,hot,2,3.162277660168379e-06,6,2,18,3,19,32,300,8,191.1875,3.0374999999999993e-06 +uniform,hot,2,5.623413251903491e-06,6,2,34,3,35,64,300,8,176.09375,5.418749999999999e-06 +uniform,hot,2,1e-05,6,2,64,3,65,124,300,7,161.4516129032258,9.909677419354836e-06 +uniform,hot,2,1.778279410038923e-05,6,2,116,3,117,228,300,7,158.05263157894737,1.7705263157894734e-05 +uniform,hot,2,3.1622776601683795e-05,5,2,22,3,23,40,250,6,131.1,3.0250000000000003e-05 +uniform,hot,2,5.623413251903491e-05,5,2,42,3,43,80,250,6,122.55,5.5125000000000005e-05 +uniform,hot,2,0.0001,5,2,76,3,77,148,250,5,112.37837837837837,9.756756756756757e-05 +uniform,hot,2,0.00017782794100389227,4,2,14,3,15,24,200,5,100.0,0.00016333333333333336 +uniform,hot,2,0.00031622776601683794,4,2,28,3,29,52,200,5,89.23076923076923,0.00030153846153846154 +uniform,hot,2,0.0005623413251903491,4,2,54,3,55,104,200,4,79.32692307692308,0.0005607692307692308 +uniform,hot,2,0.001,3,2,10,3,11,16,150,4,71.5,0.0009374999999999999 +uniform_refit,cold,0,1e-18,31,1,4,1,4,4,310,31,2048.0,3.4027546317804404e-19 +uniform_refit,cold,0,1.778279410038923e-18,30,1,4,1,4,4,300,30,1922.0,1.1909641211231541e-18 +uniform_refit,cold,0,3.1622776601683795e-18,30,1,4,1,4,4,300,30,1922.0,1.1909641211231541e-18 +uniform_refit,cold,0,5.623413251903491e-18,29,1,4,1,4,4,290,29,1800.0,4.168374423931039e-18 +uniform_refit,cold,0,1e-17,29,1,4,1,4,4,290,29,1800.0,4.168374423931039e-18 +uniform_refit,cold,0,1.7782794100389228e-17,28,1,4,1,4,4,280,28,1682.0,1.4589310483758634e-17 +uniform_refit,cold,0,3.1622776601683796e-17,28,1,4,1,4,4,280,28,1682.0,1.4589310483758634e-17 +uniform_refit,cold,0,5.62341325190349e-17,27,1,4,1,4,4,270,27,1568.0,5.106258669315523e-17 +uniform_refit,cold,0,1e-16,27,1,4,1,4,4,270,27,1568.0,5.106258669315523e-17 +uniform_refit,cold,0,1.7782794100389228e-16,27,1,4,1,4,4,270,27,1568.0,5.106258669315523e-17 +uniform_refit,cold,0,3.1622776601683793e-16,26,1,4,1,4,4,260,26,1458.0,1.7871905342604332e-16 +uniform_refit,cold,0,5.623413251903491e-16,26,1,4,1,4,4,260,26,1458.0,1.7871905342604332e-16 +uniform_refit,cold,0,1e-15,25,1,4,1,4,4,250,25,1352.0,6.255166869911515e-16 +uniform_refit,cold,0,1.7782794100389227e-15,25,1,4,1,4,4,250,25,1352.0,6.255166869911515e-16 +uniform_refit,cold,0,3.1622776601683794e-15,24,1,4,1,4,4,240,24,1250.0,2.1893084044690303e-15 +uniform_refit,cold,0,5.6234132519034904e-15,24,1,4,1,4,4,240,24,1250.0,2.1893084044690303e-15 +uniform_refit,cold,0,1e-14,23,1,4,1,4,4,230,23,1152.0,7.662579415641607e-15 +uniform_refit,cold,0,1.7782794100389227e-14,23,1,4,1,4,4,230,23,1152.0,7.662579415641607e-15 +uniform_refit,cold,0,3.1622776601683796e-14,22,1,4,1,4,4,220,22,1058.0,2.6819027954745623e-14 +uniform_refit,cold,0,5.6234132519034906e-14,22,1,4,1,4,4,220,22,1058.0,2.6819027954745623e-14 +uniform_refit,cold,0,1e-13,21,1,4,1,4,4,210,21,968.0,9.386659784160968e-14 +uniform_refit,cold,0,1.7782794100389227e-13,21,1,4,1,4,4,210,21,968.0,9.386659784160968e-14 +uniform_refit,cold,0,3.162277660168379e-13,21,1,4,1,4,4,210,21,968.0,9.386659784160968e-14 +uniform_refit,cold,0,5.62341325190349e-13,20,1,4,1,4,4,200,20,882.0,3.2853309244563385e-13 +uniform_refit,cold,0,1e-12,20,1,4,1,4,4,200,20,882.0,3.2853309244563385e-13 +uniform_refit,cold,0,1.7782794100389228e-12,19,1,4,1,4,4,190,19,800.0,1.1498658235597187e-12 +uniform_refit,cold,0,3.1622776601683794e-12,19,1,4,1,4,4,190,19,800.0,1.1498658235597187e-12 +uniform_refit,cold,0,5.6234132519034904e-12,18,1,4,1,4,4,180,18,722.0,4.0245303824590146e-12 +uniform_refit,cold,0,1e-11,18,1,4,1,4,4,180,18,722.0,4.0245303824590146e-12 +uniform_refit,cold,0,1.7782794100389227e-11,17,1,4,1,4,4,170,17,648.0,1.4085856338606554e-11 +uniform_refit,cold,0,3.1622776601683794e-11,17,1,4,1,4,4,170,17,648.0,1.4085856338606554e-11 +uniform_refit,cold,0,5.6234132519034906e-11,16,1,4,1,4,4,160,16,578.0,4.9300497185122934e-11 +uniform_refit,cold,0,1e-10,16,1,4,1,4,4,160,16,578.0,4.9300497185122934e-11 +uniform_refit,cold,0,1.778279410038923e-10,15,1,4,1,4,4,150,15,512.0,1.7255174014793028e-10 +uniform_refit,cold,0,3.1622776601683795e-10,15,1,4,1,4,4,150,15,512.0,1.7255174014793028e-10 +uniform_refit,cold,0,5.623413251903491e-10,15,1,4,1,4,4,150,15,512.0,1.7255174014793028e-10 +uniform_refit,cold,0,1e-09,14,1,4,1,4,4,140,14,450.0,6.039310905177559e-10 +uniform_refit,cold,0,1.7782794100389228e-09,14,1,4,1,4,4,140,14,450.0,6.039310905177559e-10 +uniform_refit,cold,0,3.1622776601683795e-09,13,1,4,1,4,4,130,13,392.0,2.1137588168121457e-09 +uniform_refit,cold,0,5.623413251903491e-09,13,1,4,1,4,4,130,13,392.0,2.1137588168121457e-09 +uniform_refit,cold,0,1e-08,12,1,4,1,4,4,120,12,338.0,7.39815585884251e-09 +uniform_refit,cold,0,1.7782794100389228e-08,12,1,4,1,4,4,120,12,338.0,7.39815585884251e-09 +uniform_refit,cold,0,3.162277660168379e-08,11,1,4,1,4,4,110,11,288.0,2.5893545505948784e-08 +uniform_refit,cold,0,5.6234132519034905e-08,11,1,4,1,4,4,110,11,288.0,2.5893545505948784e-08 +uniform_refit,cold,0,1e-07,10,1,4,1,4,4,100,10,242.0,9.062740927082074e-08 +uniform_refit,cold,0,1.7782794100389227e-07,10,1,4,1,4,4,100,10,242.0,9.062740927082074e-08 +uniform_refit,cold,0,3.162277660168379e-07,10,1,4,1,4,4,100,10,242.0,9.062740927082074e-08 +uniform_refit,cold,0,5.62341325190349e-07,9,1,4,1,4,4,90,9,200.0,3.171959324478726e-07 +uniform_refit,cold,0,1e-06,9,1,4,1,4,4,90,9,200.0,3.171959324478726e-07 +uniform_refit,cold,0,1.778279410038923e-06,8,1,4,1,4,4,80,8,162.0,1.1101857635675541e-06 +uniform_refit,cold,0,3.162277660168379e-06,8,1,4,1,4,4,80,8,162.0,1.1101857635675541e-06 +uniform_refit,cold,0,5.623413251903491e-06,7,1,4,1,4,4,70,7,128.0,3.885650172486439e-06 +uniform_refit,cold,0,1e-05,7,1,4,1,4,4,70,7,128.0,3.885650172486439e-06 +uniform_refit,cold,0,1.778279410038923e-05,6,1,4,1,4,4,60,6,98.0,1.359977560370254e-05 +uniform_refit,cold,0,3.1622776601683795e-05,6,1,4,1,4,4,60,6,98.0,1.359977560370254e-05 +uniform_refit,cold,0,5.623413251903491e-05,5,1,4,1,4,4,50,5,72.0,4.7599214612958884e-05 +uniform_refit,cold,0,0.0001,5,1,4,1,4,4,50,5,72.0,4.7599214612958884e-05 +uniform_refit,cold,0,0.00017782794100389227,4,1,4,1,4,4,40,4,50.0,0.0001665972511453561 +uniform_refit,cold,0,0.00031622776601683794,4,1,4,1,4,4,40,4,50.0,0.0001665972511453561 +uniform_refit,cold,0,0.0005623413251903491,4,1,4,1,4,4,40,4,50.0,0.0001665972511453561 +uniform_refit,cold,0,0.001,3,1,4,1,4,4,30,3,32.0,0.0005830903790087463 +uniform_refit,cold,2,1e-18,18,11,24,12,24,242,1620,31,859.2396694214876,2.8699356175858737e-19 +uniform_refit,cold,2,1.778279410038923e-18,17,6,18,7,18,96,850,30,850.5,1.746998569298693e-18 +uniform_refit,cold,2,3.1622776601683795e-18,17,10,20,11,20,180,1394,30,792.0,3.1441181384360568e-18 +uniform_refit,cold,2,5.623413251903491e-18,17,11,24,12,24,242,1530,29,771.1735537190083,4.065742124913322e-18 +uniform_refit,cold,2,1e-17,17,11,24,12,24,242,1530,29,771.1735537190083,4.065742124913322e-18 +uniform_refit,cold,2,1.7782794100389228e-17,17,11,24,12,24,242,1530,28,771.1735537190083,4.065742124913322e-18 +uniform_refit,cold,2,3.1622776601683796e-17,16,7,20,8,20,126,928,28,733.968253968254,3.1396072085387306e-17 +uniform_refit,cold,2,5.62341325190349e-17,16,9,28,10,28,234,1184,27,691.6239316239316,5.435434569944451e-17 +uniform_refit,cold,2,1e-16,16,11,24,12,24,242,1440,27,687.8677685950413,5.739871235171747e-17 +uniform_refit,cold,2,1.7782794100389228e-16,16,11,24,12,24,242,1440,27,687.8677685950413,5.739871235171747e-17 +uniform_refit,cold,2,3.1622776601683793e-16,15,6,16,7,16,84,750,26,682.6666666666666,3.131874185857601e-16 +uniform_refit,cold,2,5.623413251903491e-16,15,8,22,9,22,160,990,26,633.6,5.471188460556614e-16 +uniform_refit,cold,2,1e-15,15,11,24,12,24,242,1350,25,609.3223140495868,8.07169392446027e-16 +uniform_refit,cold,2,1.7782794100389227e-15,15,11,24,12,24,242,1350,25,609.3223140495868,8.07169392446027e-16 +uniform_refit,cold,2,3.1622776601683794e-15,15,11,24,12,24,242,1350,24,609.3223140495868,8.07169392446027e-16 +uniform_refit,cold,2,5.6234132519034904e-15,14,6,20,7,20,108,700,24,583.3333333333334,5.328535941216057e-15 +uniform_refit,cold,2,1e-14,14,9,26,10,26,216,1036,23,541.6666666666666,9.9958005721272e-15 +uniform_refit,cold,2,1.7782794100389227e-14,14,11,24,12,24,242,1260,23,535.5371900826447,1.130037149424438e-14 +uniform_refit,cold,2,3.1622776601683796e-14,14,11,24,12,24,242,1260,22,535.5371900826447,1.130037149424438e-14 +uniform_refit,cold,2,5.6234132519034906e-14,13,6,14,7,14,72,650,22,533.5555555555555,5.4550886698199384e-14 +uniform_refit,cold,2,1e-13,13,8,20,9,20,144,858,21,490.0,9.796893937635806e-14 +uniform_refit,cold,2,1.7782794100389227e-13,13,11,24,12,24,242,1170,21,466.5123966942149,1.5739803152697526e-13 +uniform_refit,cold,2,3.162277660168379e-13,13,11,24,12,24,242,1170,21,466.5123966942149,1.5739803152697526e-13 +uniform_refit,cold,2,5.62341325190349e-13,13,11,24,12,24,242,1170,20,466.5123966942149,1.5739803152697526e-13 +uniform_refit,cold,2,1e-12,12,7,16,8,16,98,696,20,441.46938775510205,9.809029950106005e-13 +uniform_refit,cold,2,1.7782794100389228e-12,12,8,26,9,26,192,792,19,411.9375,1.7193548860550842e-12 +uniform_refit,cold,2,3.1622776601683794e-12,12,11,24,12,24,242,1080,19,402.24793388429754,2.179357359604273e-12 +uniform_refit,cold,2,5.6234132519034904e-12,12,11,24,12,24,242,1080,18,402.24793388429754,2.179357359604273e-12 +uniform_refit,cold,2,1e-11,11,5,16,6,16,70,462,18,394.9714285714286,9.766749648596927e-12 +uniform_refit,cold,2,1.7782794100389227e-11,11,8,18,9,18,128,726,17,364.5,1.6996433470507543e-11 +uniform_refit,cold,2,3.1622776601683794e-11,11,11,24,12,24,242,990,17,342.74380165289256,2.9966163694558754e-11 +uniform_refit,cold,2,5.6234132519034906e-11,11,11,24,12,24,242,990,16,342.74380165289256,2.9966163694558754e-11 +uniform_refit,cold,2,1e-10,11,11,24,12,24,242,990,16,342.74380165289256,2.9966163694558754e-11 +uniform_refit,cold,2,1.778279410038923e-10,10,6,18,7,18,96,500,15,317.625,1.755829903978052e-10 +uniform_refit,cold,2,3.1622776601683795e-10,10,10,20,11,20,180,820,15,295.77777777777777,3.1600121179961653e-10 +uniform_refit,cold,2,5.623413251903491e-10,10,11,24,12,24,242,900,15,288.0,4.086295049258012e-10 +uniform_refit,cold,2,1e-09,10,11,24,12,24,242,900,14,288.0,4.086295049258012e-10 +uniform_refit,cold,2,1.7782794100389228e-09,9,4,20,5,20,72,306,14,277.77777777777777,1.7688360514149268e-09 +uniform_refit,cold,2,3.1622776601683795e-09,9,8,18,9,18,128,594,13,253.125,3.1288888888888894e-09 +uniform_refit,cold,2,5.623413251903491e-09,9,11,24,12,24,242,810,13,238.01652892561984,5.516498316498316e-09 +uniform_refit,cold,2,1e-08,9,11,24,12,24,242,810,12,238.01652892561984,5.516498316498316e-09 +uniform_refit,cold,2,1.7782794100389228e-08,8,4,14,5,14,48,272,12,236.25,1.7334593303866282e-08 +uniform_refit,cold,2,3.162277660168379e-08,8,6,18,7,18,96,400,11,212.625,3.160493827160494e-08 +uniform_refit,cold,2,5.6234132519034905e-08,8,9,22,10,22,180,592,11,198.0,5.589938119189148e-08 +uniform_refit,cold,2,1e-07,8,11,24,12,24,242,720,10,192.79338842975207,7.35533108866442e-08 +uniform_refit,cold,2,1.7782794100389227e-07,8,11,24,12,24,242,720,10,192.79338842975207,7.35533108866442e-08 +uniform_refit,cold,2,3.162277660168379e-07,7,5,16,6,16,70,294,10,175.54285714285714,3.1464471879286686e-07 +uniform_refit,cold,2,5.62341325190349e-07,7,8,18,9,18,128,462,9,162.0,5.475555555555554e-07 +uniform_refit,cold,2,1e-06,7,11,24,12,24,242,630,9,152.3305785123967,9.653872053872052e-07 +uniform_refit,cold,2,1.778279410038923e-06,7,11,24,12,24,242,630,8,152.3305785123967,9.653872053872052e-07 +uniform_refit,cold,2,3.162277660168379e-06,6,4,14,5,14,48,204,8,142.91666666666666,2.9252126200274354e-06 +uniform_refit,cold,2,5.623413251903491e-06,6,7,16,8,16,98,348,7,128.0,5.586549088771311e-06 +uniform_refit,cold,2,1e-05,6,8,26,9,26,192,396,7,119.4375,9.792263374485597e-06 +uniform_refit,cold,2,1.778279410038923e-05,6,11,24,12,24,242,540,6,116.62809917355372,1.2412121212121213e-05 +uniform_refit,cold,2,3.1622776601683795e-05,5,3,16,4,16,42,130,6,109.71428571428571,3.1303938859494416e-05 +uniform_refit,cold,2,5.623413251903491e-05,5,5,18,6,18,80,210,5,97.2,5.6e-05 +uniform_refit,cold,2,0.0001,5,7,24,8,24,154,290,5,89.76623376623377,9.998653198653199e-05 +uniform_refit,cold,2,0.00017782794100389227,5,11,24,12,24,242,450,4,85.68595041322314,0.00015515151515151513 +uniform_refit,cold,2,0.00031622776601683794,4,3,12,4,12,30,104,4,80.0,0.00029582222222222223 +uniform_refit,cold,2,0.0005623413251903491,4,5,14,6,14,60,168,4,70.0,0.0005420246913580248 +uniform_refit,cold,2,0.001,4,6,22,7,22,120,200,3,64.16666666666667,0.0009560493827160494 +uniform_refit,cold,64,1e-18,13,1,256,17,17,194,5252,None,583.9587628865979,5.0291661166147826e-20 +uniform_refit,cold,64,1.778279410038923e-18,13,1,256,17,17,194,5252,None,583.9587628865979,5.0291661166147826e-20 +uniform_refit,cold,64,3.1622776601683795e-18,13,1,256,17,17,194,5252,None,583.9587628865979,5.0291661166147826e-20 +uniform_refit,cold,64,5.623413251903491e-18,13,1,256,17,17,194,5252,None,583.9587628865979,5.0291661166147826e-20 +uniform_refit,cold,64,1e-17,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18 +uniform_refit,cold,64,1.7782794100389228e-17,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18 +uniform_refit,cold,64,3.1622776601683796e-17,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18 +uniform_refit,cold,64,5.62341325190349e-17,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18 +uniform_refit,cold,64,1e-16,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18 +uniform_refit,cold,64,1.7782794100389228e-16,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18 +uniform_refit,cold,64,3.1622776601683793e-16,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18 +uniform_refit,cold,64,5.623413251903491e-16,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18 +uniform_refit,cold,64,1e-15,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16 +uniform_refit,cold,64,1.7782794100389227e-15,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16 +uniform_refit,cold,64,3.1622776601683794e-15,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16 +uniform_refit,cold,64,5.6234132519034904e-15,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16 +uniform_refit,cold,64,1e-14,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16 +uniform_refit,cold,64,1.7782794100389227e-14,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16 +uniform_refit,cold,64,3.1622776601683796e-14,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16 +uniform_refit,cold,64,5.6234132519034906e-14,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16 +uniform_refit,cold,64,1e-13,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14 +uniform_refit,cold,64,1.7782794100389227e-13,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14 +uniform_refit,cold,64,3.162277660168379e-13,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14 +uniform_refit,cold,64,5.62341325190349e-13,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14 +uniform_refit,cold,64,1e-12,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14 +uniform_refit,cold,64,1.7782794100389228e-12,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14 +uniform_refit,cold,64,3.1622776601683794e-12,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14 +uniform_refit,cold,64,5.6234132519034904e-12,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14 +uniform_refit,cold,64,1e-11,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12 +uniform_refit,cold,64,1.7782794100389227e-11,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12 +uniform_refit,cold,64,3.1622776601683794e-11,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12 +uniform_refit,cold,64,5.6234132519034906e-11,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12 +uniform_refit,cold,64,1e-10,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12 +uniform_refit,cold,64,1.778279410038923e-10,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12 +uniform_refit,cold,64,3.1622776601683795e-10,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12 +uniform_refit,cold,64,5.623413251903491e-10,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12 +uniform_refit,cold,64,1e-09,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10 +uniform_refit,cold,64,1.7782794100389228e-09,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10 +uniform_refit,cold,64,3.1622776601683795e-09,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10 +uniform_refit,cold,64,5.623413251903491e-09,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10 +uniform_refit,cold,64,1e-08,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10 +uniform_refit,cold,64,1.7782794100389228e-08,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10 +uniform_refit,cold,64,3.162277660168379e-08,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10 +uniform_refit,cold,64,5.6234132519034905e-08,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10 +uniform_refit,cold,64,1e-07,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08 +uniform_refit,cold,64,1.7782794100389227e-07,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08 +uniform_refit,cold,64,3.162277660168379e-07,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08 +uniform_refit,cold,64,5.62341325190349e-07,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08 +uniform_refit,cold,64,1e-06,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08 +uniform_refit,cold,64,1.778279410038923e-06,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08 +uniform_refit,cold,64,3.162277660168379e-06,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08 +uniform_refit,cold,64,5.623413251903491e-06,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08 +uniform_refit,cold,64,1e-05,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06 +uniform_refit,cold,64,1.778279410038923e-05,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06 +uniform_refit,cold,64,3.1622776601683795e-05,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06 +uniform_refit,cold,64,5.623413251903491e-05,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06 +uniform_refit,cold,64,0.0001,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06 +uniform_refit,cold,64,0.00017782794100389227,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06 +uniform_refit,cold,64,0.00031622776601683794,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06 +uniform_refit,cold,64,0.0005623413251903491,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06 +uniform_refit,cold,64,0.001,5,1,256,17,17,194,2020,None,107.25773195876289,0.0007333410725898773 +uniform_refit,hot,0,1e-18,31,2,125,3,126,250,1550,31,3096.576,3.4027546317804404e-19 +uniform_refit,hot,0,1.778279410038923e-18,30,2,125,3,126,250,1500,30,2906.064,1.1909641211231541e-18 +uniform_refit,hot,0,3.1622776601683795e-18,30,2,125,3,126,250,1500,30,2906.064,1.1909641211231541e-18 +uniform_refit,hot,0,5.623413251903491e-18,29,2,125,3,126,250,1450,29,2721.6,4.168374423931039e-18 +uniform_refit,hot,0,1e-17,29,2,125,3,126,250,1450,29,2721.6,4.168374423931039e-18 +uniform_refit,hot,0,1.7782794100389228e-17,28,2,125,3,126,250,1400,28,2543.184,1.4589310483758634e-17 +uniform_refit,hot,0,3.1622776601683796e-17,28,2,125,3,126,250,1400,28,2543.184,1.4589310483758634e-17 +uniform_refit,hot,0,5.62341325190349e-17,27,2,125,3,126,250,1350,27,2370.816,5.106258669315523e-17 +uniform_refit,hot,0,1e-16,27,2,125,3,126,250,1350,27,2370.816,5.106258669315523e-17 +uniform_refit,hot,0,1.7782794100389228e-16,27,2,125,3,126,250,1350,27,2370.816,5.106258669315523e-17 +uniform_refit,hot,0,3.1622776601683793e-16,26,2,125,3,126,250,1300,26,2204.496,1.7871905342604332e-16 +uniform_refit,hot,0,5.623413251903491e-16,26,2,125,3,126,250,1300,26,2204.496,1.7871905342604332e-16 +uniform_refit,hot,0,1e-15,25,2,125,3,126,250,1250,25,2044.224,6.255166869911515e-16 +uniform_refit,hot,0,1.7782794100389227e-15,25,2,125,3,126,250,1250,25,2044.224,6.255166869911515e-16 +uniform_refit,hot,0,3.1622776601683794e-15,24,2,125,3,126,250,1200,24,1890.0,2.1893084044690303e-15 +uniform_refit,hot,0,5.6234132519034904e-15,24,2,125,3,126,250,1200,24,1890.0,2.1893084044690303e-15 +uniform_refit,hot,0,1e-14,23,2,125,3,126,250,1150,23,1741.824,7.662579415641607e-15 +uniform_refit,hot,0,1.7782794100389227e-14,23,2,125,3,126,250,1150,23,1741.824,7.662579415641607e-15 +uniform_refit,hot,0,3.1622776601683796e-14,22,2,125,3,126,250,1100,22,1599.696,2.6819027954745623e-14 +uniform_refit,hot,0,5.6234132519034906e-14,22,2,125,3,126,250,1100,22,1599.696,2.6819027954745623e-14 +uniform_refit,hot,0,1e-13,21,2,125,3,126,250,1050,21,1463.616,9.386659784160968e-14 +uniform_refit,hot,0,1.7782794100389227e-13,21,2,125,3,126,250,1050,21,1463.616,9.386659784160968e-14 +uniform_refit,hot,0,3.162277660168379e-13,21,2,125,3,126,250,1050,21,1463.616,9.386659784160968e-14 +uniform_refit,hot,0,5.62341325190349e-13,20,2,125,3,126,250,1000,20,1333.584,3.2853309244563385e-13 +uniform_refit,hot,0,1e-12,20,2,125,3,126,250,1000,20,1333.584,3.2853309244563385e-13 +uniform_refit,hot,0,1.7782794100389228e-12,19,2,125,3,126,250,950,19,1209.6,1.1498658235597187e-12 +uniform_refit,hot,0,3.1622776601683794e-12,19,2,125,3,126,250,950,19,1209.6,1.1498658235597187e-12 +uniform_refit,hot,0,5.6234132519034904e-12,18,2,125,3,126,250,900,18,1091.664,4.0245303824590146e-12 +uniform_refit,hot,0,1e-11,18,2,125,3,126,250,900,18,1091.664,4.0245303824590146e-12 +uniform_refit,hot,0,1.7782794100389227e-11,17,2,125,3,126,250,850,17,979.776,1.4085856338606554e-11 +uniform_refit,hot,0,3.1622776601683794e-11,17,2,125,3,126,250,850,17,979.776,1.4085856338606554e-11 +uniform_refit,hot,0,5.6234132519034906e-11,16,2,125,3,126,250,800,16,873.936,4.9300497185122934e-11 +uniform_refit,hot,0,1e-10,16,2,125,3,126,250,800,16,873.936,4.9300497185122934e-11 +uniform_refit,hot,0,1.778279410038923e-10,15,2,125,3,126,250,750,15,774.144,1.7255174014793028e-10 +uniform_refit,hot,0,3.1622776601683795e-10,15,2,125,3,126,250,750,15,774.144,1.7255174014793028e-10 +uniform_refit,hot,0,5.623413251903491e-10,15,2,125,3,126,250,750,15,774.144,1.7255174014793028e-10 +uniform_refit,hot,0,1e-09,14,2,125,3,126,250,700,14,680.4,6.039310905177559e-10 +uniform_refit,hot,0,1.7782794100389228e-09,14,2,125,3,126,250,700,14,680.4,6.039310905177559e-10 +uniform_refit,hot,0,3.1622776601683795e-09,13,2,125,3,126,250,650,13,592.704,2.1137588168121457e-09 +uniform_refit,hot,0,5.623413251903491e-09,13,2,125,3,126,250,650,13,592.704,2.1137588168121457e-09 +uniform_refit,hot,0,1e-08,12,2,125,3,126,250,600,12,511.056,7.39815585884251e-09 +uniform_refit,hot,0,1.7782794100389228e-08,12,2,125,3,126,250,600,12,511.056,7.39815585884251e-09 +uniform_refit,hot,0,3.162277660168379e-08,11,2,125,3,126,250,550,11,435.456,2.5893545505948784e-08 +uniform_refit,hot,0,5.6234132519034905e-08,11,2,125,3,126,250,550,11,435.456,2.5893545505948784e-08 +uniform_refit,hot,0,1e-07,10,2,125,3,126,250,500,10,365.904,9.062740927082074e-08 +uniform_refit,hot,0,1.7782794100389227e-07,10,2,125,3,126,250,500,10,365.904,9.062740927082074e-08 +uniform_refit,hot,0,3.162277660168379e-07,10,2,125,3,126,250,500,10,365.904,9.062740927082074e-08 +uniform_refit,hot,0,5.62341325190349e-07,9,2,125,3,126,250,450,9,302.4,3.171959324478726e-07 +uniform_refit,hot,0,1e-06,9,2,125,3,126,250,450,9,302.4,3.171959324478726e-07 +uniform_refit,hot,0,1.778279410038923e-06,8,2,125,3,126,250,400,8,244.944,1.1101857635675541e-06 +uniform_refit,hot,0,3.162277660168379e-06,8,2,125,3,126,250,400,8,244.944,1.1101857635675541e-06 +uniform_refit,hot,0,5.623413251903491e-06,7,2,125,3,126,250,350,7,193.536,3.885650172486439e-06 +uniform_refit,hot,0,1e-05,7,2,125,3,126,250,350,7,193.536,3.885650172486439e-06 +uniform_refit,hot,0,1.778279410038923e-05,6,2,125,3,126,250,300,6,148.176,1.359977560370254e-05 +uniform_refit,hot,0,3.1622776601683795e-05,6,2,125,3,126,250,300,6,148.176,1.359977560370254e-05 +uniform_refit,hot,0,5.623413251903491e-05,5,2,125,3,126,250,250,5,108.864,4.7599214612958884e-05 +uniform_refit,hot,0,0.0001,5,2,125,3,126,250,250,5,108.864,4.7599214612958884e-05 +uniform_refit,hot,0,0.00017782794100389227,4,2,125,3,126,250,200,4,75.6,0.0001665972511453561 +uniform_refit,hot,0,0.00031622776601683794,4,2,125,3,126,250,200,4,75.6,0.0001665972511453561 +uniform_refit,hot,0,0.0005623413251903491,4,2,125,3,126,250,200,4,75.6,0.0001665972511453561 +uniform_refit,hot,0,0.001,3,2,125,3,126,250,150,3,48.384,0.0005830903790087463 +uniform_refit,hot,2,1e-18,18,2,126,3,127,248,900,31,1362.1774193548388,7.796851299792269e-19 +uniform_refit,hot,2,1.778279410038923e-18,18,2,126,3,127,248,900,30,1342.717741935484,7.796851299792269e-19 +uniform_refit,hot,2,3.1622776601683795e-18,17,2,34,3,35,64,850,30,1319.0625,3.116559176094582e-18 +uniform_refit,hot,2,5.623413251903491e-18,17,2,62,3,63,120,850,29,1247.4,5.527129629945824e-18 +uniform_refit,hot,2,1e-17,17,2,112,3,113,220,850,29,1220.4,9.838092055345813e-18 +uniform_refit,hot,2,1.7782794100389228e-17,17,2,126,3,127,248,850,28,1198.3064516129032,1.1045539341372381e-17 +uniform_refit,hot,2,3.1622776601683796e-17,17,2,126,3,127,248,850,28,1198.3064516129032,1.1045539341372381e-17 +uniform_refit,hot,2,5.62341325190349e-17,16,2,44,3,45,84,800,27,1129.2857142857142,5.614174466500292e-17 +uniform_refit,hot,2,1e-16,16,2,80,3,81,156,800,27,1094.5384615384614,9.993444695613996e-17 +uniform_refit,hot,2,1.7782794100389228e-16,16,2,126,3,127,248,800,27,1079.5,1.5593702599584538e-16 +uniform_refit,hot,2,3.1622776601683793e-16,16,2,126,3,127,248,800,26,1062.0887096774193,1.5593702599584538e-16 +uniform_refit,hot,2,5.623413251903491e-16,15,2,30,3,31,56,750,26,1045.142857142857,5.505247592327814e-16 +uniform_refit,hot,2,1e-15,15,2,56,3,57,108,750,25,979.5555555555555,9.946600423603305e-16 +uniform_refit,hot,2,1.7782794100389227e-15,15,2,100,3,101,196,750,25,956.4081632653061,1.7476976483580363e-15 +uniform_refit,hot,2,3.1622776601683794e-15,15,2,126,3,127,248,750,24,934.0645161290323,2.192864428066576e-15 +uniform_refit,hot,2,5.6234132519034904e-15,15,2,126,3,127,248,750,24,934.0645161290323,2.192864428066576e-15 +uniform_refit,hot,2,1e-14,14,2,38,3,39,72,700,23,877.5,9.618007373894983e-15 +uniform_refit,hot,2,1.7782794100389227e-14,14,2,72,3,73,140,700,23,844.7142857142857,1.7757726633812592e-14 +uniform_refit,hot,2,3.1622776601683796e-14,14,2,126,3,127,248,700,22,814.233870967742,3.070010199293206e-14 +uniform_refit,hot,2,5.6234132519034906e-14,14,2,126,3,127,248,700,22,814.233870967742,3.070010199293206e-14 +uniform_refit,hot,2,1e-13,13,2,26,3,27,48,650,21,787.5,9.407244746934382e-14 +uniform_refit,hot,2,1.7782794100389227e-13,13,2,50,3,51,96,650,21,743.75,1.7395053156313578e-13 +uniform_refit,hot,2,3.162277660168379e-13,13,2,92,3,93,180,650,21,723.3333333333334,3.1409435715208127e-13 +uniform_refit,hot,2,5.62341325190349e-13,13,2,126,3,127,248,650,20,702.5967741935484,4.276085634729822e-13 +uniform_refit,hot,2,1e-12,13,2,126,3,127,248,650,20,702.5967741935484,4.276085634729822e-13 +uniform_refit,hot,2,1.7782794100389228e-12,12,2,36,3,37,68,600,19,650.7647058823529,1.7627155114446329e-12 +uniform_refit,hot,2,3.1622776601683794e-12,12,2,66,3,67,128,600,19,626.03125,3.14748767972362e-12 +uniform_refit,hot,2,5.6234132519034904e-12,12,2,118,3,119,232,600,18,600.1293103448276,5.550884196506973e-12 +uniform_refit,hot,2,1e-11,12,2,126,3,127,248,600,18,599.1532258064516,5.920733955779755e-12 +uniform_refit,hot,2,1.7782794100389227e-11,11,2,24,3,25,44,550,17,572.7272727272727,1.6647868719199307e-11 +uniform_refit,hot,2,3.1622776601683794e-11,11,2,46,3,47,88,550,17,538.3636363636364,3.057889775158484e-11 +uniform_refit,hot,2,5.6234132519034906e-11,11,2,86,3,87,168,550,16,509.57142857142856,5.59856153901777e-11 +uniform_refit,hot,2,1e-10,11,2,126,3,127,248,550,16,503.9032258064516,8.141009189197163e-11 +uniform_refit,hot,2,1.778279410038923e-10,11,2,126,3,127,248,550,15,491.61290322580646,8.141009189197163e-11 +uniform_refit,hot,2,3.1622776601683795e-10,10,2,34,3,35,64,500,15,457.1875,3.1323138410472653e-10 +uniform_refit,hot,2,5.623413251903491e-10,10,2,62,3,63,120,500,15,438.9,5.555070083038381e-10 +uniform_refit,hot,2,1e-09,10,2,112,3,113,220,500,14,418.1,9.88782505746383e-10 +uniform_refit,hot,2,1.7782794100389228e-09,10,2,126,3,127,248,500,14,416.8467741935484,1.1101376167087038e-09 +uniform_refit,hot,2,3.1622776601683795e-09,9,2,24,3,25,44,450,13,386.3636363636364,3.0647212869435092e-09 +uniform_refit,hot,2,5.623413251903491e-09,9,2,44,3,45,84,450,13,364.2857142857143,5.395693165240491e-09 +uniform_refit,hot,2,1e-08,9,2,82,3,83,160,450,12,342.375,9.838500228623686e-09 +uniform_refit,hot,2,1.7782794100389228e-08,9,2,126,3,127,248,450,12,337.98387096774195,1.4986857825567502e-08 +uniform_refit,hot,2,3.162277660168379e-08,8,2,18,3,19,32,400,11,320.625,3.160493827160494e-08 +uniform_refit,hot,2,5.6234132519034905e-08,8,2,32,3,33,60,400,11,297.0,5.3273179901437785e-08 +uniform_refit,hot,2,1e-07,8,2,62,3,63,120,400,10,274.05,9.999126149469086e-08 +uniform_refit,hot,2,1.7782794100389227e-07,8,2,110,3,111,216,400,10,268.25,1.748604266513122e-07 +uniform_refit,hot,2,3.162277660168379e-07,8,2,126,3,127,248,400,10,267.31451612903226,1.998247710075667e-07 +uniform_refit,hot,2,5.62341325190349e-07,7,2,24,3,25,44,350,9,236.36363636363637,5.363262252151139e-07 +uniform_refit,hot,2,1e-06,7,2,46,3,47,88,350,9,222.1818181818182,9.851269900652615e-07 +uniform_refit,hot,2,1.778279410038923e-06,7,2,84,3,85,164,350,8,207.3170731707317,1.7626819231155273e-06 +uniform_refit,hot,2,3.162277660168379e-06,7,2,126,3,127,248,350,8,204.83870967741936,2.6227001194743126e-06 +uniform_refit,hot,2,5.623413251903491e-06,6,2,18,3,19,32,300,7,182.875,5.3333333333333345e-06 +uniform_refit,hot,2,1e-05,6,2,34,3,35,64,300,7,168.4375,9.51440329218107e-06 +uniform_refit,hot,2,1.778279410038923e-05,6,2,64,3,65,124,300,6,154.11290322580646,1.7399707951679278e-05 +uniform_refit,hot,2,3.1622776601683795e-05,6,2,118,3,119,232,300,6,150.80172413793105,3.161402015041862e-05 +uniform_refit,hot,2,5.623413251903491e-05,5,2,14,3,15,24,250,5,135.0,5.377229080932786e-05 +uniform_refit,hot,2,0.0001,5,2,28,3,29,52,250,5,120.46153846153847,9.927192149414372e-05 +uniform_refit,hot,2,0.00017782794100389227,5,2,50,3,51,96,250,4,108.375,0.00017146776406035667 +uniform_refit,hot,2,0.00031622776601683794,5,2,94,3,95,184,250,4,105.32608695652173,0.00031619252102343894 +uniform_refit,hot,2,0.0005623413251903491,4,2,10,3,11,16,200,4,103.125,0.0004938271604938272 +uniform_refit,hot,2,0.001,4,2,22,3,23,40,200,3,80.5,0.0009560493827160494 diff --git a/wai/wai-rs/Cargo.lock b/wai/wai-rs/Cargo.lock index 4e874a70a..356ba4199 100644 --- a/wai/wai-rs/Cargo.lock +++ b/wai/wai-rs/Cargo.lock @@ -3900,7 +3900,7 @@ dependencies = [ [[package]] name = "wai-quantum" -version = "0.3.28" +version = "0.3.29" dependencies = [ "blake3", "ed25519-dalek", diff --git a/wai/wai-rs/Cargo.toml b/wai/wai-rs/Cargo.toml index 2fe108842..0e41163fa 100644 --- a/wai/wai-rs/Cargo.toml +++ b/wai/wai-rs/Cargo.toml @@ -357,6 +357,9 @@ quantum_tn = ["dep:wai-quantum", "wai-quantum/quantum_tn"] quantum_gbs = ["dep:wai-quantum", "wai-quantum/quantum_gbs"] # The dense state vector at any angle: fusion, threads, the same bits everywhere. quantum_sv = ["dep:wai-quantum", "wai-quantum/quantum_sv"] +# Architecture-level estimation: yoked storage, cultivation, CCZ factories, +# reaction-limited time, whole machines. +quantum_arch = ["dep:wai-quantum", "wai-quantum/quantum_arch"] quantum_qir = ["quantum_toolchain", "wai-quantum/quantum_qir"] # Variational quantum machine learning (extensions/quantum-sim § VML, # `wai.quantum.vml`): the interference-based ML the thermodynamic-computing pivot @@ -489,6 +492,7 @@ required-features = [ "quantum_tn", "quantum_gbs", "quantum_sv", + "quantum_arch", ] [[bin]] diff --git a/wai/wai-rs/src/bin/wai_quantum.rs b/wai/wai-rs/src/bin/wai_quantum.rs index c436c1823..f185b9632 100644 --- a/wai/wai-rs/src/bin/wai_quantum.rs +++ b/wai/wai-rs/src/bin/wai_quantum.rs @@ -165,6 +165,10 @@ fn usage() -> ! { wai-quantum gbs --squeezing r1,r2,… [--eta E] [--seed S | --unitary U.json] [--json]\n \ wai-quantum gbs … --sample K (exact click patterns)\n \ wai-quantum gbs … --check SAMPLES.txt (observed patterns vs exact marginals)\n\n\ + ARCHITECTURE:\n \ + wai-quantum arch factoring [--bits 1024|1536|2048|3072|4096|6144|8192] [--json]\n \ + wai-quantum arch storage [--target T] [--fits refit|uniform|si1000] [--json]\n \ + wai-quantum arch cultivate [--p 5e-4|1e-3|2e-3] [--target T] [--json]\n\n\ STATE VECTOR (any gate, any angle):\n \ wai-quantum sv --file CIRCUIT.jsonl [-n N] [--fuse W] [--top K | --sample S [--seed X] | --expect \"Z0 Z1; X3\"] [--json]\n\n\ TENSOR NETWORKS:\n \ @@ -957,6 +961,84 @@ fn main() { } } + // The architecture around the code: yoked storage, cultivated magic + // states, CCZ factories and the clock, priced; and the published + // factoring machine re-run region by region. + "arch" => { + use wai::quantum_arch::*; + let json = flag(args, "--json"); + match algo.map(String::as_str) { + Some("factoring") | None => { + let bits: u32 = num(args, "--bits", "", 2048); + let params = FactoringParams::published(bits).unwrap_or_else(|| die("--bits: one of 1024, 1536, 2048, 3072, 4096, 6144, 8192")); + let e = factoring_estimate(¶ms, &Machine::published()).unwrap_or_else(|e| die(&e.to_string())); + let blocks: Vec<(u32, u32, u32, u64)> = e.cold.blocks.iter().map(|(b, k)| (b.rows - 1, b.distance, b.logical, *k)).collect(); + if json { + let bs: Vec = blocks.iter().map(|(w, d, l, k)| format!("{{\"count\":{k},\"distance\":{d},\"logical\":{l},\"width\":{w}}}")).collect(); + println!( + "{{\"bits\":{bits},\"ccz_error\":{},\"ccz_rounds\":{},\"cold_blocks\":[{}],\"cold_logical\":{},\"cold_qubits\":{},\"compute_qubits\":{},\"days\":{},\"expected_shots\":{},\"hot_distance\":{},\"hot_logical\":{},\"hot_qubits\":{},\"hours_per_shot\":{},\"hours_per_shot_rounded\":{},\"physical_qubits\":{},\"shot_survival\":{},\"step_us\":{},\"t_state_d1\":{},\"t_state_volume\":{},\"toffolis_per_shot\":{}}}", + e.ccz_error, e.ccz_rounds, bs.join(","), e.cold_logical, e.cold_qubits, e.compute_qubits, e.days, e.expected_shots, e.hot_distance, e.hot_logical, + e.hot_qubits, e.hours_per_shot, e.hours_per_shot_rounded, e.physical_qubits(), e.shot_survival, e.timing.step_us(), e.t_state.d1, e.t_state.volume, e.toffolis_per_shot + ); + } else { + println!("{bits}-bit factoring (arXiv:2505.15917 parameters), re-run"); + println!("logical qubits {} cold + {} hot", e.cold_logical, e.hot_logical); + for (w, d, l, k) in &blocks { + println!("cold storage {k} × {w}×{w} grid-yoked block, d = {d}, {l} logical each"); + } + println!("hot storage d = {}", e.hot_distance); + println!("physical qubits {} = {} cold + {} hot + {} compute", e.physical_qubits(), e.cold_qubits, e.hot_qubits, e.compute_qubits); + println!("T states cultivated at d1 = {}, {:.0} qubit·rounds each", e.t_state.d1, e.t_state.volume); + println!("CCZ states {:.1} rounds per factory, error {:.1e}", e.ccz_rounds, e.ccz_error); + println!("clock {:.1} µs per step ({:?}-bound)", e.timing.step_us(), e.timing.bound()); + println!("Toffolis {:.4e} per shot", e.toffolis_per_shot); + println!("time {:.2} h per shot ({:.2} h at the clock), {:.2} shots, {:.2} days", e.hours_per_shot_rounded, e.hours_per_shot, e.expected_shots, e.days); + } + } + Some("storage") => { + let target: f64 = num(args, "--target", "", 1e-15); + let model = match opt(args, "--fits", "").as_deref() { + None | Some("refit") => StorageModel::uniform_refit(), + Some("uniform") => StorageModel::uniform(), + Some("si1000") => StorageModel::si1000(), + Some(_) => die("--fits: refit, uniform or si1000"), + }; + let rows = [ + ("cold plain", best_block(&model, Storage::Cold, Yoke::None, target, 250)), + ("cold rows", best_block(&model, Storage::Cold, Yoke::Rows, target, 250)), + ("cold grid", best_block(&model, Storage::Cold, Yoke::Grid, target, 250)), + ("hot plain", best_block(&model, Storage::Hot, Yoke::None, target, 250)), + ("hot rows", best_block(&model, Storage::Hot, Yoke::Rows, target, 250)), + ]; + if json { + let items: Vec = rows + .iter() + .filter_map(|(name, b)| b.map(|b| format!("{{\"distance\":{},\"logical\":{},\"name\":\"{name}\",\"qubits_per_logical\":{}}}", b.distance, b.logical, b.qubits_per_logical()))) + .collect(); + println!("{{\"layouts\":[{}],\"target\":{target}}}", items.join(",")); + } else { + println!("storage at {target:e} per logical qubit per round"); + for (name, b) in rows { + match b { + Some(b) => println!("{name:<11} d = {:>3} {:>4} × {:<4} patches {:>4} logical {:>8.2} qubits each", b.distance, b.rows, b.cols, b.logical, b.qubits_per_logical()), + None => println!("{name:<11} unreachable"), + } + } + } + } + Some("cultivate") => { + let p: f64 = num(args, "--p", "", 1e-3); + let target: f64 = num(args, "--target", "", 1e-7); + match cultivate(p, target) { + Some(t) if json => println!("{{\"d1\":{},\"error\":{},\"volume\":{}}}", t.d1, t.error, t.volume), + Some(t) => println!("T state at p = {p:e}: error {:.2e}, {:.0} qubit·rounds (injection distance {})", t.error, t.volume, t.d1), + None => die("no cultivation curve reaches that target at that noise (simulated: 5e-4, 1e-3, 2e-3)"), + } + } + Some(other) => die(&format!("arch: unknown '{other}' (factoring, storage, cultivate)")), + } + } + // The dense state vector, any gate at any angle: run a circuit file // (fused to --fuse qubits), then show the likeliest outcomes, draw // samples, or evaluate Pauli observables. diff --git a/wai/wai-rs/src/lib.rs b/wai/wai-rs/src/lib.rs index 960f3a554..e7243848d 100644 --- a/wai/wai-rs/src/lib.rs +++ b/wai/wai-rs/src/lib.rs @@ -634,6 +634,9 @@ pub use wai_quantum::quantum_gbs; #[cfg(feature = "quantum_sv")] pub use wai_quantum::quantum_sv; +#[cfg(feature = "quantum_arch")] +pub use wai_quantum::quantum_arch; + #[cfg(any(feature = "quantum_tn", feature = "quantum_sv"))] pub use wai_quantum::gates; #[cfg(feature = "quantum_qir")] diff --git a/wai/wai-web/Cargo.lock b/wai/wai-web/Cargo.lock index 07ccb6ab6..5e4c3cb1b 100644 --- a/wai/wai-web/Cargo.lock +++ b/wai/wai-web/Cargo.lock @@ -734,7 +734,7 @@ dependencies = [ [[package]] name = "wai-quantum" -version = "0.3.28" +version = "0.3.29" dependencies = [ "blake3", "ed25519-dalek", -- 2.54.0 (Apple Git-157)