From b1d93f75e2de3941569a2c8cf7e17bc3662908c7 Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Fri, 31 Jul 2026 15:56:41 -0300 Subject: [PATCH 1/6] aiur: circuit-level function grouping (no source pragma) Several functions can now be proven by ONE circuit: the members are walked like branches of a single function - auxiliary columns and lookup slots are shared across members (the same save/restore sharing match arms already use), selector columns are laid out consecutively per member, and every member folds its selector-gated return message (carrying its own function index) into the shared lookup slot 0 against a single shared multiplicity column. One extra constraint enforces cross-member exclusivity: the sum of the members' top-block selectors must be boolean. Callers are untouched - calls still target function indices on the function channel - so grouping is invisible to execution, the query record, and the interpreter. Grouping is a CIRCUIT-level choice, not a property of the function library, so there is no source annotation: Source.Toplevel.compile builds the default singleton partition (Bytecode.Toplevel.circuits, one circuit per constrained function - behavior-identical to before), and CompiledToplevel.groupFunctions optionally regroups it by function NAME (validated: known, constrained, non-entry, no duplicates). The merged layout is max inputs, summed selectors, max auxiliaries, max lookups - so grouping fits rarely-called functions of similar shape: each (rare) row pays the group's selector count while the system sheds one circuit (vk entry, commitment matrix, verifier work) per absorbed member. Rust consumes the partition directly (bytecode Circuit via FFI; constraints/trace/synthesis iterate circuits, witness rows concatenate the members' queried rows in member order). The stage-2 lookup group size and the branchless raw-argument rule now key on the CIRCUIT layout: multi-member circuits are branching by construction, so their arguments are selector-superposed exactly like match arms. Tests: the aiur suite proves the same toplevel twice - ungrouped and with a 3-member test group (different arities, matches, cross-member call, recursion) - plus structural checks on the partition (members, merge-rule layout, every constrained function in exactly one circuit). All suites pass unchanged (ixvm FFT pins identical - the default partition is behavior-neutral); codegen is unaffected (execution ignores the partition). --- Ix/Aiur/Compiler.lean | 81 ++++++++++++++++++++++++++- Ix/Aiur/Compiler/Lower.lean | 2 +- Ix/Aiur/Stages/Bytecode.lean | 24 ++++++++ Ix/Aiur/Statistics.lean | 41 ++++++-------- Tests/Aiur/Aiur.lean | 79 ++++++++++++++++++++++++++ Tests/Aiur/Common.lean | 5 +- Tests/Main.lean | 12 +++- crates/aiur/src/bytecode.rs | 17 ++++++ crates/aiur/src/constraints.rs | 98 +++++++++++++++++++++------------ crates/aiur/src/synthesis.rs | 43 ++++++++++----- crates/aiur/src/trace.rs | 84 +++++++++++++++++++++------- crates/ffi/src/aiur/toplevel.rs | 18 +++++- crates/ffi/src/lean.rs | 3 +- 13 files changed, 404 insertions(+), 103 deletions(-) diff --git a/Ix/Aiur/Compiler.lean b/Ix/Aiur/Compiler.lean index d85266632..752b2a878 100644 --- a/Ix/Aiur/Compiler.lean +++ b/Ix/Aiur/Compiler.lean @@ -42,6 +42,68 @@ def CompiledToplevel.getFuncIdx (ct : CompiledToplevel) (name : Lean.Name) : Option Bytecode.FunIdx := ct.nameMap[Global.mk name]? +/-- Regroup the circuit partition: each `(name, members)` in `groups` becomes +ONE circuit proving all the listed functions (branching on the member; see +`Bytecode.Circuit`), positioned where its first member's singleton circuit +was; every other constrained function keeps its singleton circuit. Grouping +is a circuit-level choice — the function "library", its bytecode, execution, +and the query record are untouched, and callers still target function +indices on the function channel. + +Grouping is favorable for RARELY-CALLED functions of similar shape: the +merged circuit sums the members' selector columns but takes the max of their +auxiliary columns, so each (rare) row pays the group's selector count, while +the system sheds one circuit (vk entry, commitment matrix, verifier work) +per absorbed member. + +Errors if a name is unknown, unconstrained (it has no circuit to group), an +entry function, listed twice, or if a group is empty. -/ +def CompiledToplevel.groupFunctions (ct : CompiledToplevel) + (groups : Array (String × Array Lean.Name)) : + Except String CompiledToplevel := do + let t := ct.bytecode + -- Resolve and validate the groups into member-index arrays. + let mut grouped : Std.HashMap Bytecode.FunIdx Nat := {} + let mut resolved : Array (String × Array Bytecode.FunIdx) := #[] + for (gname, names) in groups do + if names.isEmpty then + throw s!"group {gname} is empty" + let mut members := #[] + for name in names do + let some i := ct.getFuncIdx name + | throw s!"group {gname}: unknown function {name}" + let f := t.functions[i]! + unless f.constrained do + throw s!"group {gname}: {name} is unconstrained (it has no circuit)" + if f.entry then + throw s!"group {gname}: {name} is an entry function" + if grouped.contains i then + throw s!"group {gname}: {name} is already grouped" + grouped := grouped.insert i resolved.size + members := members.push i + resolved := resolved.push (gname, members) + -- Rebuild the partition in first-occurrence order over the existing + -- (singleton-ordered) circuits. + let mut circuits : Array Bytecode.Circuit := #[] + let mut placed : Array Bool := .replicate resolved.size false + for c in t.circuits do + let members := c.members + if h : members.size = 1 then + let i := members[0] + match grouped[i]? with + | none => circuits := circuits.push c + | some g => + unless placed[g]! do + placed := placed.set! g true + let (gname, ms) := resolved[g]! + let layout := ms.foldl (init := t.functions[ms[0]!]!.layout) + fun acc m => if m == ms[0]! then acc + else acc.merge t.functions[m]!.layout + circuits := circuits.push { name := gname, members := ms, layout } + else + throw "groupFunctions: partition already grouped; group from a freshly compiled toplevel" + pure { ct with bytecode := { t with circuits } } + /-- Termination helper for the `Block`/`Ctrl` traversal below. -/ private theorem Bytecode.Block.sizeOf_ctrl_lt'' (b : Bytecode.Block) : sizeOf b.ctrl < sizeOf b := by @@ -90,6 +152,18 @@ decreasing_by | (apply Prod.Lex.left; exact Bytecode.Block.sizeOf_ctrl_lt'' _) end +/-- The default circuit partition: one singleton circuit per constrained +function, in function-index order, named by `nameOf`. -/ +def Bytecode.Toplevel.singletonCircuits (t : Bytecode.Toplevel) + (nameOf : Bytecode.FunIdx → String) : Array Bytecode.Circuit := Id.run do + let mut circuits : Array Bytecode.Circuit := #[] + for h : i in [:t.functions.size] do + let f := t.functions[i] + if f.constrained then + circuits := circuits.push + { name := nameOf i, members := #[i], layout := f.layout } + pure circuits + /-- Compute which functions need a circuit. A function needs a circuit iff it is reachable from an entry point through a chain of constrained call edges. -/ def Bytecode.Toplevel.needsCircuit (t : Bytecode.Toplevel) : Array Bool := Id.run do @@ -118,11 +192,16 @@ def Source.Toplevel.compile (t : Source.Toplevel) : Except String CompiledToplev let (bytecodeRaw, preNameMap) ← concDecls.toBytecode let (bytecodeDedup, remap) := bytecodeRaw.deduplicate let needs := bytecodeDedup.needsCircuit - let bytecode := { bytecodeDedup with + let bytecode : Bytecode.Toplevel := { bytecodeDedup with functions := bytecodeDedup.functions.mapIdx fun i f => { f with constrained := needs[i]! } } let nameMap := preNameMap.fold (init := (∅ : Std.HashMap Global Bytecode.FunIdx)) fun acc name idx => acc.insert name (remap idx) + -- Singleton circuits are labeled with (one of) the function's source names. + let reverseMap := nameMap.fold (init := (∅ : Std.HashMap Bytecode.FunIdx String)) + fun acc global idx => if acc.contains idx then acc else acc.insert idx (toString global) + let bytecode := { bytecode with + circuits := bytecode.singletonCircuits fun i => reverseMap[i]?.getD s!"" } pure (CompiledToplevel.mk t bytecode nameMap) /-- Progress helper: given success of the three `Except`-returning stages, diff --git a/Ix/Aiur/Compiler/Lower.lean b/Ix/Aiur/Compiler/Lower.lean index 275090c4b..524fb5d21 100644 --- a/Ix/Aiur/Compiler/Lower.lean +++ b/Ix/Aiur/Compiler/Lower.lean @@ -619,7 +619,7 @@ def Concrete.Decls.toBytecode (decls : Concrete.Decls) : let memSizes := layoutMState.memSizes.fold (·.insert ·) memSizes pure (functions.push function, memSizes, nameMap) | _ => pure acc - pure (⟨functions, memSizes.toArray⟩, nameMap) + pure (⟨functions, memSizes.toArray, #[]⟩, nameMap) end Aiur diff --git a/Ix/Aiur/Stages/Bytecode.lean b/Ix/Aiur/Stages/Bytecode.lean index c18b3a0aa..85aac3d30 100644 --- a/Ix/Aiur/Stages/Bytecode.lean +++ b/Ix/Aiur/Stages/Bytecode.lean @@ -115,9 +115,33 @@ structure Function where constrained : Bool deriving Inhabited, Repr +/-- A circuit of the proving system, backing one or more functions. By +default every constrained function gets a singleton circuit named after it; +`CompiledToplevel.groupFunctions` can regroup several functions into one +circuit whose branching selects the member function. `layout` is the merged +layout: max `inputSize`, sum of `selectors`, max `auxiliaries` (which +includes the single shared multiplicity column), max `lookups` (slot 0 is +the shared return lookup). -/ +structure Circuit where + name : String + members : Array FunIdx + layout : FunctionLayout + deriving Inhabited, Repr + +/-- Merged layout of a group of functions (see `Circuit`). -/ +def FunctionLayout.merge (a b : FunctionLayout) : FunctionLayout where + inputSize := a.inputSize.max b.inputSize + selectors := a.selectors + b.selectors + auxiliaries := a.auxiliaries.max b.auxiliaries + lookups := a.lookups.max b.lookups + structure Toplevel where functions : Array Function memorySizes : Array Nat + /-- Circuit partition of the constrained functions, in first-occurrence + order. Built by `Source.Toplevel.compile` (singletons by default; see + `CompiledToplevel.groupFunctions`); empty on a freshly lowered toplevel. -/ + circuits : Array Circuit := #[] deriving Repr end Bytecode diff --git a/Ix/Aiur/Statistics.lean b/Ix/Aiur/Statistics.lean index aa91de166..095a1d2d8 100644 --- a/Ix/Aiur/Statistics.lean +++ b/Ix/Aiur/Statistics.lean @@ -81,44 +81,37 @@ def computeStats (compiled : CompiledToplevel) (queryCounts : Array QueryCount) (logBlowup : Nat := defaultCommitmentParameters.logBlowup) : ExecutionStats := let t := compiled.bytecode - -- Invert nameMap to get FunIdx → String - let reverseMap := compiled.nameMap.fold (init := (∅ : Std.HashMap Bytecode.FunIdx String)) - fun acc global idx => if !acc.contains idx then acc.insert idx (toString global) else acc let nAllFuns := t.functions.size - let nConstrained := t.functions.foldl (fun n f => if f.constrained then n + 1 else n) 0 - -- Shapes arrive in canonical system order: constrained functions - -- (ascending index), memories, `Bytes1`, `Bytes2`. A mismatch means the - -- shapes were built from a different toplevel; misindexing would silently - -- attribute costs to the wrong circuits. - if shapes.size != nConstrained + t.memorySizes.size + 2 then + -- Shapes arrive in canonical system order: function circuits (grouped; + -- singletons for ungrouped functions, in ascending member index), + -- memories, `Bytes1`, `Bytes2`. A mismatch means the shapes were built + -- from a different toplevel; misindexing would silently attribute costs + -- to the wrong circuits. + if shapes.size != t.circuits.size + t.memorySizes.size + 2 then panic! s!"computeStats: {shapes.size} circuit shapes for \ - {nConstrained} constrained functions + {t.memorySizes.size} memories + 2 gadgets" + {t.circuits.size} function circuits + {t.memorySizes.size} memories + 2 gadgets" else let mkStats (name : String) (shape : CircuitShape) (h hits : Nat) : CircuitStats := { name, width := shape.committedWidth, height := h, cacheHits := hits, fftCost := fftCost shape h logBlowup, uncachedFftCost := fftCost shape (h + hits) logBlowup } - let functionCircuits := Id.run do - let mut acc := #[] - let mut shapeIdx := 0 - for i in [:nAllFuns] do - if t.functions[i]!.constrained then - let shape := shapes[shapeIdx]! - shapeIdx := shapeIdx + 1 - let qc := queryCounts[i]! - let name := reverseMap[i]?.getD s!"" - acc := acc.push - (mkStats name shape qc.uniqueRows (qc.totalHits - qc.uniqueRows)) - acc + -- One row per function circuit: heights and cache hits are summed over + -- the circuit's member functions (singletons sum over one). + let functionCircuits := t.circuits.mapIdx fun cIdx c => + let shape := shapes[cIdx]! + let (h, hits) := c.members.foldl (init := (0, 0)) fun (h, hits) i => + let qc := queryCounts[i]! + (h + qc.uniqueRows, hits + (qc.totalHits - qc.uniqueRows)) + mkStats c.name shape h hits let memoryCircuits := t.memorySizes.mapIdx fun i size => - let shape := shapes[nConstrained + i]! + let shape := shapes[t.circuits.size + i]! let qc := queryCounts[nAllFuns + i]! mkStats s!"memory[{size}]" shape qc.uniqueRows (qc.totalHits - qc.uniqueRows) -- The byte gadgets commit full-table traces in every proof: their height -- is the (fixed) preprocessed height, independent of the query set, so -- they carry no cache-hit counterfactual. let gadgetCircuits := #["Bytes1", "Bytes2"].mapIdx fun i name => - let shape := shapes[nConstrained + t.memorySizes.size + i]! + let shape := shapes[t.circuits.size + t.memorySizes.size + i]! mkStats name shape shape.preprocessedHeight 0 let circuits := (functionCircuits ++ memoryCircuits ++ gadgetCircuits).qsort (·.fftCost > ·.fftCost) diff --git a/Tests/Aiur/Aiur.lean b/Tests/Aiur/Aiur.lean index 5a9688d32..ea5be951b 100644 --- a/Tests/Aiur/Aiur.lean +++ b/Tests/Aiur/Aiur.lean @@ -718,6 +718,38 @@ def toplevel := ⟦ let s5 = c[4] + c[0]; -- 255 s1 + s2 + 10 * s3 + s4 + s5 -- 1309 } + + --------------------------------------------------------------------------- + -- Grouped circuits (`CompiledToplevel.groupFunctions`): the test runner + -- groups these three into one circuit whose branching selects the member. + -- Grouping is a circuit-level choice, so there is NO source annotation: + -- the same functions also run ungrouped in the plain suite. Members + -- differ in arity, output and branch count, call each other (through the + -- shared circuit) and recurse. + --------------------------------------------------------------------------- + fn grouped_double(x: G) -> G { + x + x + } + + -- Different arity, a match (two selectors), calls a fellow group member. + fn grouped_pick(t: G, a: G, b: G) -> G { + match t { + 0 => grouped_double(a), + _ => b, + } + } + + -- Recursive group member: self-calls route through the shared circuit. + fn grouped_sum_range(n: G) -> G { + match n { + 0 => 0, + _ => n + grouped_sum_range(n - 1), + } + } + + pub fn calls_grouped(t: G, a: G, b: G) -> G { + grouped_pick(t, a, b) + grouped_sum_range(a) + } ⟧ /-- The PROVING suite: every case runs the full prove+verify pipeline @@ -839,6 +871,53 @@ def aiurTestCases : List AiurTestCase := [ -- Unconstrained g_to_bytes / g_inverse hints: all cases in one proof .prove `hint_test #[] #[1309], + + -- Grouped-circuit member functions, run UNGROUPED here (the grouped + -- variant runs in the grouped env; see `testGroups`). + -- t=0 → grouped_double(5) + Σ1..5 = 10 + 15 = 25; t≠0 → 9 + Σ1..3 = 15. + .prove `calls_grouped #[0, 5, 9] #[25] + (label := "calls_grouped(0,5,9)"), + .prove `calls_grouped #[1, 3, 9] #[15] + (label := "calls_grouped(1,3,9)"), ] +/-- The grouping the `aiur` runner applies for the grouped environment. -/ +def testGroups : Array (String × Array Lean.Name) := + #[("test_group", #[`grouped_double, `grouped_pick, `grouped_sum_range])] + +def groupedTestCases : List AiurTestCase := [ + .prove `calls_grouped #[0, 5, 9] #[25] + (label := "calls_grouped(0,5,9) [grouped]"), + .prove `calls_grouped #[1, 3, 9] #[15] + (label := "calls_grouped(1,3,9) [grouped]"), +] + +/-- Structural checks on the grouped partition: the grouped circuit exists, +holds exactly its members, its layout follows the merge rule (max inputs, +summed selectors, max auxiliaries, max lookups), and every constrained +function lands in exactly one circuit. -/ +def groupingStructureChecks (compiled : Aiur.CompiledToplevel) : TestSeq := + let t := compiled.bytecode + let memberOf := fun (name : Lean.Name) => compiled.getFuncIdx name |>.get! + let expectedMembers := + #[`grouped_double, `grouped_pick, `grouped_sum_range].map memberOf + match t.circuits.find? (·.name == "test_group") with + | none => test "test_group circuit exists" false + | some c => + let layouts := c.members.map (t.functions[·]!.layout) + let expected := layouts.foldl (init := (⟨0, 0, 0, 0⟩ : Aiur.Bytecode.FunctionLayout)) + Aiur.Bytecode.FunctionLayout.merge + let allCircuitMembers := t.circuits.flatMap (·.members) + let constrained := (Array.range t.functions.size).filter + (t.functions[·]!.constrained) + test "test_group circuit exists" true ++ + test "test_group members" (c.members == expectedMembers) ++ + test "test_group layout follows the merge rule" + (c.layout.inputSize == expected.inputSize && + c.layout.selectors == expected.selectors && + c.layout.auxiliaries == expected.auxiliaries && + c.layout.lookups == expected.lookups) ++ + test "every constrained function is in exactly one circuit" + (allCircuitMembers.qsort (· < ·) == constrained) + end diff --git a/Tests/Aiur/Common.lean b/Tests/Aiur/Common.lean index f90e64f66..701462489 100644 --- a/Tests/Aiur/Common.lean +++ b/Tests/Aiur/Common.lean @@ -72,10 +72,13 @@ structure AiurTestEnv where aiurSystem : Aiur.AiurSystem shapes : Array Aiur.CircuitShape -def AiurTestEnv.build (toplevelFn : Except Aiur.Global Aiur.Source.Toplevel) : +def AiurTestEnv.build (toplevelFn : Except Aiur.Global Aiur.Source.Toplevel) + (groups : Array (String × Array Lean.Name) := #[]) : Except String AiurTestEnv := do let toplevel ← toplevelFn.mapError toString let compiled ← toplevel.compile + let compiled ← if groups.isEmpty then pure compiled + else compiled.groupFunctions groups let decls ← toplevel.mkDecls.mapError toString let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters return ⟨compiled, decls, aiurSystem, aiurSystem.circuitShapes⟩ diff --git a/Tests/Main.lean b/Tests/Main.lean index 736f65958..6c9fd82bc 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -130,7 +130,17 @@ def primaryRunners : List (String × IO UInt32) := [ IO.println "aiur-prove" match AiurTestEnv.build (pure toplevel) with | .error e => IO.eprintln s!"Aiur setup failed: {e}"; return 1 - | .ok env => LSpec.lspecEachIO aiurTestCases fun tc => pure (env.runTestCase tc)), + | .ok env => do + let r1 ← LSpec.lspecEachIO aiurTestCases fun tc => pure (env.runTestCase tc) + -- The same toplevel with `testGroups` applied: the members share one + -- circuit, and the whole suite of grouped cases proves through it. + match AiurTestEnv.build (pure toplevel) testGroups with + | .error e => IO.eprintln s!"Aiur grouped setup failed: {e}"; return 1 + | .ok genv => do + let r2 ← LSpec.lspecEachIO groupedTestCases fun tc => pure (genv.runTestCase tc) + let r3 ← LSpec.lspecIO + (.ofList [("aiur-grouping", [groupingStructureChecks genv.compiled])]) [] + return if r1 == 0 && r2 == 0 && r3 == 0 then 0 else 1), ("aiur-hashes", do IO.println "aiur-hashes" let .ok blake3Env := AiurTestEnv.build (do diff --git a/crates/aiur/src/bytecode.rs b/crates/aiur/src/bytecode.rs index 65677e590..bb0259fd7 100644 --- a/crates/aiur/src/bytecode.rs +++ b/crates/aiur/src/bytecode.rs @@ -5,6 +5,23 @@ use super::G; pub struct Toplevel { pub functions: Vec, pub memory_sizes: Vec, + /// Circuit partition of the constrained functions, in first-occurrence + /// order. Computed by the Lean compiler (singletons by default; + /// `CompiledToplevel.groupFunctions` regroups); every constrained + /// function appears in exactly one circuit. + pub circuits: Vec, +} + +/// A circuit of the proving system, backing one or more functions. Ungrouped +/// functions get a singleton circuit; grouped functions share one circuit +/// whose branching selects the member function. +/// +/// `layout` is the merged layout: max `input_size`, sum of `selectors`, max +/// `auxiliaries` (which includes the single shared multiplicity column), max +/// `lookups` (slot 0 is the shared return lookup). +pub struct Circuit { + pub members: Vec, + pub layout: FunctionLayout, } pub struct Function { diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs index 2074206c0..87e237566 100644 --- a/crates/aiur/src/constraints.rs +++ b/crates/aiur/src/constraints.rs @@ -6,7 +6,7 @@ use std::{array, ops::Range, sync::LazyLock}; use crate::{ FxIndexMap, G, - bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel, ValIdx}, + bytecode::{Block, Ctrl, Op, Toplevel, ValIdx}, function_channel, gadgets::{ AiurGadget, @@ -46,11 +46,18 @@ pub struct Constraints { } struct ConstraintState { + /// Index of the circuit member currently being walked. function_index: G, - /// Exactly one selector: the function has a single leaf block (no - /// matches), so every lookup slot is written by exactly one branch. + /// Exactly one selector: the circuit backs a single function with a + /// single leaf block (no matches), so every lookup slot is written by + /// exactly one branch. branchless: bool, - layout: FunctionLayout, + /// Input size of the current member (inputs live in columns + /// `0..input_size` for every member; the circuit reserves the max). + input_size: usize, + /// Column of the current member's first selector: the circuit's input + /// block plus the selector counts of the members walked before it. + sel_base: usize, column: usize, lookup: usize, lookups: Vec>, @@ -69,7 +76,7 @@ struct SharedState { impl ConstraintState { fn selector_index(&self, sel: usize) -> usize { - sel + self.layout.input_size + sel + self.sel_base } /// Selector-gate a lookup argument. Lookup slots shared across branches @@ -112,34 +119,75 @@ impl ConstraintState { } impl Toplevel { + /// Build the constraints of one circuit. The circuit's members are walked + /// like branches of a single function: each walk restarts the auxiliary + /// column / lookup-slot counters (so members share those, like match arms + /// do), while selector columns are laid out consecutively per member. All + /// members fold their return message into the shared lookup slot 0, gated + /// by their own selectors and carrying their own function index, against + /// the single shared multiplicity column. pub fn build_constraints( &self, - function_index: usize, + circuit_index: usize, ) -> (Constraints, Vec>) { - let function = &self.functions[function_index]; + let circuit = &self.circuits[circuit_index]; + let layout = circuit.layout; let constraints = Constraints { zeros: vec![], - selectors: 0..0, - width: function.layout.width(), + selectors: layout.input_size..layout.input_size + layout.selectors, + width: layout.width(), }; let mut state = ConstraintState { - function_index: G::from_usize(function_index), - branchless: function.layout.selectors == 1, - layout: function.layout, + function_index: G::ZERO, + branchless: layout.selectors == 1, + input_size: 0, + sel_base: 0, column: 0, lookup: 0, map: vec![], - lookups: vec![empty_lookup(); function.layout.lookups], + lookups: vec![empty_lookup(); layout.lookups], constraints, yield_info: vec![], }; - function.build_constraints(&mut state); + // The shared multiplicity column: first auxiliary, right after the + // selectors. The return lookup occupies the first lookup slot. + let multiplicity = var(layout.input_size + layout.selectors); + state.lookups[0].multiplicity = -multiplicity; + let aux_start = layout.input_size + layout.selectors + 1; + let mut sel_base = layout.input_size; + let mut circuit_sel = Expr::from(G::ZERO); + for &member in &circuit.members { + let function = &self.functions[member]; + state.function_index = G::from_usize(member); + state.input_size = function.layout.input_size; + state.sel_base = sel_base; + state.column = aux_start; + state.lookup = 1; + state.map.clear(); + (0..function.layout.input_size).for_each(|i| state.map.push((var(i), 1))); + let body_sel = function.body.get_block_selector(&state); + circuit_sel = circuit_sel + body_sel.clone(); + function.body.collect_constraints(body_sel, &mut state); + debug_assert!(state.yield_info.is_empty()); + sel_base += function.layout.selectors; + } // The old `Air::eval` asserted each selector column boolean; the new // system compiles a constraint vector, so materialize those explicitly. for sel in state.constraints.selectors.clone() { let s = var(sel); state.constraints.zeros.push(s.clone() * (s - konst(G::ONE))); } + // Cross-member exclusivity: the circuit-level selector (the sum of the + // members' top-block selectors) must be boolean, so at most one member + // is active per row and the shared return lookup emits a single + // member's message. A singleton circuit already gets this from its top + // block's own boolean constraint. + if circuit.members.len() > 1 { + state + .constraints + .zeros + .push(circuit_sel.clone() * (Expr::from(G::ONE) - circuit_sel)); + } (state.constraints, state.lookups) } } @@ -148,26 +196,6 @@ fn empty_lookup() -> Lookup { Lookup { multiplicity: konst(G::ZERO), args: vec![] } } -impl Function { - fn build_constraints(&self, state: &mut ConstraintState) { - // the first columns are occupied by the input, which is also mapped - state.column += self.layout.input_size; - (0..self.layout.input_size).for_each(|i| state.map.push((var(i), 1))); - // then comes the selectors, which are not mapped - let init_sel = state.column; - let final_sel = state.column + self.layout.selectors; - state.constraints.selectors = init_sel..final_sel; - state.column = final_sel; - // the multiplicity occupies another column - let multiplicity = var(state.column); - state.column += 1; - // the return lookup occupies the first lookup slot - state.lookups[0].multiplicity = -multiplicity.clone(); - state.lookup += 1; - self.body.collect_constraints(self.body.get_block_selector(state), state); - } -} - impl Block { fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState) { // Boolean constraint for this block's selector @@ -258,7 +286,7 @@ impl Ctrl { ]; // input args.extend( - (0..state.layout.input_size) + (0..state.input_size) .map(|arg| state.gate(&sel, state.map[arg].0.clone())), ); // output diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index d0d51f663..28169c1f5 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -89,20 +89,17 @@ impl AiurSystem { }); }; - // Constrained functions (ascending index). - for i in 0..toplevel.functions.len() { - if !toplevel.functions[i].constrained { - continue; - } + // Function circuits, in partition order (singletons unless grouped). + for i in 0..toplevel.circuits.len() { let (constraints, lookups) = toplevel.build_constraints(i); - // A branchless function's lookup arguments are sent raw (degree 1; + // A branchless circuit's lookup arguments are sent raw (degree 1; // see `ConstraintState::gate`), so two lookups fit in one chained // accumulator step at degree 3 — within the degree the selector-gated - // constraints already pay for. Branching functions keep k = 1: their + // constraints already pay for. Branching circuits keep k = 1: their // superposed arguments are degree 2, and grouping would push the // logUp constraints past the quotient budget. let group_size = - if toplevel.functions[i].layout.selectors == 1 && lookups.len() >= 2 { + if toplevel.circuits[i].layout.selectors == 1 && lookups.len() >= 2 { 2 } else { 1 @@ -156,11 +153,8 @@ impl AiurSystem { /// order the circuits were chained in [`AiurSystem::build`], so index `i` /// of the returned `Vec` corresponds to `self.system.circuits[i]`. fn circuit_types(&self) -> Vec { - let functions = (0..self.toplevel.functions.len()).filter_map(|idx| { - self.toplevel.functions[idx] - .constrained - .then_some(CircuitType::Function { idx }) - }); + let functions = (0..self.toplevel.circuits.len()) + .map(|idx| CircuitType::Function { idx }); let memories = self .toplevel .memory_sizes @@ -384,6 +378,25 @@ mod tests { /// fresh auxiliary column pinned by `sel * (col - a*b)`. /// - `lookups = 1`: the function-provide (return) lookup in slot 0, which /// pulls the claim `[function_channel, fun_idx, a, b, a*b]`. + /// + /// Test-side singleton partition (production circuits come pre-built from + /// the Lean compiler). + fn with_singleton_circuits( + functions: Vec, + memory_sizes: Vec, + ) -> Toplevel { + let circuits = functions + .iter() + .enumerate() + .filter(|(_, f)| f.constrained) + .map(|(i, f)| crate::bytecode::Circuit { + members: vec![i], + layout: f.layout, + }) + .collect(); + Toplevel { functions, memory_sizes, circuits } + } + fn mul_toplevel() -> Toplevel { let body = Block { ops: vec![Op::Mul(0, 1)], ctrl: Ctrl::Return(0, vec![2]) }; @@ -398,7 +411,7 @@ mod tests { entry: true, constrained: true, }; - Toplevel { functions: vec![function], memory_sizes: vec![] } + with_singleton_circuits(vec![function], vec![]) } /// Hand-build a toplevel exercising the two migrated integration paths that @@ -478,7 +491,7 @@ mod tests { constrained: true, }; - Toplevel { functions: vec![f, g], memory_sizes: vec![1] } + with_singleton_circuits(vec![f, g], vec![1]) } #[test] diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index fe107ab10..cae5ed8eb 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -12,7 +12,7 @@ use rayon::{ use crate::{ FxIndexMap, G, - bytecode::{Block, Ctrl, Function, Op, Toplevel}, + bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel}, execute::{ IOBuffer, IOKeyInfo, QueryRecord, find_unconstrained_big_uint_div_mod, g_inverse_value, @@ -20,6 +20,7 @@ use crate::{ function_channel, gadgets::{bytes1::Bytes1, bytes2::Bytes2}, memory::Memory, + querymap::QueryRef, u8_add_channel, u8_and_channel, u8_bit_decomposition_channel, u8_chain_rotr4_channel, u8_chain_rotr7_channel, u8_less_than_channel, u8_mul_channel, u8_or_channel, u8_range_check_channel, u8_shift_left_channel, @@ -41,15 +42,23 @@ struct ColumnMutSlice<'a, 'b> { type Degree = u8; impl<'a, 'b> ColumnMutSlice<'a, 'b> { + /// Slice a circuit row into the regions of one member function: the + /// member's inputs are a prefix of the circuit's input block, its + /// selectors a sub-range of the circuit's selector block at `sel_offset`, + /// and the auxiliary block is shared by all members. fn from_slice( function: &Function, + circuit_layout: &FunctionLayout, + sel_offset: usize, slice: &'a mut [G], lookups: &'a mut LookupRowMut<'b, G>, ) -> Self { - let (inputs, slice) = slice.split_at_mut(function.layout.input_size); - let (selectors, slice) = slice.split_at_mut(function.layout.selectors); - let (auxiliaries, slice) = slice.split_at_mut(function.layout.auxiliaries); - assert!(slice.is_empty()); + let (inputs, slice) = slice.split_at_mut(circuit_layout.input_size); + let (selectors, auxiliaries) = slice.split_at_mut(circuit_layout.selectors); + assert_eq!(auxiliaries.len(), circuit_layout.auxiliaries); + let inputs = &mut inputs[..function.layout.input_size]; + let selectors = + &mut selectors[sel_offset..sel_offset + function.layout.selectors]; Self { inputs, selectors, auxiliaries, lookups } } @@ -78,22 +87,49 @@ struct TraceContext<'a> { query_record: &'a QueryRecord, } +/// One row of a circuit trace: the member function it belongs to, the +/// member's selector offset within the circuit, its function index, and the +/// recorded query. +struct RowMeta<'a> { + function: &'a Function, + sel_offset: usize, + function_index: G, + inputs: &'a [G], + result: QueryRef<'a>, +} + impl Toplevel { pub fn witness_data( &self, - function_index: usize, + circuit_index: usize, query_record: &QueryRecord, io_buffer: &IOBuffer, slot_arg_widths: &[usize], ) -> (RowMajorMatrix, LookupValues) { - let func = &self.functions[function_index]; - let width = func.width(); - let unfiltered_queries = &query_record.function_queries[function_index]; - let queries = unfiltered_queries - .iter() - .filter(|(_, res)| !res.multiplicity.is_zero()) - .collect::>(); - let height_no_padding = queries.len(); + let circuit = &self.circuits[circuit_index]; + let layout = &circuit.layout; + let width = layout.width(); + // Concatenate the members' queried rows, in member order. + let mut rows_meta = Vec::new(); + let mut sel_offset = 0; + for &member in &circuit.members { + let function = &self.functions[member]; + let function_index = G::from_usize(member); + rows_meta.extend( + query_record.function_queries[member] + .iter() + .filter(|(_, res)| !res.multiplicity.is_zero()) + .map(|(inputs, result)| RowMeta { + function, + sel_offset, + function_index, + inputs, + result, + }), + ); + sel_offset += function.layout.selectors; + } + let height_no_padding = rows_meta.len(); // An unqueried circuit yields an EMPTY trace (not a padded height-1 one): // the prover deactivates it, so it is neither committed nor opened. let height = if height_no_padding == 0 { @@ -112,21 +148,27 @@ impl Toplevel { .zip(row_writers[..height_no_padding].par_iter_mut()) .enumerate() .for_each(|(i, (row, lookups))| { - let (inputs, result) = queries[i]; + let meta = &rows_meta[i]; let index = &mut ColumnIndex { auxiliary: 0, // we skip the first lookup, which is reserved for return lookup: 1, }; - let slice = &mut ColumnMutSlice::from_slice(func, row, lookups); + let slice = &mut ColumnMutSlice::from_slice( + meta.function, + layout, + meta.sel_offset, + row, + lookups, + ); let context = TraceContext { - function_index: G::from_usize(function_index), - inputs, - multiplicity: result.multiplicity, - output: result.output, + function_index: meta.function_index, + inputs: meta.inputs, + multiplicity: meta.result.multiplicity, + output: meta.result.output, query_record, }; - func.populate_row(index, slice, context, io_buffer); + meta.function.populate_row(index, slice, context, io_buffer); }); drop(row_writers); let trace = RowMajorMatrix::new(rows, width); diff --git a/crates/ffi/src/aiur/toplevel.rs b/crates/ffi/src/aiur/toplevel.rs index 8ce24b31e..d557883d3 100644 --- a/crates/ffi/src/aiur/toplevel.rs +++ b/crates/ffi/src/aiur/toplevel.rs @@ -2,12 +2,15 @@ use multi_stark::p3_field::PrimeCharacteristicRing; use lean_ffi::object::{LeanBorrowed, LeanCtor, LeanRef}; +use crate::lean::LeanAiurCircuit; use crate::lean::LeanAiurFunction; use crate::lean::LeanAiurToplevel; use aiur::{ FxIndexMap, G, - bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel, ValIdx}, + bytecode::{ + Block, Circuit, Ctrl, Function, FunctionLayout, Op, Toplevel, ValIdx, + }, }; use crate::aiur::{lean_unbox_g, lean_unbox_nat_as_usize}; @@ -278,14 +281,23 @@ fn decode_function(ctor: LeanCtor>) -> Function { Function { body, layout, entry, constrained } } +fn decode_circuit(ctor: LeanCtor>) -> Circuit { + let ctor = LeanAiurCircuit::from_ctor(ctor); + // Object field 0 is the circuit's display name (`String`), unused here. + let members = ctor.get_obj(1).as_array().map(|x| lean_unbox_nat_as_usize(&x)); + let layout = decode_function_layout(ctor.get_obj(2).as_ctor()); + Circuit { members, layout } +} + pub(crate) fn decode_toplevel( obj: &LeanAiurToplevel, ) -> Toplevel { let ctor = obj.as_ctor(); - let [functions_obj, memory_sizes_obj] = ctor.objs::<2>(); + let [functions_obj, memory_sizes_obj, circuits_obj] = ctor.objs::<3>(); let functions = functions_obj.as_array().map(|o| decode_function(o.as_ctor())); let memory_sizes = memory_sizes_obj.as_array().map(|x| lean_unbox_nat_as_usize(&x)); - Toplevel { functions, memory_sizes } + let circuits = circuits_obj.as_array().map(|o| decode_circuit(o.as_ctor())); + Toplevel { functions, memory_sizes, circuits } } diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index e9040c66f..0cd5b9ed3 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -270,8 +270,9 @@ lean_ffi::lean_inductive! { // --- Aiur types --- - LeanAiurToplevel [ { num_obj: 2 } ]; + LeanAiurToplevel [ { num_obj: 3 } ]; LeanAiurFunction [ { num_obj: 2, num_8: 2 } ]; + LeanAiurCircuit [ { num_obj: 3 } ]; // Aiur FFI result structures (`Ix/Aiur/Semantics/BytecodeFfi.lean`, // `Ix/Aiur/Protocol.lean`). `IOBuffer` hashmaps cross the boundary as From 5cea07b20a38798d1f848ea40f8ba3eda4699f72 Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Mon, 3 Aug 2026 11:36:37 -0300 Subject: [PATCH 2/6] aiur: wire optional circuit-grouping application points (empty partitions) Route every site that compiles the IxVM kernel or the recursive-verifier toplevel for proving/verifying through `compileWithGroups` with a per-toplevel grouping datum (`IxVM.coldGroups`, `MultiStark.verifierColdGroups`) - CLI check/prove/verify, the ixvm test runner, the recursive-verifier tests, and the benches. `groupFunctions` resolves members by STRING name (the exact `toString` of the Global, the inverse of what statistics print, so measured groupings feed back verbatim). Both partitions start EMPTY, i.e. singleton circuits - behavior-identical to before; the data files are the single knob later commits turn. --- Benchmarks/RecursionDebug.lean | 6 +++--- Benchmarks/RecursiveVerifier.lean | 2 +- Benchmarks/Typecheck.lean | 4 ++-- Ix/Aiur/Compiler.lean | 15 +++++++++++++-- Ix/Cli/CheckCmd.lean | 6 +++--- Ix/Cli/ProveCmd.lean | 2 +- Ix/Cli/VerifyCmd.lean | 2 +- Ix/IxVM.lean | 1 + Ix/IxVM/ColdGroups.lean | 20 ++++++++++++++++++++ Ix/MultiStark.lean | 1 + Ix/MultiStark/VerifierColdGroups.lean | 20 ++++++++++++++++++++ Tests/Aiur/Aiur.lean | 4 ++-- Tests/Aiur/Common.lean | 2 +- Tests/Main.lean | 2 +- Tests/MultiStark.lean | 2 +- 15 files changed, 71 insertions(+), 18 deletions(-) create mode 100644 Ix/IxVM/ColdGroups.lean create mode 100644 Ix/MultiStark/VerifierColdGroups.lean diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean index 8bc203020..847c91ab2 100644 --- a/Benchmarks/RecursionDebug.lean +++ b/Benchmarks/RecursionDebug.lean @@ -70,7 +70,7 @@ def proveConst (ixePath constName : String) (skipDeps : Bool) -- production toplevel no longer carries. let .ok toplevel := (if skipDeps then IxVM.ixVMFull else IxVM.ixVM) | IO.eprintln "IxVM toplevel merge failed"; return none - let .ok compiled := toplevel.compile + let .ok compiled := toplevel.compileWithGroups IxVM.coldGroups | IO.eprintln "IxVM compile failed"; return none let entrypoint := if skipDeps then `verify_const else `verify_claim let some funIdx := compiled.getFuncIdx entrypoint @@ -153,7 +153,7 @@ def main (args : List String) : IO UInt32 := do -- `--list-funcs`: dump the compiled verifier's funIdx → name table (for -- decoding fun_idx stacks printed by the Rust bytecode interpreter). if args.contains "--list-funcs" then - let .ok vCompiled := vTop.compile + let .ok vCompiled := vTop.compileWithGroups MultiStark.verifierColdGroups | IO.eprintln "multi-stark verifier compile failed"; return 1 let entries := vCompiled.nameMap.toArray.qsort (·.2 < ·.2) for (g, i) in entries do @@ -187,7 +187,7 @@ def main (args : List String) : IO UInt32 := do IO.println s!"ACCEPTED in {secs t0 t1} s: {Aiur.Value.ppDeref s.store depth v}" return 0 else - let .ok vCompiled := vTop.compile + let .ok vCompiled := vTop.compileWithGroups MultiStark.verifierColdGroups | IO.eprintln "multi-stark verifier compile failed"; return 1 let some vIdx := vCompiled.getFuncIdx `verify_multi_stark_proof | IO.eprintln "verify_multi_stark_proof entrypoint missing"; return 1 diff --git a/Benchmarks/RecursiveVerifier.lean b/Benchmarks/RecursiveVerifier.lean index e99d1f618..ed4ab5e3d 100644 --- a/Benchmarks/RecursiveVerifier.lean +++ b/Benchmarks/RecursiveVerifier.lean @@ -147,7 +147,7 @@ def main (args : List String) : IO UInt32 := do let vTop ← match MultiStark.multiStark with | .ok t => pure t | .error e => IO.eprintln s!"verifier merge failed: {e}"; return 1 - let vCompiled ← match vTop.compile with + let vCompiled ← match vTop.compileWithGroups MultiStark.verifierColdGroups with | .ok c => pure c | .error e => IO.eprintln s!"verifier compile failed: {e}"; return 1 let vIdx := vCompiled.getFuncIdx `verify_multi_stark_proof |>.get! diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index 5d3e6edee..bebde57a2 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -329,7 +329,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do -- claim run, which is the honest reading of those numbers. let .ok toplevel := (if skipDeps then IxVM.ixVMFull else IxVM.ixVM) | throw (IO.userError "Merging IxVM kernel failed") - let .ok compiled := toplevel.compile + let .ok compiled := toplevel.compileWithGroups IxVM.coldGroups | throw (IO.userError "Compilation of IxVM kernel failed") let entrypoint := if skipDeps then `verify_const else `verify_claim let some funIdx := compiled.getFuncIdx entrypoint @@ -358,7 +358,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do if !recursive then pure none else do let .ok vTop := MultiStark.multiStark | throw (IO.userError "Merging multi-stark verifier failed") - let .ok vCompiled := vTop.compile + let .ok vCompiled := vTop.compileWithGroups MultiStark.verifierColdGroups | throw (IO.userError "Compilation of multi-stark verifier failed") let some vIdx := vCompiled.getFuncIdx `verify_multi_stark_proof | throw (IO.userError "verify_multi_stark_proof entrypoint missing") diff --git a/Ix/Aiur/Compiler.lean b/Ix/Aiur/Compiler.lean index 752b2a878..0fe32a89b 100644 --- a/Ix/Aiur/Compiler.lean +++ b/Ix/Aiur/Compiler.lean @@ -59,9 +59,14 @@ per absorbed member. Errors if a name is unknown, unconstrained (it has no circuit to group), an entry function, listed twice, or if a group is empty. -/ def CompiledToplevel.groupFunctions (ct : CompiledToplevel) - (groups : Array (String × Array Lean.Name)) : + (groups : Array (String × Array String)) : Except String CompiledToplevel := do let t := ct.bytecode + -- Function names as printed (`toString` of the `Global`), the exact + -- inverse of what statistics reports — so measured groupings can be fed + -- back verbatim. + let byName : Std.HashMap String Bytecode.FunIdx := + ct.nameMap.fold (init := {}) fun acc g i => acc.insert (toString g) i -- Resolve and validate the groups into member-index arrays. let mut grouped : Std.HashMap Bytecode.FunIdx Nat := {} let mut resolved : Array (String × Array Bytecode.FunIdx) := #[] @@ -70,7 +75,7 @@ def CompiledToplevel.groupFunctions (ct : CompiledToplevel) throw s!"group {gname} is empty" let mut members := #[] for name in names do - let some i := ct.getFuncIdx name + let some i := byName[name]? | throw s!"group {gname}: unknown function {name}" let f := t.functions[i]! unless f.constrained do @@ -204,6 +209,12 @@ def Source.Toplevel.compile (t : Source.Toplevel) : Except String CompiledToplev circuits := bytecode.singletonCircuits fun i => reverseMap[i]?.getD s!"" } pure (CompiledToplevel.mk t bytecode nameMap) +/-- `compile`, then apply a function grouping (see +`CompiledToplevel.groupFunctions`). -/ +def Source.Toplevel.compileWithGroups (t : Source.Toplevel) + (groups : Array (String × Array String)) : Except String CompiledToplevel := do + (← t.compile).groupFunctions groups + /-- Progress helper: given success of the three `Except`-returning stages, `compile` as a whole returns `.ok` (the remaining stages — `deduplicate`, `needsCircuit`, the field-setter `mapIdx`, the name-map `fold`, and the diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 565538782..ef6471162 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -656,7 +656,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do pure 1 pure go else do - let compiled ← match toplevel.compile with + let compiled ← match toplevel.compileWithGroups IxVM.coldGroups with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c let go (_ : Ix.Claim) (envHandle? : Option Aiur.EnvHandle) (target : Target) @@ -669,7 +669,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do return (← runShardCheckManifest manifest ixe k (fun c w l => runOne c none (.leanW w) l)) else do - let compiled ← match toplevel.compile with + let compiled ← match toplevel.compileWithGroups IxVM.coldGroups with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut useBytecode) @@ -678,7 +678,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) (fun c w l => runOne c none (.leanW w) l)) else do - let compiled ← match toplevel.compile with + let compiled ← match toplevel.compileWithGroups IxVM.coldGroups with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c return (← runShardManifestAllNative manifest ixe diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index a35609d9a..787853b36 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -146,7 +146,7 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let toplevel ← match IxVM.ixVM with | .error e => IO.eprintln s!"toplevel merging failed: {e}"; return 1 | .ok t => pure t - let compiled ← match toplevel.compile with + let compiled ← match toplevel.compileWithGroups IxVM.coldGroups with | .error e => IO.eprintln s!"compilation failed: {e}"; return 1 | .ok c => pure c let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index 381352579..c2262b0d6 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -73,7 +73,7 @@ def verifyOneProof (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledTople def buildBackend : IO (Except String (Aiur.AiurSystem × Aiur.CompiledToplevel)) := do match IxVM.ixVM with | .error e => return .error s!"toplevel merging failed: {e}" - | .ok toplevel => match toplevel.compile with + | .ok toplevel => match toplevel.compileWithGroups IxVM.coldGroups with | .error e => return .error s!"compilation failed: {e}" | .ok compiled => return .ok (Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters, compiled) diff --git a/Ix/IxVM.lean b/Ix/IxVM.lean index 45c6b898d..0add22904 100644 --- a/Ix/IxVM.lean +++ b/Ix/IxVM.lean @@ -1,6 +1,7 @@ module public import Ix.Aiur.Meta public import Ix.IxVM.Core +public import Ix.IxVM.ColdGroups public import Ix.IxVM.ByteStream public import Ix.IxVM.Blake3 public import Ix.IxVM.RBTreeMap diff --git a/Ix/IxVM/ColdGroups.lean b/Ix/IxVM/ColdGroups.lean new file mode 100644 index 000000000..328731478 --- /dev/null +++ b/Ix/IxVM/ColdGroups.lean @@ -0,0 +1,20 @@ +module + +/-! +Circuit-grouping data for the IxVM kernel toplevel, applied wherever the +kernel is compiled for proving or verifying (see +`CompiledToplevel.groupFunctions`). Empty = no grouping: every constrained +function keeps its singleton circuit. Fill from measured workload +statistics; a stale grouping stays sound (grouping never affects +semantics), only less efficient. +-/ + +public section + +namespace IxVM + +def coldGroups : Array (String × Array String) := #[] + +end IxVM + +end diff --git a/Ix/MultiStark.lean b/Ix/MultiStark.lean index c99114428..6881ad134 100644 --- a/Ix/MultiStark.lean +++ b/Ix/MultiStark.lean @@ -11,6 +11,7 @@ public import Ix.MultiStark.Keccak public import Ix.MultiStark.Pcs public import Ix.MultiStark.SystemDeserialize public import Ix.MultiStark.Verifier +public import Ix.MultiStark.VerifierColdGroups public import Ix.MultiStark.Tests /-! diff --git a/Ix/MultiStark/VerifierColdGroups.lean b/Ix/MultiStark/VerifierColdGroups.lean new file mode 100644 index 000000000..58359883b --- /dev/null +++ b/Ix/MultiStark/VerifierColdGroups.lean @@ -0,0 +1,20 @@ +module + +/-! +Circuit-grouping data for the recursive-verifier toplevel, applied wherever +it is compiled for proving or verifying (see +`CompiledToplevel.groupFunctions`). Empty = no grouping: every constrained +function keeps its singleton circuit. Fill from measured workload +statistics; a stale grouping stays sound (grouping never affects +semantics), only less efficient. +-/ + +public section + +namespace MultiStark + +def verifierColdGroups : Array (String × Array String) := #[] + +end MultiStark + +end diff --git a/Tests/Aiur/Aiur.lean b/Tests/Aiur/Aiur.lean index ea5be951b..93793782f 100644 --- a/Tests/Aiur/Aiur.lean +++ b/Tests/Aiur/Aiur.lean @@ -882,8 +882,8 @@ def aiurTestCases : List AiurTestCase := [ ] /-- The grouping the `aiur` runner applies for the grouped environment. -/ -def testGroups : Array (String × Array Lean.Name) := - #[("test_group", #[`grouped_double, `grouped_pick, `grouped_sum_range])] +def testGroups : Array (String × Array String) := + #[("test_group", #["grouped_double", "grouped_pick", "grouped_sum_range"])] def groupedTestCases : List AiurTestCase := [ .prove `calls_grouped #[0, 5, 9] #[25] diff --git a/Tests/Aiur/Common.lean b/Tests/Aiur/Common.lean index 701462489..39ffb9305 100644 --- a/Tests/Aiur/Common.lean +++ b/Tests/Aiur/Common.lean @@ -73,7 +73,7 @@ structure AiurTestEnv where shapes : Array Aiur.CircuitShape def AiurTestEnv.build (toplevelFn : Except Aiur.Global Aiur.Source.Toplevel) - (groups : Array (String × Array Lean.Name) := #[]) : + (groups : Array (String × Array String) := #[]) : Except String AiurTestEnv := do let toplevel ← toplevelFn.mapError toString let compiled ← toplevel.compile diff --git a/Tests/Main.lean b/Tests/Main.lean index 6c9fd82bc..41b1a36ab 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -182,7 +182,7 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ -- committed kernel system). let kernelUnitTests := .exec `kernel_unit_tests let serdeTest ← serdeNatAddComm env - match AiurTestEnv.build IxVM.ixVM, AiurTestEnv.build IxVM.ixVMFull with + match AiurTestEnv.build IxVM.ixVM IxVM.coldGroups, AiurTestEnv.build IxVM.ixVMFull with | .error e, _ | _, .error e => IO.eprintln s!"IxVM env build failed: {e}"; return 1 | .ok v2Env, .ok v2FullEnv => diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index c46b9477e..f59ded1ee 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -177,7 +177,7 @@ def endToEndSuite : IO UInt32 := do let vTop ← match MultiStark.multiStark with | .error e => IO.eprintln s!"verifier toplevel merge failed: {e}"; return 1 | .ok t => pure t - let vCompiled ← match vTop.compile with + let vCompiled ← match vTop.compileWithGroups MultiStark.verifierColdGroups with | .error e => IO.eprintln s!"verifier compilation failed: {e}"; return 1 | .ok c => pure c let vIdx ← match vCompiled.getFuncIdx `verify_multi_stark_proof with From 03cd9450d43079f469e10dbdcc4d9ec36af55bb6 Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Wed, 12 Aug 2026 12:12:04 -0300 Subject: [PATCH 3/6] stats: print circuit layout shape columns (TEMP - revert before merge) Add Sel/Aux/Lkp columns (the circuit layout's selectors, auxiliaries, lookups; zero for memory/gadget rows) to the per-circuit statistics table. Grouping instrumentation only: merging is cheapest between circuits whose auxiliaries and lookups are CLOSE (both merge by max, selectors sum), so these columns are what a partition builder needs next to the width. Meant to be reverted once the partitions are chosen - this commit is self-contained in Ix/Aiur/Statistics.lean. --- Ix/Aiur/Statistics.lean | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/Ix/Aiur/Statistics.lean b/Ix/Aiur/Statistics.lean index 095a1d2d8..05603516c 100644 --- a/Ix/Aiur/Statistics.lean +++ b/Ix/Aiur/Statistics.lean @@ -45,6 +45,13 @@ structure CircuitStats where /-- FFT cost at the uncached height `height + cacheHits` (fixed-height gadget circuits keep their normal cost). Feeds `totalUncachedFftCost`. -/ uncachedFftCost : Float + -- TEMP (grouping instrumentation, revert with this commit): the circuit + -- layout shape, for picking group members — merging is cheapest between + -- circuits whose auxiliaries and lookups are CLOSE (both merge by max; + -- selectors sum). Zero for memory/gadget circuits (no function layout). + selectors : Nat := 0 + auxiliaries : Nat := 0 + lookups : Nat := 0 structure ExecutionStats where circuits : Array CircuitStats @@ -102,7 +109,9 @@ def computeStats (compiled : CompiledToplevel) (queryCounts : Array QueryCount) let (h, hits) := c.members.foldl (init := (0, 0)) fun (h, hits) i => let qc := queryCounts[i]! (h + qc.uniqueRows, hits + (qc.totalHits - qc.uniqueRows)) - mkStats c.name shape h hits + { mkStats c.name shape h hits with + selectors := c.layout.selectors, auxiliaries := c.layout.auxiliaries, + lookups := c.layout.lookups } let memoryCircuits := t.memorySizes.mapIdx fun i size => let shape := shapes[t.circuits.size + i]! let qc := queryCounts[nAllFuns + i]! @@ -162,9 +171,14 @@ def printStats (stats : ExecutionStats) : IO Unit := do let n := f.round.toUInt64.toNat toString n let wFftCost := stats.circuits.foldl (fun m cs => Nat.max m (formatSci cs.fftCost).length) 8 + -- TEMP (grouping instrumentation, revert with this commit) + let wSel := stats.circuits.foldl (fun m cs => Nat.max m (toString cs.selectors).length) 3 + let wAux := stats.circuits.foldl (fun m cs => Nat.max m (toString cs.auxiliaries).length) 3 + let wLkp := stats.circuits.foldl (fun m cs => Nat.max m (toString cs.lookups).length) 3 let wPct := 7 let wCum := 7 - let totalW := wName + 1 + wWidth + 1 + wHeight + 1 + wHits + 1 + wFftCost + 1 + wPct + 1 + wCum + let totalW := wName + 1 + wWidth + 1 + wSel + 1 + wAux + 1 + wLkp + 1 + + wHeight + 1 + wHits + 1 + wFftCost + 1 + wPct + 1 + wCum let totalWidth := stats.circuits.foldl (· + ·.width) 0 let savedPct := if stats.totalUncachedFftCost == 0.0 then "0.00%" @@ -177,14 +191,14 @@ def printStats (stats : ExecutionStats) : IO Unit := do IO.println s!"Total cache hits: {stats.totalCacheHits}" IO.println s!"Total saved cost: {savedPct}" IO.println sep - IO.println s!"{padRight "Name" wName} {padLeft "Width" wWidth} {padLeft "Height" wHeight} {padLeft "Hits" wHits} {padLeft "FFT cost" wFftCost} {padLeft "%" wPct} {padLeft "%++" wCum}" + IO.println s!"{padRight "Name" wName} {padLeft "Width" wWidth} {padLeft "Sel" wSel} {padLeft "Aux" wAux} {padLeft "Lkp" wLkp} {padLeft "Height" wHeight} {padLeft "Hits" wHits} {padLeft "FFT cost" wFftCost} {padLeft "%" wPct} {padLeft "%++" wCum}" IO.println sep let mut cumFftCost : Float := 0.0 for cs in stats.circuits do cumFftCost := cumFftCost + cs.fftCost let pct := formatPercent cs.fftCost stats.totalFftCost let cum := formatPercent cumFftCost stats.totalFftCost - IO.println s!"{padRight cs.name wName} {padLeft (toString cs.width) wWidth} {padLeft (toString cs.height) wHeight} {padLeft (toString cs.cacheHits) wHits} {padLeft (formatSci cs.fftCost) wFftCost} {padLeft pct wPct} {padLeft cum wCum}" + IO.println s!"{padRight cs.name wName} {padLeft (toString cs.width) wWidth} {padLeft (toString cs.selectors) wSel} {padLeft (toString cs.auxiliaries) wAux} {padLeft (toString cs.lookups) wLkp} {padLeft (toString cs.height) wHeight} {padLeft (toString cs.cacheHits) wHits} {padLeft (formatSci cs.fftCost) wFftCost} {padLeft pct wPct} {padLeft cum wCum}" end Aiur From e768a95bbe4013818fc34ad89a96be6d37fc6857 Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Wed, 12 Aug 2026 12:39:46 -0300 Subject: [PATCH 4/6] ixvm: populate cold grouping by layout-shape proximity (730 -> 185) Fill IxVM.coldGroups with 85 bands over the 630 groupable cold circuits (<0.5% max FFT share across the Nat.add_comm / String.split / Array.extract_append execute workloads; verify_claim excluded as the entry). Bands cluster by SHAPE, not width: aux within 1.6x, lookups within max(2x, +4), summed selectors <= 40 per band - aux and lookups merge by max so mismatch is pure per-row waste, while selectors are the only additive term under this merge rule. Circuits 730 -> 185, total committed width 33,827 -> 16,311 (-52%). Measured FFT cost: +10.2% / +12.8% / +9.3% per workload (+10.3% summed; the shape model predicted +11.1%) - about half the damage the width-band partition took for its deeper 730 -> 76 cut. All 71 kernel-check pins and the shard aggregate (+6.2%) re-measured. ixvm (pins + parity), aiur-prove, multi-stark and recursive-verifier suites pass; fmt clean; no Rust change. --- Ix/IxVM/ColdGroups.lean | 803 +++++++++++++++++- Tests/Ix/IxVM.lean | 142 ++-- Tests/Main.lean | 4 +- cold-groups/kernel-band-summary.txt | 86 ++ cold-groups/kernel-bands-shape.json | 803 ++++++++++++++++++ cold-groups/kernel-shape-grouping.md | 117 +++ cold-groups/kstats-Array.extract_append.txt | 739 ++++++++++++++++ cold-groups/kstats-Nat.add_comm.txt | 739 ++++++++++++++++ cold-groups/kstats-String.split.txt | 739 ++++++++++++++++ .../kstats-grouped-Array.extract_append.txt | 194 +++++ cold-groups/kstats-grouped-Nat.add_comm.txt | 194 +++++ cold-groups/kstats-grouped-String.split.txt | 194 +++++ 12 files changed, 4680 insertions(+), 74 deletions(-) create mode 100644 cold-groups/kernel-band-summary.txt create mode 100644 cold-groups/kernel-bands-shape.json create mode 100644 cold-groups/kernel-shape-grouping.md create mode 100644 cold-groups/kstats-Array.extract_append.txt create mode 100644 cold-groups/kstats-Nat.add_comm.txt create mode 100644 cold-groups/kstats-String.split.txt create mode 100644 cold-groups/kstats-grouped-Array.extract_append.txt create mode 100644 cold-groups/kstats-grouped-Nat.add_comm.txt create mode 100644 cold-groups/kstats-grouped-String.split.txt diff --git a/Ix/IxVM/ColdGroups.lean b/Ix/IxVM/ColdGroups.lean index 328731478..ac33a9b7f 100644 --- a/Ix/IxVM/ColdGroups.lean +++ b/Ix/IxVM/ColdGroups.lean @@ -13,7 +13,808 @@ public section namespace IxVM -def coldGroups : Array (String × Array String) := #[] +def coldGroups : Array (String × Array String) := #[ + ("cold_shape_00", #[ + "canon_kind_ord", + "canon_sord_eq_strong", + "canon_sord_gt_strong", + "canon_sord_lt_strong", + "canon_sord_of_g", + "check_opt_bool", + "check_opt_u64", + "const_num_lvls", + "const_type_of", + "def_safety_tag", + "flatten_u64", + ]), + ("cold_shape_01", #[ + "pack_def_kind_safety", + "quot_kind_tag", + "unpack_def_kind_safety", + "check_opt_ctor_entries", + "check_opt_recr_rules", + ]), + ("cold_shape_02", #[ + "canon_ord_then", + "canon_sord_then", + "defn_is_unsafe_ci", + "delta_rank", + "is_unsafe_ci", + "lbr_dec", + "relaxed_u64_pred", + "relaxed_u64_succ", + ]), + ("cold_shape_03", #[ + "u64_eq", + "u64_is_zero", + "addr_set_member", + "assert_wire_bool", + "bit_vec_addr", + "bit_vec_of_nat_addr", + "bit_vec_to_nat_addr", + "bit_vec_ult_addr", + "bool_false_addr", + "bool_true_addr", + "bool_type_addr_dec", + "build_all_minors", + "build_all_motives", + "build_recur_addrs", + "byte_array_empty_addr", + "canon_addr_chunk", + "canon_cmp_kliteral", + "char_of_nat_addr", + "char_type_addr", + "check_parent_inductive_shape", + ]), + ("cold_shape_04", #[ + "decidable_decide_addr", + "decidable_is_false_addr_dec", + "decidable_is_true_addr_dec", + "decidable_rec_addr", + "eq_refl_addr_dec", + "fin_addr", + "int_dec_eq_addr_dec", + "int_dec_le_addr_dec", + "int_dec_lt_addr_dec", + "int_neg_succ_addr_dec", + "int_of_nat_addr_dec", + "k_is_def_eq_struct", + "klimbs_add", + "list_cons_addr", + "list_nil_addr", + "literal_eq", + "lt_lt_addr", + "mk_nat_lit", + "nat_add_addr", + "nat_addr_io", + "nat_beq_addr", + "nat_ble_addr", + "nat_dec_eq_addr_dec", + "nat_dec_le_addr_dec", + "nat_dec_lt_addr_dec", + "nat_div_addr", + "nat_eq_of_beq_eq_true_addr_dec", + "nat_gcd_addr", + "nat_land_addr", + "nat_le_of_ble_eq_true_addr_dec", + "nat_lor_addr", + "nat_mod_addr", + "nat_mul_addr", + "nat_ne_of_beq_eq_false_addr_dec", + "nat_not_le_of_not_ble_eq_true_addr_dec", + "nat_pow_addr", + "nat_pred_addr", + ]), + ("cold_shape_05", #[ + "nat_shift_left_addr", + "nat_shift_right_addr", + "nat_sub_addr", + "nat_succ_addr_iota", + "nat_xor_addr", + "nat_zero_addr", + "punit_addr", + "punit_size_of_1_addr", + "put_constant_info", + "put_quot_kind", + "quot_ctor_addr", + "quot_ind_addr", + "quot_lift_addr_iota", + "quot_type_addr", + "reduce_bool_addr", + "reduce_nat_addr", + "size_of_size_of_addr", + "str_addr", + "string_append_addr", + "string_back_addr", + "string_dec_eq_addr", + "string_legacy_back_addr", + "string_of_list_addr", + "string_to_byte_array_addr", + "string_utf8_byte_size_addr", + "subtype_val_addr", + "system_platform_get_num_bits_addr", + "system_platform_num_bits_addr", + "unit_addr", + "utf8_last_codepoint", + ]), + ("cold_shape_06", #[ + "check_param_agreement", + "is_defn_or_thm", + "assert_safety", + "build_ctor_app_params", + "extract_aux_spec_params_from_rec", + "is_rec_field", + "klimbs_div", + "klimbs_mod", + "check_opt_def_kind", + "check_opt_def_safety", + "check_opt_quot_kind", + "convert_axiom", + "convert_quotient", + "has_bvar_in_range_binder", + "k_check", + "klimbs_mul", + "list_reverse.G", + "put_definition_proj", + "put_mut_const", + "run_contains", + "utf8_cont", + "check_inductive_shape", + ]), + ("cold_shape_07", #[ + "get_opt_addr_masked", + "get_opt_bool_masked", + "get_opt_def_kind_masked", + "get_opt_quot_kind_masked", + "list_is_empty.U8", + "defn_member_recur_addrs", + "expr_inst1_bvar", + "k_is_def_eq_ordered", + "klimbs_shl_limbs", + "klimbs_sub", + "put_u64_le", + "try_unfold_head", + "env_walk_leaves", + "expr_glb_binder", + "has_bvar_in_range_let", + "k_infer", + ]), + ("cold_shape_08", #[ + "k_infer_lit", + "klimbs_dec", + "klimbs_gcd", + "mk_nat_literal_64", + "mk_nat_one", + "put_constructor_proj", + "validate_univ_params_list", + "get_opt_addr", + "list_lookup_or_default.Ptr.U8_32", + "nl_add_const", + "read_byte", + "apply_indices_in_conclusion", + "apply_n_projs", + "build_apply_field_bvars", + "build_apply_xs", + "build_major_params", + "build_motive_apps", + "build_param_lvls_range", + "build_rec_lvls_list", + "canon_ctor_ctx_entries", + "check_prop_field_if_prop", + ]), + ("cold_shape_09", #[ + "expr_lower", + "mk_bool", + "np_whnf_inner_bv", + "peel_leading_foralls", + "unfold_a_and_loop", + "unfold_b_and_loop", + "check_positivity", + "expr_inst1_let", + "expr_inst_many_let", + "expr_lift_let", + "klimbs_shl", + "klimbs_shr", + "leaf_hash", + "level_equal", + "count_foralls_body", + "expr_inst_levels", + "level_offset_of", + "skip_bytes", + "canon_all_singleton", + "canon_flatten", + "canon_ins_sort", + "canon_refine_one", + ]), + ("cold_shape_10", #[ + "check_field_universes", + "check_rec_rules_wellscoped", + "convert_definition", + "ctx_next_cut", + "level_max_subsumes", + "list_reverse_acc.G", + "put_address_list", + "utf8_validate", + "wrap_foralls", + "wrap_lams", + "check_positivity_fields", + "check_quot", + "env_walk_refs", + "put_tag0", + "put_tag2", + ]), + ("cold_shape_11", #[ + "put_tag4", + "try_proof_irrel", + "walk_refs_transitive", + "convert_constructor", + "convert_inductive", + "expr_glb_let", + "node_hash", + "rbtree_map_insert.G", + "check_native_nat", + "count_foralls_at_least", + "level_explicit_val", + "list_length.KRecRule", + "peel_n_foralls", + "rbtree_map_balance.G", + "se_peel_tol", + "addr_list_contains", + "all_bvars_in_args", + ]), + ("cold_shape_12", #[ + "char_lit_codepoint", + "check_field_universes_skip_params", + "is_large_eliminator", + "is_nat_zero", + "k_ensure_sort", + "k_is_def_eq_slow", + "level_is_not_zero", + "list_any_mentions_block", + "list_concat.Tup.Ptr.U8_32.G", + "list_take.Ptr.KExprNode", + "se_addr_in", + "str_lit_to_ctor_app_or_self", + ]), + ("cold_shape_13", #[ + "utf8_last_go", + "apply_spec_params_lifted", + "canon_cmp_member_ctx", + "canon_group_consec", + "canon_refine_classes", + "check_no_dep_data_field_if_prop", + "compare_struct_fields", + "const_idxs_exprs", + "level_inst_params", + "level_list_inst", + "level_reduce", + "list_lift_each", + "list_lift_indices", + "nl_subsumption_walk", + "whnf_spine", + ]), + ("cold_shape_14", #[ + "const_idxs_of", + "k_is_def_eq", + "try_unit_like", + "canon_cmp_klimbs", + "expr_lbr_let", + "mk_nat_binop_stuck", + "replace_spine_major", + ]), + ("cold_shape_15", #[ + "list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode", + "assert_lvls_are_params", + "canon_ctx_class_idx", + "canon_g_list_eq", + "check_large_prop_ctor", + "glist_eq_len", + "peel_leading_foralls_acc", + "se_scan_fields", + "try_prim_dispatch", + "canon_build_ctx_classes", + "canon_cmp_krec_rule_ctx", + "get_expr_let", + "nl_le_vars", + ]), + ("cold_shape_16", #[ + "normalize_aux", + "try_string_lit_one", + "canon_ctx_cmp_addr", + "canon_sort_loop", + "check_field_universes_inner", + "intern_int_lit", + "spec_params_lower", + "try_quot_iota", + "unfold_both_and_loop", + "convert_recursor", + "assert_first_args_are_param_bvars", + "assert_occ_param_bvars", + "head_addr", + "list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode", + ]), + ("cold_shape_17", #[ + "peel_n_foralls_with_types", + "check_rec_major_spine", + "get_result_sort_level", + "io_peel_field_loop", + "level_list_struct_eq", + "peel_motive_params_subst", + "peel_n_alls_whnf", + "spec_params_ptr_eq", + "try_extract_nat", + "whnf_get_ctor_or_none", + "expr_inst_levels_walk", + ]), + ("cold_shape_18", #[ + "is_inductive_prop", + "k_is_def_eq_slow_nd", + "level_leq", + "peel_field_loop", + "level_normalize", + "u64_and", + "u64_or", + "u64_xor_kbits", + ]), + ("cold_shape_19", #[ + "find_rule", + "args_contain_bvar", + "peel_n_lams_collect", + "build_peer_recs", + "canon_classes_eq", + "de_args", + "expr_mentions_block", + ]), + ("cold_shape_20", #[ + "lazy_delta_loop", + "level_eq", + "level_list_eq", + "canon_cmp_bytes", + ]), + ("cold_shape_21", #[ + "canon_cmp_kuniv", + "canon_cmp_kuniv_list", + "extract_aux_spec_params", + "idx_to_u64", + "normalize_imax_dispatch", + "spec_params_dom_prefix_match", + "check_native_bool", + ]), + ("cold_shape_22", #[ + "is_bitvec_prim_addr", + "is_int_dec_prim_addr", + "lazy_delta_both_proj", + "whnf_nd_apply_beta", + "canonical_rules_at_pos", + "mk_nat_offset_stuck", + ]), + ("cold_shape_23", #[ + "get_opt_u64_masked", + "flat_find_pos", + "put_refs", + "put_sharing", + "put_univs", + "try_eta_swap", + "aux_already_in", + "is_prop_type", + "level_struct_eq", + "nl_skip_empty", + "peel_params_subst", + ]), + ("cold_shape_24", #[ + "se_mentions", + "whnf_nd_with_spine", + "nl_covers_var", + "parse_atree_body", + "try_extract_nat_app", + "try_unfold_proj_app", + "klimbs_from_g", + "get_inductive_proj", + "list_length.U8_8", + "canon_cmp_kexpr_ctx", + "ensure_sort_only", + ]), + ("cold_shape_25", #[ + "flat_member_at", + "rec_to_parent_addr", + "check_param_agreement_go", + "k_is_def_eq_struct_safe", + "nl_le", + "nlvars_eq", + ]), + ("cold_shape_26", #[ + "build_char_list", + "build_motive_type_flat", + "k_def_eq_rebase", + "klimbs_pow", + ]), + ("cold_shape_27", #[ + "get_opt_ctor_entry_list_masked", + "get_opt_rule_list_masked", + "klimbs_is_zero", + "klimbs_le", + "list_snoc.U8_8", + "put_u64_list", + "convert_univ", + "se_parent_addr", + ]), + ("cold_shape_28", #[ + "kexpr_struct_eq", + "level_imax", + "lbr_max", + "lbr_min", + ]), + ("cold_shape_29", #[ + "level_max_go", + "memo_u32_less_than", + "bitvec_of_nat_args_direct", + "glimbs_to_klimbs", + "quot_extract_arg", + "bv_to_nat_via", + "nl_add_var", + "check_ctor_return_type", + ]), + ("cold_shape_30", #[ + "canon_member_num_ctors", + "put_recursor_rule_list", + "run_check", + "get_axiom", + "extract_aux_occ_us", + "whnf", + "whnf_nd", + ]), + ("cold_shape_31", #[ + "canon_ord_cmp_g", + "put_constant", + "walk_fields_classify", + "check_large_walk_fields", + "expr_lift_bvar", + "dec_dispatch_le_eq", + "nat_lit_to_ctor_or_self", + "try_eta_expand", + "klimbs_div_mod", + "dec_rewrite_lt_to_le", + ]), + ("cold_shape_32", #[ + "assert_return_head_is_parent", + "caddr_is_peer", + "canon_member_ci", + "check_eq_type", + "check_muts_member_at", + "const_idxs_rules", + "flat_find_matching", + "get_quotient", + "put_univ_list", + "get_address_list", + "get_all_telescope", + "get_expr_list", + "get_lam_telescope", + "collect_index_doms", + "compute_iprj_addr", + "k_is_def_eq_core", + ]), + ("cold_shape_33", #[ + "bitvec_prep_spine", + "build_rule_rhs", + ]), + ("cold_shape_34", #[ + "addr_set_build", + "struct_is_rec", + "convert_rec_rules", + "run_check_env", + "collect_n_doms_whnf", + "convert_univ_idxs", + "is_rec_field_peel", + "klimbs_mul_outer", + "try_def_eq_nat", + "peel_ctor_params_subst", + "validate_univ_params_seen", + ]), + ("cold_shape_35", #[ + "bitvec_prep_spine_ult", + "ctx_seek_cut", + "normalize_int_dec_rebuild", + "canon_cmp_u64_lex", + "u64_add", + "u64_sub_with_borrow", + ]), + ("cold_shape_36", #[ + "flat_find_pos_kind", + "canon_cmp_krec_rule_list_ctx", + "check_valid_ind_app", + "level_max", + "subst_param_for", + "try_match_nat_add", + "check_inductive_shape_ctors", + "ctor_subst_param_for", + "ctx_close_cut", + ]), + ("cold_shape_37", #[ + "get_definition", + "populate_rules", + "char_lit_codepoint_syn", + "try_def_eq_app", + "level_max_offsets", + "nl_eq", + "try_k_synth_iota", + ]), + ("cold_shape_38", #[ + "univ_succ_base", + "struct_scan_ctors", + "build_minor_doms", + ]), + ("cold_shape_39", #[ + "cleanup_nat_offset_major", + "nlvars_any_offset_geq", + "nlvars_dominates", + "nlvars_max_offset", + "ctx_trim", + "is_dec_prim_addr", + "is_native_prim_addr", + "try_nat_offset_dispatch", + ]), + ("cold_shape_40", #[ + "bytes_to_u64_limb", + "list_length_u64.Ptr.Univ", + "build_rec_type", + "build_succ_chain", + ]), + ("cold_shape_41", #[ + "check_nested_ctors_positivity", + "try_extract_int", + "k_is_def_eq_slow2", + "check_const", + ]), + ("cold_shape_42", #[ + "get_constructor_proj", + "put_recursor_rule", + ]), + ("cold_shape_43", #[ + "expr_addr", + "put_axiom", + "put_quotient", + "get_u64_list", + "put_univ", + "delta_unfold", + ]), + ("cold_shape_44", #[ + "nl_add_const_go", + "try_quot_ind", + "try_quot_lift", + "walk_char_list_bytes", + "is_str_prim_addr", + ]), + ("cold_shape_45", #[ + "get_tag0", + "get_tag2", + "klimbs_eq", + "klimbs_succ", + "collect_spine_of_ctor", + "whnf_nd_const_head", + "compute_k_target", + "canon_cprj_addr", + ]), + ("cold_shape_46", #[ + "nat_offset_of", + "projection_addr_ctor", + "projection_definition_info", + "canon_cmp_ctor_pair_ctx", + "try_bitvec_dispatch", + ]), + ("cold_shape_47", #[ + "ctors_before_pos", + "put_expr_list", + "build_flat_own_params", + "canon_cmp_klimbs_tail", + "get_recursor_rule_list", + "get_univ_list", + "build_all_minors_walk", + "build_all_motives_walk", + "lazy_delta_a_const_b_proj", + "lazy_delta_b_const_a_proj", + "whnf_iota_major", + ]), + ("cold_shape_48", #[ + "nl_covers_const", + "canon_build_ctx_members", + "check_recursor_member", + "try_nat_binop_dispatch", + "try_reduce_bit_vec_ult", + "build_ih_doms", + ]), + ("cold_shape_49", #[ + "klimbs_normalize", + "put_constructor", + ]), + ("cold_shape_50", #[ + "is_nat_succ_ih_step", + "try_normalize_int_decidable", + "try_reduce_subtype_val", + "try_str_to_byte_array", + "try_dec_dispatch", + ]), + ("cold_shape_51", #[ + "try_nat_linear_rec", + "try_str_back", + ]), + ("cold_shape_52", #[ + "rbtree_map_lookup_or_default.G", + "whnf_nd_proj_head", + "whnf_proj_head", + "bytes_to_limbs", + "has_bvar_in_range", + "try_str_dec_eq", + "try_reduce_size_of_unit", + ]), + ("cold_shape_53", #[ + "build_rec_type_from", + "k_synth_gate", + "dec_build_proof", + "apply_ihs_full", + ]), + ("cold_shape_54", #[ + "klimbs_land", + "klimbs_lor", + "klimbs_xor_op", + ]), + ("cold_shape_55", #[ + "str_lit_delta_step", + "glist_ordered_insert", + "try_nat_dispatch_prewhnf", + ]), + ("cold_shape_56", #[ + "glist_cmp", + "glist_subset", + "utf8_decode_one", + "dec_finish", + ]), + ("cold_shape_57", #[ + "verify_bytes_against", + "get_univ", + ]), + ("cold_shape_58", #[ + "canon_insert_sorted", + "bytes_to_addr", + "is_unit_like_type", + ]), + ("cold_shape_59", #[ + "canon_cmp_ctor_range_ctx", + "put_inductive", + ]), + ("cold_shape_60", #[ + "all_telescope_count", + "app_telescope_count", + "lam_telescope_count", + "check_ctor_entry", + ]), + ("cold_shape_61", #[ + "canon_group_walk", + "check_positivity_aug", + ]), + ("cold_shape_62", #[ + "put_recursor", + "canon_cmp_member_same_kind_ctx", + "try_native_dispatch", + ]), + ("cold_shape_63", #[ + "count_ctors", + "put_constructor_list", + "put_all_telescope", + "put_app_telescope", + "put_lam_telescope", + "check_recr_rules", + ]), + ("cold_shape_64", #[ + "try_lazy_delta_app", + "rbtree_map_ins.G", + "k_infer_proj", + "try_struct_eta_iota", + ]), + ("cold_shape_65", #[ + "klimbs_add_carry", + "get_constructor", + "klimbs_sub_borrow", + "put_definition", + ]), + ("cold_shape_66", #[ + "str_dec_eq_build", + "nlvars_add", + "try_nat_binop_addr", + ]), + ("cold_shape_67", #[ + "get_mut_const", + "check_muts_all", + "get_constructor_list", + ]), + ("cold_shape_68", #[ + "try_eta_struct", + "run_reveal", + ]), + ("cold_shape_69", #[ + "is_muts_block", + "detect_aux_from_recrs_ex", + "find_peer_recursor_with_spec", + "muts_indc_count_is_one", + "canon_indc_positions", + "put_mut_const_list", + ]), + ("cold_shape_70", #[ + "canon_muts_has_kind", + "get_ctor_entry", + "check_ctor_entries", + "build_recur_addrs_walk", + ]), + ("cold_shape_71", #[ + "check_block_peer_param_agreement", + "ind_is_solo", + "struct_block_member_addrs", + "list_length_u64.Constructor", + "const_idxs_muts", + ]), + ("cold_shape_72", #[ + "run_check_transitive", + "env_walk", + ]), + ("cold_shape_73", #[ + "get_mut_const_list", + "put_expr", + ]), + ("cold_shape_74", #[ + "prim_family", + "lazy_delta_step_const_const", + ]), + ("cold_shape_75", #[ + "check_opt_addr", + "get_mut_entry", + ]), + ("cold_shape_76", #[ + "address_eq_tail", + "check_opt_expr_addr", + "get_ci", + ]), + ("cold_shape_77", #[ + "flat_originals_walk", + "get_recursor", + "peer_agree_walk", + "run_claim", + ]), + ("cold_shape_78", #[ + "try_reduce_decide_bitvec_lt", + "check_canonical_block", + ]), + ("cold_shape_79", #[ + "get_mut_entry_list_inner", + "first_recr_parent_block", + "list_lookup_u64.Constructor", + ]), + ("cold_shape_80", #[ + "load_assumption_tree", + "find_peer_rec_spec_walk", + ]), + ("cold_shape_81", #[ + "aux_from_recrs_walk_ex", + "get_reveal_info", + "get_reveal_mut_const_info", + ]), + ("cold_shape_82", #[ + "get_address", + "utf8_encode_prepend", + ]), + ("cold_shape_83", #[ + "list_lookup_u64.MutConst", + "projection_addr", + "get_ci_iprj", + "get_ci_rprj", + "get_ci_dprj", + "check_muts_components", + ]), + ("cold_shape_84", #[ + "blake3_next_layer", + "get_constant", + "get_ci_cprj", + "blake3_finish", + ]), +] end IxVM diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index fcb66cb39..b596bf112 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -276,77 +276,77 @@ private def nameOfString (str : String) : Lean.Name := listed constant fails the suite, so a regression cannot land quietly and an improvement has to be acknowledged by re-pinning. -/ private def kernelCheckEntries : List (String × Nat) := [ - ("HEq", 129_468_104), - ("HEq.rec", 132_906_026), - ("Eq.rec", 132_478_828), - ("Nat", 129_465_234), - ("Nat.add", 165_101_768), - ("Nat.add_comm", 292_233_964), - ("Nat.decEq", 341_688_609), - ("Nat.decLe", 732_649_143), - ("Nat.sub_le_of_le_add", 1_793_179_373), - ("Nat.shiftRight_succ", 1_331_066_612), - ("Trans.mk", 134_728_178), - ("Array.append_assoc", 8_622_658_358), - ("Vector.append", 8_832_851_736), - ("IxVMPrim.nat_add_lit", 205_724_339), - ("IxVMPrim.nat_sub_lit", 222_270_629), - ("IxVMPrim.nat_mul_lit", 197_332_156), - ("IxVMPrim.nat_mul_big", 195_705_843), - ("IxVMPrim.nat_div_lit", 1_300_339_885), - ("IxVMPrim.nat_mod_lit", 1_325_741_257), - ("IxVMPrim.nat_succ_lit", 143_973_320), - ("IxVMPrim.nat_pred_lit", 165_092_837), - ("IxVMPrim.nat_gcd_lit", 2_077_835_172), - ("IxVMPrim.nat_land_lit", 3_392_593_650), - ("IxVMPrim.nat_lor_lit", 3_394_992_980), - ("IxVMPrim.nat_xor_lit", 3_414_869_484), - ("IxVMPrim.nat_shl_lit", 225_040_363), - ("IxVMPrim.nat_shr_lit", 1_315_348_247), - ("IxVMPrim.nat_pow_big", 386_936_789), - ("IxVMPrim.nat_beq_lit", 195_521_462), - ("IxVMPrim.nat_ble_lit", 190_279_372), - ("IxVMPrim.nat_cases_big", 164_636_470), - ("IxVMPrim.nat_dec_le", 750_956_369), - ("IxVMPrim.nat_dec_lt", 762_189_408), - ("IxVMPrim.nat_dec_eq", 380_458_982), - ("IxVMPrim.str_size_lit", 2_388_927_980), - ("IxVMPrim.bv_to_nat_lit", 1_978_174_861), - ("IxVMInd.Even", 199_959_069), - ("IxVMInd.Odd", 199_961_684), - ("IxVMInd.Even.rec", 217_262_251), - ("IxVMInd.Odd.rec", 217_263_174), - ("IxVMInd.Tree", 130_857_345), - ("IxVMInd.Tree.rec", 139_889_786), - ("IxVMInd.DedupM", 134_173_839), - ("IxVMInd.DedupM.rec", 146_300_644), - ("IxVMInd.DepthM", 132_567_341), - ("IxVMInd.DepthM.rec", 142_699_828), - ("String.Internal.append", 2_360_689_108), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_499_089_916), - ("Lean.Syntax.rec", 2_415_335_613), - ("IxVMInd.AuxTie", 315_165_566), - ("IxVMInd.AuxTie.rec", 353_876_276), - ("IxVMInd.HiddenIdx", 130_050_254), - ("IxVMInd.HiddenIdx.rec", 132_543_931), - ("IxVMInd.thmMajorUse", 488_836_722), - ("IxVMInd.partialKRec", 149_911_108), - ("IxVMInd.deepRebase", 208_423_967), - ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec", 3_305_647_446), - ("Lean.Widget.TaggedText.rec", 2_384_562_452), - ("Lean.Doc.Part.rec", 2_425_540_913), - ("Lean.Doc.Block.rec", 2_582_167_982), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_244_429), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 135_209_335), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 134_204_496), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 134_204_496), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 134_204_496), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_442_751), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 142_670_108), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 142_669_322), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 134_204_496), - ("strOfListFoldSize", 2_677_189_647), - ("strOfListFoldSizeAscii", 2_678_115_796), + ("HEq", 129_678_983), + ("HEq.rec", 134_241_101), + ("Eq.rec", 133_581_016), + ("Nat", 129_672_949), + ("Nat.add", 173_617_348), + ("Nat.add_comm", 321_971_743), + ("Nat.decEq", 383_643_343), + ("Nat.decLe", 845_605_659), + ("Nat.sub_le_of_le_add", 2_075_355_953), + ("Nat.shiftRight_succ", 1_543_426_285), + ("Trans.mk", 137_383_223), + ("Array.append_assoc", 10_255_769_663), + ("Vector.append", 10_489_258_989), + ("IxVMPrim.nat_add_lit", 220_356_452), + ("IxVMPrim.nat_sub_lit", 239_014_330), + ("IxVMPrim.nat_mul_lit", 209_777_728), + ("IxVMPrim.nat_mul_big", 208_100_370), + ("IxVMPrim.nat_div_lit", 1_508_368_244), + ("IxVMPrim.nat_mod_lit", 1_538_202_876), + ("IxVMPrim.nat_succ_lit", 146_059_227), + ("IxVMPrim.nat_pred_lit", 170_592_080), + ("IxVMPrim.nat_gcd_lit", 2_408_943_875), + ("IxVMPrim.nat_land_lit", 3_899_609_280), + ("IxVMPrim.nat_lor_lit", 3_902_101_711), + ("IxVMPrim.nat_xor_lit", 3_923_979_646), + ("IxVMPrim.nat_shl_lit", 241_746_873), + ("IxVMPrim.nat_shr_lit", 1_524_446_380), + ("IxVMPrim.nat_pow_big", 696_489_969), + ("IxVMPrim.nat_beq_lit", 208_369_156), + ("IxVMPrim.nat_ble_lit", 202_201_769), + ("IxVMPrim.nat_cases_big", 170_304_869), + ("IxVMPrim.nat_dec_le", 865_930_198), + ("IxVMPrim.nat_dec_lt", 878_858_550), + ("IxVMPrim.nat_dec_eq", 428_043_949), + ("IxVMPrim.str_size_lit", 2_762_853_095), + ("IxVMPrim.bv_to_nat_lit", 2_291_375_200), + ("IxVMInd.Even", 213_875_569), + ("IxVMInd.Odd", 213_878_185), + ("IxVMInd.Even.rec", 234_816_859), + ("IxVMInd.Odd.rec", 234_817_781), + ("IxVMInd.Tree", 131_412_608), + ("IxVMInd.Tree.rec", 142_646_628), + ("IxVMInd.DedupM", 134_965_622), + ("IxVMInd.DedupM.rec", 150_065_976), + ("IxVMInd.DepthM", 133_250_401), + ("IxVMInd.DepthM.rec", 145_837_235), + ("String.Internal.append", 2_731_341_529), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 4_054_424_603), + ("Lean.Syntax.rec", 2_795_742_005), + ("IxVMInd.AuxTie", 342_459_468), + ("IxVMInd.AuxTie.rec", 389_232_383), + ("IxVMInd.HiddenIdx", 130_335_222), + ("IxVMInd.HiddenIdx.rec", 133_643_799), + ("IxVMInd.thmMajorUse", 559_678_932), + ("IxVMInd.partialKRec", 153_670_282), + ("IxVMInd.deepRebase", 223_487_467), + ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec", 3_808_635_812), + ("Lean.Widget.TaggedText.rec", 2_761_031_456), + ("Lean.Doc.Part.rec", 2_812_240_373), + ("Lean.Doc.Block.rec", 2_998_866_393), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_902_791), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 136_599_727), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 135_785_543), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 135_785_543), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 135_785_543), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 133_168_061), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 145_843_978), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 145_843_191), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 135_785_543), + ("strOfListFoldSize", 3_088_094_493), + ("strOfListFoldSizeAscii", 3_089_043_625), ] /-- Variant of `kernelChecks`, pinned to the baseline diff --git a/Tests/Main.lean b/Tests/Main.lean index 41b1a36ab..e2874a5fa 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -233,8 +233,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ let actual := (Aiur.computeStats v2Env.compiled qc v2Env.shapes).totalFftCost.round.toUInt64.toNat pure (LSpec.test - s!"Shard pipeline FFT matches: expected 7332697739, got {actual}" - (actual = 7_332_697_739)) + s!"Shard pipeline FFT matches: expected 7785690777, got {actual}" + (actual = 7_785_690_777)) LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []), diff --git a/cold-groups/kernel-band-summary.txt b/cold-groups/kernel-band-summary.txt new file mode 100644 index 000000000..b09ec6bea --- /dev/null +++ b/cold-groups/kernel-band-summary.txt @@ -0,0 +1,86 @@ +band n Wg aux-range lkp-range ungrouped grouped + 0 11 60 1..1 1..1 3.15e+07 1.28e+08 + 1 6 68 1..1 1..2 2.70e+03 2.36e+04 + 2 8 60 2..2 1..1 4.44e+07 1.13e+08 + 3 20 66 2..2 1..2 3.91e+07 1.07e+08 + 4 37 54 2..2 2..2 7.61e+05 3.96e+06 + 5 30 96 2..2 2..2 5.92e+05 1.34e+06 + 6 22 94 2..3 1..4 3.45e+08 2.25e+09 + 7 16 70 4..4 2..4 8.90e+08 4.46e+09 + 8 21 75 4..5 3..4 6.31e+06 3.21e+07 + 9 22 64 5..6 3..5 6.77e+08 2.08e+09 + 10 15 77 6..6 4..5 3.88e+07 1.87e+08 + 11 17 102 6..7 2..6 9.51e+07 4.10e+08 + 12 12 74 7..7 4..4 9.56e+08 3.40e+09 + 13 15 84 7..7 4..5 3.05e+08 1.14e+09 + 14 7 89 7..7 6..7 5.59e+08 1.84e+09 + 15 13 68 8..8 3..5 8.11e+08 1.88e+09 + 16 14 119 8..9 4..8 1.79e+08 8.41e+08 + 17 11 71 9..9 4..6 2.36e+08 5.62e+08 + 18 8 61 9..9 6..9 8.95e+07 1.86e+08 + 19 7 64 10..10 3..5 2.26e+08 4.75e+08 + 20 4 56 10..10 5..6 1.88e+07 3.31e+07 + 21 7 71 10..10 6..7 7.12e+04 1.66e+05 + 22 6 71 10..10 7..9 6.85e+07 1.54e+08 + 23 11 66 11..11 2..5 1.30e+07 3.43e+07 + 24 11 74 11..12 3..7 4.80e+08 1.14e+09 + 25 6 60 12..12 5..6 7.62e+07 1.23e+08 + 26 4 57 12..12 9..11 1.86e+08 2.54e+08 + 27 8 58 13..13 3..5 1.58e+05 4.64e+05 + 28 4 71 13..13 6..7 1.47e+07 3.64e+07 + 29 8 74 13..13 7..12 7.04e+06 2.08e+07 + 30 7 64 14..14 2..6 9.02e+08 1.67e+09 + 31 10 131 14..14 7..13 7.90e+07 2.71e+08 + 32 16 114 15..15 4..8 1.02e+09 3.32e+09 + 33 2 60 15..15 10..12 1.01e+05 1.68e+05 + 34 11 75 16..16 4..8 2.36e+07 5.08e+07 + 35 6 80 16..16 10..16 1.87e+08 3.61e+08 + 36 9 83 17..17 5..10 1.74e+08 3.50e+08 + 37 7 91 18..18 6..12 2.80e+08 5.64e+08 + 38 3 60 19..19 3..7 2.79e+05 4.18e+05 + 39 8 91 19..19 8..14 5.49e+08 1.11e+09 + 40 4 67 20..20 3..5 5.17e+05 9.55e+05 + 41 4 92 20..20 9..15 5.75e+07 9.80e+07 + 42 2 45 21..21 4..4 2.16e+05 3.58e+05 + 43 6 65 22..22 5..7 3.52e+08 4.94e+08 + 44 5 86 22..22 12..15 3.34e+06 5.11e+06 + 45 8 89 23..23 5..9 5.31e+08 1.23e+09 + 46 5 109 23..23 9..15 5.13e+07 1.10e+08 + 47 11 93 24..24 5..9 1.39e+08 2.67e+08 + 48 6 105 24..24 12..20 3.02e+06 5.81e+06 + 49 2 85 25..25 7..8 4.04e+04 9.05e+04 + 50 5 90 26..26 10..16 5.31e+06 9.25e+06 + 51 2 79 27..27 17..17 4.48e+08 4.84e+08 + 52 7 113 28..29 9..16 3.12e+08 6.26e+08 + 53 4 115 29..30 14..26 2.26e+06 4.07e+06 + 54 3 58 31..31 6..6 1.18e+03 2.32e+03 + 55 3 95 31..31 10..20 1.14e+07 1.39e+07 + 56 4 105 32..32 16..22 3.84e+06 6.92e+06 + 57 2 88 33..33 2..6 1.69e+07 2.47e+07 + 58 3 67 33..34 3..7 1.30e+06 2.05e+06 + 59 2 89 34..34 8..10 0.00e+00 0.00e+00 + 60 4 111 35..35 4..8 0.00e+00 0.00e+00 + 61 2 82 35..35 9..15 9.32e+05 1.12e+06 + 62 3 149 36..37 12..23 3.49e+03 8.65e+03 + 63 6 86 38..39 3..6 3.74e+05 7.28e+05 + 64 4 104 39..39 10..16 6.87e+07 8.85e+07 + 65 4 88 41..42 7..8 5.49e+05 1.14e+06 + 66 3 144 43..44 23..35 2.61e+05 4.21e+05 + 67 3 80 48..48 3..6 2.30e+06 3.62e+06 + 68 2 153 48..49 11..14 9.26e+07 1.63e+08 + 69 6 82 50..50 2..4 7.95e+05 1.51e+06 + 70 4 80 51..51 3..5 1.85e+06 2.72e+06 + 71 5 99 52..53 4..7 1.03e+06 1.92e+06 + 72 2 109 55..58 6..8 1.50e+07 2.27e+07 + 73 2 112 59..59 6..8 1.06e+06 1.58e+06 + 74 2 173 59..60 22..37 1.01e+07 1.41e+07 + 75 2 81 65..65 3..3 0.00e+00 0.00e+00 + 76 3 107 66..68 3..7 1.89e+07 2.42e+07 + 77 4 145 68..71 8..11 1.90e+06 3.59e+06 + 78 2 171 72..75 20..40 3.50e+06 5.07e+06 + 79 3 118 77..80 5..8 0.00e+00 0.00e+00 + 80 2 132 84..85 6..12 0.00e+00 0.00e+00 + 81 3 152 90..90 14..14 0.00e+00 0.00e+00 + 82 2 213 98..100 34..51 3.27e+08 5.40e+08 + 83 6 153 102..110 5..9 1.47e+06 2.35e+06 + 84 4 259 136..151 5..9 9.91e+07 1.72e+08 diff --git a/cold-groups/kernel-bands-shape.json b/cold-groups/kernel-bands-shape.json new file mode 100644 index 000000000..740d11ba5 --- /dev/null +++ b/cold-groups/kernel-bands-shape.json @@ -0,0 +1,803 @@ +[ +[ +"canon_kind_ord", +"canon_sord_eq_strong", +"canon_sord_gt_strong", +"canon_sord_lt_strong", +"canon_sord_of_g", +"check_opt_bool", +"check_opt_u64", +"const_num_lvls", +"const_type_of", +"def_safety_tag", +"flatten_u64" +], +[ +"pack_def_kind_safety", +"quot_kind_tag", +"unpack_def_kind_safety", +"check_opt_ctor_entries", +"check_opt_recr_rules", +"verify_claim" +], +[ +"canon_ord_then", +"canon_sord_then", +"defn_is_unsafe_ci", +"delta_rank", +"is_unsafe_ci", +"lbr_dec", +"relaxed_u64_pred", +"relaxed_u64_succ" +], +[ +"u64_eq", +"u64_is_zero", +"addr_set_member", +"assert_wire_bool", +"bit_vec_addr", +"bit_vec_of_nat_addr", +"bit_vec_to_nat_addr", +"bit_vec_ult_addr", +"bool_false_addr", +"bool_true_addr", +"bool_type_addr_dec", +"build_all_minors", +"build_all_motives", +"build_recur_addrs", +"byte_array_empty_addr", +"canon_addr_chunk", +"canon_cmp_kliteral", +"char_of_nat_addr", +"char_type_addr", +"check_parent_inductive_shape" +], +[ +"decidable_decide_addr", +"decidable_is_false_addr_dec", +"decidable_is_true_addr_dec", +"decidable_rec_addr", +"eq_refl_addr_dec", +"fin_addr", +"int_dec_eq_addr_dec", +"int_dec_le_addr_dec", +"int_dec_lt_addr_dec", +"int_neg_succ_addr_dec", +"int_of_nat_addr_dec", +"k_is_def_eq_struct", +"klimbs_add", +"list_cons_addr", +"list_nil_addr", +"literal_eq", +"lt_lt_addr", +"mk_nat_lit", +"nat_add_addr", +"nat_addr_io", +"nat_beq_addr", +"nat_ble_addr", +"nat_dec_eq_addr_dec", +"nat_dec_le_addr_dec", +"nat_dec_lt_addr_dec", +"nat_div_addr", +"nat_eq_of_beq_eq_true_addr_dec", +"nat_gcd_addr", +"nat_land_addr", +"nat_le_of_ble_eq_true_addr_dec", +"nat_lor_addr", +"nat_mod_addr", +"nat_mul_addr", +"nat_ne_of_beq_eq_false_addr_dec", +"nat_not_le_of_not_ble_eq_true_addr_dec", +"nat_pow_addr", +"nat_pred_addr" +], +[ +"nat_shift_left_addr", +"nat_shift_right_addr", +"nat_sub_addr", +"nat_succ_addr_iota", +"nat_xor_addr", +"nat_zero_addr", +"punit_addr", +"punit_size_of_1_addr", +"put_constant_info", +"put_quot_kind", +"quot_ctor_addr", +"quot_ind_addr", +"quot_lift_addr_iota", +"quot_type_addr", +"reduce_bool_addr", +"reduce_nat_addr", +"size_of_size_of_addr", +"str_addr", +"string_append_addr", +"string_back_addr", +"string_dec_eq_addr", +"string_legacy_back_addr", +"string_of_list_addr", +"string_to_byte_array_addr", +"string_utf8_byte_size_addr", +"subtype_val_addr", +"system_platform_get_num_bits_addr", +"system_platform_num_bits_addr", +"unit_addr", +"utf8_last_codepoint" +], +[ +"check_param_agreement", +"is_defn_or_thm", +"assert_safety", +"build_ctor_app_params", +"extract_aux_spec_params_from_rec", +"is_rec_field", +"klimbs_div", +"klimbs_mod", +"check_opt_def_kind", +"check_opt_def_safety", +"check_opt_quot_kind", +"convert_axiom", +"convert_quotient", +"has_bvar_in_range_binder", +"k_check", +"klimbs_mul", +"list_reverse.G", +"put_definition_proj", +"put_mut_const", +"run_contains", +"utf8_cont", +"check_inductive_shape" +], +[ +"get_opt_addr_masked", +"get_opt_bool_masked", +"get_opt_def_kind_masked", +"get_opt_quot_kind_masked", +"list_is_empty.U8", +"defn_member_recur_addrs", +"expr_inst1_bvar", +"k_is_def_eq_ordered", +"klimbs_shl_limbs", +"klimbs_sub", +"put_u64_le", +"try_unfold_head", +"env_walk_leaves", +"expr_glb_binder", +"has_bvar_in_range_let", +"k_infer" +], +[ +"k_infer_lit", +"klimbs_dec", +"klimbs_gcd", +"mk_nat_literal_64", +"mk_nat_one", +"put_constructor_proj", +"validate_univ_params_list", +"get_opt_addr", +"list_lookup_or_default.Ptr.U8_32", +"nl_add_const", +"read_byte", +"apply_indices_in_conclusion", +"apply_n_projs", +"build_apply_field_bvars", +"build_apply_xs", +"build_major_params", +"build_motive_apps", +"build_param_lvls_range", +"build_rec_lvls_list", +"canon_ctor_ctx_entries", +"check_prop_field_if_prop" +], +[ +"expr_lower", +"mk_bool", +"np_whnf_inner_bv", +"peel_leading_foralls", +"unfold_a_and_loop", +"unfold_b_and_loop", +"check_positivity", +"expr_inst1_let", +"expr_inst_many_let", +"expr_lift_let", +"klimbs_shl", +"klimbs_shr", +"leaf_hash", +"level_equal", +"count_foralls_body", +"expr_inst_levels", +"level_offset_of", +"skip_bytes", +"canon_all_singleton", +"canon_flatten", +"canon_ins_sort", +"canon_refine_one" +], +[ +"check_field_universes", +"check_rec_rules_wellscoped", +"convert_definition", +"ctx_next_cut", +"level_max_subsumes", +"list_reverse_acc.G", +"put_address_list", +"utf8_validate", +"wrap_foralls", +"wrap_lams", +"check_positivity_fields", +"check_quot", +"env_walk_refs", +"put_tag0", +"put_tag2" +], +[ +"put_tag4", +"try_proof_irrel", +"walk_refs_transitive", +"convert_constructor", +"convert_inductive", +"expr_glb_let", +"node_hash", +"rbtree_map_insert.G", +"check_native_nat", +"count_foralls_at_least", +"level_explicit_val", +"list_length.KRecRule", +"peel_n_foralls", +"rbtree_map_balance.G", +"se_peel_tol", +"addr_list_contains", +"all_bvars_in_args" +], +[ +"char_lit_codepoint", +"check_field_universes_skip_params", +"is_large_eliminator", +"is_nat_zero", +"k_ensure_sort", +"k_is_def_eq_slow", +"level_is_not_zero", +"list_any_mentions_block", +"list_concat.Tup.Ptr.U8_32.G", +"list_take.Ptr.KExprNode", +"se_addr_in", +"str_lit_to_ctor_app_or_self" +], +[ +"utf8_last_go", +"apply_spec_params_lifted", +"canon_cmp_member_ctx", +"canon_group_consec", +"canon_refine_classes", +"check_no_dep_data_field_if_prop", +"compare_struct_fields", +"const_idxs_exprs", +"level_inst_params", +"level_list_inst", +"level_reduce", +"list_lift_each", +"list_lift_indices", +"nl_subsumption_walk", +"whnf_spine" +], +[ +"const_idxs_of", +"k_is_def_eq", +"try_unit_like", +"canon_cmp_klimbs", +"expr_lbr_let", +"mk_nat_binop_stuck", +"replace_spine_major" +], +[ +"list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode", +"assert_lvls_are_params", +"canon_ctx_class_idx", +"canon_g_list_eq", +"check_large_prop_ctor", +"glist_eq_len", +"peel_leading_foralls_acc", +"se_scan_fields", +"try_prim_dispatch", +"canon_build_ctx_classes", +"canon_cmp_krec_rule_ctx", +"get_expr_let", +"nl_le_vars" +], +[ +"normalize_aux", +"try_string_lit_one", +"canon_ctx_cmp_addr", +"canon_sort_loop", +"check_field_universes_inner", +"intern_int_lit", +"spec_params_lower", +"try_quot_iota", +"unfold_both_and_loop", +"convert_recursor", +"assert_first_args_are_param_bvars", +"assert_occ_param_bvars", +"head_addr", +"list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode" +], +[ +"peel_n_foralls_with_types", +"check_rec_major_spine", +"get_result_sort_level", +"io_peel_field_loop", +"level_list_struct_eq", +"peel_motive_params_subst", +"peel_n_alls_whnf", +"spec_params_ptr_eq", +"try_extract_nat", +"whnf_get_ctor_or_none", +"expr_inst_levels_walk" +], +[ +"is_inductive_prop", +"k_is_def_eq_slow_nd", +"level_leq", +"peel_field_loop", +"level_normalize", +"u64_and", +"u64_or", +"u64_xor_kbits" +], +[ +"find_rule", +"args_contain_bvar", +"peel_n_lams_collect", +"build_peer_recs", +"canon_classes_eq", +"de_args", +"expr_mentions_block" +], +[ +"lazy_delta_loop", +"level_eq", +"level_list_eq", +"canon_cmp_bytes" +], +[ +"canon_cmp_kuniv", +"canon_cmp_kuniv_list", +"extract_aux_spec_params", +"idx_to_u64", +"normalize_imax_dispatch", +"spec_params_dom_prefix_match", +"check_native_bool" +], +[ +"is_bitvec_prim_addr", +"is_int_dec_prim_addr", +"lazy_delta_both_proj", +"whnf_nd_apply_beta", +"canonical_rules_at_pos", +"mk_nat_offset_stuck" +], +[ +"get_opt_u64_masked", +"flat_find_pos", +"put_refs", +"put_sharing", +"put_univs", +"try_eta_swap", +"aux_already_in", +"is_prop_type", +"level_struct_eq", +"nl_skip_empty", +"peel_params_subst" +], +[ +"se_mentions", +"whnf_nd_with_spine", +"nl_covers_var", +"parse_atree_body", +"try_extract_nat_app", +"try_unfold_proj_app", +"klimbs_from_g", +"get_inductive_proj", +"list_length.U8_8", +"canon_cmp_kexpr_ctx", +"ensure_sort_only" +], +[ +"flat_member_at", +"rec_to_parent_addr", +"check_param_agreement_go", +"k_is_def_eq_struct_safe", +"nl_le", +"nlvars_eq" +], +[ +"build_char_list", +"build_motive_type_flat", +"k_def_eq_rebase", +"klimbs_pow" +], +[ +"get_opt_ctor_entry_list_masked", +"get_opt_rule_list_masked", +"klimbs_is_zero", +"klimbs_le", +"list_snoc.U8_8", +"put_u64_list", +"convert_univ", +"se_parent_addr" +], +[ +"kexpr_struct_eq", +"level_imax", +"lbr_max", +"lbr_min" +], +[ +"level_max_go", +"memo_u32_less_than", +"bitvec_of_nat_args_direct", +"glimbs_to_klimbs", +"quot_extract_arg", +"bv_to_nat_via", +"nl_add_var", +"check_ctor_return_type" +], +[ +"canon_member_num_ctors", +"put_recursor_rule_list", +"run_check", +"get_axiom", +"extract_aux_occ_us", +"whnf", +"whnf_nd" +], +[ +"canon_ord_cmp_g", +"put_constant", +"walk_fields_classify", +"check_large_walk_fields", +"expr_lift_bvar", +"dec_dispatch_le_eq", +"nat_lit_to_ctor_or_self", +"try_eta_expand", +"klimbs_div_mod", +"dec_rewrite_lt_to_le" +], +[ +"assert_return_head_is_parent", +"caddr_is_peer", +"canon_member_ci", +"check_eq_type", +"check_muts_member_at", +"const_idxs_rules", +"flat_find_matching", +"get_quotient", +"put_univ_list", +"get_address_list", +"get_all_telescope", +"get_expr_list", +"get_lam_telescope", +"collect_index_doms", +"compute_iprj_addr", +"k_is_def_eq_core" +], +[ +"bitvec_prep_spine", +"build_rule_rhs" +], +[ +"addr_set_build", +"struct_is_rec", +"convert_rec_rules", +"run_check_env", +"collect_n_doms_whnf", +"convert_univ_idxs", +"is_rec_field_peel", +"klimbs_mul_outer", +"try_def_eq_nat", +"peel_ctor_params_subst", +"validate_univ_params_seen" +], +[ +"bitvec_prep_spine_ult", +"ctx_seek_cut", +"normalize_int_dec_rebuild", +"canon_cmp_u64_lex", +"u64_add", +"u64_sub_with_borrow" +], +[ +"flat_find_pos_kind", +"canon_cmp_krec_rule_list_ctx", +"check_valid_ind_app", +"level_max", +"subst_param_for", +"try_match_nat_add", +"check_inductive_shape_ctors", +"ctor_subst_param_for", +"ctx_close_cut" +], +[ +"get_definition", +"populate_rules", +"char_lit_codepoint_syn", +"try_def_eq_app", +"level_max_offsets", +"nl_eq", +"try_k_synth_iota" +], +[ +"univ_succ_base", +"struct_scan_ctors", +"build_minor_doms" +], +[ +"cleanup_nat_offset_major", +"nlvars_any_offset_geq", +"nlvars_dominates", +"nlvars_max_offset", +"ctx_trim", +"is_dec_prim_addr", +"is_native_prim_addr", +"try_nat_offset_dispatch" +], +[ +"bytes_to_u64_limb", +"list_length_u64.Ptr.Univ", +"build_rec_type", +"build_succ_chain" +], +[ +"check_nested_ctors_positivity", +"try_extract_int", +"k_is_def_eq_slow2", +"check_const" +], +[ +"get_constructor_proj", +"put_recursor_rule" +], +[ +"expr_addr", +"put_axiom", +"put_quotient", +"get_u64_list", +"put_univ", +"delta_unfold" +], +[ +"nl_add_const_go", +"try_quot_ind", +"try_quot_lift", +"walk_char_list_bytes", +"is_str_prim_addr" +], +[ +"get_tag0", +"get_tag2", +"klimbs_eq", +"klimbs_succ", +"collect_spine_of_ctor", +"whnf_nd_const_head", +"compute_k_target", +"canon_cprj_addr" +], +[ +"nat_offset_of", +"projection_addr_ctor", +"projection_definition_info", +"canon_cmp_ctor_pair_ctx", +"try_bitvec_dispatch" +], +[ +"ctors_before_pos", +"put_expr_list", +"build_flat_own_params", +"canon_cmp_klimbs_tail", +"get_recursor_rule_list", +"get_univ_list", +"build_all_minors_walk", +"build_all_motives_walk", +"lazy_delta_a_const_b_proj", +"lazy_delta_b_const_a_proj", +"whnf_iota_major" +], +[ +"nl_covers_const", +"canon_build_ctx_members", +"check_recursor_member", +"try_nat_binop_dispatch", +"try_reduce_bit_vec_ult", +"build_ih_doms" +], +[ +"klimbs_normalize", +"put_constructor" +], +[ +"is_nat_succ_ih_step", +"try_normalize_int_decidable", +"try_reduce_subtype_val", +"try_str_to_byte_array", +"try_dec_dispatch" +], +[ +"try_nat_linear_rec", +"try_str_back" +], +[ +"rbtree_map_lookup_or_default.G", +"whnf_nd_proj_head", +"whnf_proj_head", +"bytes_to_limbs", +"has_bvar_in_range", +"try_str_dec_eq", +"try_reduce_size_of_unit" +], +[ +"build_rec_type_from", +"k_synth_gate", +"dec_build_proof", +"apply_ihs_full" +], +[ +"klimbs_land", +"klimbs_lor", +"klimbs_xor_op" +], +[ +"str_lit_delta_step", +"glist_ordered_insert", +"try_nat_dispatch_prewhnf" +], +[ +"glist_cmp", +"glist_subset", +"utf8_decode_one", +"dec_finish" +], +[ +"verify_bytes_against", +"get_univ" +], +[ +"canon_insert_sorted", +"bytes_to_addr", +"is_unit_like_type" +], +[ +"canon_cmp_ctor_range_ctx", +"put_inductive" +], +[ +"all_telescope_count", +"app_telescope_count", +"lam_telescope_count", +"check_ctor_entry" +], +[ +"canon_group_walk", +"check_positivity_aug" +], +[ +"put_recursor", +"canon_cmp_member_same_kind_ctx", +"try_native_dispatch" +], +[ +"count_ctors", +"put_constructor_list", +"put_all_telescope", +"put_app_telescope", +"put_lam_telescope", +"check_recr_rules" +], +[ +"try_lazy_delta_app", +"rbtree_map_ins.G", +"k_infer_proj", +"try_struct_eta_iota" +], +[ +"klimbs_add_carry", +"get_constructor", +"klimbs_sub_borrow", +"put_definition" +], +[ +"str_dec_eq_build", +"nlvars_add", +"try_nat_binop_addr" +], +[ +"get_mut_const", +"check_muts_all", +"get_constructor_list" +], +[ +"try_eta_struct", +"run_reveal" +], +[ +"is_muts_block", +"detect_aux_from_recrs_ex", +"find_peer_recursor_with_spec", +"muts_indc_count_is_one", +"canon_indc_positions", +"put_mut_const_list" +], +[ +"canon_muts_has_kind", +"get_ctor_entry", +"check_ctor_entries", +"build_recur_addrs_walk" +], +[ +"check_block_peer_param_agreement", +"ind_is_solo", +"struct_block_member_addrs", +"list_length_u64.Constructor", +"const_idxs_muts" +], +[ +"run_check_transitive", +"env_walk" +], +[ +"get_mut_const_list", +"put_expr" +], +[ +"prim_family", +"lazy_delta_step_const_const" +], +[ +"check_opt_addr", +"get_mut_entry" +], +[ +"address_eq_tail", +"check_opt_expr_addr", +"get_ci" +], +[ +"flat_originals_walk", +"get_recursor", +"peer_agree_walk", +"run_claim" +], +[ +"try_reduce_decide_bitvec_lt", +"check_canonical_block" +], +[ +"get_mut_entry_list_inner", +"first_recr_parent_block", +"list_lookup_u64.Constructor" +], +[ +"load_assumption_tree", +"find_peer_rec_spec_walk" +], +[ +"aux_from_recrs_walk_ex", +"get_reveal_info", +"get_reveal_mut_const_info" +], +[ +"get_address", +"utf8_encode_prepend" +], +[ +"list_lookup_u64.MutConst", +"projection_addr", +"get_ci_iprj", +"get_ci_rprj", +"get_ci_dprj", +"check_muts_components" +], +[ +"blake3_next_layer", +"get_constant", +"get_ci_cprj", +"blake3_finish" +] +] \ No newline at end of file diff --git a/cold-groups/kernel-shape-grouping.md b/cold-groups/kernel-shape-grouping.md new file mode 100644 index 000000000..d8f47132b --- /dev/null +++ b/cold-groups/kernel-shape-grouping.md @@ -0,0 +1,117 @@ +# Kernel cold-circuit grouping by layout shape (2026-08-12, old merge rule) + +Method state: summed selectors, max aux, max lookups; groups chain lookups at +k = 1 (branchless singletons k = 2). Workloads: execute-only `ix check --ixe +InitStd.ixe` over Nat.add_comm / String.split / Array.extract_append, with the +TEMP Sel/Aux/Lkp stats columns. + +## Heuristic +Cold = <0.5% max FFT share across the three workloads (670 of 710 function +circuits). Cluster cold circuits by SHAPE PROXIMITY, not width: a band admits a +member while max(aux) <= 1.6 * min(aux), max(lkp) <= max(2 * min(lkp), min + 4), +and the summed selectors stay <= 40 (selectors sum under this merge rule, so +band size is capped by selector mass, not member count). Rationale: aux and +lookups merge by MAX, so mismatch = pure per-row waste; selectors are the only +additive width term. verify_claim is excluded (entry functions cannot group +under this rule). + +## Result: 85 bands over 630 circuits +- circuits 730 -> 185, total committed width 33,827 -> 16,311 (-52%) +- measured FFT cost: Nat.add_comm +10.2%, String.split +12.8%, + Array.extract_append +9.3% (summed +10.3%; the shape model predicted +11.1%) +- for comparison, the width-band partition (new method, 15 bands, 730 -> 76) + cost +17-27% on the same workloads: shape proximity buys the circuit-count + win at roughly HALF the FFT damage, at the price of more surviving circuits +## Per-band summary (model) +``` +band n Wg aux-range lkp-range ungrouped grouped + 0 11 60 1..1 1..1 3.15e+07 1.28e+08 + 1 6 68 1..1 1..2 2.70e+03 2.36e+04 + 2 8 60 2..2 1..1 4.44e+07 1.13e+08 + 3 20 66 2..2 1..2 3.91e+07 1.07e+08 + 4 37 54 2..2 2..2 7.61e+05 3.96e+06 + 5 30 96 2..2 2..2 5.92e+05 1.34e+06 + 6 22 94 2..3 1..4 3.45e+08 2.25e+09 + 7 16 70 4..4 2..4 8.90e+08 4.46e+09 + 8 21 75 4..5 3..4 6.31e+06 3.21e+07 + 9 22 64 5..6 3..5 6.77e+08 2.08e+09 + 10 15 77 6..6 4..5 3.88e+07 1.87e+08 + 11 17 102 6..7 2..6 9.51e+07 4.10e+08 + 12 12 74 7..7 4..4 9.56e+08 3.40e+09 + 13 15 84 7..7 4..5 3.05e+08 1.14e+09 + 14 7 89 7..7 6..7 5.59e+08 1.84e+09 + 15 13 68 8..8 3..5 8.11e+08 1.88e+09 + 16 14 119 8..9 4..8 1.79e+08 8.41e+08 + 17 11 71 9..9 4..6 2.36e+08 5.62e+08 + 18 8 61 9..9 6..9 8.95e+07 1.86e+08 + 19 7 64 10..10 3..5 2.26e+08 4.75e+08 + 20 4 56 10..10 5..6 1.88e+07 3.31e+07 + 21 7 71 10..10 6..7 7.12e+04 1.66e+05 + 22 6 71 10..10 7..9 6.85e+07 1.54e+08 + 23 11 66 11..11 2..5 1.30e+07 3.43e+07 + 24 11 74 11..12 3..7 4.80e+08 1.14e+09 + 25 6 60 12..12 5..6 7.62e+07 1.23e+08 + 26 4 57 12..12 9..11 1.86e+08 2.54e+08 + 27 8 58 13..13 3..5 1.58e+05 4.64e+05 + 28 4 71 13..13 6..7 1.47e+07 3.64e+07 + 29 8 74 13..13 7..12 7.04e+06 2.08e+07 + 30 7 64 14..14 2..6 9.02e+08 1.67e+09 + 31 10 131 14..14 7..13 7.90e+07 2.71e+08 + 32 16 114 15..15 4..8 1.02e+09 3.32e+09 + 33 2 60 15..15 10..12 1.01e+05 1.68e+05 + 34 11 75 16..16 4..8 2.36e+07 5.08e+07 + 35 6 80 16..16 10..16 1.87e+08 3.61e+08 + 36 9 83 17..17 5..10 1.74e+08 3.50e+08 + 37 7 91 18..18 6..12 2.80e+08 5.64e+08 + 38 3 60 19..19 3..7 2.79e+05 4.18e+05 + 39 8 91 19..19 8..14 5.49e+08 1.11e+09 + 40 4 67 20..20 3..5 5.17e+05 9.55e+05 + 41 4 92 20..20 9..15 5.75e+07 9.80e+07 + 42 2 45 21..21 4..4 2.16e+05 3.58e+05 + 43 6 65 22..22 5..7 3.52e+08 4.94e+08 + 44 5 86 22..22 12..15 3.34e+06 5.11e+06 + 45 8 89 23..23 5..9 5.31e+08 1.23e+09 + 46 5 109 23..23 9..15 5.13e+07 1.10e+08 + 47 11 93 24..24 5..9 1.39e+08 2.67e+08 + 48 6 105 24..24 12..20 3.02e+06 5.81e+06 + 49 2 85 25..25 7..8 4.04e+04 9.05e+04 + 50 5 90 26..26 10..16 5.31e+06 9.25e+06 + 51 2 79 27..27 17..17 4.48e+08 4.84e+08 + 52 7 113 28..29 9..16 3.12e+08 6.26e+08 + 53 4 115 29..30 14..26 2.26e+06 4.07e+06 + 54 3 58 31..31 6..6 1.18e+03 2.32e+03 + 55 3 95 31..31 10..20 1.14e+07 1.39e+07 + 56 4 105 32..32 16..22 3.84e+06 6.92e+06 + 57 2 88 33..33 2..6 1.69e+07 2.47e+07 + 58 3 67 33..34 3..7 1.30e+06 2.05e+06 + 59 2 89 34..34 8..10 0.00e+00 0.00e+00 + 60 4 111 35..35 4..8 0.00e+00 0.00e+00 + 61 2 82 35..35 9..15 9.32e+05 1.12e+06 + 62 3 149 36..37 12..23 3.49e+03 8.65e+03 + 63 6 86 38..39 3..6 3.74e+05 7.28e+05 + 64 4 104 39..39 10..16 6.87e+07 8.85e+07 + 65 4 88 41..42 7..8 5.49e+05 1.14e+06 + 66 3 144 43..44 23..35 2.61e+05 4.21e+05 + 67 3 80 48..48 3..6 2.30e+06 3.62e+06 + 68 2 153 48..49 11..14 9.26e+07 1.63e+08 + 69 6 82 50..50 2..4 7.95e+05 1.51e+06 + 70 4 80 51..51 3..5 1.85e+06 2.72e+06 + 71 5 99 52..53 4..7 1.03e+06 1.92e+06 + 72 2 109 55..58 6..8 1.50e+07 2.27e+07 + 73 2 112 59..59 6..8 1.06e+06 1.58e+06 + 74 2 173 59..60 22..37 1.01e+07 1.41e+07 + 75 2 81 65..65 3..3 0.00e+00 0.00e+00 + 76 3 107 66..68 3..7 1.89e+07 2.42e+07 + 77 4 145 68..71 8..11 1.90e+06 3.59e+06 + 78 2 171 72..75 20..40 3.50e+06 5.07e+06 + 79 3 118 77..80 5..8 0.00e+00 0.00e+00 + 80 2 132 84..85 6..12 0.00e+00 0.00e+00 + 81 3 152 90..90 14..14 0.00e+00 0.00e+00 + 82 2 213 98..100 34..51 3.27e+08 5.40e+08 + 83 6 153 102..110 5..9 1.47e+06 2.35e+06 + 84 4 259 136..151 5..9 9.91e+07 1.72e+08 +``` + +## Files +- `kernel-bands-shape.json` — the 85 bands (member lists, before verify_claim removal) +- `kstats-.txt` / `kstats-grouped-.txt` — per-circuit stats with Sel/Aux/Lkp \ No newline at end of file diff --git a/cold-groups/kstats-Array.extract_append.txt b/cold-groups/kstats-Array.extract_append.txt new file mode 100644 index 000000000..a4e2098ab --- /dev/null +++ b/cold-groups/kstats-Array.extract_append.txt @@ -0,0 +1,739 @@ +=== Circuit Statistics === +Circuits: 730 +Total width: 33827 +Total FFT cost: 141656951881 (1.42e11) +Total cache hits: 72393508 +Total saved cost: 56.09% +---------------------------------------------------------------------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +---------------------------------------------------------------------------------------------------------------------------------------------- +expr_inst_many_walk 34 9 8 5 5471753 0 2.10e10 14.84% 14.84% +expr_inst_many 21 2 4 4 6975351 1584350 1.69e10 11.93% 26.77% +blake3_compress_inner_j 1192 1 561 497 151585 0 1.56e10 10.98% 37.75% +memory[3] 12 0 0 0 6181533 17946311 8.59e9 6.06% 43.81% +list_snoc.G 22 2 6 4 2593801 881702 6.17e9 4.36% 48.17% +peel_beta 32 3 12 5 1637758 10634 5.47e9 3.86% 52.03% +list_drop.Ptr.Expr 20 2 6 3 2151895 1151414 4.60e9 3.25% 55.28% +blake3_compress_chunks 29 3 7 4 1288914 0 3.84e9 2.71% 57.99% +whnf_with_spine 34 6 11 5 1108779 14944 3.82e9 2.70% 60.69% +expr_inst_many_bvar 24 2 5 5 1528825 0 3.82e9 2.70% 63.39% +list_concat.Ptr.KExprNode 22 2 6 4 1505977 731709 3.45e9 2.44% 65.83% +expr_lbr 35 9 9 6 870475 9468745 3.04e9 2.14% 67.97% +collect_spine 23 2 8 4 1199012 836589 2.83e9 2.00% 69.97% +k_infer_app_spine_loop 59 8 21 11 470161 506 2.63e9 1.86% 71.83% +memory[4] 13 0 0 0 1735873 17182092 2.40e9 1.70% 73.52% +list_lookup.Ptr.KLevelNode 16 1 5 3 1364948 403575 2.27e9 1.61% 75.13% +list_length.Ptr.KExprNode 18 2 5 3 1166659 2680089 2.16e9 1.52% 76.65% +get_expr 50 12 23 5 391929 17 1.83e9 1.30% 77.95% +whnf_const_head 77 16 32 10 246268 0 1.71e9 1.20% 79.15% +blake3_compress 1080 1 929 40 21655 14 1.68e9 1.19% 80.34% +convert_expr 60 12 25 7 292994 154982 1.61e9 1.13% 81.47% +get_tag4 37 2 22 4 393551 0 1.37e9 0.97% 82.44% +apply_spine_expr 22 2 6 4 618392 83404 1.33e9 0.94% 83.38% +get_u64_le 28 2 14 3 422899 22 1.12e9 0.79% 84.17% +whnf_apply_beta 34 3 10 7 339939 0 1.07e9 0.76% 84.93% +get_app_telescope 43 2 15 6 264610 0 1.03e9 0.73% 85.66% +expr_inst1_walk 34 9 8 5 326314 0 1.03e9 0.73% 86.38% +expr_glb_walk 34 10 8 5 295964 0 9.25e8 0.65% 87.04% +g_list_has 21 3 6 3 413484 3025 8.25e8 0.58% 87.62% +validate_expr_well_scoped 52 9 20 8 176535 152144 8.06e8 0.57% 88.19% +expr_inst1 21 2 4 4 400830 220687 7.98e8 0.56% 88.75% +expr_lift 23 3 5 4 359613 1596071 7.76e8 0.55% 89.30% +try_reduce_projection_definition 59 3 24 13 151416 11396 7.74e8 0.55% 89.85% +const_idxs_expr 52 7 26 7 160015 209196 7.25e8 0.51% 90.36% +k_infer_core 53 9 22 8 156068 76251 7.19e8 0.51% 90.87% +expr_lift_walk 34 9 8 5 232640 0 7.13e8 0.50% 91.37% +try_prim_dispatch 30 6 8 4 254764 16347 6.95e8 0.49% 91.86% +list_take.Ptr.KExprNode 23 2 7 4 311258 46370 6.64e8 0.47% 92.33% +expr_lower_walk 53 10 18 9 141436 0 6.46e8 0.46% 92.79% +expr_glb 21 2 5 4 307017 351230 5.99e8 0.42% 93.21% +try_iota 108 5 39 25 66939 2106 5.82e8 0.41% 93.62% +whnf 38 6 14 6 157482 59630 5.22e8 0.37% 93.99% +safe_refs_only 43 9 19 5 140151 138582 5.20e8 0.37% 94.36% +try_nat_linear_rec 75 5 27 17 66603 305 4.03e8 0.28% 94.64% +bytes_to_block 265 1 193 65 20371 601 3.87e8 0.27% 94.91% +memory[18] 27 0 0 0 160015 742479 3.79e8 0.27% 95.18% +expr_lower 23 3 5 4 159506 145656 3.23e8 0.23% 95.41% +k_infer 15 1 4 4 232319 67885 3.19e8 0.23% 95.63% +whnf_nd_with_spine 34 6 11 5 108049 5848 3.11e8 0.22% 95.85% +k_is_def_eq 29 3 7 6 124776 117155 3.11e8 0.22% 96.07% +get_expr_list 42 2 15 6 88735 268 3.09e8 0.22% 96.29% +blake3_compress_block 211 2 169 15 19287 0 2.90e8 0.20% 96.50% +whnf_proj_head 61 4 28 10 47524 0 2.27e8 0.16% 96.66% +k_check 15 1 3 3 159446 212233 2.12e8 0.15% 96.81% +ctx_trim 52 3 19 12 48396 403673 1.98e8 0.14% 96.95% +try_def_eq_app 49 6 18 9 50776 2516 1.96e8 0.14% 97.08% +de_args 32 5 10 5 67744 21012 1.76e8 0.12% 97.21% +const_idxs_exprs 24 2 7 5 86624 1620 1.74e8 0.12% 97.33% +get_u64_list 49 2 22 6 44676 0 1.71e8 0.12% 97.45% +get_tag0 40 2 23 5 50253 2087 1.59e8 0.11% 97.56% +get_address 138 1 98 34 15781 90 1.52e8 0.11% 97.67% +whnf_nd 38 6 14 6 49692 10756 1.49e8 0.11% 97.78% +try_reduce_fin_val_decidable_rec 149 9 58 37 14010 42719 1.44e8 0.10% 97.88% +cleanup_nat_offset_major 45 5 19 8 37490 96326 1.30e8 0.09% 97.97% +Bytes2 24 0 0 0 65536 0 1.28e8 0.09% 98.06% +k_def_eq_rebase 44 2 12 11 36566 0 1.23e8 0.09% 98.15% +whnf_iota_major 51 3 24 9 30949 36035 1.19e8 0.08% 98.23% +k_is_def_eq_core 40 2 15 8 37176 11532 1.14e8 0.08% 98.31% +address_eq 82 2 66 4 19339 105521 1.14e8 0.08% 98.39% +whnf_nd_const_head 55 9 23 7 24843 0 1.01e8 0.07% 98.46% +try_string_lit_one 28 3 8 5 45390 0 9.99e7 0.07% 98.53% +ctx_seek_cut 44 2 16 10 28518 2605 9.39e7 0.07% 98.60% +try_match_nat_add 47 6 17 9 24711 0 8.56e7 0.06% 98.66% +try_eta_struct 91 8 48 14 12585 1295 7.84e7 0.06% 98.72% +expr_glb_binder 16 1 4 4 56426 179 7.33e7 0.05% 98.77% +expr_inst_levels_walk 36 9 9 6 26401 0 7.08e7 0.05% 98.82% +get_lam_telescope 42 2 15 6 22282 1 6.84e7 0.05% 98.87% +pad_block 18 2 4 3 46924 203 6.72e7 0.05% 98.91% +try_extract_nat 30 6 9 5 28819 38736 6.51e7 0.05% 98.96% +collect_spine_of_ctor 45 3 23 7 18694 48214 6.04e7 0.04% 99.00% +memory[32] 41 0 0 0 20282 85992 6.02e7 0.04% 99.04% +nat_lit_to_ctor_or_self 43 4 14 10 18695 48216 5.77e7 0.04% 99.09% +try_extract_nat_app 33 4 11 6 22971 0 5.57e7 0.04% 99.12% +k_is_def_eq_ordered 19 2 4 3 36613 563 5.40e7 0.04% 99.16% +k_is_def_eq_slow_nd 32 4 9 6 22695 0 5.34e7 0.04% 99.20% +try_struct_eta_iota 93 9 39 16 8529 0 5.21e7 0.04% 99.24% +k_is_def_eq_struct_safe 40 9 12 6 17527 45 5.00e7 0.04% 99.27% +whnf_nd_apply_beta 34 3 10 7 20065 0 4.95e7 0.03% 99.31% +get_address_list 42 2 15 6 15776 1546 4.68e7 0.03% 99.34% +k_infer_only 93 12 45 15 7639 13614 4.61e7 0.03% 99.37% +expr_inst1_bvar 20 3 4 3 29243 0 4.44e7 0.03% 99.40% +k_is_def_eq_slow 26 4 7 4 22695 0 4.35e7 0.03% 99.43% +expr_inst_levels 20 2 6 3 27486 203854 4.15e7 0.03% 99.46% +get_all_telescope 42 2 15 6 13871 8 4.06e7 0.03% 99.49% +whnf_nd_proj_head 61 4 28 10 9205 0 3.73e7 0.03% 99.52% +walk_refs_transitive 27 4 6 5 19062 467 3.73e7 0.03% 99.55% +nat_offset_of 58 12 23 9 9203 3526 3.55e7 0.03% 99.57% +ctx_close_cut 46 3 17 10 11155 3972 3.49e7 0.02% 99.60% +u64_is_zero 25 9 2 1 18991 574396 3.44e7 0.02% 99.62% +relaxed_u64_pred 25 9 2 1 18983 276989 3.44e7 0.02% 99.64% +k_is_def_eq_slow2 58 9 20 11 8692 0 3.33e7 0.02% 99.67% +k_ensure_sort 18 1 7 4 23106 11234 3.10e7 0.02% 99.69% +str_lit_to_ctor_app_or_self 24 3 7 4 15628 41101 2.67e7 0.02% 99.71% +blake3_compress_layer 223 3 170 6 2064 0 2.54e7 0.02% 99.73% +list_is_empty.U8 15 2 4 2 19025 18852 2.10e7 0.01% 99.74% +flatten_u64 14 1 1 1 18983 99858 1.92e7 0.01% 99.75% +blake3_finish 190 11 151 9 1707 0 1.75e7 0.01% 99.77% +blake3_next_layer 221 4 136 5 1464 0 1.71e7 0.01% 99.78% +try_def_eq_nat 41 4 16 7 6316 478 1.66e7 0.01% 99.79% +is_nat_zero 24 4 7 4 9134 3498 1.47e7 0.01% 99.80% +head_addr 24 2 9 4 9059 3989 1.46e7 0.01% 99.81% +ctx_next_cut 16 1 6 4 12668 23715 1.43e7 0.01% 99.82% +lazy_delta_loop 35 7 10 5 6269 470 1.41e7 0.01% 99.83% +get_constant 162 3 136 9 1621 0 1.41e7 0.01% 99.84% +replace_spine_major 23 1 7 7 8498 163 1.31e7 0.01% 99.85% +try_unit_like 28 2 7 6 6443 643 1.16e7 0.01% 99.86% +try_proof_irrel 25 2 6 5 6483 643 1.05e7 0.01% 99.87% +load_verified_constant 100 1 88 5 1621 2066 8.70e6 0.01% 99.87% +get_ci 97 10 68 7 1542 348070 7.98e6 0.01% 99.88% +blake3 86 1 72 8 1707 114 7.94e6 0.01% 99.88% +try_nat_dispatch_prewhnf 86 8 31 20 1550 0 7.12e6 0.01% 99.89% +memory[34] 43 0 0 0 2815 7298 7.04e6 0.00% 99.89% +run_check_transitive 79 7 55 6 1621 15636 6.89e6 0.00% 99.90% +verify_bytes_against 73 1 33 2 1707 0 6.75e6 0.00% 99.90% +const_idxs_of 77 6 7 6 1621 0 6.71e6 0.00% 99.91% +check_const 75 8 20 15 1542 79 6.18e6 0.00% 99.91% +expr_lift_bvar 39 2 14 8 2657 0 5.99e6 0.00% 99.92% +get_constant_info_by_variant 64 8 46 2 1542 0 5.28e6 0.00% 99.92% +prim_family 161 23 59 37 510 254254 3.71e6 0.00% 99.92% +whnf_spine 25 2 7 5 2502 1358 3.62e6 0.00% 99.93% +projection_definition_info 54 5 23 10 1196 151095 3.34e6 0.00% 99.93% +lbr_max 35 2 13 7 1593 890375 3.02e6 0.00% 99.93% +lbr_min 35 2 13 7 1545 388016 2.92e6 0.00% 99.93% +convert_definition 40 5 6 4 1341 0 2.83e6 0.00% 99.93% +memo_u32_less_than 28 1 13 7 1612 9659746 2.46e6 0.00% 99.94% +expr_mentions_block 40 14 10 5 1175 574 2.44e6 0.00% 99.94% +assert_safety 15 2 3 2 2730 153 2.44e6 0.00% 99.94% +is_unsafe_ci 29 9 2 1 1542 1977 2.42e6 0.00% 99.94% +const_type_of 27 8 1 1 1541 976 2.26e6 0.00% 99.94% +const_num_lvls 27 8 1 1 1541 11939 2.26e6 0.00% 99.94% +peel_params_subst 30 2 11 5 1376 290 2.20e6 0.00% 99.95% +get_definition 30 1 18 6 1341 0 2.14e6 0.00% 99.95% +run_check 24 1 14 4 1542 0 2.02e6 0.00% 99.95% +try_dec_dispatch 70 4 26 16 613 0 2.01e6 0.00% 99.95% +k_infer_proj 62 1 39 13 647 0 1.90e6 0.00% 99.95% +peel_n_alls_whnf 29 3 9 5 1215 0 1.85e6 0.00% 99.95% +is_prop_type 30 3 11 5 1141 5347 1.78e6 0.00% 99.95% +memory[12] 21 0 0 0 1548 416435 1.78e6 0.00% 99.95% +k_is_def_eq_struct_go 58 26 13 6 625 0 1.71e6 0.00% 99.96% +read_byte 18 2 5 3 1628 0 1.62e6 0.00% 99.96% +peel_field_loop 34 2 9 6 923 0 1.58e6 0.00% 99.96% +level_struct_eq 39 12 11 5 810 522 1.56e6 0.00% 99.96% +nl_subsume_entry 121 13 54 24 297 59 1.49e6 0.00% 99.96% +is_str_prim_addr 65 8 22 15 497 0 1.46e6 0.00% 99.96% +try_nat_binop_dispatch 65 6 24 14 476 790 1.39e6 0.00% 99.96% +is_nat_succ_ih_step 58 7 26 10 493 530 1.30e6 0.00% 99.96% +try_reduce_decide_bitvec_lt 165 8 72 40 202 15 1.28e6 0.00% 99.96% +is_native_prim_addr 57 7 19 13 495 0 1.28e6 0.00% 99.97% +is_dec_prim_addr 57 7 19 13 494 0 1.28e6 0.00% 99.97% +level_imax 37 6 13 6 653 7954 1.15e6 0.00% 99.97% +convert_univ_idxs 38 2 16 7 634 17502 1.14e6 0.00% 99.97% +level_inst_params 28 5 7 5 798 914 1.11e6 0.00% 99.97% +level_list_inst 25 2 7 5 870 1878 1.09e6 0.00% 99.97% +dec_build_proof 95 8 30 22 268 0 1.04e6 0.00% 99.97% +lazy_delta_step_const_const 120 6 60 22 214 0 1.00e6 0.00% 99.97% +dec_finish 90 4 32 22 267 0 9.78e5 0.00% 99.97% +get_univ 55 5 33 6 397 44 9.57e5 0.00% 99.97% +level_eq 36 10 10 5 545 133 9.11e5 0.00% 99.97% +try_eta_swap 30 4 11 4 626 59 8.95e5 0.00% 99.97% +is_bitvec_prim_addr 33 4 10 7 497 0 7.52e5 0.00% 99.97% +try_lazy_delta_app 72 6 39 10 255 0 7.43e5 0.00% 99.97% +try_normalize_int_decidable 64 4 26 13 277 0 7.29e5 0.00% 99.97% +try_unfold_proj_app 31 3 11 6 499 234 7.11e5 0.00% 99.98% +get_tag2 40 2 23 5 397 0 7.00e5 0.00% 99.98% +utf8_decode_one 76 4 32 17 228 0 6.87e5 0.00% 99.98% +peel_n_foralls 21 2 7 3 662 62 6.75e5 0.00% 99.98% +address_eq_tail 84 6 66 3 204 0 6.65e5 0.00% 99.98% +check_prop_field_if_prop 22 2 5 4 616 31 6.50e5 0.00% 99.98% +dec_dispatch_le_eq 47 5 14 9 321 0 6.40e5 0.00% 99.98% +peer_agree_walk 107 5 69 11 158 0 6.23e5 0.00% 99.98% +lazy_delta_both_proj 39 7 10 7 365 0 6.19e5 0.00% 99.98% +compare_struct_fields 31 3 7 5 416 0 5.76e5 0.00% 99.98% +try_bitvec_dispatch 66 6 23 15 219 0 5.70e5 0.00% 99.98% +normalize_int_dec_rebuild 53 3 16 12 258 0 5.57e5 0.00% 99.98% +level_max 45 4 17 9 295 110 5.55e5 0.00% 99.98% +level_is_not_zero 27 7 7 4 431 679 5.25e5 0.00% 99.98% +try_unfold_head 33 5 4 3 359 66 5.16e5 0.00% 99.98% +get_ci_cprj 158 1 142 7 96 1019 5.03e5 0.00% 99.98% +level_max_subsumes 23 3 6 4 474 44 5.02e5 0.00% 99.98% +level_max_go 39 6 13 7 289 0 4.71e5 0.00% 99.98% +expr_lbr_let 23 1 7 7 443 0 4.64e5 0.00% 99.98% +get_mut_const_list 86 2 59 6 146 12 4.57e5 0.00% 99.98% +get_constructor_list 75 2 48 6 163 12 4.55e5 0.00% 99.98% +is_inductive_prop 24 1 9 6 414 233 4.47e5 0.00% 99.98% +level_max_offsets 47 3 18 10 235 0 4.43e5 0.00% 99.98% +check_canonical_block 123 3 75 20 105 0 4.37e5 0.00% 99.98% +is_unit_like_type 60 7 34 7 189 6254 4.36e5 0.00% 99.98% +build_recur_addrs_walk 71 2 51 5 158 0 4.15e5 0.00% 99.98% +check_positivity_aug 78 5 35 15 145 4 4.11e5 0.00% 99.99% +ensure_sort_only 30 2 12 5 315 111 4.03e5 0.00% 99.99% +canon_muts_has_kind 69 6 51 3 155 80 3.95e5 0.00% 99.99% +get_univ_list 53 2 24 7 192 1620 3.93e5 0.00% 99.99% +check_muts_all 66 2 48 4 158 0 3.87e5 0.00% 99.99% +k_synth_gate 71 4 30 14 144 5 3.72e5 0.00% 99.99% +k_is_def_eq_struct 12 1 2 2 622 59 3.69e5 0.00% 99.99% +normalize_aux 33 7 8 5 268 95 3.66e5 0.00% 99.99% +put_constant 90 9 14 7 114 19 3.55e5 0.00% 99.99% +glist_subset 75 5 32 16 131 267 3.50e5 0.00% 99.99% +ctor_at 86 2 72 3 117 2 3.50e5 0.00% 99.99% +check_inductive_shape_ctors 52 2 17 10 175 0 3.45e5 0.00% 99.99% +projection_addr 134 4 105 9 79 105 3.37e5 0.00% 99.99% +try_k_synth_iota 59 4 18 12 149 0 3.23e5 0.00% 99.99% +check_no_dep_data_field_if_prop 28 3 7 5 269 7 3.14e5 0.00% 99.99% +nl_add_var 43 4 13 9 185 33 3.06e5 0.00% 99.99% +get_ci_iprj 121 1 108 6 79 9496 3.04e5 0.00% 99.99% +wrap_foralls 22 2 6 4 314 49 2.98e5 0.00% 99.99% +check_param_agreement_go 34 2 12 6 207 0 2.78e5 0.00% 99.99% +put_address 106 1 65 34 79 35 2.67e5 0.00% 99.99% +muts_member_at 108 2 94 3 77 177 2.63e5 0.00% 99.99% +check_positivity_fields 26 2 6 5 244 0 2.60e5 0.00% 99.99% +put_constant_info 64 8 2 2 114 0 2.53e5 0.00% 99.99% +peel_ctor_params_subst 46 3 16 8 146 2 2.47e5 0.00% 99.99% +try_nat_offset_dispatch 59 4 19 14 119 0 2.46e5 0.00% 99.99% +expr_inst1_let 21 1 5 5 268 0 2.37e5 0.00% 99.99% +peel_n_lams_collect 29 3 10 4 205 0 2.36e5 0.00% 99.99% +walk_fields_classify 42 3 14 7 149 2 2.31e5 0.00% 99.99% +peel_n_foralls_with_types 27 3 9 4 207 3 2.22e5 0.00% 99.99% +get_expr_let 28 1 8 5 191 0 2.09e5 0.00% 99.99% +delta_unfold 45 4 22 7 128 108 2.06e5 0.00% 99.99% +check_block_peer_param_agreement 81 4 52 4 79 0 2.05e5 0.00% 99.99% +bytes_to_u64_limb 50 10 20 3 116 0 2.03e5 0.00% 99.99% +utf8_validate 21 2 6 4 229 61 1.97e5 0.00% 99.99% +expr_inst_many_let 21 1 5 5 229 0 1.97e5 0.00% 99.99% +caddr_is_peer 31 2 15 4 164 13 1.93e5 0.00% 99.99% +const_idxs_muts 76 4 53 7 78 78 1.89e5 0.00% 99.99% +check_muts_member_at 74 1 15 5 79 0 1.87e5 0.00% 99.99% +convert_constructor 57 1 6 6 96 0 1.84e5 0.00% 99.99% +const_idxs_ctors 57 2 40 5 95 76 1.81e5 0.00% 99.99% +get_constructor 55 1 41 8 96 0 1.77e5 0.00% 99.99% +bytes_to_addr 44 1 34 3 114 19 1.75e5 0.00% 99.99% +get_inductive 67 1 51 9 79 0 1.70e5 0.00% 99.99% +canon_indc_positions 67 3 50 4 78 78 1.67e5 0.00% 99.99% +level_offset_of 20 2 6 3 207 288 1.67e5 0.00% 99.99% +check_field_universes_inner 29 2 8 6 153 0 1.67e5 0.00% 99.99% +compare_rules 89 4 40 16 61 0 1.63e5 0.00% 99.99% +count_ctors 51 2 38 3 95 78 1.63e5 0.00% 99.99% +try_extract_int 49 6 20 9 98 611 1.62e5 0.00% 99.99% +validate_univ_params_list 20 2 4 4 202 10956 1.62e5 0.00% 99.99% +get_mut_const 62 3 48 3 79 0 1.57e5 0.00% 99.99% +glist_cmp 76 6 32 16 67 189 1.57e5 0.00% 99.99% +build_motive_apps 23 2 5 4 172 0 1.53e5 0.00% 99.99% +flat_originals_walk 100 5 68 9 52 0 1.50e5 0.00% 99.99% +memory[10] 19 0 0 0 195 108527 1.48e5 0.00% 99.99% +put_tag0 32 3 6 5 127 25 1.47e5 0.00% 99.99% +memory[36] 45 0 0 0 95 375 1.44e5 0.00% 99.99% +relaxed_u64_succ 25 9 2 1 150 547 1.41e5 0.00% 99.99% +memory[47] 56 0 0 0 78 1009 1.40e5 0.00% 100.00% +try_nat_binop_addr 128 15 44 31 40 2 1.38e5 0.00% 100.00% +put_tag4 33 3 6 5 114 0 1.33e5 0.00% 100.00% +load_verified_blob 46 1 36 3 85 739 1.28e5 0.00% 100.00% +convert_inductive 50 1 6 6 79 0 1.27e5 0.00% 100.00% +Bytes1 11 0 0 0 256 0 1.22e5 0.00% 100.00% +check_ctor_return_type 37 1 13 12 94 92 1.17e5 0.00% 100.00% +is_rec_field_peel 40 3 16 7 87 0 1.15e5 0.00% 100.00% +validate_univ_params_seen 43 5 16 8 81 521 1.13e5 0.00% 100.00% +apply_ihs_full 100 2 30 26 41 0 1.11e5 0.00% 100.00% +whnf_get_ctor_or_none 26 2 9 5 119 56302 1.11e5 0.00% 100.00% +addr_list_contains 24 3 7 4 126 41 1.10e5 0.00% 100.00% +check_field_universes_skip_params 25 2 7 4 120 0 1.08e5 0.00% 100.00% +get_result_sort_level 28 2 9 5 105 187 1.02e5 0.00% 100.00% +io_peel_field_loop 30 2 9 5 98 18 1.01e5 0.00% 100.00% +build_minor_doms 54 2 19 7 61 0 9.99e4 0.00% 100.00% +memory[8] 17 0 0 0 151 44897 9.83e4 0.00% 100.00% +build_flat_block 159 7 121 12 26 0 9.81e4 0.00% 100.00% +get_recursor_rule_list 53 2 24 7 61 0 9.81e4 0.00% 100.00% +mk_nat_offset_stuck 37 2 10 9 81 0 9.79e4 0.00% 100.00% +nl_subsumption_walk 25 2 7 5 110 41 9.72e4 0.00% 100.00% +populate_rules 52 3 18 6 61 0 9.63e4 0.00% 100.00% +get_constructor_proj 31 1 21 4 90 0 9.38e4 0.00% 100.00% +is_muts_block 61 2 50 2 52 78 9.23e4 0.00% 100.00% +nl_eq 51 7 18 10 58 51 8.87e4 0.00% 100.00% +flat_find_matching 39 5 15 5 70 8 8.62e4 0.00% 100.00% +bytes_to_limbs 57 5 29 9 51 711 8.43e4 0.00% 100.00% +build_all_minors_walk 55 3 24 8 52 0 8.34e4 0.00% 100.00% +list_any_mentions_block 24 3 7 4 95 24 7.83e4 0.00% 100.00% +check_recursor_canonical_full 125 9 50 18 26 0 7.73e4 0.00% 100.00% +list_reverse_acc.G 22 2 6 4 99 0 7.58e4 0.00% 100.00% +convert_rec_rules 40 2 16 6 61 0 7.46e4 0.00% 100.00% +build_apply_field_bvars 23 2 5 4 94 28 7.42e4 0.00% 100.00% +check_field_universes 23 2 6 4 94 92 7.42e4 0.00% 100.00% +assert_first_args_are_param_bvars 27 2 9 4 81 65 7.22e4 0.00% 100.00% +assert_return_head_is_parent 27 1 15 4 78 16 6.90e4 0.00% 100.00% +level_list_eq 31 5 10 5 69 21987 6.78e4 0.00% 100.00% +check_positivity 20 1 5 5 94 92 6.50e4 0.00% 100.00% +level_equal 23 2 5 5 83 1315 6.38e4 0.00% 100.00% +build_ih_doms 78 2 24 20 32 9 6.36e4 0.00% 100.00% +k_infer_lit 20 2 4 4 88 0 6.00e4 0.00% 100.00% +u64_sub_with_borrow 53 1 16 16 41 1 5.97e4 0.00% 100.00% +build_minor_at_depth 65 1 25 21 35 0 5.96e4 0.00% 100.00% +klimbs_mul_single 86 3 47 7 28 0 5.89e4 0.00% 100.00% +build_rec_type_from 93 3 29 23 26 0 5.78e4 0.00% 100.00% +get_inductive_proj 22 1 12 3 79 0 5.76e4 0.00% 100.00% +put_definition_proj 22 1 3 3 79 0 5.76e4 0.00% 100.00% +nl_covers_var 35 4 11 6 54 1 5.63e4 0.00% 100.00% +level_normalize 25 1 9 9 68 94 5.42e4 0.00% 100.00% +get_recursor 87 1 69 11 26 0 5.41e4 0.00% 100.00% +u64_mul 222 1 155 46 13 0 5.39e4 0.00% 100.00% +lazy_delta_b_const_a_proj 55 6 24 8 36 0 5.25e4 0.00% 100.00% +check_inductive_shape 19 1 3 4 79 26 5.02e4 0.00% 100.00% +level_reduce 27 5 7 5 57 214 4.69e4 0.00% 100.00% +skip_bytes 21 3 6 3 69 47 4.67e4 0.00% 100.00% +check_param_agreement 14 1 2 3 94 92 4.65e4 0.00% 100.00% +nl_skip_empty 30 4 11 5 52 69 4.63e4 0.00% 100.00% +build_apply_xs 22 2 5 4 66 17 4.63e4 0.00% 100.00% +count_foralls_body 20 2 6 3 71 4 4.62e4 0.00% 100.00% +klimbs_sub_borrow 69 6 42 7 27 20 4.53e4 0.00% 100.00% +check_recursor_member 72 3 24 14 26 0 4.49e4 0.00% 100.00% +build_peer_recs 29 2 10 5 52 0 4.49e4 0.00% 100.00% +convert_recursor 71 1 8 8 26 0 4.43e4 0.00% 100.00% +convert_univ 33 5 13 5 46 1994 4.36e4 0.00% 100.00% +u64_add 53 1 16 16 32 28 4.36e4 0.00% 100.00% +muts_indc_count_is_one 66 4 50 3 27 25 4.33e4 0.00% 100.00% +ind_is_solo 69 3 52 4 26 0 4.31e4 0.00% 100.00% +build_succ_offset 57 2 17 16 30 0 4.30e4 0.00% 100.00% +expr_glb_let 21 1 6 6 64 0 4.26e4 0.00% 100.00% +level_explicit_val 22 4 7 3 61 274 4.20e4 0.00% 100.00% +build_all_motives_walk 51 3 24 8 32 20 4.20e4 0.00% 100.00% +klimbs_add_carry 67 5 41 7 26 9 4.19e4 0.00% 100.00% +find_peer_recursor_with_spec 67 2 50 3 26 0 4.19e4 0.00% 100.00% +build_rule_rhs 45 1 15 12 35 0 4.17e4 0.00% 100.00% +nlvars_subsume 111 6 49 25 17 3 3.92e4 0.00% 100.00% +compute_k_target 62 6 23 8 26 0 3.88e4 0.00% 100.00% +build_major_params 23 2 5 4 55 0 3.85e4 0.00% 100.00% +collect_n_doms_whnf 40 4 16 7 36 15 3.85e4 0.00% 100.00% +projection_addr_ctor 41 1 23 9 35 0 3.81e4 0.00% 100.00% +nl_add_const 22 4 5 3 53 49 3.53e4 0.00% 100.00% +is_rec_field 13 1 3 2 79 2 3.52e4 0.00% 100.00% +normalize_imax_dispatch 39 8 10 6 34 5 3.50e4 0.00% 100.00% +nl_add_const_go 58 5 22 12 25 0 3.46e4 0.00% 100.00% +nl_le 36 6 12 6 35 6 3.36e4 0.00% 100.00% +peel_motive_params_subst 31 2 9 5 39 12 3.34e4 0.00% 100.00% +klimbs_mul_outer 40 2 16 7 32 1 3.32e4 0.00% 100.00% +se_mentions 39 12 11 5 32 6 3.24e4 0.00% 100.00% +nl_le_vars 28 3 8 5 41 4 3.22e4 0.00% 100.00% +const_idxs_rules 32 2 15 5 36 25 3.11e4 0.00% 100.00% +check_rec_rules_wellscoped 23 2 6 4 46 15 3.09e4 0.00% 100.00% +build_motive_type_flat 48 3 12 10 26 0 3.03e4 0.00% 100.00% +build_recur_addrs 11 1 2 2 79 105 3.02e4 0.00% 100.00% +glist_eq_len 26 4 8 4 41 116 3.00e4 0.00% 100.00% +build_flat_own_params 45 4 24 6 27 25 2.99e4 0.00% 100.00% +put_constructor_proj 31 1 4 4 35 0 2.91e4 0.00% 100.00% +ctors_before_pos 46 5 24 5 26 0 2.90e4 0.00% 100.00% +build_rec_type 45 2 20 5 26 0 2.84e4 0.00% 100.00% +flat_find_pos_kind 43 7 17 5 26 0 2.72e4 0.00% 100.00% +nlvars_dominates 50 4 19 10 23 16 2.68e4 0.00% 100.00% +canonical_rules_at_pos 41 1 10 8 26 0 2.60e4 0.00% 100.00% +klimbs_normalize 48 4 25 7 23 316 2.58e4 0.00% 100.00% +memory[9] 18 0 0 0 46 304 2.45e4 0.00% 100.00% +glist_ordered_insert 73 4 31 16 16 73 2.39e4 0.00% 100.00% +lbr_dec 11 2 2 1 63 150172 2.30e4 0.00% 100.00% +lazy_delta_a_const_b_proj 55 6 24 8 19 0 2.29e4 0.00% 100.00% +memory[11] 20 0 0 0 36 122 1.99e4 0.00% 100.00% +list_length.KRecRule 20 2 7 3 36 25 1.99e4 0.00% 100.00% +flat_member_at 31 3 12 5 26 52 1.99e4 0.00% 100.00% +nlvars_add 102 5 44 23 11 12 1.98e4 0.00% 100.00% +expr_lift_let 21 1 5 5 33 0 1.87e4 0.00% 100.00% +build_ctor_app_params 19 2 3 2 35 0 1.83e4 0.00% 100.00% +rec_to_parent_addr 28 1 12 5 26 69045 1.80e4 0.00% 100.00% +struct_scan_ctors 45 4 19 6 18 0 1.75e4 0.00% 100.00% +is_large_eliminator 41 7 7 4 19 7 1.72e4 0.00% 100.00% +check_rec_major_spine 26 1 9 5 26 0 1.68e4 0.00% 100.00% +check_parent_inductive_shape 24 2 2 2 26 0 1.56e4 0.00% 100.00% +find_rule 25 3 10 3 25 58228 1.54e4 0.00% 100.00% +dec_rewrite_lt_to_le 49 2 14 13 15 0 1.49e4 0.00% 100.00% +klimbs_succ 41 3 23 5 17 107 1.49e4 0.00% 100.00% +build_succ_chain 53 2 20 5 14 141 1.46e4 0.00% 100.00% +list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode 21 2 8 3 27 25 1.45e4 0.00% 100.00% +memory[5] 14 0 0 0 36 17400 1.43e4 0.00% 100.00% +is_defn_or_thm 24 3 3 1 24 459 1.41e4 0.00% 100.00% +list_reverse.G 13 1 3 3 37 180 1.39e4 0.00% 100.00% +se_scan_fields 25 3 8 4 23 0 1.38e4 0.00% 100.00% +level_leq 30 3 9 6 20 70 1.37e4 0.00% 100.00% +check_large_walk_fields 44 5 14 8 15 0 1.34e4 0.00% 100.00% +klimbs_sub 18 2 4 3 26 38 1.19e4 0.00% 100.00% +compute_iprj_addr 30 1 15 8 18 12181 1.19e4 0.00% 100.00% +memory[6] 15 0 0 0 27 337 1.06e4 0.00% 100.00% +se_parent_addr 34 5 13 5 15 151 1.05e4 0.00% 100.00% +klimbs_is_zero 26 2 13 3 18 406 1.04e4 0.00% 100.00% +se_peel_tol 22 3 7 3 20 0 1.02e4 0.00% 100.00% +struct_block_member_addrs 68 2 52 4 9 0 1.00e4 0.00% 100.00% +collect_index_doms 39 4 15 7 13 47 9.85e3 0.00% 100.00% +build_all_minors 14 1 2 2 26 0 9.49e3 0.00% 100.00% +assert_lvls_are_params 25 2 8 4 17 96 9.30e3 0.00% 100.00% +check_large_prop_ctor 27 3 8 4 15 0 8.45e3 0.00% 100.00% +build_all_motives 12 1 2 2 26 0 8.27e3 0.00% 100.00% +list_lift_indices 26 2 7 5 15 19 8.16e3 0.00% 100.00% +assert_occ_param_bvars 27 2 9 4 14 1 7.70e3 0.00% 100.00% +klimbs_add 11 1 2 2 26 16 7.66e3 0.00% 100.00% +peel_leading_foralls_acc 24 2 8 4 15 0 7.57e3 0.00% 100.00% +ctor_subst_param_for 49 3 17 10 9 69 7.31e3 0.00% 100.00% +list_snoc.U8_8 36 2 13 4 11 4 7.25e3 0.00% 100.00% +nlvars_eq 36 6 12 6 11 40 7.25e3 0.00% 100.00% +se_addr_in 24 3 7 4 14 0 6.90e3 0.00% 100.00% +apply_n_projs 24 2 5 4 14 0 6.90e3 0.00% 100.00% +klimbs_div_mod 46 2 14 12 9 0 6.89e3 0.00% 100.00% +list_lift_each 26 2 7 5 13 33 6.72e3 0.00% 100.00% +count_foralls_at_least 23 3 7 3 14 0 6.63e3 0.00% 100.00% +u64_byte_count 150 128 8 1 4 237 6.14e3 0.00% 100.00% +klimbs_mul 14 1 3 3 18 4 5.90e3 0.00% 100.00% +apply_indices_in_conclusion 22 2 5 4 13 19 5.76e3 0.00% 100.00% +klimbs_pow 43 3 12 11 8 0 5.45e3 0.00% 100.00% +klimbs_dec 14 1 4 4 16 120 5.06e3 0.00% 100.00% +struct_is_rec 33 2 16 5 9 160 5.03e3 0.00% 100.00% +mk_nat_lit 10 1 2 2 19 118 4.72e3 0.00% 100.00% +try_eta_expand 45 3 14 10 7 3 4.67e3 0.00% 100.00% +klimbs_eq 44 5 23 5 7 316 4.58e3 0.00% 100.00% +args_contain_bvar 28 4 10 4 9 1 4.32e3 0.00% 100.00% +klimbs_le 27 2 13 3 9 10 4.18e3 0.00% 100.00% +build_rec_lvls_list 21 2 5 4 10 22 3.85e3 0.00% 100.00% +klimbs_shl_limbs 18 2 4 3 11 4 3.82e3 0.00% 100.00% +check_valid_ind_app 35 1 17 8 7 0 3.69e3 0.00% 100.00% +build_param_lvls_range 22 2 5 4 9 47 3.46e3 0.00% 100.00% +peel_leading_foralls 15 1 5 4 11 1 3.25e3 0.00% 100.00% +list_lookup_or_default.Ptr.U8_32 20 2 5 3 9 21 3.18e3 0.00% 100.00% +check_nested_ctors_positivity 51 2 20 9 5 0 3.14e3 0.00% 100.00% +glimbs_to_klimbs 36 2 13 8 6 17 3.01e3 0.00% 100.00% +wrap_lams 22 2 6 4 8 0 2.93e3 0.00% 100.00% +memory[2] 11 0 0 0 12 96 2.80e3 0.00% 100.00% +is_int_dec_prim_addr 33 4 10 7 6 607 2.78e3 0.00% 100.00% +all_bvars_in_args 24 3 7 4 7 0 2.61e3 0.00% 100.00% +nl_covers_const 61 6 24 12 4 2 2.58e3 0.00% 100.00% +intern_int_lit 29 3 8 6 6 300 2.46e3 0.00% 100.00% +try_quot_iota 30 3 8 6 4 0 1.34e3 0.00% 100.00% +subst_param_for 46 3 17 9 3 22 1.20e3 0.00% 100.00% +unfold_b_and_loop 23 2 5 4 4 0 1.06e3 0.00% 100.00% +try_native_dispatch 98 8 37 23 2 0 1.05e3 0.00% 100.00% +klimbs_gcd 20 2 4 4 4 2 9.44e2 0.00% 100.00% +u64_eq 33 9 2 1 3 0 8.93e2 0.00% 100.00% +check_quot 29 5 6 5 3 0 7.97e2 0.00% 100.00% +get_quotient 27 1 15 5 3 0 7.50e2 0.00% 100.00% +convert_quotient 26 1 3 3 3 0 7.26e2 0.00% 100.00% +get_axiom 26 1 14 5 3 0 7.26e2 0.00% 100.00% +convert_axiom 26 1 3 3 3 0 7.26e2 0.00% 100.00% +try_reduce_subtype_val 63 4 26 14 2 0 7.02e2 0.00% 100.00% +try_quot_lift 59 3 22 14 2 0 6.62e2 0.00% 100.00% +run_claim 128 5 71 8 1 0 6.56e2 0.00% 100.00% +klimbs_land 52 3 31 6 2 0 5.92e2 0.00% 100.00% +unpack_def_kind_safety 17 9 1 1 3 1338 5.12e2 0.00% 100.00% +bitvec_prep_spine 44 3 15 10 2 0 5.12e2 0.00% 100.00% +bv_to_nat_via 41 4 13 9 2 0 4.82e2 0.00% 100.00% +defn_is_unsafe_ci 15 5 2 1 3 1338 4.65e2 0.00% 100.00% +quot_extract_arg 39 4 13 8 2 0 4.62e2 0.00% 100.00% +bitvec_of_nat_args_direct 38 4 13 8 2 0 4.52e2 0.00% 100.00% +quot_kind_tag 12 4 1 1 3 0 3.93e2 0.00% 100.00% +idx_to_u64 22 1 10 6 2 167 2.92e2 0.00% 100.00% +mk_bool 20 2 5 4 2 3 2.72e2 0.00% 100.00% +put_expr_list 42 2 24 5 1 0 2.26e2 0.00% 100.00% +canon_cprj_addr 41 1 23 9 1 143 2.21e2 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +u64_and 40 1 9 9 1 0 2.16e2 0.00% 100.00% +klimbs_mod 12 1 3 2 2 0 1.92e2 0.00% 100.00% +list_length_u64.Ptr.Univ 35 2 20 4 1 2 1.91e2 0.00% 100.00% +put_univ_list 33 2 15 5 1 0 1.81e2 0.00% 100.00% +unfold_both_and_loop 31 3 8 6 1 0 1.71e2 0.00% 100.00% +check_eq_type 24 1 15 4 1 0 1.36e2 0.00% 100.00% +mk_nat_binop_stuck 24 1 7 7 1 0 1.36e2 0.00% 100.00% +put_refs 22 1 11 4 1 113 1.26e2 0.00% 100.00% +put_sharing 22 1 11 4 1 113 1.26e2 0.00% 100.00% +put_address_list 22 2 6 4 1 0 1.26e2 0.00% 100.00% +put_univs 22 1 11 4 1 113 1.26e2 0.00% 100.00% +delta_rank 22 2 2 1 1 1 1.26e2 0.00% 100.00% +klimbs_shr 18 1 5 5 1 0 1.06e2 0.00% 100.00% +get_opt_addr 18 2 5 3 1 0 1.06e2 0.00% 100.00% +klimbs_div 12 1 3 2 1 0 7.60e1 0.00% 100.00% +assert_wire_bool 10 1 2 2 1 98 6.60e1 0.00% 100.00% +string_append_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +bool_true_addr 9 1 2 2 1 144 6.10e1 0.00% 100.00% +size_of_size_of_addr 9 1 2 2 1 493 6.10e1 0.00% 100.00% +quot_type_addr 9 1 2 2 1 0 6.10e1 0.00% 100.00% +string_back_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +string_legacy_back_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +string_to_byte_array_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +string_dec_eq_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +str_addr 9 1 2 2 1 34 6.10e1 0.00% 100.00% +nat_zero_addr 9 1 2 2 1 22 6.10e1 0.00% 100.00% +nat_succ_addr_iota 9 1 2 2 1 4454 6.10e1 0.00% 100.00% +nat_pred_addr 9 1 2 2 1 2058 6.10e1 0.00% 100.00% +nat_add_addr 9 1 2 2 1 25720 6.10e1 0.00% 100.00% +nat_sub_addr 9 1 2 2 1 533 6.10e1 0.00% 100.00% +nat_mul_addr 9 1 2 2 1 523 6.10e1 0.00% 100.00% +nat_pow_addr 9 1 2 2 1 510 6.10e1 0.00% 100.00% +nat_gcd_addr 9 1 2 2 1 513 6.10e1 0.00% 100.00% +nat_mod_addr 9 1 2 2 1 634 6.10e1 0.00% 100.00% +fin_addr 9 1 2 2 1 14009 6.10e1 0.00% 100.00% +decidable_rec_addr 9 1 2 2 1 2 6.10e1 0.00% 100.00% +nat_addr_io 9 1 2 2 1 54 6.10e1 0.00% 100.00% +quot_ctor_addr 9 1 2 2 1 2 6.10e1 0.00% 100.00% +quot_lift_addr_iota 9 1 2 2 1 4 6.10e1 0.00% 100.00% +quot_ind_addr 9 1 2 2 1 1 6.10e1 0.00% 100.00% +nat_div_addr 9 1 2 2 1 635 6.10e1 0.00% 100.00% +nat_land_addr 9 1 2 2 1 505 6.10e1 0.00% 100.00% +nat_lor_addr 9 1 2 2 1 503 6.10e1 0.00% 100.00% +nat_xor_addr 9 1 2 2 1 503 6.10e1 0.00% 100.00% +nat_shift_left_addr 9 1 2 2 1 503 6.10e1 0.00% 100.00% +nat_shift_right_addr 9 1 2 2 1 503 6.10e1 0.00% 100.00% +nat_beq_addr 9 1 2 2 1 505 6.10e1 0.00% 100.00% +nat_ble_addr 9 1 2 2 1 501 6.10e1 0.00% 100.00% +int_dec_lt_addr_dec 9 1 2 2 1 492 6.10e1 0.00% 100.00% +bool_false_addr 9 1 2 2 1 123 6.10e1 0.00% 100.00% +system_platform_num_bits_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +nat_dec_le_addr_dec 9 1 2 2 1 842 6.10e1 0.00% 100.00% +nat_dec_eq_addr_dec 9 1 2 2 1 828 6.10e1 0.00% 100.00% +nat_dec_lt_addr_dec 9 1 2 2 1 827 6.10e1 0.00% 100.00% +decidable_is_true_addr_dec 9 1 2 2 1 143 6.10e1 0.00% 100.00% +decidable_is_false_addr_dec 9 1 2 2 1 122 6.10e1 0.00% 100.00% +nat_le_of_ble_eq_true_addr_dec 9 1 2 2 1 6 6.10e1 0.00% 100.00% +nat_eq_of_beq_eq_true_addr_dec 9 1 2 2 1 136 6.10e1 0.00% 100.00% +nat_ne_of_beq_eq_false_addr_dec 9 1 2 2 1 122 6.10e1 0.00% 100.00% +bool_type_addr_dec 9 1 2 2 1 266 6.10e1 0.00% 100.00% +eq_refl_addr_dec 9 1 2 2 1 266 6.10e1 0.00% 100.00% +int_dec_eq_addr_dec 9 1 2 2 1 494 6.10e1 0.00% 100.00% +int_dec_le_addr_dec 9 1 2 2 1 496 6.10e1 0.00% 100.00% +string_of_list_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +int_of_nat_addr_dec 9 1 2 2 1 13 6.10e1 0.00% 100.00% +int_neg_succ_addr_dec 9 1 2 2 1 11 6.10e1 0.00% 100.00% +punit_size_of_1_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +bit_vec_to_nat_addr 9 1 2 2 1 715 6.10e1 0.00% 100.00% +bit_vec_of_nat_addr 9 1 2 2 1 1 6.10e1 0.00% 100.00% +bit_vec_addr 9 1 2 2 1 97 6.10e1 0.00% 100.00% +reduce_bool_addr 9 1 2 2 1 494 6.10e1 0.00% 100.00% +lt_lt_addr 9 1 2 2 1 199 6.10e1 0.00% 100.00% +reduce_nat_addr 9 1 2 2 1 494 6.10e1 0.00% 100.00% +bit_vec_ult_addr 9 1 2 2 1 712 6.10e1 0.00% 100.00% +decidable_decide_addr 9 1 2 2 1 712 6.10e1 0.00% 100.00% +system_platform_get_num_bits_addr 9 1 2 2 1 0 6.10e1 0.00% 100.00% +subtype_val_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +string_utf8_byte_size_addr 9 1 2 2 1 496 6.10e1 0.00% 100.00% +canon_cmp_klimbs 29 2 7 7 0 0 0 0.00% 100.00% +put_axiom 44 1 22 5 0 0 0 0.00% 100.00% +nlvars_max_offset 47 3 19 10 0 0 0 0.00% 100.00% +put_quotient 44 1 22 5 0 0 0 0.00% 100.00% +put_u64_list 29 2 13 4 0 0 0 0.00% 100.00% +app_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +lam_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +canon_cmp_krec_rule_ctx 26 1 8 5 0 0 0 0.00% 100.00% +canon_cmp_krec_rule_list_ctx 40 4 17 6 0 0 0 0.00% 100.00% +all_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +put_univ 53 5 22 6 0 0 0 0.00% 100.00% +put_app_telescope 74 2 39 5 0 0 0 0.00% 100.00% +try_str_dispatch 128 18 47 28 0 0 0 0.00% 100.00% +try_str_back 70 4 27 17 0 0 0 0.00% 100.00% +u64_or 40 1 9 9 0 0 0 0.00% 100.00% +u64_xor_kbits 40 1 9 9 0 0 0 0.00% 100.00% +try_str_to_byte_array 64 5 26 14 0 0 0 0.00% 100.00% +klimbs_lor 52 3 31 6 0 0 0 0.00% 100.00% +extract_aux_occ_us 46 4 14 6 0 0 0 0.00% 100.00% +extract_aux_spec_params 27 1 10 6 0 0 0 0.00% 100.00% +spec_params_lower 28 2 8 6 0 0 0 0.00% 100.00% +klimbs_xor_op 52 3 31 6 0 0 0 0.00% 100.00% +klimbs_shl 18 1 5 5 0 0 0 0.00% 100.00% +aux_already_in 33 5 11 5 0 0 0 0.00% 100.00% +kexpr_struct_eq 59 28 13 6 0 0 0 0.00% 100.00% +level_list_struct_eq 30 5 9 5 0 0 0 0.00% 100.00% +spec_params_ptr_eq 30 5 9 5 0 0 0 0.00% 100.00% +extract_aux_spec_params_from_rec 26 2 3 2 0 0 0 0.00% 100.00% +first_recr_parent_block 107 5 77 8 0 0 0 0.00% 100.00% +put_mut_const_list 66 2 50 4 0 0 0 0.00% 100.00% +detect_aux_from_recrs_ex 66 2 50 3 0 0 0 0.00% 100.00% +aux_from_recrs_walk_ex 138 9 90 14 0 0 0 0.00% 100.00% +flat_find_pos 29 3 11 4 0 0 0 0.00% 100.00% +canon_kind_ord 27 8 1 1 0 0 0 0.00% 100.00% +canon_cmp_member_ctx 48 2 7 5 0 0 0 0.00% 100.00% +put_constructor 73 1 25 8 0 0 0 0.00% 100.00% +put_constructor_list 55 2 39 4 0 0 0 0.00% 100.00% +canon_cmp_member_same_kind_ctx 118 8 37 22 0 0 0 0.00% 100.00% +canon_cmp_ctor_range_ctx 63 2 34 8 0 0 0 0.00% 100.00% +apply_spec_params_lifted 26 2 7 5 0 0 0 0.00% 100.00% +put_inductive 77 1 34 10 0 0 0 0.00% 100.00% +canon_cmp_ctor_pair_ctx 83 3 23 14 0 0 0 0.00% 100.00% +nlvars_any_offset_geq 48 3 19 10 0 0 0 0.00% 100.00% +put_lam_telescope 74 2 39 5 0 0 0 0.00% 100.00% +char_of_nat_addr 9 1 2 2 0 0 0 0.00% 100.00% +canon_member_ci 26 1 15 4 0 0 0 0.00% 100.00% +canon_member_num_ctors 26 2 14 2 0 0 0 0.00% 100.00% +utf8_last_codepoint 10 1 2 2 0 0 0 0.00% 100.00% +canon_build_ctx_classes 29 2 8 5 0 0 0 0.00% 100.00% +unfold_a_and_loop 23 2 5 4 0 0 0 0.00% 100.00% +canon_build_ctx_members 64 3 24 14 0 0 0 0.00% 100.00% +canon_ctor_ctx_entries 24 2 5 4 0 0 0 0.00% 100.00% +canon_sort_loop 31 3 8 6 0 0 0 0.00% 100.00% +canon_refine_classes 26 2 7 5 0 0 0 0.00% 100.00% +canon_refine_one 24 3 6 4 0 0 0 0.00% 100.00% +canon_ins_sort 23 2 6 4 0 0 0 0.00% 100.00% +canon_insert_sorted 58 3 33 7 0 0 0 0.00% 100.00% +utf8_last_go 23 2 7 4 0 0 0 0.00% 100.00% +canon_group_consec 26 2 7 5 0 0 0 0.00% 100.00% +canon_group_walk 65 3 35 9 0 0 0 0.00% 100.00% +find_peer_rec_spec_walk 131 10 85 12 0 0 0 0.00% 100.00% +utf8_cont 13 1 3 3 0 0 0 0.00% 100.00% +canon_classes_eq 31 5 10 5 0 0 0 0.00% 100.00% +canon_flatten 21 2 6 4 0 0 0 0.00% 100.00% +canon_all_singleton 22 3 6 4 0 0 0 0.00% 100.00% +list_nil_addr 9 1 2 2 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +put_all_telescope 74 2 39 5 0 0 0 0.00% 100.00% +build_char_list 40 2 12 9 0 0 0 0.00% 100.00% +str_lit_delta_step 62 5 31 10 0 0 0 0.00% 100.00% +char_lit_codepoint 23 2 7 4 0 0 0 0.00% 100.00% +get_ci_dprj 130 1 109 6 0 0 0 0.00% 100.00% +canon_cmp_klimbs_tail 44 2 24 6 0 0 0 0.00% 100.00% +punit_addr 9 1 2 2 0 0 0 0.00% 100.00% +unit_addr 9 1 2 2 0 0 0 0.00% 100.00% +char_lit_codepoint_syn 43 6 18 7 0 0 0 0.00% 100.00% +klimbs_scalar_value 117 7 63 21 0 0 0 0.00% 100.00% +pack_def_kind_safety 18 9 1 1 0 0 0 0.00% 100.00% +canon_cmp_u64_lex 53 1 16 16 0 0 0 0.00% 100.00% +spec_params_dom_prefix_match 33 4 10 6 0 0 0 0.00% 100.00% +get_ci_rprj 121 1 108 6 0 0 0 0.00% 100.00% +nat_not_le_of_not_ble_eq_true_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +utf8_encode_prepend 212 4 100 51 0 0 0 0.00% 100.00% +char_type_addr 9 1 2 2 0 0 0 0.00% 100.00% +mk_nat_literal_64 13 1 4 4 0 0 0 0.00% 100.00% +put_quot_kind 16 4 2 2 0 0 0 0.00% 100.00% +canon_cmp_bytes 32 4 10 6 0 0 0 0.00% 100.00% +canon_g_list_eq 27 5 8 4 0 0 0 0.00% 100.00% +literal_eq 18 4 2 2 0 0 0 0.00% 100.00% +try_reduce_size_of_unit 71 5 29 16 0 0 0 0.00% 100.00% +check_native_bool 32 3 10 7 0 0 0 0.00% 100.00% +put_definition 68 1 42 8 0 0 0 0.00% 100.00% +canon_cmp_kexpr_ctx 29 2 12 4 0 0 0 0.00% 100.00% +put_mut_const 62 3 3 3 0 0 0 0.00% 100.00% +check_native_nat 21 3 7 3 0 0 0 0.00% 100.00% +put_recursor_rule 40 1 21 4 0 0 0 0.00% 100.00% +canon_cmp_kexpr_node_ctx 79 40 12 7 0 0 0 0.00% 100.00% +put_recursor_rule_list 30 2 14 4 0 0 0 0.00% 100.00% +list_cons_addr 9 1 2 2 0 0 0 0.00% 100.00% +klimbs_from_g 25 1 11 7 0 0 0 0.00% 100.00% +leaf_hash 17 1 5 5 0 0 0 0.00% 100.00% +node_hash 19 1 6 6 0 0 0 0.00% 100.00% +parse_atree_body 31 3 11 6 0 0 0 0.00% 100.00% +load_assumption_tree 96 1 84 6 0 0 0 0.00% 100.00% +addr_set_build 37 2 16 4 0 0 0 0.00% 100.00% +addr_set_member 16 1 2 2 0 0 0 0.00% 100.00% +env_walk 102 10 58 8 0 0 0 0.00% 100.00% +env_walk_refs 40 4 6 5 0 0 0 0.00% 100.00% +env_walk_leaves 31 2 4 4 0 0 0 0.00% 100.00% +run_check_env 38 3 16 6 0 0 0 0.00% 100.00% +walk_char_list_bytes 64 8 22 14 0 0 0 0.00% 100.00% +get_opt_u64_masked 23 2 11 2 0 0 0 0.00% 100.00% +get_opt_addr_masked 16 2 4 2 0 0 0 0.00% 100.00% +get_opt_bool_masked 16 2 4 2 0 0 0 0.00% 100.00% +get_opt_def_kind_masked 18 4 4 2 0 0 0 0.00% 100.00% +get_opt_quot_kind_masked 19 5 4 2 0 0 0 0.00% 100.00% +get_reveal_rule_list_inner 59 2 32 6 0 0 0 0.00% 100.00% +get_opt_rule_list_masked 27 2 13 3 0 0 0 0.00% 100.00% +get_reveal_ctor_info 80 1 64 9 0 0 0 0.00% 100.00% +get_ctor_entry 61 1 51 3 0 0 0 0.00% 100.00% +get_ctor_entry_list_inner 90 2 63 6 0 0 0 0.00% 100.00% +get_opt_ctor_entry_list_masked 27 2 13 3 0 0 0 0.00% 100.00% +get_reveal_mut_const_info 126 3 90 14 0 0 0 0.00% 100.00% +get_mut_entry 75 1 65 3 0 0 0 0.00% 100.00% +get_mut_entry_list_inner 104 2 77 6 0 0 0 0.00% 100.00% +get_reveal_info 134 11 90 14 0 0 0 0.00% 100.00% +expr_addr 34 1 22 5 0 0 0 0.00% 100.00% +def_safety_tag 11 3 1 1 0 0 0 0.00% 100.00% +check_opt_def_kind 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_def_safety 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_quot_kind 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_bool 12 2 1 1 0 0 0 0.00% 100.00% +check_opt_u64 26 2 1 1 0 0 0 0.00% 100.00% +check_opt_addr 80 2 65 3 0 0 0 0.00% 100.00% +check_opt_expr_addr 83 2 66 4 0 0 0 0.00% 100.00% +check_recr_rules 67 2 39 6 0 0 0 0.00% 100.00% +check_opt_recr_rules 14 2 1 2 0 0 0 0.00% 100.00% +check_ctor_entry 97 1 35 8 0 0 0 0.00% 100.00% +check_ctor_entries 67 2 51 4 0 0 0 0.00% 100.00% +check_opt_ctor_entries 14 2 1 2 0 0 0 0.00% 100.00% +check_mut_const 127 3 1 10 0 0 0 0.00% 100.00% +check_muts_components 128 2 110 5 0 0 0 0.00% 100.00% +run_reveal 139 9 49 11 0 0 0 0.00% 100.00% +run_contains 14 1 3 3 0 0 0 0.00% 100.00% +has_bvar_in_range 75 11 29 14 0 0 0 0.00% 100.00% +has_bvar_in_range_binder 19 2 3 3 0 0 0 0.00% 100.00% +mk_nat_one 13 1 4 4 0 0 0 0.00% 100.00% +has_bvar_in_range_let 24 3 4 4 0 0 0 0.00% 100.00% +list_length_u64.U8_8 42 2 27 4 0 0 0 0.00% 100.00% +list_concat.Tup.Ptr.U8_32.G 23 2 7 4 0 0 0 0.00% 100.00% +try_quot_ind 59 3 22 14 0 0 0 0.00% 100.00% +rbtree_map_lookup_or_default.G 64 4 28 10 0 0 0 0.00% 100.00% +defn_member_recur_addrs 30 2 4 3 0 0 0 0.00% 100.00% +put_expr 110 12 59 8 0 0 0 0.00% 100.00% +put_u64_le 26 2 4 3 0 0 0 0.00% 100.00% +list_length_u64.Constructor 68 2 53 4 0 0 0 0.00% 100.00% +univ_succ_count 49 2 26 4 0 0 0 0.00% 100.00% +list_length.U8_8 25 2 12 3 0 0 0 0.00% 100.00% +list_lookup_u64.MutConst 127 2 102 5 0 0 0 0.00% 100.00% +list_length_u64.MutConst 79 2 64 4 0 0 0 0.00% 100.00% +list_length_u64.RecursorRule 43 2 28 4 0 0 0 0.00% 100.00% +list_lookup_u64.Constructor 105 2 80 5 0 0 0 0.00% 100.00% +byte_array_empty_addr 9 1 2 2 0 0 0 0.00% 100.00% +list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode 28 2 9 4 0 0 0 0.00% 100.00% +try_str_dec_eq 71 7 29 14 0 0 0 0.00% 100.00% +try_reduce_bit_vec_ult 63 4 24 15 0 0 0 0.00% 100.00% +str_dec_eq_build 123 2 43 35 0 0 0 0.00% 100.00% +rbtree_map_insert.G 22 1 7 2 0 0 0 0.00% 100.00% +put_tag2 33 3 6 5 0 0 0 0.00% 100.00% +canon_ord_cmp_g 37 3 14 7 0 0 0 0.00% 100.00% +canon_ord_then 12 2 2 1 0 0 0 0.00% 100.00% +rbtree_map_ins.G 77 4 39 11 0 0 0 0.00% 100.00% +rbtree_map_balance.G 34 2 7 3 0 0 0 0.00% 100.00% +rbtree_map_balance_fix.G 122 57 31 8 0 0 0 0.00% 100.00% +canon_sord_lt_strong 6 1 1 1 0 0 0 0.00% 100.00% +univ_succ_base 40 2 19 3 0 0 0 0.00% 100.00% +canon_sord_eq_strong 6 1 1 1 0 0 0 0.00% 100.00% +canon_sord_gt_strong 6 1 1 1 0 0 0 0.00% 100.00% +canon_sord_then 14 2 2 1 0 0 0 0.00% 100.00% +canon_sord_of_g 7 1 1 1 0 0 0 0.00% 100.00% +canon_addr_cmp 105 1 80 18 0 0 0 0.00% 100.00% +canon_addr_chunk 17 1 2 2 0 0 0 0.00% 100.00% +canon_ctx_class_idx 25 3 8 4 0 0 0 0.00% 100.00% +canon_ctx_cmp_addr 32 5 8 6 0 0 0 0.00% 100.00% +bitvec_prep_spine_ult 46 4 16 10 0 0 0 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +np_whnf_inner_bv 16 1 5 4 0 0 0 0.00% 100.00% +put_recursor 98 1 36 12 0 0 0 0.00% 100.00% +canon_cmp_kuniv 44 16 10 6 0 0 0 0.00% 100.00% +canon_cmp_kuniv_list 32 4 10 6 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +canon_cmp_kliteral 18 4 2 2 0 0 0 0.00% 100.00% diff --git a/cold-groups/kstats-Nat.add_comm.txt b/cold-groups/kstats-Nat.add_comm.txt new file mode 100644 index 000000000..1df4ac49d --- /dev/null +++ b/cold-groups/kstats-Nat.add_comm.txt @@ -0,0 +1,739 @@ +=== Circuit Statistics === +Circuits: 730 +Total width: 33827 +Total FFT cost: 292233964 (2.92e8) +Total cache hits: 86596 +Total saved cost: 29.32% +------------------------------------------------------------------------------------------------------------------------------------------ +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +------------------------------------------------------------------------------------------------------------------------------------------ +Bytes2 24 0 0 0 65536 0 1.28e8 43.86% 43.86% +blake3_compress_inner_j 1192 1 561 497 973 0 5.76e7 19.71% 63.57% +memory[3] 12 0 0 0 17239 30090 1.52e7 5.19% 68.77% +blake3_compress_chunks 29 3 7 4 7303 0 1.39e7 4.74% 73.51% +blake3_compress 1080 1 929 40 139 0 5.35e6 1.83% 75.34% +address_eq 82 2 66 4 1019 107 4.21e6 1.44% 76.78% +convert_expr 60 12 25 7 1238 526 3.86e6 1.32% 78.10% +get_expr 50 12 23 5 1443 0 3.84e6 1.31% 79.41% +validate_expr_well_scoped 52 9 20 8 1197 630 3.23e6 1.10% 80.52% +get_tag4 37 2 22 4 1493 0 2.97e6 1.01% 81.53% +expr_lbr 35 9 9 6 1507 6551 2.84e6 0.97% 82.50% +expr_inst_many_walk 34 9 8 5 1240 0 2.21e6 0.76% 83.26% +const_idxs_expr 52 7 26 7 800 832 2.03e6 0.70% 83.96% +k_infer_app_spine_loop 59 8 21 11 713 1 2.02e6 0.69% 84.65% +expr_inst_many 21 2 4 4 1710 429 1.99e6 0.68% 85.33% +list_drop.Ptr.Expr 20 2 6 3 1623 706 1.79e6 0.61% 85.94% +k_infer_core 53 9 22 8 701 182 1.78e6 0.61% 86.55% +pad_block 18 2 4 3 1697 0 1.70e6 0.58% 87.13% +get_app_telescope 43 2 15 6 740 0 1.54e6 0.53% 87.66% +memory[4] 13 0 0 0 1955 14173 1.46e6 0.50% 88.16% +safe_refs_only 43 9 19 5 698 597 1.44e6 0.49% 88.65% +expr_glb_walk 34 10 8 5 801 0 1.34e6 0.46% 89.11% +bytes_to_block 265 1 193 65 139 0 1.32e6 0.45% 89.56% +expr_inst_levels_walk 36 9 9 6 663 0 1.14e6 0.39% 89.95% +collect_spine 23 2 8 4 964 634 1.13e6 0.39% 90.34% +list_snoc.G 22 2 6 4 982 513 1.11e6 0.38% 90.72% +memory[18] 27 0 0 0 800 3009 1.07e6 0.37% 91.09% +expr_glb 21 2 5 4 945 814 1.01e6 0.35% 91.44% +g_list_has 21 3 6 3 943 21 1.01e6 0.35% 91.78% +get_tag0 40 2 23 5 484 74 8.81e5 0.30% 92.08% +list_concat.Ptr.KExprNode 22 2 6 4 743 1138 8.06e5 0.28% 92.36% +list_lookup.Ptr.KLevelNode 16 1 5 3 846 175 6.89e5 0.24% 92.59% +ctx_trim 52 3 19 12 314 930 6.88e5 0.24% 92.83% +k_infer 15 1 4 4 883 81 6.80e5 0.23% 93.06% +expr_inst_levels 20 2 6 3 678 438 6.62e5 0.23% 93.29% +get_address 138 1 98 34 134 8 6.58e5 0.23% 93.51% +whnf_with_spine 34 6 11 5 420 22 6.37e5 0.22% 93.73% +whnf 38 6 14 6 373 142 6.19e5 0.21% 93.94% +list_length.Ptr.KExprNode 18 2 5 3 691 2172 6.11e5 0.21% 94.15% +blake3_compress_block 211 2 169 15 87 0 5.94e5 0.20% 94.36% +expr_lower_walk 53 10 18 9 270 0 5.88e5 0.20% 94.56% +get_u64_list 49 2 22 6 280 0 5.68e5 0.19% 94.75% +k_is_def_eq 29 3 7 6 416 156 5.40e5 0.18% 94.94% +expr_inst_many_bvar 24 2 5 5 472 0 5.20e5 0.18% 95.12% +peel_beta 32 3 12 5 364 8 5.09e5 0.17% 95.29% +expr_inst1_walk 34 9 8 5 296 0 4.24e5 0.15% 95.43% +get_expr_list 42 2 15 6 238 16 4.03e5 0.14% 95.57% +expr_inst1 21 2 4 4 421 95 4.01e5 0.14% 95.71% +expr_lift 23 3 5 4 380 529 3.88e5 0.13% 95.84% +whnf_nd 38 6 14 6 249 14 3.86e5 0.13% 95.97% +get_all_telescope 42 2 15 6 218 0 3.63e5 0.12% 96.10% +apply_spine_expr 22 2 6 4 361 64 3.50e5 0.12% 96.22% +expr_lower 23 3 5 4 342 218 3.43e5 0.12% 96.34% +get_u64_le 28 2 14 3 284 0 3.34e5 0.11% 96.45% +blake3_compress_layer 223 3 170 6 52 0 3.32e5 0.11% 96.56% +get_lam_telescope 42 2 15 6 199 1 3.26e5 0.11% 96.68% +whnf_nd_with_spine 34 6 11 5 228 18 3.12e5 0.11% 96.78% +whnf_const_head 77 16 32 10 114 0 3.04e5 0.10% 96.89% +blake3_finish 190 11 151 9 52 0 2.83e5 0.10% 96.98% +memory[32] 41 0 0 0 177 2427 2.77e5 0.09% 97.08% +try_string_lit_one 28 3 8 5 238 0 2.72e5 0.09% 97.17% +try_def_eq_app 49 6 18 9 150 10 2.71e5 0.09% 97.26% +k_check 15 1 3 3 362 191 2.44e5 0.08% 97.35% +get_constant 162 3 136 9 49 0 2.25e5 0.08% 97.42% +get_address_list 42 2 15 6 140 35 2.15e5 0.07% 97.50% +k_ensure_sort 18 1 7 4 278 163 2.13e5 0.07% 97.57% +ctx_seek_cut 44 2 16 10 134 6 2.13e5 0.07% 97.64% +expr_lift_walk 34 9 8 5 159 0 2.03e5 0.07% 97.71% +k_is_def_eq_core 40 2 15 8 137 16 1.99e5 0.07% 97.78% +const_idxs_exprs 24 2 7 5 200 48 1.91e5 0.07% 97.85% +list_take.Ptr.KExprNode 23 2 7 4 202 107 1.85e5 0.06% 97.91% +nl_subsume_entry 121 13 54 24 52 11 1.81e5 0.06% 97.97% +walk_refs_transitive 27 4 6 5 158 26 1.61e5 0.06% 98.03% +k_def_eq_rebase 44 2 12 11 106 0 1.61e5 0.05% 98.08% +expr_glb_binder 16 1 4 4 220 0 1.45e5 0.05% 98.13% +load_verified_constant 100 1 88 5 49 85 1.39e5 0.05% 98.18% +try_prim_dispatch 30 6 8 4 127 36 1.38e5 0.05% 98.23% +k_is_def_eq_slow_nd 32 4 9 6 119 0 1.36e5 0.05% 98.27% +ctx_close_cut 46 3 17 10 86 32 1.30e5 0.04% 98.32% +blake3 86 1 72 8 52 10 1.29e5 0.04% 98.36% +k_is_def_eq_struct_safe 40 9 12 6 94 0 1.27e5 0.04% 98.41% +level_struct_eq 39 12 11 5 95 41 1.25e5 0.04% 98.45% +Bytes1 11 0 0 0 256 0 1.22e5 0.04% 98.49% +get_ci 97 10 68 7 42 543 1.11e5 0.04% 98.53% +k_is_def_eq_slow 26 4 7 4 119 0 1.11e5 0.04% 98.57% +run_check_transitive 79 7 55 6 49 95 1.10e5 0.04% 98.60% +verify_bytes_against 73 1 33 2 52 0 1.10e5 0.04% 98.64% +prim_family 161 23 59 37 28 99 1.09e5 0.04% 98.68% +const_idxs_of 77 6 7 6 49 0 1.08e5 0.04% 98.72% +try_reduce_projection_definition 59 3 24 13 60 23 1.07e5 0.04% 98.75% +whnf_apply_beta 34 3 10 7 88 0 9.98e4 0.03% 98.79% +k_is_def_eq_ordered 19 2 4 3 131 6 9.22e4 0.03% 98.82% +check_const 75 8 20 15 42 7 8.64e4 0.03% 98.85% +level_imax 37 6 13 6 69 63 8.05e4 0.03% 98.87% +get_univ 55 5 33 6 49 4 7.74e4 0.03% 98.90% +whnf_nd_const_head 55 9 23 7 49 0 7.74e4 0.03% 98.93% +level_inst_params 28 5 7 5 83 65 7.71e4 0.03% 98.95% +get_constant_info_by_variant 64 8 46 2 42 0 7.40e4 0.03% 98.98% +projection_definition_info 54 5 23 10 46 46 7.03e4 0.02% 99.00% +memory[34] 43 0 0 0 53 155 6.72e4 0.02% 99.03% +de_args 32 5 10 5 60 12 5.89e4 0.02% 99.05% +ctx_next_cut 16 1 6 4 102 85 5.81e4 0.02% 99.07% +get_tag2 40 2 23 5 49 0 5.68e4 0.02% 99.09% +lbr_min 35 2 13 7 53 1058 5.50e4 0.02% 99.10% +memo_u32_less_than 28 1 13 7 63 4217 5.50e4 0.02% 99.12% +k_infer_only 93 12 45 15 25 13 5.49e4 0.02% 99.14% +lbr_max 35 2 13 7 52 1499 5.37e4 0.02% 99.16% +convert_univ_idxs 38 2 16 7 48 121 5.27e4 0.02% 99.18% +level_max 45 4 17 9 41 16 5.09e4 0.02% 99.20% +expr_inst1_bvar 20 3 4 3 75 0 4.94e4 0.02% 99.21% +whnf_proj_head 61 4 28 10 31 0 4.80e4 0.02% 99.23% +level_eq 36 10 10 5 46 10 4.74e4 0.02% 99.25% +level_max_subsumes 23 3 6 4 63 0 4.56e4 0.02% 99.26% +try_nat_dispatch_prewhnf 86 8 31 20 23 0 4.56e4 0.02% 99.28% +list_is_empty.U8 15 2 4 2 87 87 4.52e4 0.02% 99.29% +level_list_inst 25 2 7 5 57 51 4.36e4 0.01% 99.31% +is_str_prim_addr 65 8 22 15 26 0 4.07e4 0.01% 99.32% +try_eta_struct 91 8 48 14 20 0 4.00e4 0.01% 99.33% +level_max_go 39 6 13 7 37 0 3.89e4 0.01% 99.35% +level_is_not_zero 27 7 7 4 49 57 3.89e4 0.01% 99.36% +expr_lift_bvar 39 2 14 8 36 0 3.76e4 0.01% 99.37% +is_native_prim_addr 57 7 19 13 26 0 3.58e4 0.01% 99.39% +is_dec_prim_addr 57 7 19 13 26 0 3.58e4 0.01% 99.40% +nat_offset_of 58 12 23 9 25 2 3.46e4 0.01% 99.41% +is_unsafe_ci 29 9 2 1 42 62 3.44e4 0.01% 99.42% +level_max_offsets 47 3 18 10 29 0 3.42e4 0.01% 99.43% +u64_is_zero 25 9 2 1 45 2419 3.25e4 0.01% 99.45% +try_iota 108 5 39 25 15 3 3.22e4 0.01% 99.46% +whnf_nd_apply_beta 34 3 10 7 35 0 3.18e4 0.01% 99.47% +assert_safety 15 2 3 2 65 2 3.17e4 0.01% 99.48% +get_univ_list 53 2 24 7 25 48 3.17e4 0.01% 99.49% +relaxed_u64_pred 25 9 2 1 44 1187 3.16e4 0.01% 99.50% +const_num_lvls 27 8 1 1 41 211 3.11e4 0.01% 99.51% +const_type_of 27 8 1 1 41 28 3.11e4 0.01% 99.52% +k_is_def_eq_slow2 58 9 20 11 23 0 3.10e4 0.01% 99.53% +peel_n_foralls 21 2 7 3 49 4 3.07e4 0.01% 99.54% +peer_agree_walk 107 5 69 11 14 0 2.90e4 0.01% 99.55% +run_check 24 1 14 4 42 0 2.87e4 0.01% 99.56% +read_byte 18 2 5 3 50 0 2.72e4 0.01% 99.57% +level_offset_of 20 2 6 3 46 27 2.71e4 0.01% 99.58% +whnf_spine 25 2 7 5 37 16 2.54e4 0.01% 99.59% +memory[12] 21 0 0 0 42 670 2.53e4 0.01% 99.60% +glist_subset 75 5 32 16 16 39 2.46e4 0.01% 99.61% +validate_univ_params_seen 43 5 16 8 24 45 2.45e4 0.01% 99.61% +convert_definition 40 5 6 4 25 0 2.41e4 0.01% 99.62% +get_mut_const_list 86 2 59 6 14 0 2.34e4 0.01% 99.63% +address_eq_tail 84 6 66 3 14 0 2.29e4 0.01% 99.64% +get_constructor_list 75 2 48 6 15 0 2.25e4 0.01% 99.65% +try_nat_linear_rec 75 5 27 17 15 0 2.25e4 0.01% 99.65% +normalize_aux 33 7 8 5 27 6 2.22e4 0.01% 99.66% +is_bitvec_prim_addr 33 4 10 7 26 0 2.11e4 0.01% 99.67% +canon_muts_has_kind 69 6 51 3 15 6 2.08e4 0.01% 99.68% +build_recur_addrs_walk 71 2 51 5 14 0 1.94e4 0.01% 99.68% +get_ci_cprj 158 1 142 7 8 27 1.92e4 0.01% 99.69% +get_definition 30 1 18 6 25 0 1.83e4 0.01% 99.70% +try_reduce_fin_val_decidable_rec 149 9 58 37 8 37 1.82e4 0.01% 99.70% +check_muts_all 66 2 48 4 14 0 1.81e4 0.01% 99.71% +check_canonical_block 123 3 75 20 9 0 1.79e4 0.01% 99.71% +nl_subsumption_walk 25 2 7 5 28 1 1.78e4 0.01% 99.72% +flatten_u64 14 1 1 1 44 674 1.75e4 0.01% 99.73% +peel_params_subst 30 2 11 5 24 0 1.74e4 0.01% 99.73% +peel_n_alls_whnf 29 3 9 5 24 0 1.68e4 0.01% 99.74% +whnf_nd_proj_head 61 4 28 10 14 0 1.68e4 0.01% 99.74% +check_inductive_shape_ctors 52 2 17 10 15 0 1.58e4 0.01% 99.75% +put_constant 90 9 14 7 10 1 1.53e4 0.01% 99.75% +wrap_foralls 22 2 6 4 25 3 1.37e4 0.00% 99.76% +projection_addr 134 4 105 9 7 9 1.34e4 0.00% 99.76% +check_param_agreement_go 34 2 12 6 18 0 1.34e4 0.00% 99.77% +validate_univ_params_list 20 2 4 4 26 179 1.32e4 0.00% 99.77% +nl_add_var 43 4 13 9 15 1 1.31e4 0.00% 99.78% +whnf_iota_major 51 3 24 9 13 2 1.27e4 0.00% 99.78% +ctor_at 86 2 72 3 9 0 1.26e4 0.00% 99.79% +level_reduce 27 5 7 5 20 15 1.24e4 0.00% 99.79% +get_ci_iprj 121 1 108 6 7 20 1.21e4 0.00% 99.79% +try_nat_binop_dispatch 65 6 24 14 10 0 1.12e4 0.00% 99.80% +get_result_sort_level 28 2 9 5 18 12 1.12e4 0.00% 99.80% +convert_univ 33 5 13 5 16 75 1.11e4 0.00% 99.81% +put_constant_info 64 8 2 2 10 0 1.10e4 0.00% 99.81% +muts_member_at 108 2 94 3 7 15 1.09e4 0.00% 99.81% +peel_n_foralls_with_types 27 3 9 4 18 0 1.08e4 0.00% 99.82% +put_address 106 1 65 34 7 3 1.07e4 0.00% 99.82% +is_nat_zero 24 4 7 4 19 1 1.04e4 0.00% 99.82% +assert_first_args_are_param_bvars 27 2 9 4 17 1 9.99e3 0.00% 99.83% +glist_cmp 76 6 32 16 8 11 9.41e3 0.00% 99.83% +const_idxs_muts 76 4 53 7 8 6 9.41e3 0.00% 99.83% +build_succ_chain 53 2 20 5 10 13 9.16e3 0.00% 99.84% +expr_mentions_block 40 14 10 5 12 3 9.04e3 0.00% 99.84% +put_tag0 32 3 6 5 14 2 9.03e3 0.00% 99.84% +level_explicit_val 22 4 7 3 18 42 8.90e3 0.00% 99.85% +const_idxs_ctors 57 2 40 5 9 6 8.45e3 0.00% 99.85% +memory[10] 19 0 0 0 19 381 8.35e3 0.00% 99.85% +canon_indc_positions 67 3 50 4 8 6 8.33e3 0.00% 99.85% +str_lit_to_ctor_app_or_self 24 3 7 4 16 29 8.26e3 0.00% 99.86% +peel_n_lams_collect 29 3 10 4 14 0 8.23e3 0.00% 99.86% +check_block_peer_param_agreement 81 4 52 4 7 0 8.21e3 0.00% 99.86% +peel_ctor_params_subst 46 3 16 8 10 0 8.00e3 0.00% 99.87% +check_field_universes_skip_params 25 2 7 4 15 0 7.87e3 0.00% 99.87% +k_infer_proj 62 1 39 13 8 0 7.73e3 0.00% 99.87% +bytes_to_addr 44 1 34 3 10 1 7.67e3 0.00% 99.87% +count_ctors 51 2 38 3 9 6 7.60e3 0.00% 99.88% +check_muts_member_at 74 1 15 5 7 0 7.52e3 0.00% 99.88% +check_field_universes_inner 29 2 8 6 13 0 7.44e3 0.00% 99.88% +check_positivity_fields 26 2 6 5 14 0 7.43e3 0.00% 99.88% +build_motive_apps 23 2 5 4 15 0 7.28e3 0.00% 99.89% +try_def_eq_nat 41 4 16 7 10 0 7.17e3 0.00% 99.89% +convert_constructor 57 1 6 6 8 0 7.13e3 0.00% 99.89% +memory[47] 56 0 0 0 8 93 7.01e3 0.00% 99.89% +get_constructor 55 1 41 8 8 0 6.89e3 0.00% 99.90% +try_extract_nat 30 6 9 5 12 38 6.88e3 0.00% 99.90% +get_inductive 67 1 51 9 7 0 6.84e3 0.00% 99.90% +memory[36] 45 0 0 0 9 33 6.74e3 0.00% 99.90% +get_mut_const 62 3 48 3 7 0 6.34e3 0.00% 99.91% +memory[9] 18 0 0 0 16 42 6.34e3 0.00% 99.91% +check_positivity_aug 78 5 35 15 6 0 6.26e3 0.00% 99.91% +u64_byte_count 150 128 8 1 4 20 6.14e3 0.00% 99.91% +put_tag4 33 3 6 5 10 0 5.84e3 0.00% 99.91% +compare_rules 89 4 40 16 5 0 5.35e3 0.00% 99.92% +walk_fields_classify 42 3 14 7 8 0 5.33e3 0.00% 99.92% +nl_eq 51 7 18 10 7 0 5.26e3 0.00% 99.92% +convert_inductive 50 1 6 6 7 0 5.16e3 0.00% 99.92% +try_unit_like 28 2 7 6 10 0 5.01e3 0.00% 99.92% +check_ctor_return_type 37 1 13 12 8 8 4.73e3 0.00% 99.92% +nl_add_const_go 58 5 22 12 6 0 4.71e3 0.00% 99.93% +try_proof_irrel 25 2 6 5 10 0 4.51e3 0.00% 99.93% +level_normalize 25 1 9 9 10 4 4.51e3 0.00% 99.93% +assert_lvls_are_params 25 2 8 4 10 5 4.51e3 0.00% 99.93% +peel_field_loop 34 2 9 6 8 0 4.37e3 0.00% 99.93% +flat_originals_walk 100 5 68 9 4 0 4.14e3 0.00% 99.93% +apply_ihs_full 100 2 30 26 4 0 4.14e3 0.00% 99.94% +get_constructor_proj 31 1 21 4 8 0 4.01e3 0.00% 99.94% +nl_skip_empty 30 4 11 5 8 7 3.89e3 0.00% 99.94% +cleanup_nat_offset_major 45 5 19 8 6 24 3.71e3 0.00% 99.94% +level_equal 23 2 5 5 9 13 3.60e3 0.00% 99.94% +try_extract_nat_app 33 4 11 6 7 0 3.49e3 0.00% 99.94% +build_minor_doms 54 2 19 7 5 0 3.31e3 0.00% 99.94% +level_list_eq 31 5 10 5 7 17 3.30e3 0.00% 99.94% +build_ih_doms 78 2 24 20 4 0 3.26e3 0.00% 99.94% +get_recursor_rule_list 53 2 24 7 5 0 3.26e3 0.00% 99.95% +is_prop_type 30 3 11 5 7 3 3.20e3 0.00% 99.95% +populate_rules 52 3 18 6 5 0 3.20e3 0.00% 99.95% +is_inductive_prop 24 1 9 6 8 0 3.17e3 0.00% 99.95% +head_addr 24 2 9 4 8 0 3.17e3 0.00% 99.95% +list_any_mentions_block 24 3 7 4 8 2 3.17e3 0.00% 99.95% +check_field_universes 23 2 6 4 8 8 3.05e3 0.00% 99.95% +build_apply_field_bvars 23 2 5 4 8 0 3.05e3 0.00% 99.95% +check_prop_field_if_prop 22 2 5 4 8 0 2.93e3 0.00% 99.95% +nl_add_const 22 4 5 3 8 3 2.93e3 0.00% 99.96% +try_match_nat_add 47 6 17 9 5 0 2.91e3 0.00% 99.96% +assert_return_head_is_parent 27 1 15 4 7 1 2.90e3 0.00% 99.96% +whnf_get_ctor_or_none 26 2 9 5 7 38 2.81e3 0.00% 99.96% +glist_eq_len 26 4 8 4 7 22 2.81e3 0.00% 99.96% +check_positivity 20 1 5 5 8 8 2.69e3 0.00% 99.96% +is_muts_block 61 2 50 2 4 6 2.58e3 0.00% 99.96% +convert_rec_rules 40 2 16 6 5 0 2.50e3 0.00% 99.96% +put_definition_proj 22 1 3 3 7 0 2.41e3 0.00% 99.96% +get_inductive_proj 22 1 12 3 7 0 2.41e3 0.00% 99.96% +build_all_minors_walk 55 3 24 8 4 0 2.34e3 0.00% 99.96% +try_struct_eta_iota 93 9 39 16 3 0 2.32e3 0.00% 99.97% +nl_le 36 6 12 6 5 1 2.27e3 0.00% 99.97% +nl_covers_var 35 4 11 6 5 0 2.21e3 0.00% 99.97% +build_all_motives_walk 51 3 24 8 4 0 2.18e3 0.00% 99.97% +nlvars_dominates 50 4 19 10 4 0 2.14e3 0.00% 99.97% +bytes_to_u64_limb 50 10 20 3 4 0 2.14e3 0.00% 99.97% +check_inductive_shape 19 1 3 4 7 2 2.12e3 0.00% 99.97% +ctor_subst_param_for 49 3 17 10 4 0 2.10e3 0.00% 99.97% +check_param_agreement 14 1 2 3 8 8 1.97e3 0.00% 99.97% +collect_spine_of_ctor 45 3 23 7 4 11 1.94e3 0.00% 99.97% +build_apply_xs 22 2 5 4 6 2 1.92e3 0.00% 99.97% +level_leq 30 3 9 6 5 1 1.92e3 0.00% 99.97% +nat_lit_to_ctor_or_self 43 4 14 10 4 11 1.86e3 0.00% 99.97% +glist_ordered_insert 73 4 31 16 3 3 1.84e3 0.00% 99.97% +nl_le_vars 28 3 8 5 5 1 1.81e3 0.00% 99.98% +klimbs_sub_borrow 69 6 42 7 3 0 1.75e3 0.00% 99.98% +collect_n_doms_whnf 40 4 16 7 4 0 1.74e3 0.00% 99.98% +muts_indc_count_is_one 66 4 50 3 3 1 1.68e3 0.00% 99.98% +build_flat_block 159 7 121 12 2 0 1.66e3 0.00% 99.98% +build_minor_at_depth 65 1 25 21 3 0 1.65e3 0.00% 99.98% +lbr_dec 11 2 2 1 8 456 1.61e3 0.00% 99.98% +lazy_delta_loop 35 7 10 5 4 0 1.54e3 0.00% 99.98% +is_unit_like_type 60 7 34 7 3 7 1.53e3 0.00% 99.98% +check_rec_rules_wellscoped 23 2 6 4 5 0 1.52e3 0.00% 99.98% +try_nat_offset_dispatch 59 4 19 14 3 0 1.51e3 0.00% 99.98% +const_idxs_rules 32 2 15 5 4 1 1.42e3 0.00% 99.98% +build_rec_lvls_list 21 2 5 4 5 0 1.40e3 0.00% 99.98% +try_unfold_proj_app 31 3 11 6 4 0 1.38e3 0.00% 99.98% +peel_motive_params_subst 31 2 9 5 4 0 1.38e3 0.00% 99.98% +build_recur_addrs 11 1 2 2 7 8 1.33e3 0.00% 99.98% +check_recursor_canonical_full 125 9 50 18 2 0 1.32e3 0.00% 99.98% +build_peer_recs 29 2 10 5 4 0 1.30e3 0.00% 99.98% +klimbs_normalize 48 4 25 7 3 8 1.25e3 0.00% 99.98% +build_rule_rhs 45 1 15 12 3 0 1.18e3 0.00% 99.98% +build_flat_own_params 45 4 24 6 3 1 1.18e3 0.00% 99.99% +projection_addr_ctor 41 1 23 9 3 0 1.08e3 0.00% 99.99% +build_major_params 23 2 5 4 4 0 1.06e3 0.00% 99.99% +collect_index_doms 39 4 15 7 3 2 1.04e3 0.00% 99.99% +build_rec_type_from 93 3 29 23 2 0 1.00e3 0.00% 99.99% +mk_nat_offset_stuck 37 2 10 9 3 0 9.88e2 0.00% 99.99% +count_foralls_body 20 2 6 3 4 0 9.44e2 0.00% 99.99% +memory[11] 20 0 0 0 4 10 9.44e2 0.00% 99.99% +list_length.KRecRule 20 2 7 3 4 1 9.44e2 0.00% 99.99% +get_recursor 87 1 69 11 2 0 9.42e2 0.00% 99.99% +put_constructor_proj 31 1 4 4 3 0 8.45e2 0.00% 99.99% +memory[2] 11 0 0 0 5 6 8.19e2 0.00% 99.99% +check_recursor_member 72 3 24 14 2 0 7.92e2 0.00% 99.99% +convert_recursor 71 1 8 8 2 0 7.82e2 0.00% 99.99% +ind_is_solo 69 3 52 4 2 0 7.62e2 0.00% 99.99% +find_peer_recursor_with_spec 67 2 50 3 2 0 7.42e2 0.00% 99.99% +list_lift_each 26 2 7 5 3 1 7.26e2 0.00% 99.99% +list_lift_indices 26 2 7 5 3 0 7.26e2 0.00% 99.99% +memory[5] 14 0 0 0 4 24 7.04e2 0.00% 99.99% +find_rule 25 3 10 3 3 10 7.02e2 0.00% 99.99% +compute_k_target 62 6 23 8 2 0 6.92e2 0.00% 99.99% +run_claim 128 5 71 8 1 0 6.56e2 0.00% 99.99% +try_nat_binop_addr 128 15 44 31 1 0 6.56e2 0.00% 99.99% +replace_spine_major 23 1 7 7 3 0 6.55e2 0.00% 99.99% +k_is_def_eq_struct_go 58 26 13 6 2 0 6.52e2 0.00% 99.99% +bytes_to_limbs 57 5 29 9 2 5 6.42e2 0.00% 99.99% +apply_indices_in_conclusion 22 2 5 4 3 0 6.31e2 0.00% 99.99% +build_param_lvls_range 22 2 5 4 3 2 6.31e2 0.00% 99.99% +list_reverse_acc.G 22 2 6 4 3 0 6.31e2 0.00% 99.99% +list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode 21 2 8 3 3 1 6.07e2 0.00% 99.99% +skip_bytes 21 3 6 3 3 1 6.07e2 0.00% 99.99% +u64_sub_with_borrow 53 1 16 16 2 0 6.02e2 0.00% 99.99% +build_ctor_app_params 19 2 3 2 3 0 5.60e2 0.00% 99.99% +build_motive_type_flat 48 3 12 10 2 0 5.52e2 0.00% 99.99% +load_verified_blob 46 1 36 3 2 5 5.32e2 0.00% 99.99% +ctors_before_pos 46 5 24 5 2 0 5.32e2 0.00% 99.99% +subst_param_for 46 3 17 9 2 0 5.32e2 0.00% 99.99% +build_rec_type 45 2 20 5 2 0 5.22e2 0.00% 99.99% +klimbs_eq 44 5 23 5 2 4 5.12e2 0.00% 99.99% +flat_find_pos_kind 43 7 17 5 2 0 5.02e2 0.00% 99.99% +is_large_eliminator 41 7 7 4 2 0 4.82e2 0.00% 99.99% +canonical_rules_at_pos 41 1 10 8 2 0 4.82e2 0.00% 100.00% +is_rec_field_peel 40 3 16 7 2 0 4.72e2 0.00% 100.00% +memory[6] 15 0 0 0 3 25 4.65e2 0.00% 100.00% +flat_find_matching 39 5 15 5 2 0 4.62e2 0.00% 100.00% +lazy_delta_both_proj 39 7 10 7 2 0 4.62e2 0.00% 100.00% +nlvars_eq 36 6 12 6 2 1 4.32e2 0.00% 100.00% +flat_member_at 31 3 12 5 2 4 3.82e2 0.00% 100.00% +try_eta_swap 30 4 11 4 2 0 3.72e2 0.00% 100.00% +rec_to_parent_addr 28 1 12 5 2 18 3.52e2 0.00% 100.00% +klimbs_add_carry 67 5 41 7 1 0 3.51e2 0.00% 100.00% +check_rec_major_spine 26 1 9 5 2 0 3.32e2 0.00% 100.00% +klimbs_is_zero 26 2 13 3 2 11 3.32e2 0.00% 100.00% +check_parent_inductive_shape 24 2 2 2 2 0 3.12e2 0.00% 100.00% +is_nat_succ_ih_step 58 7 26 10 1 0 3.06e2 0.00% 100.00% +build_succ_offset 57 2 17 16 1 0 3.01e2 0.00% 100.00% +idx_to_u64 22 1 10 6 2 12 2.92e2 0.00% 100.00% +k_infer_lit 20 2 4 4 2 0 2.72e2 0.00% 100.00% +list_lookup_or_default.Ptr.U8_32 20 2 5 3 2 3 2.72e2 0.00% 100.00% +klimbs_sub 18 2 4 3 2 1 2.52e2 0.00% 100.00% +unpack_def_kind_safety 17 9 1 1 2 23 2.42e2 0.00% 100.00% +put_expr_list 42 2 24 5 1 0 2.26e2 0.00% 100.00% +defn_is_unsafe_ci 15 5 2 1 2 23 2.22e2 0.00% 100.00% +klimbs_succ 41 3 23 5 1 7 2.21e2 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +klimbs_dec 14 1 4 4 2 1 2.12e2 0.00% 100.00% +build_all_minors 14 1 2 2 2 0 2.12e2 0.00% 100.00% +list_reverse.G 13 1 3 3 2 17 2.02e2 0.00% 100.00% +is_rec_field 13 1 3 2 2 0 2.02e2 0.00% 100.00% +k_is_def_eq_struct 12 1 2 2 2 0 1.92e2 0.00% 100.00% +build_all_motives 12 1 2 2 2 0 1.92e2 0.00% 100.00% +list_length_u64.Ptr.Univ 35 2 20 4 1 2 1.91e2 0.00% 100.00% +check_valid_ind_app 35 1 17 8 1 0 1.91e2 0.00% 100.00% +u64_eq 33 9 2 1 1 0 1.81e2 0.00% 100.00% +put_univ_list 33 2 15 5 1 0 1.81e2 0.00% 100.00% +mk_nat_lit 10 1 2 2 2 0 1.72e2 0.00% 100.00% +caddr_is_peer 31 2 15 4 1 1 1.71e2 0.00% 100.00% +compute_iprj_addr 30 1 15 8 1 2 1.66e2 0.00% 100.00% +get_expr_let 28 1 8 5 1 0 1.56e2 0.00% 100.00% +assert_occ_param_bvars 27 2 9 4 1 0 1.51e2 0.00% 100.00% +addr_list_contains 24 3 7 4 1 0 1.36e2 0.00% 100.00% +peel_leading_foralls_acc 24 2 8 4 1 0 1.36e2 0.00% 100.00% +expr_lbr_let 23 1 7 7 1 0 1.31e2 0.00% 100.00% +put_sharing 22 1 11 4 1 9 1.26e2 0.00% 100.00% +wrap_lams 22 2 6 4 1 0 1.26e2 0.00% 100.00% +put_address_list 22 2 6 4 1 0 1.26e2 0.00% 100.00% +put_univs 22 1 11 4 1 9 1.26e2 0.00% 100.00% +put_refs 22 1 11 4 1 9 1.26e2 0.00% 100.00% +get_opt_addr 18 2 5 3 1 0 1.06e2 0.00% 100.00% +memory[8] 17 0 0 0 1 329 1.01e2 0.00% 100.00% +peel_leading_foralls 15 1 5 4 1 1 9.10e1 0.00% 100.00% +klimbs_add 11 1 2 2 1 0 7.10e1 0.00% 100.00% +assert_wire_bool 10 1 2 2 1 7 6.60e1 0.00% 100.00% +reduce_nat_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_sub_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +string_to_byte_array_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +string_dec_eq_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_dec_le_addr_dec 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_dec_eq_addr_dec 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_dec_lt_addr_dec 9 1 2 2 1 25 6.10e1 0.00% 100.00% +int_dec_eq_addr_dec 9 1 2 2 1 25 6.10e1 0.00% 100.00% +int_dec_le_addr_dec 9 1 2 2 1 25 6.10e1 0.00% 100.00% +int_dec_lt_addr_dec 9 1 2 2 1 25 6.10e1 0.00% 100.00% +size_of_size_of_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +subtype_val_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +bit_vec_to_nat_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +bit_vec_ult_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +decidable_decide_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +fin_addr 9 1 2 2 1 7 6.10e1 0.00% 100.00% +nat_addr_io 9 1 2 2 1 2 6.10e1 0.00% 100.00% +string_utf8_byte_size_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_zero_addr 9 1 2 2 1 1 6.10e1 0.00% 100.00% +nat_succ_addr_iota 9 1 2 2 1 62 6.10e1 0.00% 100.00% +nat_pred_addr 9 1 2 2 1 49 6.10e1 0.00% 100.00% +nat_add_addr 9 1 2 2 1 43 6.10e1 0.00% 100.00% +nat_shift_left_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_mul_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_pow_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_gcd_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +string_append_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_mod_addr 9 1 2 2 1 28 6.10e1 0.00% 100.00% +nat_div_addr 9 1 2 2 1 28 6.10e1 0.00% 100.00% +nat_land_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_lor_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_xor_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +string_back_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_shift_right_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +string_of_list_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_beq_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +nat_ble_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +punit_size_of_1_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +system_platform_num_bits_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +string_legacy_back_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +reduce_bool_addr 9 1 2 2 1 25 6.10e1 0.00% 100.00% +put_quot_kind 16 4 2 2 0 0 0 0.00% 100.00% +nl_covers_const 61 6 24 12 0 0 0 0.00% 100.00% +nlvars_any_offset_geq 48 3 19 10 0 0 0 0.00% 100.00% +check_no_dep_data_field_if_prop 28 3 7 5 0 0 0 0.00% 100.00% +utf8_cont 13 1 3 3 0 0 0 0.00% 100.00% +utf8_decode_one 76 4 32 17 0 0 0 0.00% 100.00% +klimbs_gcd 20 2 4 4 0 0 0 0.00% 100.00% +klimbs_pow 43 3 12 11 0 0 0 0.00% 100.00% +klimbs_le 27 2 13 3 0 0 0 0.00% 100.00% +put_recursor_rule 40 1 21 4 0 0 0 0.00% 100.00% +u64_mul 222 1 155 46 0 0 0 0.00% 100.00% +decidable_is_true_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +decidable_is_false_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +nat_le_of_ble_eq_true_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +nat_not_le_of_not_ble_eq_true_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +nat_eq_of_beq_eq_true_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +nat_ne_of_beq_eq_false_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +bool_type_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +eq_refl_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +klimbs_mul 14 1 3 3 0 0 0 0.00% 100.00% +klimbs_mul_outer 40 2 16 7 0 0 0 0.00% 100.00% +klimbs_mul_single 86 3 47 7 0 0 0 0.00% 100.00% +int_of_nat_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +int_neg_succ_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +u64_and 40 1 9 9 0 0 0 0.00% 100.00% +is_int_dec_prim_addr 33 4 10 7 0 0 0 0.00% 100.00% +try_extract_int 49 6 20 9 0 0 0 0.00% 100.00% +intern_int_lit 29 3 8 6 0 0 0 0.00% 100.00% +try_normalize_int_decidable 64 4 26 13 0 0 0 0.00% 100.00% +normalize_int_dec_rebuild 53 3 16 12 0 0 0 0.00% 100.00% +try_dec_dispatch 70 4 26 16 0 0 0 0.00% 100.00% +dec_rewrite_lt_to_le 49 2 14 13 0 0 0 0.00% 100.00% +dec_dispatch_le_eq 47 5 14 9 0 0 0 0.00% 100.00% +dec_build_proof 95 8 30 22 0 0 0 0.00% 100.00% +try_str_dec_eq 71 7 29 14 0 0 0 0.00% 100.00% +str_dec_eq_build 123 2 43 35 0 0 0 0.00% 100.00% +dec_finish 90 4 32 22 0 0 0 0.00% 100.00% +canon_ord_cmp_g 37 3 14 7 0 0 0 0.00% 100.00% +canon_ord_then 12 2 2 1 0 0 0 0.00% 100.00% +canon_sord_lt_strong 6 1 1 1 0 0 0 0.00% 100.00% +canon_sord_eq_strong 6 1 1 1 0 0 0 0.00% 100.00% +canon_sord_gt_strong 6 1 1 1 0 0 0 0.00% 100.00% +canon_sord_then 14 2 2 1 0 0 0 0.00% 100.00% +canon_sord_of_g 7 1 1 1 0 0 0 0.00% 100.00% +canon_addr_cmp 105 1 80 18 0 0 0 0.00% 100.00% +canon_addr_chunk 17 1 2 2 0 0 0 0.00% 100.00% +canon_ctx_class_idx 25 3 8 4 0 0 0 0.00% 100.00% +canon_ctx_cmp_addr 32 5 8 6 0 0 0 0.00% 100.00% +canon_cmp_kuniv 44 16 10 6 0 0 0 0.00% 100.00% +canon_cmp_kuniv_list 32 4 10 6 0 0 0 0.00% 100.00% +canon_cmp_kliteral 18 4 2 2 0 0 0 0.00% 100.00% +canon_cmp_klimbs 29 2 7 7 0 0 0 0.00% 100.00% +canon_cmp_klimbs_tail 44 2 24 6 0 0 0 0.00% 100.00% +canon_cmp_u64_lex 53 1 16 16 0 0 0 0.00% 100.00% +canon_cmp_bytes 32 4 10 6 0 0 0 0.00% 100.00% +canon_cmp_kexpr_ctx 29 2 12 4 0 0 0 0.00% 100.00% +canon_cmp_kexpr_node_ctx 79 40 12 7 0 0 0 0.00% 100.00% +canon_cmp_krec_rule_ctx 26 1 8 5 0 0 0 0.00% 100.00% +canon_cmp_krec_rule_list_ctx 40 4 17 6 0 0 0 0.00% 100.00% +canon_kind_ord 27 8 1 1 0 0 0 0.00% 100.00% +canon_cmp_member_ctx 48 2 7 5 0 0 0 0.00% 100.00% +canon_cmp_member_same_kind_ctx 118 8 37 22 0 0 0 0.00% 100.00% +canon_cmp_ctor_range_ctx 63 2 34 8 0 0 0 0.00% 100.00% +canon_cmp_ctor_pair_ctx 83 3 23 14 0 0 0 0.00% 100.00% +canon_cprj_addr 41 1 23 9 0 0 0 0.00% 100.00% +canon_member_ci 26 1 15 4 0 0 0 0.00% 100.00% +canon_member_num_ctors 26 2 14 2 0 0 0 0.00% 100.00% +canon_build_ctx_classes 29 2 8 5 0 0 0 0.00% 100.00% +canon_build_ctx_members 64 3 24 14 0 0 0 0.00% 100.00% +canon_ctor_ctx_entries 24 2 5 4 0 0 0 0.00% 100.00% +canon_sort_loop 31 3 8 6 0 0 0 0.00% 100.00% +canon_refine_classes 26 2 7 5 0 0 0 0.00% 100.00% +canon_refine_one 24 3 6 4 0 0 0 0.00% 100.00% +canon_ins_sort 23 2 6 4 0 0 0 0.00% 100.00% +canon_insert_sorted 58 3 33 7 0 0 0 0.00% 100.00% +canon_group_consec 26 2 7 5 0 0 0 0.00% 100.00% +canon_group_walk 65 3 35 9 0 0 0 0.00% 100.00% +canon_classes_eq 31 5 10 5 0 0 0 0.00% 100.00% +canon_flatten 21 2 6 4 0 0 0 0.00% 100.00% +canon_all_singleton 22 3 6 4 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +build_char_list 40 2 12 9 0 0 0 0.00% 100.00% +str_lit_delta_step 62 5 31 10 0 0 0 0.00% 100.00% +u64_or 40 1 9 9 0 0 0 0.00% 100.00% +u64_xor_kbits 40 1 9 9 0 0 0 0.00% 100.00% +klimbs_land 52 3 31 6 0 0 0 0.00% 100.00% +klimbs_lor 52 3 31 6 0 0 0 0.00% 100.00% +klimbs_shl_limbs 18 2 4 3 0 0 0 0.00% 100.00% +klimbs_xor_op 52 3 31 6 0 0 0 0.00% 100.00% +quot_type_addr 9 1 2 2 0 0 0 0.00% 100.00% +count_foralls_at_least 23 3 7 3 0 0 0 0.00% 100.00% +check_eq_type 24 1 15 4 0 0 0 0.00% 100.00% +check_quot 29 5 6 5 0 0 0 0.00% 100.00% +klimbs_shl 18 1 5 5 0 0 0 0.00% 100.00% +klimbs_from_g 25 1 11 7 0 0 0 0.00% 100.00% +put_recursor 98 1 36 12 0 0 0 0.00% 100.00% +put_axiom 44 1 22 5 0 0 0 0.00% 100.00% +put_quotient 44 1 22 5 0 0 0 0.00% 100.00% +put_constructor 73 1 25 8 0 0 0 0.00% 100.00% +put_constructor_list 55 2 39 4 0 0 0 0.00% 100.00% +walk_char_list_bytes 64 8 22 14 0 0 0 0.00% 100.00% +put_inductive 77 1 34 10 0 0 0 0.00% 100.00% +char_lit_codepoint 23 2 7 4 0 0 0 0.00% 100.00% +char_lit_codepoint_syn 43 6 18 7 0 0 0 0.00% 100.00% +klimbs_scalar_value 117 7 63 21 0 0 0 0.00% 100.00% +put_mut_const 62 3 3 3 0 0 0 0.00% 100.00% +put_mut_const_list 66 2 50 4 0 0 0 0.00% 100.00% +utf8_encode_prepend 212 4 100 51 0 0 0 0.00% 100.00% +punit_addr 9 1 2 2 0 0 0 0.00% 100.00% +canon_g_list_eq 27 5 8 4 0 0 0 0.00% 100.00% +literal_eq 18 4 2 2 0 0 0 0.00% 100.00% +unit_addr 9 1 2 2 0 0 0 0.00% 100.00% +check_nested_ctors_positivity 51 2 20 9 0 0 0 0.00% 100.00% +byte_array_empty_addr 9 1 2 2 0 0 0 0.00% 100.00% +univ_succ_count 49 2 26 4 0 0 0 0.00% 100.00% +mk_nat_literal_64 13 1 4 4 0 0 0 0.00% 100.00% +mk_nat_one 13 1 4 4 0 0 0 0.00% 100.00% +try_native_dispatch 98 8 37 23 0 0 0 0.00% 100.00% +has_bvar_in_range 75 11 29 14 0 0 0 0.00% 100.00% +klimbs_shr 18 1 5 5 0 0 0 0.00% 100.00% +has_bvar_in_range_binder 19 2 3 3 0 0 0 0.00% 100.00% +check_large_prop_ctor 27 3 8 4 0 0 0 0.00% 100.00% +check_large_walk_fields 44 5 14 8 0 0 0 0.00% 100.00% +all_bvars_in_args 24 3 7 4 0 0 0 0.00% 100.00% +args_contain_bvar 28 4 10 4 0 0 0 0.00% 100.00% +has_bvar_in_range_let 24 3 4 4 0 0 0 0.00% 100.00% +try_reduce_subtype_val 63 4 26 14 0 0 0 0.00% 100.00% +try_reduce_size_of_unit 71 5 29 16 0 0 0 0.00% 100.00% +check_native_bool 32 3 10 7 0 0 0 0.00% 100.00% +u64_add 53 1 16 16 0 0 0 0.00% 100.00% +extract_aux_occ_us 46 4 14 6 0 0 0 0.00% 100.00% +extract_aux_spec_params 27 1 10 6 0 0 0 0.00% 100.00% +spec_params_lower 28 2 8 6 0 0 0 0.00% 100.00% +check_native_nat 21 3 7 3 0 0 0 0.00% 100.00% +blake3_next_layer 221 4 136 5 0 0 0 0.00% 100.00% +aux_already_in 33 5 11 5 0 0 0 0.00% 100.00% +kexpr_struct_eq 59 28 13 6 0 0 0 0.00% 100.00% +level_list_struct_eq 30 5 9 5 0 0 0 0.00% 100.00% +spec_params_ptr_eq 30 5 9 5 0 0 0 0.00% 100.00% +extract_aux_spec_params_from_rec 26 2 3 2 0 0 0 0.00% 100.00% +first_recr_parent_block 107 5 77 8 0 0 0 0.00% 100.00% +relaxed_u64_succ 25 9 2 1 0 0 0 0.00% 100.00% +detect_aux_from_recrs_ex 66 2 50 3 0 0 0 0.00% 100.00% +aux_from_recrs_walk_ex 138 9 90 14 0 0 0 0.00% 100.00% +flat_find_pos 29 3 11 4 0 0 0 0.00% 100.00% +expr_glb_let 21 1 6 6 0 0 0 0.00% 100.00% +put_expr 110 12 59 8 0 0 0 0.00% 100.00% +put_u64_le 26 2 4 3 0 0 0 0.00% 100.00% +compare_struct_fields 31 3 7 5 0 0 0 0.00% 100.00% +expr_lift_let 21 1 5 5 0 0 0 0.00% 100.00% +bit_vec_of_nat_addr 9 1 2 2 0 0 0 0.00% 100.00% +apply_spec_params_lifted 26 2 7 5 0 0 0 0.00% 100.00% +mk_nat_binop_stuck 24 1 7 7 0 0 0 0.00% 100.00% +put_tag2 33 3 6 5 0 0 0 0.00% 100.00% +bit_vec_addr 9 1 2 2 0 0 0 0.00% 100.00% +put_u64_list 29 2 13 4 0 0 0 0.00% 100.00% +expr_inst1_let 21 1 5 5 0 0 0 0.00% 100.00% +app_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +lam_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +put_definition 68 1 42 8 0 0 0 0.00% 100.00% +expr_inst_many_let 21 1 5 5 0 0 0 0.00% 100.00% +nlvars_add 102 5 44 23 0 0 0 0.00% 100.00% +lt_lt_addr 9 1 2 2 0 0 0 0.00% 100.00% +univ_succ_base 40 2 19 3 0 0 0 0.00% 100.00% +put_univ 53 5 22 6 0 0 0 0.00% 100.00% +str_addr 9 1 2 2 0 0 0 0.00% 100.00% +decidable_rec_addr 9 1 2 2 0 0 0 0.00% 100.00% +nlvars_max_offset 47 3 19 10 0 0 0 0.00% 100.00% +quot_ctor_addr 9 1 2 2 0 0 0 0.00% 100.00% +quot_lift_addr_iota 9 1 2 2 0 0 0 0.00% 100.00% +quot_ind_addr 9 1 2 2 0 0 0 0.00% 100.00% +system_platform_get_num_bits_addr 9 1 2 2 0 0 0 0.00% 100.00% +find_peer_rec_spec_walk 131 10 85 12 0 0 0 0.00% 100.00% +convert_axiom 26 1 3 3 0 0 0 0.00% 100.00% +get_axiom 26 1 14 5 0 0 0 0.00% 100.00% +quot_kind_tag 12 4 1 1 0 0 0 0.00% 100.00% +bitvec_prep_spine 44 3 15 10 0 0 0 0.00% 100.00% +get_quotient 27 1 15 5 0 0 0 0.00% 100.00% +convert_quotient 26 1 3 3 0 0 0 0.00% 100.00% +try_quot_iota 30 3 8 6 0 0 0 0.00% 100.00% +try_quot_lift 59 3 22 14 0 0 0 0.00% 100.00% +try_quot_ind 59 3 22 14 0 0 0 0.00% 100.00% +quot_extract_arg 39 4 13 8 0 0 0 0.00% 100.00% +mk_bool 20 2 5 4 0 0 0 0.00% 100.00% +bv_to_nat_via 41 4 13 9 0 0 0 0.00% 100.00% +try_reduce_bit_vec_ult 63 4 24 15 0 0 0 0.00% 100.00% +try_reduce_decide_bitvec_lt 165 8 72 40 0 0 0 0.00% 100.00% +try_k_synth_iota 59 4 18 12 0 0 0 0.00% 100.00% +k_synth_gate 71 4 30 14 0 0 0 0.00% 100.00% +bitvec_of_nat_args_direct 38 4 13 8 0 0 0 0.00% 100.00% +try_bitvec_dispatch 66 6 23 15 0 0 0 0.00% 100.00% +spec_params_dom_prefix_match 33 4 10 6 0 0 0 0.00% 100.00% +bitvec_prep_spine_ult 46 4 16 10 0 0 0 0.00% 100.00% +np_whnf_inner_bv 16 1 5 4 0 0 0 0.00% 100.00% +nlvars_subsume 111 6 49 25 0 0 0 0.00% 100.00% +defn_member_recur_addrs 30 2 4 3 0 0 0 0.00% 100.00% +se_parent_addr 34 5 13 5 0 0 0 0.00% 100.00% +apply_n_projs 24 2 5 4 0 0 0 0.00% 100.00% +struct_is_rec 33 2 16 5 0 0 0 0.00% 100.00% +try_eta_expand 45 3 14 10 0 0 0 0.00% 100.00% +pack_def_kind_safety 18 9 1 1 0 0 0 0.00% 100.00% +try_str_dispatch 128 18 47 28 0 0 0 0.00% 100.00% +try_str_back 70 4 27 17 0 0 0 0.00% 100.00% +struct_block_member_addrs 68 2 52 4 0 0 0 0.00% 100.00% +struct_scan_ctors 45 4 19 6 0 0 0 0.00% 100.00% +se_peel_tol 22 3 7 3 0 0 0 0.00% 100.00% +try_str_to_byte_array 64 5 26 14 0 0 0 0.00% 100.00% +delta_rank 22 2 2 1 0 0 0 0.00% 100.00% +lazy_delta_step_const_const 120 6 60 22 0 0 0 0.00% 100.00% +unfold_a_and_loop 23 2 5 4 0 0 0 0.00% 100.00% +se_scan_fields 25 3 8 4 0 0 0 0.00% 100.00% +se_mentions 39 12 11 5 0 0 0 0.00% 100.00% +leaf_hash 17 1 5 5 0 0 0 0.00% 100.00% +node_hash 19 1 6 6 0 0 0 0.00% 100.00% +parse_atree_body 31 3 11 6 0 0 0 0.00% 100.00% +load_assumption_tree 96 1 84 6 0 0 0 0.00% 100.00% +addr_set_build 37 2 16 4 0 0 0 0.00% 100.00% +addr_set_member 16 1 2 2 0 0 0 0.00% 100.00% +env_walk 102 10 58 8 0 0 0 0.00% 100.00% +env_walk_refs 40 4 6 5 0 0 0 0.00% 100.00% +env_walk_leaves 31 2 4 4 0 0 0 0.00% 100.00% +run_check_env 38 3 16 6 0 0 0 0.00% 100.00% +se_addr_in 24 3 7 4 0 0 0 0.00% 100.00% +get_opt_u64_masked 23 2 11 2 0 0 0 0.00% 100.00% +get_opt_addr_masked 16 2 4 2 0 0 0 0.00% 100.00% +get_opt_bool_masked 16 2 4 2 0 0 0 0.00% 100.00% +get_opt_def_kind_masked 18 4 4 2 0 0 0 0.00% 100.00% +get_opt_quot_kind_masked 19 5 4 2 0 0 0 0.00% 100.00% +get_reveal_rule_list_inner 59 2 32 6 0 0 0 0.00% 100.00% +get_opt_rule_list_masked 27 2 13 3 0 0 0 0.00% 100.00% +get_reveal_ctor_info 80 1 64 9 0 0 0 0.00% 100.00% +get_ctor_entry 61 1 51 3 0 0 0 0.00% 100.00% +get_ctor_entry_list_inner 90 2 63 6 0 0 0 0.00% 100.00% +get_opt_ctor_entry_list_masked 27 2 13 3 0 0 0 0.00% 100.00% +get_reveal_mut_const_info 126 3 90 14 0 0 0 0.00% 100.00% +get_mut_entry 75 1 65 3 0 0 0 0.00% 100.00% +get_mut_entry_list_inner 104 2 77 6 0 0 0 0.00% 100.00% +get_reveal_info 134 11 90 14 0 0 0 0.00% 100.00% +expr_addr 34 1 22 5 0 0 0 0.00% 100.00% +def_safety_tag 11 3 1 1 0 0 0 0.00% 100.00% +check_opt_def_kind 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_def_safety 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_quot_kind 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_bool 12 2 1 1 0 0 0 0.00% 100.00% +check_opt_u64 26 2 1 1 0 0 0 0.00% 100.00% +check_opt_addr 80 2 65 3 0 0 0 0.00% 100.00% +check_opt_expr_addr 83 2 66 4 0 0 0 0.00% 100.00% +check_recr_rules 67 2 39 6 0 0 0 0.00% 100.00% +check_opt_recr_rules 14 2 1 2 0 0 0 0.00% 100.00% +check_ctor_entry 97 1 35 8 0 0 0 0.00% 100.00% +check_ctor_entries 67 2 51 4 0 0 0 0.00% 100.00% +check_opt_ctor_entries 14 2 1 2 0 0 0 0.00% 100.00% +check_mut_const 127 3 1 10 0 0 0 0.00% 100.00% +check_muts_components 128 2 110 5 0 0 0 0.00% 100.00% +run_reveal 139 9 49 11 0 0 0 0.00% 100.00% +run_contains 14 1 3 3 0 0 0 0.00% 100.00% +unfold_b_and_loop 23 2 5 4 0 0 0 0.00% 100.00% +all_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +put_app_telescope 74 2 39 5 0 0 0 0.00% 100.00% +unfold_both_and_loop 31 3 8 6 0 0 0 0.00% 100.00% +list_length_u64.U8_8 42 2 27 4 0 0 0 0.00% 100.00% +list_concat.Tup.Ptr.U8_32.G 23 2 7 4 0 0 0 0.00% 100.00% +put_lam_telescope 74 2 39 5 0 0 0 0.00% 100.00% +rbtree_map_lookup_or_default.G 64 4 28 10 0 0 0 0.00% 100.00% +get_ci_dprj 130 1 109 6 0 0 0 0.00% 100.00% +lazy_delta_a_const_b_proj 55 6 24 8 0 0 0 0.00% 100.00% +lazy_delta_b_const_a_proj 55 6 24 8 0 0 0 0.00% 100.00% +list_length_u64.Constructor 68 2 53 4 0 0 0 0.00% 100.00% +normalize_imax_dispatch 39 8 10 6 0 0 0 0.00% 100.00% +list_length.U8_8 25 2 12 3 0 0 0 0.00% 100.00% +list_lookup_u64.MutConst 127 2 102 5 0 0 0 0.00% 100.00% +list_length_u64.MutConst 79 2 64 4 0 0 0 0.00% 100.00% +list_length_u64.RecursorRule 43 2 28 4 0 0 0 0.00% 100.00% +list_lookup_u64.Constructor 105 2 80 5 0 0 0 0.00% 100.00% +is_defn_or_thm 24 3 3 1 0 0 0 0.00% 100.00% +list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode 28 2 9 4 0 0 0 0.00% 100.00% +utf8_validate 21 2 6 4 0 0 0 0.00% 100.00% +delta_unfold 45 4 22 7 0 0 0 0.00% 100.00% +put_all_telescope 74 2 39 5 0 0 0 0.00% 100.00% +rbtree_map_insert.G 22 1 7 2 0 0 0 0.00% 100.00% +list_snoc.U8_8 36 2 13 4 0 0 0 0.00% 100.00% +try_lazy_delta_app 72 6 39 10 0 0 0 0.00% 100.00% +char_of_nat_addr 9 1 2 2 0 0 0 0.00% 100.00% +rbtree_map_ins.G 77 4 39 11 0 0 0 0.00% 100.00% +rbtree_map_balance.G 34 2 7 3 0 0 0 0.00% 100.00% +rbtree_map_balance_fix.G 122 57 31 8 0 0 0 0.00% 100.00% +get_ci_rprj 121 1 108 6 0 0 0 0.00% 100.00% +put_recursor_rule_list 30 2 14 4 0 0 0 0.00% 100.00% +try_unfold_head 33 5 4 3 0 0 0 0.00% 100.00% +ensure_sort_only 30 2 12 5 0 0 0 0.00% 100.00% +list_nil_addr 9 1 2 2 0 0 0 0.00% 100.00% +io_peel_field_loop 30 2 9 5 0 0 0 0.00% 100.00% +list_cons_addr 9 1 2 2 0 0 0 0.00% 100.00% +char_type_addr 9 1 2 2 0 0 0 0.00% 100.00% +klimbs_div_mod 46 2 14 12 0 0 0 0.00% 100.00% +bool_true_addr 9 1 2 2 0 0 0 0.00% 100.00% +bool_false_addr 9 1 2 2 0 0 0 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +klimbs_div 12 1 3 2 0 0 0 0.00% 100.00% +klimbs_mod 12 1 3 2 0 0 0 0.00% 100.00% +glimbs_to_klimbs 36 2 13 8 0 0 0 0.00% 100.00% +utf8_last_codepoint 10 1 2 2 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +utf8_last_go 23 2 7 4 0 0 0 0.00% 100.00% diff --git a/cold-groups/kstats-String.split.txt b/cold-groups/kstats-String.split.txt new file mode 100644 index 000000000..87a252f76 --- /dev/null +++ b/cold-groups/kstats-String.split.txt @@ -0,0 +1,739 @@ +=== Circuit Statistics === +Circuits: 730 +Total width: 33827 +Total FFT cost: 55287969781 (5.53e10) +Total cache hits: 22638136 +Total saved cost: 48.62% +--------------------------------------------------------------------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +--------------------------------------------------------------------------------------------------------------------------------------------- +blake3_compress_inner_j 1192 1 561 497 136626 0 1.39e10 25.13% 25.13% +memory[3] 12 0 0 0 2947763 6323771 3.91e9 7.07% 32.20% +blake3_compress_chunks 29 3 7 4 1157705 0 3.42e9 6.19% 38.39% +expr_inst_many_walk 34 9 8 5 915195 0 3.11e9 5.63% 44.03% +expr_inst_many 21 2 4 4 1199626 299856 2.59e9 4.68% 48.70% +blake3_compress 1080 1 929 40 19518 15 1.50e9 2.72% 51.42% +get_expr 50 12 23 5 309599 20 1.42e9 2.57% 54.00% +convert_expr 60 12 25 7 240901 122716 1.30e9 2.35% 56.35% +k_infer_app_spine_loop 59 8 21 11 241267 677 1.28e9 2.32% 58.67% +list_drop.Ptr.Expr 20 2 6 3 592814 270333 1.16e9 2.09% 60.76% +expr_lbr 35 9 9 6 350993 2611613 1.14e9 2.07% 62.83% +list_snoc.G 22 2 6 4 521574 184967 1.11e9 2.00% 64.84% +get_tag4 37 2 22 4 311460 0 1.06e9 1.92% 66.76% +g_list_has 21 3 6 3 396339 3419 7.88e8 1.43% 68.18% +get_app_telescope 43 2 15 6 204828 0 7.84e8 1.42% 69.60% +expr_glb_walk 34 10 8 5 231083 0 7.08e8 1.28% 70.88% +validate_expr_well_scoped 52 9 20 8 144351 118355 6.48e8 1.17% 72.06% +peel_beta 32 3 12 5 221723 3113 6.38e8 1.15% 73.21% +memory[4] 13 0 0 0 497573 4533682 6.30e8 1.14% 74.35% +expr_inst_many_bvar 24 2 5 5 278974 0 6.16e8 1.11% 75.46% +expr_inst1_walk 34 9 8 5 202168 0 6.13e8 1.11% 76.57% +get_u64_le 28 2 14 3 240867 22 6.12e8 1.11% 77.68% +collect_spine 23 2 8 4 281491 197009 5.96e8 1.08% 78.76% +list_concat.Ptr.KExprNode 22 2 6 4 278551 242297 5.64e8 1.02% 79.78% +whnf_with_spine 34 6 11 5 175764 4941 5.27e8 0.95% 80.73% +expr_lower_walk 53 10 18 9 115078 0 5.17e8 0.93% 81.66% +k_infer_core 53 9 22 8 112780 54815 5.06e8 0.91% 82.58% +expr_inst1 21 2 4 4 261823 104786 5.04e8 0.91% 83.49% +const_idxs_expr 52 7 26 7 110757 166346 4.87e8 0.88% 84.37% +expr_glb 21 2 5 4 240811 257285 4.61e8 0.83% 85.20% +list_lookup.Ptr.KLevelNode 16 1 5 3 294825 71690 4.39e8 0.79% 86.00% +list_length.Ptr.KExprNode 18 2 5 3 249239 712085 4.11e8 0.74% 86.74% +expr_lift_walk 34 9 8 5 139072 0 4.09e8 0.74% 87.48% +safe_refs_only 43 9 19 5 111679 109780 4.07e8 0.74% 88.22% +expr_lift 23 3 5 4 182612 389282 3.74e8 0.68% 88.89% +bytes_to_block 265 1 193 65 18371 661 3.45e8 0.62% 89.52% +whnf_const_head 77 16 32 10 44889 0 2.69e8 0.49% 90.00% +expr_lower 23 3 5 4 130790 108524 2.60e8 0.47% 90.47% +memory[18] 27 0 0 0 110757 606238 2.55e8 0.46% 90.94% +blake3_compress_block 211 2 169 15 17109 0 2.54e8 0.46% 91.40% +k_infer 15 1 4 4 167595 29463 2.24e8 0.41% 91.80% +get_expr_list 42 2 15 6 63218 309 2.14e8 0.39% 92.19% +k_is_def_eq 29 3 7 6 83990 46963 2.02e8 0.37% 92.55% +ctx_trim 52 3 19 12 48098 190084 1.96e8 0.35% 92.91% +apply_spine_expr 22 2 6 4 104043 16635 1.94e8 0.35% 93.26% +get_u64_list 49 2 22 6 46876 0 1.80e8 0.33% 93.59% +get_address 138 1 98 34 17795 109 1.74e8 0.31% 93.90% +get_tag0 40 2 23 5 53295 2412 1.69e8 0.31% 94.21% +whnf 38 6 14 6 47030 19542 1.40e8 0.25% 94.46% +address_eq 82 2 66 4 22618 19841 1.35e8 0.24% 94.70% +try_reduce_projection_definition 59 3 24 13 29751 4863 1.31e8 0.24% 94.94% +whnf_apply_beta 34 3 10 7 48959 0 1.31e8 0.24% 95.18% +Bytes2 24 0 0 0 65536 0 1.28e8 0.23% 95.41% +k_check 15 1 3 3 99155 88585 1.27e8 0.23% 95.64% +const_idxs_exprs 24 2 7 5 60784 1859 1.18e8 0.21% 95.86% +try_prim_dispatch 30 6 8 4 48652 4883 1.15e8 0.21% 96.06% +list_take.Ptr.KExprNode 23 2 7 4 57432 26941 1.06e8 0.19% 96.26% +whnf_nd_with_spine 34 6 11 5 38656 4799 1.02e8 0.18% 96.44% +ctx_seek_cut 44 2 16 10 27929 2587 9.18e7 0.17% 96.61% +expr_inst_levels_walk 36 9 9 6 31303 0 8.53e7 0.15% 96.76% +whnf_nd 38 6 14 6 29812 3465 8.53e7 0.15% 96.91% +pad_block 18 2 4 3 53030 230 7.68e7 0.14% 97.05% +try_def_eq_app 49 6 18 9 21499 1644 7.66e7 0.14% 97.19% +get_lam_telescope 42 2 15 6 23359 1 7.20e7 0.13% 97.32% +expr_glb_binder 16 1 4 4 53542 191 6.92e7 0.13% 97.45% +try_iota 108 5 39 25 9346 388 6.69e7 0.12% 97.57% +k_def_eq_rebase 44 2 12 11 19680 0 6.25e7 0.11% 97.68% +try_string_lit_one 28 3 8 5 28280 0 5.96e7 0.11% 97.79% +k_is_def_eq_core 40 2 15 8 19045 7010 5.48e7 0.10% 97.89% +memory[32] 41 0 0 0 18539 87446 5.46e7 0.10% 97.99% +get_address_list 42 2 15 6 17784 1775 5.34e7 0.10% 98.08% +expr_inst_levels 20 2 6 3 32535 56169 4.99e7 0.09% 98.17% +get_all_telescope 42 2 15 6 15506 8 4.59e7 0.08% 98.26% +try_nat_linear_rec 75 5 27 17 9011 306 4.47e7 0.08% 98.34% +de_args 32 5 10 5 19108 5106 4.42e7 0.08% 98.42% +walk_refs_transitive 27 4 6 5 21264 546 4.20e7 0.08% 98.49% +expr_inst1_bvar 20 3 4 3 26224 0 3.94e7 0.07% 98.57% +whnf_proj_head 61 4 28 10 9276 0 3.76e7 0.07% 98.63% +ctx_close_cut 46 3 17 10 11451 3941 3.59e7 0.06% 98.70% +k_ensure_sort 18 1 7 4 24483 12547 3.30e7 0.06% 98.76% +k_is_def_eq_slow_nd 32 4 9 6 14140 0 3.17e7 0.06% 98.82% +whnf_nd_const_head 55 9 23 7 8646 0 3.14e7 0.06% 98.87% +blake3_compress_layer 223 3 170 6 2324 0 2.91e7 0.05% 98.92% +k_infer_only 93 12 45 15 4753 2955 2.72e7 0.05% 98.97% +k_is_def_eq_slow 26 4 7 4 14140 0 2.59e7 0.05% 99.02% +k_is_def_eq_ordered 19 2 4 3 18630 415 2.58e7 0.05% 99.07% +k_is_def_eq_struct_safe 40 9 12 6 9419 39 2.52e7 0.05% 99.11% +try_reduce_fin_val_decidable_rec 149 9 58 37 2472 9544 2.08e7 0.04% 99.15% +blake3_finish 190 11 151 9 1950 0 2.03e7 0.04% 99.19% +whnf_iota_major 51 3 24 9 5749 3630 1.85e7 0.03% 99.22% +list_is_empty.U8 15 2 4 2 16811 16906 1.83e7 0.03% 99.25% +cleanup_nat_offset_major 45 5 19 8 6158 12476 1.77e7 0.03% 99.29% +get_constant 162 3 136 9 1860 0 1.64e7 0.03% 99.32% +whnf_nd_apply_beta 34 3 10 7 7111 0 1.57e7 0.03% 99.34% +try_match_nat_add 47 6 17 9 5013 0 1.47e7 0.03% 99.37% +ctx_next_cut 16 1 6 4 12876 23232 1.45e7 0.03% 99.40% +try_eta_struct 91 8 48 14 2712 483 1.42e7 0.03% 99.42% +blake3_next_layer 221 4 136 5 1074 0 1.20e7 0.02% 99.44% +try_struct_eta_iota 93 9 39 16 2179 0 1.13e7 0.02% 99.46% +k_is_def_eq_slow2 58 9 20 11 3064 0 1.04e7 0.02% 99.48% +load_verified_constant 100 1 88 5 1860 2402 1.02e7 0.02% 99.50% +whnf_nd_proj_head 61 4 28 10 2740 0 9.64e6 0.02% 99.52% +get_ci 97 10 68 7 1765 82225 9.30e6 0.02% 99.54% +blake3 86 1 72 8 1950 140 9.23e6 0.02% 99.55% +try_extract_nat 30 6 9 5 4611 5517 8.58e6 0.02% 99.57% +try_extract_nat_app 33 4 11 6 4219 0 8.54e6 0.02% 99.58% +run_check_transitive 79 7 55 6 1860 17498 8.05e6 0.01% 99.60% +verify_bytes_against 73 1 33 2 1950 0 7.85e6 0.01% 99.61% +const_idxs_of 77 6 7 6 1860 0 7.84e6 0.01% 99.63% +check_const 75 8 20 15 1765 95 7.20e6 0.01% 99.64% +collect_spine_of_ctor 45 3 23 7 2757 6560 7.19e6 0.01% 99.65% +nat_offset_of 58 12 23 9 2153 692 6.99e6 0.01% 99.67% +nat_lit_to_ctor_or_self 43 4 14 10 2758 6563 6.88e6 0.01% 99.68% +memory[34] 43 0 0 0 2651 7671 6.58e6 0.01% 99.69% +str_lit_to_ctor_app_or_self 24 3 7 4 4185 7831 6.19e6 0.01% 99.70% +get_constant_info_by_variant 64 8 46 2 1765 0 6.16e6 0.01% 99.71% +expr_lift_bvar 39 2 14 8 2721 0 6.15e6 0.01% 99.72% +u64_is_zero 25 9 2 1 3017 482566 4.47e6 0.01% 99.73% +relaxed_u64_pred 25 9 2 1 3008 241141 4.45e6 0.01% 99.74% +prim_family 161 23 59 37 595 48057 4.44e6 0.01% 99.75% +try_nat_dispatch_prewhnf 86 8 31 20 972 0 4.18e6 0.01% 99.75% +projection_definition_info 54 5 23 10 1440 29368 4.13e6 0.01% 99.76% +convert_definition 40 5 6 4 1523 0 3.28e6 0.01% 99.77% +lbr_max 35 2 13 7 1601 369274 3.04e6 0.01% 99.77% +try_def_eq_nat 41 4 16 7 1374 185 2.99e6 0.01% 99.78% +lbr_min 35 2 13 7 1544 292203 2.92e6 0.01% 99.78% +expr_mentions_block 40 14 10 5 1354 607 2.87e6 0.01% 99.79% +is_nat_zero 24 4 7 4 2084 664 2.83e6 0.01% 99.79% +assert_safety 15 2 3 2 3122 166 2.83e6 0.01% 99.80% +is_unsafe_ci 29 9 2 1 1765 2323 2.82e6 0.01% 99.81% +replace_spine_major 23 1 7 7 2124 164 2.78e6 0.01% 99.81% +head_addr 24 2 9 4 2009 1093 2.72e6 0.00% 99.81% +const_num_lvls 27 8 1 1 1764 13102 2.63e6 0.00% 99.82% +const_type_of 27 8 1 1 1764 1101 2.63e6 0.00% 99.82% +flatten_u64 14 1 1 1 3008 93860 2.48e6 0.00% 99.83% +get_definition 30 1 18 6 1523 0 2.47e6 0.00% 99.83% +memo_u32_less_than 28 1 13 7 1612 2290680 2.46e6 0.00% 99.84% +lazy_delta_loop 35 7 10 5 1326 178 2.45e6 0.00% 99.84% +run_check 24 1 14 4 1765 0 2.35e6 0.00% 99.85% +peel_params_subst 30 2 11 5 1420 297 2.28e6 0.00% 99.85% +try_unit_like 28 2 7 6 1428 208 2.15e6 0.00% 99.85% +level_struct_eq 39 12 11 5 1070 750 2.14e6 0.00% 99.86% +memory[12] 21 0 0 0 1772 97658 2.07e6 0.00% 99.86% +try_proof_irrel 25 2 6 5 1460 208 1.97e6 0.00% 99.87% +k_infer_proj 62 1 39 13 665 0 1.96e6 0.00% 99.87% +whnf_spine 25 2 7 5 1440 780 1.94e6 0.00% 99.87% +read_byte 18 2 5 3 1868 0 1.89e6 0.00% 99.88% +peel_n_alls_whnf 29 3 9 5 1235 0 1.88e6 0.00% 99.88% +is_str_prim_addr 65 8 22 15 582 0 1.76e6 0.00% 99.88% +k_is_def_eq_struct_go 58 26 13 6 623 0 1.70e6 0.00% 99.89% +peel_field_loop 34 2 9 6 956 0 1.64e6 0.00% 99.89% +nl_subsume_entry 121 13 54 24 311 63 1.57e6 0.00% 99.89% +is_native_prim_addr 57 7 19 13 578 0 1.53e6 0.00% 99.89% +is_dec_prim_addr 57 7 19 13 577 0 1.53e6 0.00% 99.90% +level_imax 37 6 13 6 816 8708 1.49e6 0.00% 99.90% +try_nat_binop_dispatch 65 6 24 14 467 232 1.36e6 0.00% 99.90% +convert_univ_idxs 38 2 16 7 728 19588 1.34e6 0.00% 99.90% +level_list_inst 25 2 7 5 1035 2276 1.33e6 0.00% 99.91% +level_inst_params 28 5 7 5 935 1077 1.33e6 0.00% 99.91% +try_reduce_decide_bitvec_lt 165 8 72 40 194 15 1.22e6 0.00% 99.91% +get_univ 55 5 33 6 464 53 1.15e6 0.00% 99.91% +level_eq 36 10 10 5 653 177 1.12e6 0.00% 99.92% +is_prop_type 30 3 11 5 692 774 1.00e6 0.00% 99.92% +utf8_decode_one 76 4 32 17 306 0 9.71e5 0.00% 99.92% +peel_n_foralls 21 2 7 3 854 75 9.04e5 0.00% 99.92% +is_bitvec_prim_addr 33 4 10 7 580 0 8.99e5 0.00% 99.92% +try_eta_swap 30 4 11 4 625 49 8.93e5 0.00% 99.92% +lazy_delta_step_const_const 120 6 60 22 188 0 8.59e5 0.00% 99.93% +get_tag2 40 2 23 5 464 0 8.39e5 0.00% 99.93% +address_eq_tail 84 6 66 3 237 0 7.94e5 0.00% 99.93% +peer_agree_walk 107 5 69 11 190 0 7.76e5 0.00% 99.93% +try_unfold_proj_app 31 3 11 6 535 248 7.71e5 0.00% 99.93% +try_dec_dispatch 70 4 26 16 269 0 7.70e5 0.00% 99.93% +level_max 45 4 17 9 382 123 7.51e5 0.00% 99.93% +level_is_not_zero 27 7 7 4 553 877 7.00e5 0.00% 99.94% +level_max_subsumes 23 3 6 4 622 54 6.86e5 0.00% 99.94% +check_prop_field_if_prop 22 2 5 4 632 33 6.70e5 0.00% 99.94% +lazy_delta_both_proj 39 7 10 7 390 0 6.69e5 0.00% 99.94% +try_lazy_delta_app 72 6 39 10 225 0 6.41e5 0.00% 99.94% +level_max_go 39 6 13 7 375 0 6.39e5 0.00% 99.94% +get_ci_cprj 158 1 142 7 116 1097 6.33e5 0.00% 99.94% +level_max_offsets 47 3 18 10 306 0 6.05e5 0.00% 99.94% +get_mut_const_list 86 2 59 6 177 13 5.75e5 0.00% 99.94% +get_constructor_list 75 2 48 6 198 13 5.74e5 0.00% 99.95% +check_canonical_block 123 3 75 20 127 0 5.50e5 0.00% 99.95% +try_bitvec_dispatch 66 6 23 15 211 0 5.45e5 0.00% 99.95% +build_recur_addrs_walk 71 2 51 5 190 0 5.17e5 0.00% 99.95% +check_positivity_aug 78 5 35 15 175 5 5.15e5 0.00% 99.95% +canon_muts_has_kind 69 6 51 3 185 97 4.87e5 0.00% 99.95% +check_muts_all 66 2 48 4 190 0 4.81e5 0.00% 99.95% +get_univ_list 53 2 24 7 227 1859 4.79e5 0.00% 99.95% +expr_lbr_let 23 1 7 7 448 0 4.70e5 0.00% 99.95% +is_unit_like_type 60 7 34 7 197 1231 4.58e5 0.00% 99.95% +is_inductive_prop 24 1 9 6 421 244 4.56e5 0.00% 99.95% +put_constant 90 9 14 7 140 23 4.54e5 0.00% 99.96% +try_unfold_head 33 5 4 3 315 58 4.43e5 0.00% 99.96% +ctor_at 86 2 72 3 141 3 4.38e5 0.00% 99.96% +check_inductive_shape_ctors 52 2 17 10 211 0 4.31e5 0.00% 99.96% +projection_addr 134 4 105 9 95 127 4.22e5 0.00% 99.96% +ensure_sort_only 30 2 12 5 326 104 4.20e5 0.00% 99.96% +normalize_aux 33 7 8 5 288 104 3.99e5 0.00% 99.96% +check_param_agreement_go 34 2 12 6 272 0 3.84e5 0.00% 99.96% +wrap_foralls 22 2 6 4 390 65 3.83e5 0.00% 99.96% +get_ci_iprj 121 1 108 6 95 1037 3.81e5 0.00% 99.96% +peel_ctor_params_subst 46 3 16 8 210 3 3.80e5 0.00% 99.96% +k_is_def_eq_struct 12 1 2 2 619 49 3.67e5 0.00% 99.96% +try_normalize_int_decidable 64 4 26 13 152 0 3.58e5 0.00% 99.96% +glist_subset 75 5 32 16 131 280 3.50e5 0.00% 99.97% +peel_n_lams_collect 29 3 10 4 281 0 3.42e5 0.00% 99.97% +put_address 106 1 65 34 95 45 3.34e5 0.00% 99.97% +check_no_dep_data_field_if_prop 28 3 7 5 280 11 3.29e5 0.00% 99.97% +muts_member_at 108 2 94 3 92 214 3.27e5 0.00% 99.97% +put_constant_info 64 8 2 2 140 0 3.24e5 0.00% 99.97% +check_positivity_fields 26 2 6 5 294 0 3.24e5 0.00% 99.97% +nl_add_var 43 4 13 9 192 36 3.20e5 0.00% 99.97% +walk_fields_classify 42 3 14 7 192 3 3.13e5 0.00% 99.97% +peel_n_foralls_with_types 27 3 9 4 272 3 3.07e5 0.00% 99.97% +k_synth_gate 71 4 30 14 117 4 2.90e5 0.00% 99.97% +utf8_validate 21 2 6 4 307 64 2.77e5 0.00% 99.97% +normalize_int_dec_rebuild 53 3 16 12 140 0 2.70e5 0.00% 99.97% +try_nat_offset_dispatch 59 4 19 14 126 0 2.64e5 0.00% 99.97% +check_block_peer_param_agreement 81 4 52 4 95 0 2.56e5 0.00% 99.97% +caddr_is_peer 31 2 15 4 208 13 2.56e5 0.00% 99.97% +try_k_synth_iota 59 4 18 12 121 0 2.51e5 0.00% 99.97% +expr_inst1_let 21 1 5 5 269 0 2.38e5 0.00% 99.97% +const_idxs_muts 76 4 53 7 93 94 2.34e5 0.00% 99.97% +check_muts_member_at 74 1 15 5 95 0 2.34e5 0.00% 99.98% +compare_struct_fields 31 3 7 5 192 0 2.33e5 0.00% 99.98% +convert_constructor 57 1 6 6 116 0 2.31e5 0.00% 99.98% +const_idxs_ctors 57 2 40 5 114 91 2.26e5 0.00% 99.98% +check_field_universes_inner 29 2 8 6 197 0 2.25e5 0.00% 99.98% +bytes_to_addr 44 1 34 3 140 23 2.25e5 0.00% 99.98% +delta_unfold 45 4 22 7 137 124 2.24e5 0.00% 99.98% +get_constructor 55 1 41 8 116 0 2.23e5 0.00% 99.98% +compare_rules 89 4 40 16 77 0 2.18e5 0.00% 99.98% +get_expr_let 28 1 8 5 197 0 2.17e5 0.00% 99.98% +level_offset_of 20 2 6 3 258 381 2.16e5 0.00% 99.98% +get_inductive 67 1 51 9 95 0 2.13e5 0.00% 99.98% +build_motive_apps 23 2 5 4 224 0 2.09e5 0.00% 99.98% +bytes_to_u64_limb 50 10 20 3 118 0 2.07e5 0.00% 99.98% +canon_indc_positions 67 3 50 4 93 94 2.07e5 0.00% 99.98% +count_ctors 51 2 38 3 114 94 2.03e5 0.00% 99.98% +get_mut_const 62 3 48 3 95 0 1.97e5 0.00% 99.98% +validate_univ_params_list 20 2 4 4 238 11994 1.96e5 0.00% 99.98% +flat_originals_walk 100 5 68 9 64 0 1.94e5 0.00% 99.98% +put_tag0 32 3 6 5 157 31 1.89e5 0.00% 99.98% +memory[36] 45 0 0 0 114 453 1.79e5 0.00% 99.98% +check_field_universes_skip_params 25 2 7 4 179 0 1.74e5 0.00% 99.98% +memory[47] 56 0 0 0 93 1214 1.74e5 0.00% 99.98% +put_tag4 33 3 6 5 140 0 1.70e5 0.00% 99.98% +dec_dispatch_le_eq 47 5 14 9 102 0 1.64e5 0.00% 99.98% +memory[10] 19 0 0 0 210 59730 1.61e5 0.00% 99.98% +dec_build_proof 95 8 30 22 57 0 1.60e5 0.00% 99.98% +glist_cmp 76 6 32 16 68 200 1.60e5 0.00% 99.98% +convert_inductive 50 1 6 6 95 0 1.59e5 0.00% 99.99% +get_result_sort_level 28 2 9 5 150 222 1.57e5 0.00% 99.99% +try_extract_int 49 6 20 9 92 251 1.50e5 0.00% 99.99% +is_rec_field_peel 40 3 16 7 108 0 1.50e5 0.00% 99.99% +dec_finish 90 4 32 22 56 0 1.48e5 0.00% 99.99% +check_ctor_return_type 37 1 13 12 113 112 1.47e5 0.00% 99.99% +apply_ihs_full 100 2 30 26 51 0 1.46e5 0.00% 99.99% +addr_list_contains 24 3 7 4 159 54 1.45e5 0.00% 99.99% +is_nat_succ_ih_step 58 7 26 10 78 39 1.45e5 0.00% 99.99% +whnf_get_ctor_or_none 26 2 9 5 143 11527 1.38e5 0.00% 99.99% +load_verified_blob 46 1 36 3 89 711 1.36e5 0.00% 99.99% +build_minor_doms 54 2 19 7 77 0 1.33e5 0.00% 99.99% +get_recursor_rule_list 53 2 24 7 77 0 1.31e5 0.00% 99.99% +build_flat_block 159 7 121 12 32 0 1.28e5 0.00% 99.99% +populate_rules 52 3 18 6 77 0 1.28e5 0.00% 99.99% +validate_univ_params_seen 43 5 16 8 87 585 1.24e5 0.00% 99.99% +Bytes1 11 0 0 0 256 0 1.22e5 0.00% 99.99% +is_muts_block 61 2 50 2 64 96 1.19e5 0.00% 99.99% +get_constructor_proj 31 1 21 4 109 0 1.18e5 0.00% 99.99% +flat_find_matching 39 5 15 5 88 10 1.14e5 0.00% 99.99% +mk_nat_offset_stuck 37 2 10 9 88 0 1.08e5 0.00% 99.99% +build_all_minors_walk 55 3 24 8 64 0 1.08e5 0.00% 99.99% +io_peel_field_loop 30 2 9 5 103 17 1.07e5 0.00% 99.99% +nl_subsumption_walk 25 2 7 5 117 46 1.05e5 0.00% 99.99% +build_apply_field_bvars 23 2 5 4 123 36 1.03e5 0.00% 99.99% +check_recursor_canonical_full 125 9 50 18 32 0 1.01e5 0.00% 99.99% +convert_rec_rules 40 2 16 6 77 0 9.93e4 0.00% 99.99% +assert_first_args_are_param_bvars 27 2 9 4 104 79 9.78e4 0.00% 99.99% +nl_eq 51 7 18 10 62 58 9.64e4 0.00% 99.99% +list_any_mentions_block 24 3 7 4 111 27 9.45e4 0.00% 99.99% +list_reverse_acc.G 22 2 6 4 118 0 9.36e4 0.00% 99.99% +check_field_universes 23 2 6 4 113 112 9.27e4 0.00% 99.99% +assert_return_head_is_parent 27 1 15 4 94 19 8.66e4 0.00% 99.99% +bytes_to_limbs 57 5 29 9 52 683 8.64e4 0.00% 99.99% +try_nat_binop_addr 128 15 44 31 27 2 8.31e4 0.00% 99.99% +build_minor_at_depth 65 1 25 21 45 0 8.19e4 0.00% 99.99% +build_ih_doms 78 2 24 20 39 12 8.18e4 0.00% 99.99% +check_positivity 20 1 5 5 113 112 8.11e4 0.00% 99.99% +build_rec_type_from 93 3 29 23 32 0 7.56e4 0.00% 99.99% +level_list_eq 31 5 10 5 75 6077 7.51e4 0.00% 99.99% +level_equal 23 2 5 5 94 1417 7.42e4 0.00% 99.99% +put_definition_proj 22 1 3 3 95 0 7.21e4 0.00% 99.99% +get_inductive_proj 22 1 12 3 95 0 7.21e4 0.00% 99.99% +get_recursor 87 1 69 11 32 0 7.08e4 0.00% 99.99% +k_infer_lit 20 2 4 4 92 0 6.33e4 0.00% 99.99% +check_inductive_shape 19 1 3 4 95 32 6.27e4 0.00% 99.99% +count_foralls_body 20 2 6 3 91 5 6.25e4 0.00% 99.99% +level_normalize 25 1 9 9 75 105 6.11e4 0.00% 99.99% +check_recursor_member 72 3 24 14 32 0 5.88e4 0.00% 99.99% +check_param_agreement 14 1 2 3 113 112 5.80e4 0.00% 99.99% +build_peer_recs 29 2 10 5 64 0 5.80e4 0.00% 99.99% +convert_recursor 71 1 8 8 32 0 5.80e4 0.00% 99.99% +build_rule_rhs 45 1 15 12 45 0 5.72e4 0.00% 99.99% +collect_n_doms_whnf 40 4 16 7 49 20 5.68e4 0.00% 99.99% +ind_is_solo 69 3 52 4 32 0 5.64e4 0.00% 99.99% +nl_covers_var 35 4 11 6 54 1 5.63e4 0.00% 99.99% +klimbs_mul_single 86 3 47 7 27 0 5.62e4 0.00% 100.00% +muts_indc_count_is_one 66 4 50 3 33 31 5.61e4 0.00% 100.00% +build_apply_xs 22 2 5 4 77 18 5.59e4 0.00% 100.00% +build_all_motives_walk 51 3 24 8 40 24 5.57e4 0.00% 100.00% +build_major_params 23 2 5 4 74 0 5.55e4 0.00% 100.00% +find_peer_recursor_with_spec 67 2 50 3 32 0 5.48e4 0.00% 100.00% +u64_mul 222 1 155 46 13 0 5.39e4 0.00% 100.00% +lazy_delta_b_const_a_proj 55 6 24 8 36 0 5.25e4 0.00% 100.00% +projection_addr_ctor 41 1 23 9 45 0 5.23e4 0.00% 100.00% +nl_skip_empty 30 4 11 5 57 73 5.19e4 0.00% 100.00% +peel_motive_params_subst 31 2 9 5 55 15 5.13e4 0.00% 100.00% +compute_k_target 62 6 23 8 32 0 5.08e4 0.00% 100.00% +level_reduce 27 5 7 5 60 232 5.00e4 0.00% 100.00% +expr_inst_many_let 21 1 5 5 70 0 4.76e4 0.00% 100.00% +skip_bytes 21 3 6 3 70 48 4.76e4 0.00% 100.00% +is_rec_field 13 1 3 2 100 5 4.68e4 0.00% 100.00% +level_explicit_val 22 4 7 3 66 357 4.63e4 0.00% 100.00% +convert_univ 33 5 13 5 48 2312 4.60e4 0.00% 100.00% +build_succ_offset 57 2 17 16 30 0 4.30e4 0.00% 100.00% +const_idxs_rules 32 2 15 5 46 31 4.23e4 0.00% 100.00% +check_rec_rules_wellscoped 23 2 6 4 59 18 4.20e4 0.00% 100.00% +expr_glb_let 21 1 6 6 63 0 4.18e4 0.00% 100.00% +ctor_subst_param_for 49 3 17 10 32 91 4.04e4 0.00% 100.00% +put_constructor_proj 31 1 4 4 45 0 3.99e4 0.00% 100.00% +build_motive_type_flat 48 3 12 10 32 0 3.96e4 0.00% 100.00% +nlvars_subsume 111 6 49 25 17 3 3.92e4 0.00% 100.00% +se_mentions 39 12 11 5 37 6 3.89e4 0.00% 100.00% +build_flat_own_params 45 4 24 6 33 31 3.86e4 0.00% 100.00% +nl_add_const_go 58 5 22 12 27 0 3.82e4 0.00% 100.00% +ctors_before_pos 46 5 24 5 32 0 3.80e4 0.00% 100.00% +build_recur_addrs 11 1 2 2 95 128 3.77e4 0.00% 100.00% +build_rec_type 45 2 20 5 32 0 3.72e4 0.00% 100.00% +nl_add_const 22 4 5 3 55 53 3.70e4 0.00% 100.00% +flat_find_pos_kind 43 7 17 5 32 0 3.56e4 0.00% 100.00% +normalize_imax_dispatch 39 8 10 6 34 5 3.50e4 0.00% 100.00% +canonical_rules_at_pos 41 1 10 8 32 0 3.40e4 0.00% 100.00% +nl_le 36 6 12 6 35 7 3.36e4 0.00% 100.00% +nl_le_vars 28 3 8 5 41 4 3.22e4 0.00% 100.00% +klimbs_mul_outer 40 2 16 7 31 0 3.18e4 0.00% 100.00% +klimbs_add_carry 67 5 41 7 21 4 3.17e4 0.00% 100.00% +glist_eq_len 26 4 8 4 41 124 3.00e4 0.00% 100.00% +memory[11] 20 0 0 0 46 154 2.71e4 0.00% 100.00% +list_length.KRecRule 20 2 7 3 46 31 2.71e4 0.00% 100.00% +nlvars_dominates 50 4 19 10 23 16 2.68e4 0.00% 100.00% +flat_member_at 31 3 12 5 32 64 2.60e4 0.00% 100.00% +memory[9] 18 0 0 0 48 351 2.59e4 0.00% 100.00% +struct_scan_ctors 45 4 19 6 24 0 2.56e4 0.00% 100.00% +u64_sub_with_borrow 53 1 16 16 21 1 2.52e4 0.00% 100.00% +build_ctor_app_params 19 2 3 2 45 0 2.51e4 0.00% 100.00% +glist_ordered_insert 73 4 31 16 16 78 2.39e4 0.00% 100.00% +rec_to_parent_addr 28 1 12 5 32 9734 2.36e4 0.00% 100.00% +lbr_dec 11 2 2 1 63 75506 2.30e4 0.00% 100.00% +lazy_delta_a_const_b_proj 55 6 24 8 19 0 2.29e4 0.00% 100.00% +find_rule 25 3 10 3 34 7005 2.28e4 0.00% 100.00% +is_large_eliminator 41 7 7 4 23 9 2.22e4 0.00% 100.00% +check_rec_major_spine 26 1 9 5 32 0 2.20e4 0.00% 100.00% +klimbs_sub_borrow 69 6 42 7 15 10 2.08e4 0.00% 100.00% +u64_add 53 1 16 16 18 22 2.05e4 0.00% 100.00% +check_parent_inductive_shape 24 2 2 2 32 0 2.04e4 0.00% 100.00% +nlvars_add 102 5 44 23 11 12 1.98e4 0.00% 100.00% +memory[5] 14 0 0 0 46 4726 1.94e4 0.00% 100.00% +expr_lift_let 21 1 5 5 33 0 1.87e4 0.00% 100.00% +list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode 21 2 8 3 33 31 1.87e4 0.00% 100.00% +se_scan_fields 25 3 8 4 29 0 1.87e4 0.00% 100.00% +relaxed_u64_succ 25 9 2 1 28 473 1.78e4 0.00% 100.00% +list_reverse.G 13 1 3 3 44 230 1.72e4 0.00% 100.00% +level_leq 30 3 9 6 23 94 1.64e4 0.00% 100.00% +is_defn_or_thm 24 3 3 1 27 404 1.64e4 0.00% 100.00% +se_peel_tol 22 3 7 3 28 0 1.58e4 0.00% 100.00% +compute_iprj_addr 30 1 15 8 22 1590 1.55e4 0.00% 100.00% +struct_block_member_addrs 68 2 52 4 12 0 1.51e4 0.00% 100.00% +dec_rewrite_lt_to_le 49 2 14 13 15 0 1.49e4 0.00% 100.00% +build_succ_chain 53 2 20 5 14 170 1.46e4 0.00% 100.00% +memory[6] 15 0 0 0 33 417 1.37e4 0.00% 100.00% +check_large_walk_fields 44 5 14 8 15 0 1.34e4 0.00% 100.00% +klimbs_normalize 48 4 25 7 14 279 1.33e4 0.00% 100.00% +memory[8] 17 0 0 0 29 40990 1.30e4 0.00% 100.00% +build_all_minors 14 1 2 2 32 0 1.24e4 0.00% 100.00% +collect_index_doms 39 4 15 7 14 58 1.09e4 0.00% 100.00% +build_all_motives 12 1 2 2 32 0 1.08e4 0.00% 100.00% +se_addr_in 24 3 7 4 18 0 9.66e3 0.00% 100.00% +se_parent_addr 34 5 13 5 14 124 9.57e3 0.00% 100.00% +assert_lvls_are_params 25 2 8 4 17 115 9.30e3 0.00% 100.00% +subst_param_for 46 3 17 9 11 27 9.15e3 0.00% 100.00% +list_lift_indices 26 2 7 5 16 24 8.90e3 0.00% 100.00% +u64_byte_count 150 128 8 1 5 292 8.89e3 0.00% 100.00% +check_large_prop_ctor 27 3 8 4 15 0 8.45e3 0.00% 100.00% +apply_n_projs 24 2 5 4 16 0 8.26e3 0.00% 100.00% +nlvars_eq 36 6 12 6 12 43 8.18e3 0.00% 100.00% +assert_occ_param_bvars 27 2 9 4 14 1 7.70e3 0.00% 100.00% +peel_leading_foralls_acc 24 2 8 4 15 0 7.57e3 0.00% 100.00% +struct_is_rec 33 2 16 5 12 82 7.53e3 0.00% 100.00% +list_snoc.U8_8 36 2 13 4 11 4 7.25e3 0.00% 100.00% +klimbs_div_mod 46 2 14 12 9 0 6.89e3 0.00% 100.00% +try_eta_expand 45 3 14 10 9 3 6.74e3 0.00% 100.00% +list_lift_each 26 2 7 5 13 43 6.72e3 0.00% 100.00% +count_foralls_at_least 23 3 7 3 14 0 6.63e3 0.00% 100.00% +apply_indices_in_conclusion 22 2 5 4 14 24 6.37e3 0.00% 100.00% +klimbs_add 11 1 2 2 21 14 5.83e3 0.00% 100.00% +klimbs_mul 14 1 3 3 17 2 5.48e3 0.00% 100.00% +klimbs_pow 43 3 12 11 8 0 5.45e3 0.00% 100.00% +klimbs_sub 18 2 4 3 14 36 5.30e3 0.00% 100.00% +args_contain_bvar 28 4 10 4 9 1 4.32e3 0.00% 100.00% +klimbs_succ 41 3 23 5 7 96 4.28e3 0.00% 100.00% +klimbs_le 27 2 13 3 9 10 4.18e3 0.00% 100.00% +klimbs_is_zero 26 2 13 3 9 427 4.03e3 0.00% 100.00% +build_rec_lvls_list 21 2 5 4 10 28 3.85e3 0.00% 100.00% +klimbs_shl_limbs 18 2 4 3 11 3 3.82e3 0.00% 100.00% +check_valid_ind_app 35 1 17 8 7 0 3.69e3 0.00% 100.00% +klimbs_eq 44 5 23 5 6 109 3.63e3 0.00% 100.00% +build_param_lvls_range 22 2 5 4 9 59 3.46e3 0.00% 100.00% +peel_leading_foralls 15 1 5 4 11 1 3.25e3 0.00% 100.00% +list_lookup_or_default.Ptr.U8_32 20 2 5 3 9 21 3.18e3 0.00% 100.00% +check_nested_ctors_positivity 51 2 20 9 5 0 3.14e3 0.00% 100.00% +memory[2] 11 0 0 0 13 99 3.11e3 0.00% 100.00% +glimbs_to_klimbs 36 2 13 8 6 17 3.01e3 0.00% 100.00% +wrap_lams 22 2 6 4 8 0 2.93e3 0.00% 100.00% +is_int_dec_prim_addr 33 4 10 7 6 263 2.78e3 0.00% 100.00% +all_bvars_in_args 24 3 7 4 7 0 2.61e3 0.00% 100.00% +nl_covers_const 61 6 24 12 4 2 2.58e3 0.00% 100.00% +try_native_dispatch 98 8 37 23 3 0 2.44e3 0.00% 100.00% +mk_nat_lit 10 1 2 2 9 105 1.75e3 0.00% 100.00% +try_reduce_subtype_val 63 4 26 14 3 0 1.61e3 0.00% 100.00% +try_str_dispatch 128 18 47 28 2 0 1.35e3 0.00% 100.00% +try_quot_iota 30 3 8 6 4 0 1.34e3 0.00% 100.00% +intern_int_lit 29 3 8 6 4 70 1.30e3 0.00% 100.00% +klimbs_dec 14 1 4 4 6 127 1.30e3 0.00% 100.00% +unfold_b_and_loop 23 2 5 4 4 0 1.06e3 0.00% 100.00% +klimbs_gcd 20 2 4 4 4 2 9.44e2 0.00% 100.00% +u64_eq 33 9 2 1 3 0 8.93e2 0.00% 100.00% +check_quot 29 5 6 5 3 0 7.97e2 0.00% 100.00% +get_quotient 27 1 15 5 3 0 7.50e2 0.00% 100.00% +convert_axiom 26 1 3 3 3 0 7.26e2 0.00% 100.00% +get_axiom 26 1 14 5 3 0 7.26e2 0.00% 100.00% +convert_quotient 26 1 3 3 3 0 7.26e2 0.00% 100.00% +try_quot_lift 59 3 22 14 2 0 6.62e2 0.00% 100.00% +run_claim 128 5 71 8 1 0 6.56e2 0.00% 100.00% +idx_to_u64 22 1 10 6 3 206 6.31e2 0.00% 100.00% +klimbs_land 52 3 31 6 2 0 5.92e2 0.00% 100.00% +unpack_def_kind_safety 17 9 1 1 3 1520 5.12e2 0.00% 100.00% +bitvec_prep_spine 44 3 15 10 2 0 5.12e2 0.00% 100.00% +bv_to_nat_via 41 4 13 9 2 0 4.82e2 0.00% 100.00% +defn_is_unsafe_ci 15 5 2 1 3 1520 4.65e2 0.00% 100.00% +quot_extract_arg 39 4 13 8 2 0 4.62e2 0.00% 100.00% +bitvec_of_nat_args_direct 38 4 13 8 2 0 4.52e2 0.00% 100.00% +quot_kind_tag 12 4 1 1 3 0 3.93e2 0.00% 100.00% +try_str_to_byte_array 64 5 26 14 1 0 3.36e2 0.00% 100.00% +mk_bool 20 2 5 4 2 3 2.72e2 0.00% 100.00% +put_expr_list 42 2 24 5 1 0 2.26e2 0.00% 100.00% +canon_cprj_addr 41 1 23 9 1 116 2.21e2 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +u64_and 40 1 9 9 1 0 2.16e2 0.00% 100.00% +klimbs_mod 12 1 3 2 2 0 1.92e2 0.00% 100.00% +list_length_u64.Ptr.Univ 35 2 20 4 1 2 1.91e2 0.00% 100.00% +put_univ_list 33 2 15 5 1 0 1.81e2 0.00% 100.00% +unfold_both_and_loop 31 3 8 6 1 0 1.71e2 0.00% 100.00% +mk_nat_binop_stuck 24 1 7 7 1 0 1.36e2 0.00% 100.00% +check_eq_type 24 1 15 4 1 0 1.36e2 0.00% 100.00% +put_refs 22 1 11 4 1 139 1.26e2 0.00% 100.00% +put_address_list 22 2 6 4 1 0 1.26e2 0.00% 100.00% +put_univs 22 1 11 4 1 139 1.26e2 0.00% 100.00% +put_sharing 22 1 11 4 1 139 1.26e2 0.00% 100.00% +delta_rank 22 2 2 1 1 1 1.26e2 0.00% 100.00% +klimbs_shr 18 1 5 5 1 0 1.06e2 0.00% 100.00% +get_opt_addr 18 2 5 3 1 0 1.06e2 0.00% 100.00% +literal_eq 18 4 2 2 1 0 1.06e2 0.00% 100.00% +klimbs_div 12 1 3 2 1 0 7.60e1 0.00% 100.00% +assert_wire_bool 10 1 2 2 1 118 6.60e1 0.00% 100.00% +nat_beq_addr 9 1 2 2 1 590 6.10e1 0.00% 100.00% +bool_type_addr_dec 9 1 2 2 1 55 6.10e1 0.00% 100.00% +eq_refl_addr_dec 9 1 2 2 1 55 6.10e1 0.00% 100.00% +int_dec_eq_addr_dec 9 1 2 2 1 577 6.10e1 0.00% 100.00% +int_dec_le_addr_dec 9 1 2 2 1 579 6.10e1 0.00% 100.00% +int_dec_lt_addr_dec 9 1 2 2 1 575 6.10e1 0.00% 100.00% +int_of_nat_addr_dec 9 1 2 2 1 8 6.10e1 0.00% 100.00% +int_neg_succ_addr_dec 9 1 2 2 1 8 6.10e1 0.00% 100.00% +bool_true_addr 9 1 2 2 1 35 6.10e1 0.00% 100.00% +str_addr 9 1 2 2 1 37 6.10e1 0.00% 100.00% +nat_ble_addr 9 1 2 2 1 586 6.10e1 0.00% 100.00% +nat_mul_addr 9 1 2 2 1 605 6.10e1 0.00% 100.00% +nat_pow_addr 9 1 2 2 1 595 6.10e1 0.00% 100.00% +nat_dec_le_addr_dec 9 1 2 2 1 706 6.10e1 0.00% 100.00% +nat_gcd_addr 9 1 2 2 1 598 6.10e1 0.00% 100.00% +nat_dec_eq_addr_dec 9 1 2 2 1 692 6.10e1 0.00% 100.00% +nat_succ_addr_iota 9 1 2 2 1 2576 6.10e1 0.00% 100.00% +nat_pred_addr 9 1 2 2 1 1565 6.10e1 0.00% 100.00% +string_append_addr 9 1 2 2 1 580 6.10e1 0.00% 100.00% +nat_dec_lt_addr_dec 9 1 2 2 1 691 6.10e1 0.00% 100.00% +decidable_is_true_addr_dec 9 1 2 2 1 34 6.10e1 0.00% 100.00% +decidable_is_false_addr_dec 9 1 2 2 1 20 6.10e1 0.00% 100.00% +bool_false_addr 9 1 2 2 1 21 6.10e1 0.00% 100.00% +system_platform_num_bits_addr 9 1 2 2 1 580 6.10e1 0.00% 100.00% +punit_size_of_1_addr 9 1 2 2 1 580 6.10e1 0.00% 100.00% +nat_zero_addr 9 1 2 2 1 22 6.10e1 0.00% 100.00% +system_platform_get_num_bits_addr 9 1 2 2 1 1 6.10e1 0.00% 100.00% +size_of_size_of_addr 9 1 2 2 1 576 6.10e1 0.00% 100.00% +string_back_addr 9 1 2 2 1 581 6.10e1 0.00% 100.00% +reduce_bool_addr 9 1 2 2 1 577 6.10e1 0.00% 100.00% +quot_type_addr 9 1 2 2 1 0 6.10e1 0.00% 100.00% +string_legacy_back_addr 9 1 2 2 1 581 6.10e1 0.00% 100.00% +nat_add_addr 9 1 2 2 1 6090 6.10e1 0.00% 100.00% +nat_mod_addr 9 1 2 2 1 726 6.10e1 0.00% 100.00% +nat_le_of_ble_eq_true_addr_dec 9 1 2 2 1 6 6.10e1 0.00% 100.00% +string_of_list_addr 9 1 2 2 1 582 6.10e1 0.00% 100.00% +nat_div_addr 9 1 2 2 1 727 6.10e1 0.00% 100.00% +nat_land_addr 9 1 2 2 1 590 6.10e1 0.00% 100.00% +nat_lor_addr 9 1 2 2 1 588 6.10e1 0.00% 100.00% +nat_sub_addr 9 1 2 2 1 611 6.10e1 0.00% 100.00% +reduce_nat_addr 9 1 2 2 1 577 6.10e1 0.00% 100.00% +bit_vec_to_nat_addr 9 1 2 2 1 790 6.10e1 0.00% 100.00% +bit_vec_of_nat_addr 9 1 2 2 1 1 6.10e1 0.00% 100.00% +bit_vec_addr 9 1 2 2 1 93 6.10e1 0.00% 100.00% +quot_lift_addr_iota 9 1 2 2 1 4 6.10e1 0.00% 100.00% +nat_xor_addr 9 1 2 2 1 588 6.10e1 0.00% 100.00% +string_utf8_byte_size_addr 9 1 2 2 1 583 6.10e1 0.00% 100.00% +fin_addr 9 1 2 2 1 2471 6.10e1 0.00% 100.00% +decidable_rec_addr 9 1 2 2 1 2 6.10e1 0.00% 100.00% +bit_vec_ult_addr 9 1 2 2 1 787 6.10e1 0.00% 100.00% +decidable_decide_addr 9 1 2 2 1 787 6.10e1 0.00% 100.00% +nat_addr_io 9 1 2 2 1 56 6.10e1 0.00% 100.00% +quot_ctor_addr 9 1 2 2 1 2 6.10e1 0.00% 100.00% +string_dec_eq_addr 9 1 2 2 1 579 6.10e1 0.00% 100.00% +quot_ind_addr 9 1 2 2 1 1 6.10e1 0.00% 100.00% +string_to_byte_array_addr 9 1 2 2 1 581 6.10e1 0.00% 100.00% +nat_eq_of_beq_eq_true_addr_dec 9 1 2 2 1 27 6.10e1 0.00% 100.00% +lt_lt_addr 9 1 2 2 1 191 6.10e1 0.00% 100.00% +nat_ne_of_beq_eq_false_addr_dec 9 1 2 2 1 20 6.10e1 0.00% 100.00% +nat_shift_left_addr 9 1 2 2 1 588 6.10e1 0.00% 100.00% +subtype_val_addr 9 1 2 2 1 580 6.10e1 0.00% 100.00% +nat_shift_right_addr 9 1 2 2 1 588 6.10e1 0.00% 100.00% +try_reduce_bit_vec_ult 63 4 24 15 0 0 0 0.00% 100.00% +put_inductive 77 1 34 10 0 0 0 0.00% 100.00% +utf8_encode_prepend 212 4 100 51 0 0 0 0.00% 100.00% +list_nil_addr 9 1 2 2 0 0 0 0.00% 100.00% +nat_not_le_of_not_ble_eq_true_addr_dec 9 1 2 2 0 0 0 0.00% 100.00% +defn_member_recur_addrs 30 2 4 3 0 0 0 0.00% 100.00% +put_quot_kind 16 4 2 2 0 0 0 0.00% 100.00% +get_ci_dprj 130 1 109 6 0 0 0 0.00% 100.00% +list_cons_addr 9 1 2 2 0 0 0 0.00% 100.00% +put_mut_const_list 66 2 50 4 0 0 0 0.00% 100.00% +put_definition 68 1 42 8 0 0 0 0.00% 100.00% +get_ci_rprj 121 1 108 6 0 0 0 0.00% 100.00% +put_univ 53 5 22 6 0 0 0 0.00% 100.00% +u64_or 40 1 9 9 0 0 0 0.00% 100.00% +u64_xor_kbits 40 1 9 9 0 0 0 0.00% 100.00% +extract_aux_occ_us 46 4 14 6 0 0 0 0.00% 100.00% +extract_aux_spec_params 27 1 10 6 0 0 0 0.00% 100.00% +spec_params_lower 28 2 8 6 0 0 0 0.00% 100.00% +univ_succ_base 40 2 19 3 0 0 0 0.00% 100.00% +put_recursor_rule 40 1 21 4 0 0 0 0.00% 100.00% +aux_already_in 33 5 11 5 0 0 0 0.00% 100.00% +kexpr_struct_eq 59 28 13 6 0 0 0 0.00% 100.00% +level_list_struct_eq 30 5 9 5 0 0 0 0.00% 100.00% +spec_params_ptr_eq 30 5 9 5 0 0 0 0.00% 100.00% +extract_aux_spec_params_from_rec 26 2 3 2 0 0 0 0.00% 100.00% +first_recr_parent_block 107 5 77 8 0 0 0 0.00% 100.00% +klimbs_lor 52 3 31 6 0 0 0 0.00% 100.00% +detect_aux_from_recrs_ex 66 2 50 3 0 0 0 0.00% 100.00% +aux_from_recrs_walk_ex 138 9 90 14 0 0 0 0.00% 100.00% +flat_find_pos 29 3 11 4 0 0 0 0.00% 100.00% +klimbs_xor_op 52 3 31 6 0 0 0 0.00% 100.00% +klimbs_shl 18 1 5 5 0 0 0 0.00% 100.00% +char_type_addr 9 1 2 2 0 0 0 0.00% 100.00% +put_recursor_rule_list 30 2 14 4 0 0 0 0.00% 100.00% +try_str_back 70 4 27 17 0 0 0 0.00% 100.00% +np_whnf_inner_bv 16 1 5 4 0 0 0 0.00% 100.00% +apply_spec_params_lifted 26 2 7 5 0 0 0 0.00% 100.00% +try_str_dec_eq 71 7 29 14 0 0 0 0.00% 100.00% +str_dec_eq_build 123 2 43 35 0 0 0 0.00% 100.00% +put_recursor 98 1 36 12 0 0 0 0.00% 100.00% +canon_ord_cmp_g 37 3 14 7 0 0 0 0.00% 100.00% +canon_ord_then 12 2 2 1 0 0 0 0.00% 100.00% +canon_sord_lt_strong 6 1 1 1 0 0 0 0.00% 100.00% +canon_sord_eq_strong 6 1 1 1 0 0 0 0.00% 100.00% +canon_sord_gt_strong 6 1 1 1 0 0 0 0.00% 100.00% +canon_sord_then 14 2 2 1 0 0 0 0.00% 100.00% +canon_sord_of_g 7 1 1 1 0 0 0 0.00% 100.00% +canon_addr_cmp 105 1 80 18 0 0 0 0.00% 100.00% +canon_addr_chunk 17 1 2 2 0 0 0 0.00% 100.00% +canon_ctx_class_idx 25 3 8 4 0 0 0 0.00% 100.00% +canon_ctx_cmp_addr 32 5 8 6 0 0 0 0.00% 100.00% +canon_cmp_kuniv 44 16 10 6 0 0 0 0.00% 100.00% +canon_cmp_kuniv_list 32 4 10 6 0 0 0 0.00% 100.00% +canon_cmp_kliteral 18 4 2 2 0 0 0 0.00% 100.00% +canon_cmp_klimbs 29 2 7 7 0 0 0 0.00% 100.00% +canon_cmp_klimbs_tail 44 2 24 6 0 0 0 0.00% 100.00% +canon_cmp_u64_lex 53 1 16 16 0 0 0 0.00% 100.00% +find_peer_rec_spec_walk 131 10 85 12 0 0 0 0.00% 100.00% +canon_cmp_bytes 32 4 10 6 0 0 0 0.00% 100.00% +canon_cmp_kexpr_ctx 29 2 12 4 0 0 0 0.00% 100.00% +canon_cmp_kexpr_node_ctx 79 40 12 7 0 0 0 0.00% 100.00% +canon_cmp_krec_rule_ctx 26 1 8 5 0 0 0 0.00% 100.00% +canon_cmp_krec_rule_list_ctx 40 4 17 6 0 0 0 0.00% 100.00% +canon_kind_ord 27 8 1 1 0 0 0 0.00% 100.00% +canon_cmp_member_ctx 48 2 7 5 0 0 0 0.00% 100.00% +canon_cmp_member_same_kind_ctx 118 8 37 22 0 0 0 0.00% 100.00% +canon_cmp_ctor_range_ctx 63 2 34 8 0 0 0 0.00% 100.00% +canon_cmp_ctor_pair_ctx 83 3 23 14 0 0 0 0.00% 100.00% +put_axiom 44 1 22 5 0 0 0 0.00% 100.00% +canon_member_ci 26 1 15 4 0 0 0 0.00% 100.00% +canon_member_num_ctors 26 2 14 2 0 0 0 0.00% 100.00% +canon_build_ctx_classes 29 2 8 5 0 0 0 0.00% 100.00% +canon_build_ctx_members 64 3 24 14 0 0 0 0.00% 100.00% +canon_ctor_ctx_entries 24 2 5 4 0 0 0 0.00% 100.00% +canon_sort_loop 31 3 8 6 0 0 0 0.00% 100.00% +canon_refine_classes 26 2 7 5 0 0 0 0.00% 100.00% +spec_params_dom_prefix_match 33 4 10 6 0 0 0 0.00% 100.00% +canon_refine_one 24 3 6 4 0 0 0 0.00% 100.00% +canon_ins_sort 23 2 6 4 0 0 0 0.00% 100.00% +canon_insert_sorted 58 3 33 7 0 0 0 0.00% 100.00% +canon_group_consec 26 2 7 5 0 0 0 0.00% 100.00% +canon_group_walk 65 3 35 9 0 0 0 0.00% 100.00% +canon_classes_eq 31 5 10 5 0 0 0 0.00% 100.00% +canon_flatten 21 2 6 4 0 0 0 0.00% 100.00% +canon_all_singleton 22 3 6 4 0 0 0 0.00% 100.00% +bitvec_prep_spine_ult 46 4 16 10 0 0 0 0.00% 100.00% +punit_addr 9 1 2 2 0 0 0 0.00% 100.00% +unit_addr 9 1 2 2 0 0 0 0.00% 100.00% +canon_g_list_eq 27 5 8 4 0 0 0 0.00% 100.00% +utf8_last_codepoint 10 1 2 2 0 0 0 0.00% 100.00% +try_quot_ind 59 3 22 14 0 0 0 0.00% 100.00% +pack_def_kind_safety 18 9 1 1 0 0 0 0.00% 100.00% +mk_nat_literal_64 13 1 4 4 0 0 0 0.00% 100.00% +mk_nat_one 13 1 4 4 0 0 0 0.00% 100.00% +utf8_last_go 23 2 7 4 0 0 0 0.00% 100.00% +utf8_cont 13 1 3 3 0 0 0 0.00% 100.00% +put_lam_telescope 74 2 39 5 0 0 0 0.00% 100.00% +leaf_hash 17 1 5 5 0 0 0 0.00% 100.00% +node_hash 19 1 6 6 0 0 0 0.00% 100.00% +parse_atree_body 31 3 11 6 0 0 0 0.00% 100.00% +load_assumption_tree 96 1 84 6 0 0 0 0.00% 100.00% +addr_set_build 37 2 16 4 0 0 0 0.00% 100.00% +addr_set_member 16 1 2 2 0 0 0 0.00% 100.00% +env_walk 102 10 58 8 0 0 0 0.00% 100.00% +env_walk_refs 40 4 6 5 0 0 0 0.00% 100.00% +env_walk_leaves 31 2 4 4 0 0 0 0.00% 100.00% +run_check_env 38 3 16 6 0 0 0 0.00% 100.00% +put_all_telescope 74 2 39 5 0 0 0 0.00% 100.00% +get_opt_u64_masked 23 2 11 2 0 0 0 0.00% 100.00% +get_opt_addr_masked 16 2 4 2 0 0 0 0.00% 100.00% +get_opt_bool_masked 16 2 4 2 0 0 0 0.00% 100.00% +get_opt_def_kind_masked 18 4 4 2 0 0 0 0.00% 100.00% +get_opt_quot_kind_masked 19 5 4 2 0 0 0 0.00% 100.00% +get_reveal_rule_list_inner 59 2 32 6 0 0 0 0.00% 100.00% +get_opt_rule_list_masked 27 2 13 3 0 0 0 0.00% 100.00% +get_reveal_ctor_info 80 1 64 9 0 0 0 0.00% 100.00% +get_ctor_entry 61 1 51 3 0 0 0 0.00% 100.00% +get_ctor_entry_list_inner 90 2 63 6 0 0 0 0.00% 100.00% +get_opt_ctor_entry_list_masked 27 2 13 3 0 0 0 0.00% 100.00% +get_reveal_mut_const_info 126 3 90 14 0 0 0 0.00% 100.00% +get_mut_entry 75 1 65 3 0 0 0 0.00% 100.00% +get_mut_entry_list_inner 104 2 77 6 0 0 0 0.00% 100.00% +get_reveal_info 134 11 90 14 0 0 0 0.00% 100.00% +expr_addr 34 1 22 5 0 0 0 0.00% 100.00% +def_safety_tag 11 3 1 1 0 0 0 0.00% 100.00% +check_opt_def_kind 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_def_safety 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_quot_kind 18 2 3 3 0 0 0 0.00% 100.00% +check_opt_bool 12 2 1 1 0 0 0 0.00% 100.00% +check_opt_u64 26 2 1 1 0 0 0 0.00% 100.00% +check_opt_addr 80 2 65 3 0 0 0 0.00% 100.00% +check_opt_expr_addr 83 2 66 4 0 0 0 0.00% 100.00% +check_recr_rules 67 2 39 6 0 0 0 0.00% 100.00% +check_opt_recr_rules 14 2 1 2 0 0 0 0.00% 100.00% +check_ctor_entry 97 1 35 8 0 0 0 0.00% 100.00% +check_ctor_entries 67 2 51 4 0 0 0 0.00% 100.00% +check_opt_ctor_entries 14 2 1 2 0 0 0 0.00% 100.00% +check_mut_const 127 3 1 10 0 0 0 0.00% 100.00% +check_muts_components 128 2 110 5 0 0 0 0.00% 100.00% +run_reveal 139 9 49 11 0 0 0 0.00% 100.00% +run_contains 14 1 3 3 0 0 0 0.00% 100.00% +char_of_nat_addr 9 1 2 2 0 0 0 0.00% 100.00% +unfold_a_and_loop 23 2 5 4 0 0 0 0.00% 100.00% +nlvars_max_offset 47 3 19 10 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +list_length_u64.U8_8 42 2 27 4 0 0 0 0.00% 100.00% +list_concat.Tup.Ptr.U8_32.G 23 2 7 4 0 0 0 0.00% 100.00% +put_quotient 44 1 22 5 0 0 0 0.00% 100.00% +rbtree_map_lookup_or_default.G 64 4 28 10 0 0 0 0.00% 100.00% +has_bvar_in_range 75 11 29 14 0 0 0 0.00% 100.00% +try_reduce_size_of_unit 71 5 29 16 0 0 0 0.00% 100.00% +check_native_bool 32 3 10 7 0 0 0 0.00% 100.00% +list_length_u64.Constructor 68 2 53 4 0 0 0 0.00% 100.00% +check_native_nat 21 3 7 3 0 0 0 0.00% 100.00% +list_length.U8_8 25 2 12 3 0 0 0 0.00% 100.00% +list_lookup_u64.MutConst 127 2 102 5 0 0 0 0.00% 100.00% +list_length_u64.MutConst 79 2 64 4 0 0 0 0.00% 100.00% +list_length_u64.RecursorRule 43 2 28 4 0 0 0 0.00% 100.00% +list_lookup_u64.Constructor 105 2 80 5 0 0 0 0.00% 100.00% +has_bvar_in_range_binder 19 2 3 3 0 0 0 0.00% 100.00% +list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode 28 2 9 4 0 0 0 0.00% 100.00% +has_bvar_in_range_let 24 3 4 4 0 0 0 0.00% 100.00% +put_constructor 73 1 25 8 0 0 0 0.00% 100.00% +put_expr 110 12 59 8 0 0 0 0.00% 100.00% +rbtree_map_insert.G 22 1 7 2 0 0 0 0.00% 100.00% +put_u64_le 26 2 4 3 0 0 0 0.00% 100.00% +put_constructor_list 55 2 39 4 0 0 0 0.00% 100.00% +put_tag2 33 3 6 5 0 0 0 0.00% 100.00% +rbtree_map_ins.G 77 4 39 11 0 0 0 0.00% 100.00% +rbtree_map_balance.G 34 2 7 3 0 0 0 0.00% 100.00% +rbtree_map_balance_fix.G 122 57 31 8 0 0 0 0.00% 100.00% +build_char_list 40 2 12 9 0 0 0 0.00% 100.00% +str_lit_delta_step 62 5 31 10 0 0 0 0.00% 100.00% +byte_array_empty_addr 9 1 2 2 0 0 0 0.00% 100.00% +put_mut_const 62 3 3 3 0 0 0 0.00% 100.00% +put_u64_list 29 2 13 4 0 0 0 0.00% 100.00% +app_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +klimbs_from_g 25 1 11 7 0 0 0 0.00% 100.00% +lam_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +walk_char_list_bytes 64 8 22 14 0 0 0 0.00% 100.00% +all_telescope_count 67 2 35 4 0 0 0 0.00% 100.00% +univ_succ_count 49 2 26 4 0 0 0 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +char_lit_codepoint 23 2 7 4 0 0 0 0.00% 100.00% +put_app_telescope 74 2 39 5 0 0 0 0.00% 100.00% +nlvars_any_offset_geq 48 3 19 10 0 0 0 0.00% 100.00% +char_lit_codepoint_syn 43 6 18 7 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +klimbs_scalar_value 117 7 63 21 0 0 0 0.00% 100.00% diff --git a/cold-groups/kstats-grouped-Array.extract_append.txt b/cold-groups/kstats-grouped-Array.extract_append.txt new file mode 100644 index 000000000..3e8ca2bda --- /dev/null +++ b/cold-groups/kstats-grouped-Array.extract_append.txt @@ -0,0 +1,194 @@ +=== Circuit Statistics === +Circuits: 185 +Total width: 16311 +Total FFT cost: 154785962220 (1.55e11) +Total cache hits: 72393508 +Total saved cost: 62.04% +-------------------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +-------------------------------------------------------------------------------------------- +expr_inst_many_walk 34 9 8 5 5471753 0 2.10e10 13.58% 13.58% +expr_inst_many 21 2 4 4 6975351 1584350 1.69e10 10.92% 24.50% +blake3_compress_inner_j 1192 1 561 497 151585 0 1.56e10 10.05% 34.55% +memory[3] 12 0 0 0 6181533 17946311 8.59e9 5.55% 40.10% +list_snoc.G 22 2 6 4 2593801 881702 6.17e9 3.99% 44.08% +peel_beta 32 3 12 5 1637758 10634 5.47e9 3.53% 47.62% +list_drop.Ptr.Expr 20 2 6 3 2151895 1151414 4.60e9 2.97% 50.59% +blake3_compress_chunks 29 3 7 4 1288914 0 3.84e9 2.48% 53.07% +whnf_with_spine 34 6 11 5 1108779 14944 3.82e9 2.47% 55.54% +expr_inst_many_bvar 24 2 5 5 1528825 0 3.82e9 2.47% 58.01% +list_concat.Ptr.KExprNode 22 2 6 4 1505977 731709 3.45e9 2.23% 60.25% +expr_lbr 35 9 9 6 870475 9468745 3.04e9 1.96% 62.21% +collect_spine 23 2 8 4 1199012 836589 2.83e9 1.83% 64.03% +cold_shape_12 74 40 7 4 382500 102913 2.64e9 1.70% 65.74% +k_infer_app_spine_loop 59 8 21 11 470161 506 2.63e9 1.70% 67.44% +cold_shape_07 70 40 4 4 374022 87587 2.44e9 1.57% 69.01% +memory[4] 13 0 0 0 1735873 17182092 2.40e9 1.55% 70.56% +list_lookup.Ptr.KLevelNode 16 1 5 3 1364948 403575 2.27e9 1.47% 72.03% +list_length.Ptr.KExprNode 18 2 5 3 1166659 2680089 2.16e9 1.39% 73.43% +get_expr 50 12 23 5 391929 17 1.83e9 1.19% 74.61% +cold_shape_32 114 31 15 8 178303 25645 1.78e9 1.15% 75.76% +whnf_const_head 77 16 32 10 246268 0 1.71e9 1.10% 76.87% +blake3_compress 1080 1 929 40 21655 14 1.68e9 1.09% 77.95% +convert_expr 60 12 25 7 292994 154982 1.61e9 1.04% 78.99% +cold_shape_15 68 37 8 5 255134 16588 1.57e9 1.01% 80.00% +get_tag4 37 2 22 4 393551 0 1.37e9 0.88% 80.89% +apply_spine_expr 22 2 6 4 618392 83404 1.33e9 0.86% 81.75% +cold_shape_06 94 33 3 4 162630 213149 1.33e9 0.86% 82.61% +cold_shape_30 64 22 14 6 208719 70386 1.19e9 0.77% 83.37% +get_u64_le 28 2 14 3 422899 22 1.12e9 0.72% 84.10% +cold_shape_14 89 16 7 7 141782 117961 1.08e9 0.70% 84.80% +whnf_apply_beta 34 3 10 7 339939 0 1.07e9 0.69% 85.49% +cold_shape_09 64 39 6 5 188064 351260 1.06e9 0.69% 86.18% +get_app_telescope 43 2 15 6 264610 0 1.03e9 0.67% 86.85% +expr_inst1_walk 34 9 8 5 326314 0 1.03e9 0.66% 87.51% +expr_glb_walk 34 10 8 5 295964 0 9.25e8 0.60% 88.11% +cold_shape_24 74 40 12 7 131999 6200 8.36e8 0.54% 88.65% +g_list_has 21 3 6 3 413484 3025 8.25e8 0.53% 89.18% +validate_expr_well_scoped 52 9 20 8 176535 152144 8.06e8 0.52% 89.70% +expr_inst1 21 2 4 4 400830 220687 7.98e8 0.52% 90.22% +expr_lift 23 3 5 4 359613 1596071 7.76e8 0.50% 90.72% +try_reduce_projection_definition 59 3 24 13 151416 11396 7.74e8 0.50% 91.22% +const_idxs_expr 52 7 26 7 160015 209196 7.25e8 0.47% 91.69% +k_infer_core 53 9 22 8 156068 76251 7.19e8 0.46% 92.15% +expr_lift_walk 34 9 8 5 232640 0 7.13e8 0.46% 92.61% +cold_shape_45 89 31 23 9 94238 50867 6.96e8 0.45% 93.06% +cold_shape_39 91 36 19 14 87017 500015 6.53e8 0.42% 93.48% +expr_lower_walk 53 10 18 9 141436 0 6.46e8 0.42% 93.90% +cold_shape_13 84 38 7 5 91674 6084 6.38e8 0.41% 94.31% +expr_glb 21 2 5 4 307017 351230 5.99e8 0.39% 94.70% +try_iota 108 5 39 25 66939 2106 5.82e8 0.38% 95.08% +safe_refs_only 43 9 19 5 140151 138582 5.20e8 0.34% 95.41% +cold_shape_16 119 40 9 8 55002 4450 5.17e8 0.33% 95.75% +cold_shape_52 113 40 29 16 56780 711 5.09e8 0.33% 96.08% +cold_shape_51 79 9 27 17 66603 305 4.24e8 0.27% 96.35% +bytes_to_block 265 1 193 65 20371 601 3.87e8 0.25% 96.60% +memory[18] 27 0 0 0 160015 742479 3.79e8 0.24% 96.85% +cold_shape_37 91 30 18 12 52620 2567 3.77e8 0.24% 97.09% +cold_shape_19 64 36 10 5 69210 79815 3.59e8 0.23% 97.32% +cold_shape_17 71 40 9 6 57029 95258 3.22e8 0.21% 97.53% +blake3_compress_block 211 2 169 15 19287 0 2.90e8 0.19% 97.72% +cold_shape_82 213 5 100 51 15781 90 2.35e8 0.15% 97.87% +cold_shape_36 83 33 17 10 36381 4173 2.30e8 0.15% 98.02% +cold_shape_43 65 14 22 7 44804 108 2.27e8 0.15% 98.16% +cold_shape_47 93 38 24 9 31395 37700 2.19e8 0.14% 98.30% +cold_shape_31 131 38 14 13 21982 48240 2.08e8 0.13% 98.44% +cold_shape_11 102 39 7 6 26824 1512 2.02e8 0.13% 98.57% +cold_shape_35 80 12 16 16 28849 2634 1.72e8 0.11% 98.68% +cold_shape_26 57 10 12 11 36600 0 1.59e8 0.10% 98.78% +try_reduce_fin_val_decidable_rec 149 9 58 37 14010 42719 1.44e8 0.09% 98.88% +cold_shape_68 153 17 49 14 12585 1295 1.32e8 0.09% 98.96% +Bytes2 24 0 0 0 65536 0 1.28e8 0.08% 99.04% +address_eq 82 2 66 4 19339 105521 1.14e8 0.07% 99.12% +cold_shape_22 71 21 10 9 21040 607 1.08e8 0.07% 99.19% +cold_shape_18 61 14 9 9 24121 397 1.08e8 0.07% 99.26% +cold_shape_00 60 36 1 1 22065 112773 9.63e7 0.06% 99.32% +cold_shape_03 66 40 2 2 19159 576657 9.06e7 0.06% 99.38% +cold_shape_02 60 40 2 1 20742 431024 9.00e7 0.06% 99.44% +cold_shape_10 77 40 6 5 15648 24001 8.45e7 0.05% 99.49% +cold_shape_46 109 27 23 15 10653 154621 7.81e7 0.05% 99.54% +cold_shape_84 259 19 151 9 4888 1019 7.77e7 0.05% 99.59% +cold_shape_25 60 27 12 6 17832 69188 7.62e7 0.05% 99.64% +pad_block 18 2 4 3 46924 203 6.72e7 0.04% 99.68% +cold_shape_64 104 20 39 16 9431 0 6.51e7 0.04% 99.73% +cold_shape_41 92 25 20 15 10337 690 6.38e7 0.04% 99.77% +memory[32] 41 0 0 0 20282 85992 6.02e7 0.04% 99.81% +k_infer_only 93 12 45 15 7639 13614 4.61e7 0.03% 99.84% +cold_shape_34 75 32 16 8 7402 18679 3.59e7 0.02% 99.86% +blake3_compress_layer 223 3 170 6 2064 0 2.54e7 0.02% 99.88% +cold_shape_20 56 26 10 6 6883 22590 2.48e7 0.02% 99.89% +cold_shape_28 71 38 13 7 3791 1286345 1.61e7 0.01% 99.90% +cold_shape_23 66 38 11 5 4008 6626 1.60e7 0.01% 99.91% +cold_shape_08 75 40 5 4 3085 11312 1.35e7 0.01% 99.92% +cold_shape_57 88 6 33 6 2104 44 1.03e7 0.01% 99.93% +cold_shape_76 107 18 68 7 1746 348070 1.01e7 0.01% 99.94% +cold_shape_72 109 17 58 8 1621 15636 9.48e6 0.01% 99.94% +cold_shape_29 74 26 13 12 2192 9659888 9.08e6 0.01% 99.95% +load_verified_constant 100 1 88 5 1621 2066 8.70e6 0.01% 99.95% +cold_shape_55 95 17 31 20 1566 73 7.95e6 0.01% 99.96% +blake3 86 1 72 8 1707 114 7.94e6 0.01% 99.96% +memory[34] 43 0 0 0 2815 7298 7.04e6 0.00% 99.97% +cold_shape_50 90 24 26 16 1385 530 6.55e6 0.00% 99.97% +cold_shape_74 173 29 60 37 724 254254 5.98e6 0.00% 99.98% +get_constant_info_by_variant 64 8 46 2 1542 0 5.28e6 0.00% 99.98% +cold_shape_56 105 19 32 22 693 456 3.46e6 0.00% 99.98% +cold_shape_48 105 24 24 20 538 801 2.58e6 0.00% 99.98% +cold_shape_53 115 17 30 26 479 5 2.47e6 0.00% 99.98% +cold_shape_78 171 11 75 40 307 15 2.18e6 0.00% 99.99% +cold_shape_44 86 27 22 15 524 0 2.05e6 0.00% 99.99% +cold_shape_04 54 40 2 2 697 52574 1.80e6 0.00% 99.99% +memory[12] 21 0 0 0 1548 416435 1.78e6 0.00% 99.99% +k_is_def_eq_struct_go 58 26 13 6 625 0 1.71e6 0.00% 99.99% +nl_subsume_entry 121 13 54 24 297 59 1.49e6 0.00% 99.99% +cold_shape_67 80 7 48 6 400 12 1.40e6 0.00% 99.99% +cold_shape_77 145 16 71 11 237 0 1.36e6 0.00% 99.99% +cold_shape_70 80 11 51 5 313 80 1.05e6 0.00% 99.99% +cold_shape_83 153 11 110 9 158 9601 8.88e5 0.00% 99.99% +cold_shape_58 67 11 34 7 303 6273 8.48e5 0.00% 100.00% +cold_shape_71 99 15 53 7 192 78 7.28e5 0.00% 100.00% +cold_shape_73 112 14 59 8 146 12 5.93e5 0.00% 100.00% +cold_shape_69 82 15 50 4 183 181 5.70e5 0.00% 100.00% +cold_shape_05 96 40 2 2 139 13000 4.80e5 0.00% 100.00% +cold_shape_65 88 13 42 8 149 29 4.79e5 0.00% 100.00% +cold_shape_61 82 8 35 15 145 4 4.32e5 0.00% 100.00% +cold_shape_40 67 16 20 5 157 143 3.89e5 0.00% 100.00% +ctor_at 86 2 72 3 117 2 3.50e5 0.00% 100.00% +cold_shape_63 86 12 39 6 95 78 2.72e5 0.00% 100.00% +put_address 106 1 65 34 79 35 2.67e5 0.00% 100.00% +muts_member_at 108 2 94 3 77 177 2.63e5 0.00% 100.00% +cold_shape_66 144 22 44 35 51 14 2.10e5 0.00% 100.00% +cold_shape_27 58 22 13 5 99 2565 1.94e5 0.00% 100.00% +const_idxs_ctors 57 2 40 5 95 76 1.81e5 0.00% 100.00% +get_inductive 67 1 51 9 79 0 1.70e5 0.00% 100.00% +compare_rules 89 4 40 16 61 0 1.63e5 0.00% 100.00% +cold_shape_38 60 8 19 7 79 0 1.52e5 0.00% 100.00% +memory[10] 19 0 0 0 195 108527 1.48e5 0.00% 100.00% +memory[36] 45 0 0 0 95 375 1.44e5 0.00% 100.00% +memory[47] 56 0 0 0 78 1009 1.40e5 0.00% 100.00% +cold_shape_42 45 2 21 4 90 0 1.35e5 0.00% 100.00% +load_verified_blob 46 1 36 3 85 739 1.28e5 0.00% 100.00% +Bytes1 11 0 0 0 256 0 1.22e5 0.00% 100.00% +memory[8] 17 0 0 0 151 44897 9.83e4 0.00% 100.00% +build_flat_block 159 7 121 12 26 0 9.81e4 0.00% 100.00% +check_recursor_canonical_full 125 9 50 18 26 0 7.73e4 0.00% 100.00% +cold_shape_21 71 37 10 7 36 172 6.74e4 0.00% 100.00% +build_minor_at_depth 65 1 25 21 35 0 5.96e4 0.00% 100.00% +cold_shape_33 60 4 15 12 37 0 5.92e4 0.00% 100.00% +klimbs_mul_single 86 3 47 7 28 0 5.89e4 0.00% 100.00% +u64_mul 222 1 155 46 13 0 5.39e4 0.00% 100.00% +cold_shape_49 85 5 25 8 23 316 4.50e4 0.00% 100.00% +build_succ_offset 57 2 17 16 30 0 4.30e4 0.00% 100.00% +nlvars_subsume 111 6 49 25 17 3 3.92e4 0.00% 100.00% +memory[9] 18 0 0 0 46 304 2.45e4 0.00% 100.00% +memory[11] 20 0 0 0 36 122 1.99e4 0.00% 100.00% +memory[5] 14 0 0 0 36 17400 1.43e4 0.00% 100.00% +memory[6] 15 0 0 0 27 337 1.06e4 0.00% 100.00% +u64_byte_count 150 128 8 1 4 237 6.14e3 0.00% 100.00% +cold_shape_01 38 26 1 2 6 1338 3.16e3 0.00% 100.00% +memory[2] 11 0 0 0 12 96 2.80e3 0.00% 100.00% +cold_shape_62 149 17 37 23 2 0 1.56e3 0.00% 100.00% +cold_shape_54 58 9 31 6 2 0 6.52e2 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +cold_shape_79 118 9 80 8 0 0 0 0.00% 100.00% +list_length_u64.RecursorRule 43 2 28 4 0 0 0 0.00% 100.00% +cold_shape_81 152 23 90 14 0 0 0 0.00% 100.00% +rbtree_map_balance_fix.G 122 57 31 8 0 0 0 0.00% 100.00% +get_reveal_rule_list_inner 59 2 32 6 0 0 0 0.00% 100.00% +get_reveal_ctor_info 80 1 64 9 0 0 0 0.00% 100.00% +get_ctor_entry_list_inner 90 2 63 6 0 0 0 0.00% 100.00% +cold_shape_75 81 3 65 3 0 0 0 0.00% 100.00% +check_mut_const 127 3 1 10 0 0 0 0.00% 100.00% +cold_shape_80 132 11 85 12 0 0 0 0.00% 100.00% +cold_shape_59 89 3 34 10 0 0 0 0.00% 100.00% +univ_succ_count 49 2 26 4 0 0 0 0.00% 100.00% +list_length_u64.U8_8 42 2 27 4 0 0 0 0.00% 100.00% +cold_shape_60 111 7 35 8 0 0 0 0.00% 100.00% +canon_addr_cmp 105 1 80 18 0 0 0 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +canon_cmp_kexpr_node_ctx 79 40 12 7 0 0 0 0.00% 100.00% +klimbs_scalar_value 117 7 63 21 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +try_str_dispatch 128 18 47 28 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +list_length_u64.MutConst 79 2 64 4 0 0 0 0.00% 100.00% diff --git a/cold-groups/kstats-grouped-Nat.add_comm.txt b/cold-groups/kstats-grouped-Nat.add_comm.txt new file mode 100644 index 000000000..5342767fd --- /dev/null +++ b/cold-groups/kstats-grouped-Nat.add_comm.txt @@ -0,0 +1,194 @@ +=== Circuit Statistics === +Circuits: 185 +Total width: 16311 +Total FFT cost: 321971743 (3.22e8) +Total cache hits: 86596 +Total saved cost: 34.11% +---------------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +---------------------------------------------------------------------------------------- +Bytes2 24 0 0 0 65536 0 1.28e8 39.81% 39.81% +blake3_compress_inner_j 1192 1 561 497 973 0 5.76e7 17.89% 57.70% +memory[3] 12 0 0 0 17239 30090 1.52e7 4.71% 62.42% +blake3_compress_chunks 29 3 7 4 7303 0 1.39e7 4.30% 66.72% +cold_shape_32 114 31 15 8 958 75 5.44e6 1.69% 68.41% +blake3_compress 1080 1 929 40 139 0 5.35e6 1.66% 70.07% +cold_shape_07 70 40 4 4 1398 175 5.16e6 1.60% 71.67% +address_eq 82 2 66 4 1019 107 4.21e6 1.31% 72.98% +convert_expr 60 12 25 7 1238 526 3.86e6 1.20% 74.18% +get_expr 50 12 23 5 1443 0 3.84e6 1.19% 75.37% +cold_shape_09 64 39 6 5 1091 706 3.56e6 1.11% 76.48% +validate_expr_well_scoped 52 9 20 8 1197 630 3.23e6 1.00% 77.48% +get_tag4 37 2 22 4 1493 0 2.97e6 0.92% 78.40% +expr_lbr 35 9 9 6 1507 6551 2.84e6 0.88% 79.28% +cold_shape_17 71 40 9 6 748 88 2.56e6 0.80% 80.08% +cold_shape_12 74 40 7 4 708 359 2.51e6 0.78% 80.86% +cold_shape_45 89 31 23 9 591 96 2.44e6 0.76% 81.62% +expr_inst_many_walk 34 9 8 5 1240 0 2.21e6 0.69% 82.30% +const_idxs_expr 52 7 26 7 800 832 2.03e6 0.63% 82.94% +k_infer_app_spine_loop 59 8 21 11 713 1 2.02e6 0.63% 83.56% +cold_shape_30 64 22 14 6 664 156 2.02e6 0.63% 84.19% +expr_inst_many 21 2 4 4 1710 429 1.99e6 0.62% 84.81% +cold_shape_14 89 16 7 7 479 156 1.92e6 0.59% 85.40% +cold_shape_06 94 33 3 4 456 220 1.91e6 0.59% 85.99% +list_drop.Ptr.Expr 20 2 6 3 1623 706 1.79e6 0.56% 86.55% +k_infer_core 53 9 22 8 701 182 1.78e6 0.55% 87.10% +pad_block 18 2 4 3 1697 0 1.70e6 0.53% 87.63% +cold_shape_13 84 38 7 5 431 197 1.60e6 0.50% 88.13% +get_app_telescope 43 2 15 6 740 0 1.54e6 0.48% 88.61% +cold_shape_16 119 40 9 8 306 7 1.51e6 0.47% 89.08% +cold_shape_39 91 36 19 14 379 954 1.49e6 0.46% 89.54% +memory[4] 13 0 0 0 1955 14173 1.46e6 0.45% 89.99% +safe_refs_only 43 9 19 5 698 597 1.44e6 0.45% 90.44% +expr_glb_walk 34 10 8 5 801 0 1.34e6 0.42% 90.86% +bytes_to_block 265 1 193 65 139 0 1.32e6 0.41% 91.27% +collect_spine 23 2 8 4 964 634 1.13e6 0.35% 91.62% +list_snoc.G 22 2 6 4 982 513 1.11e6 0.34% 91.97% +cold_shape_11 102 39 7 6 265 73 1.10e6 0.34% 92.31% +memory[18] 27 0 0 0 800 3009 1.07e6 0.33% 92.64% +expr_glb 21 2 5 4 945 814 1.01e6 0.32% 92.95% +cold_shape_82 213 5 100 51 134 8 1.01e6 0.31% 93.27% +g_list_has 21 3 6 3 943 21 1.01e6 0.31% 93.58% +cold_shape_84 259 19 151 9 109 27 9.59e5 0.30% 93.88% +cold_shape_10 77 40 6 5 261 98 8.16e5 0.25% 94.13% +list_concat.Ptr.KExprNode 22 2 6 4 743 1138 8.06e5 0.25% 94.38% +cold_shape_37 91 30 18 12 216 10 7.70e5 0.24% 94.62% +cold_shape_43 65 14 22 7 280 0 7.50e5 0.23% 94.86% +cold_shape_24 74 40 12 7 251 18 7.49e5 0.23% 95.09% +list_lookup.Ptr.KLevelNode 16 1 5 3 846 175 6.89e5 0.21% 95.30% +whnf_with_spine 34 6 11 5 420 22 6.37e5 0.20% 95.50% +list_length.Ptr.KExprNode 18 2 5 3 691 2172 6.11e5 0.19% 95.69% +blake3_compress_block 211 2 169 15 87 0 5.94e5 0.18% 95.88% +expr_lower_walk 53 10 18 9 270 0 5.88e5 0.18% 96.06% +expr_inst_many_bvar 24 2 5 5 472 0 5.20e5 0.16% 96.22% +peel_beta 32 3 12 5 364 8 5.09e5 0.16% 96.38% +cold_shape_36 83 33 17 10 156 48 4.77e5 0.15% 96.53% +cold_shape_28 71 38 13 7 174 2620 4.66e5 0.14% 96.67% +expr_inst1_walk 34 9 8 5 296 0 4.24e5 0.13% 96.80% +expr_inst1 21 2 4 4 421 95 4.01e5 0.12% 96.93% +cold_shape_08 75 40 5 4 146 190 3.99e5 0.12% 97.05% +cold_shape_35 80 12 16 16 136 6 3.90e5 0.12% 97.17% +expr_lift 23 3 5 4 380 529 3.88e5 0.12% 97.29% +cold_shape_15 68 37 8 5 154 65 3.86e5 0.12% 97.41% +apply_spine_expr 22 2 6 4 361 64 3.50e5 0.11% 97.52% +cold_shape_18 61 14 9 9 150 5 3.36e5 0.10% 97.63% +get_u64_le 28 2 14 3 284 0 3.34e5 0.10% 97.73% +blake3_compress_layer 223 3 170 6 52 0 3.32e5 0.10% 97.83% +cold_shape_23 66 38 11 5 139 78 3.32e5 0.10% 97.94% +cold_shape_29 74 26 13 12 123 4226 3.20e5 0.10% 98.03% +whnf_const_head 77 16 32 10 114 0 3.04e5 0.09% 98.13% +cold_shape_57 88 6 33 6 101 4 3.00e5 0.09% 98.22% +memory[32] 41 0 0 0 177 2427 2.77e5 0.09% 98.31% +cold_shape_00 60 36 1 1 126 913 2.68e5 0.08% 98.39% +cold_shape_34 75 32 16 8 103 166 2.62e5 0.08% 98.47% +cold_shape_25 60 27 12 6 123 24 2.61e5 0.08% 98.55% +cold_shape_46 109 27 23 15 74 48 2.53e5 0.08% 98.63% +cold_shape_31 131 38 14 13 58 12 2.25e5 0.07% 98.70% +cold_shape_26 57 10 12 11 108 0 2.12e5 0.07% 98.77% +expr_lift_walk 34 9 8 5 159 0 2.03e5 0.06% 98.83% +cold_shape_19 64 36 10 5 93 25 1.98e5 0.06% 98.89% +cold_shape_02 60 40 2 1 96 1728 1.93e5 0.06% 98.95% +cold_shape_41 92 25 20 15 65 7 1.82e5 0.06% 99.01% +nl_subsume_entry 121 13 54 24 52 11 1.81e5 0.06% 99.07% +cold_shape_76 107 18 68 7 56 543 1.76e5 0.05% 99.12% +cold_shape_47 93 38 24 9 57 51 1.57e5 0.05% 99.17% +cold_shape_72 109 17 58 8 49 95 1.52e5 0.05% 99.22% +cold_shape_22 71 21 10 9 68 0 1.49e5 0.05% 99.26% +cold_shape_52 113 40 29 16 47 5 1.49e5 0.05% 99.31% +load_verified_constant 100 1 88 5 49 85 1.39e5 0.04% 99.35% +blake3 86 1 72 8 52 10 1.29e5 0.04% 99.39% +cold_shape_03 66 40 2 2 62 2484 1.24e5 0.04% 99.43% +Bytes1 11 0 0 0 256 0 1.22e5 0.04% 99.47% +cold_shape_74 173 29 60 37 28 99 1.17e5 0.04% 99.51% +try_reduce_projection_definition 59 3 24 13 60 23 1.07e5 0.03% 99.54% +whnf_apply_beta 34 3 10 7 88 0 9.98e4 0.03% 99.57% +cold_shape_20 56 26 10 6 57 27 9.51e4 0.03% 99.60% +cold_shape_67 80 7 48 6 36 0 7.57e4 0.02% 99.62% +get_constant_info_by_variant 64 8 46 2 42 0 7.40e4 0.02% 99.65% +cold_shape_44 86 27 22 15 32 0 7.00e4 0.02% 99.67% +cold_shape_05 96 40 2 2 29 488 6.87e4 0.02% 99.69% +cold_shape_77 145 16 71 11 21 0 6.76e4 0.02% 99.71% +memory[34] 43 0 0 0 53 155 6.72e4 0.02% 99.73% +cold_shape_68 153 17 49 14 20 0 6.68e4 0.02% 99.75% +cold_shape_55 95 17 31 20 26 3 5.90e4 0.02% 99.77% +cold_shape_56 105 19 32 22 24 50 5.86e4 0.02% 99.79% +cold_shape_70 80 11 51 5 29 6 5.74e4 0.02% 99.81% +k_infer_only 93 12 45 15 25 13 5.49e4 0.02% 99.82% +cold_shape_83 153 11 110 9 14 29 4.13e4 0.01% 99.84% +cold_shape_71 99 15 53 7 17 6 3.50e4 0.01% 99.85% +cold_shape_48 105 24 24 20 16 0 3.42e4 0.01% 99.86% +cold_shape_04 54 40 2 2 25 507 3.22e4 0.01% 99.87% +try_iota 108 5 39 25 15 3 3.22e4 0.01% 99.88% +cold_shape_73 112 14 59 8 14 0 3.04e4 0.01% 99.89% +cold_shape_69 82 15 50 4 17 13 2.91e4 0.01% 99.90% +memory[12] 21 0 0 0 42 670 2.53e4 0.01% 99.90% +cold_shape_78 171 11 75 40 9 0 2.47e4 0.01% 99.91% +cold_shape_40 67 16 20 5 17 15 2.39e4 0.01% 99.92% +cold_shape_51 79 9 27 17 15 0 2.37e4 0.01% 99.93% +cold_shape_27 58 22 13 5 18 86 2.24e4 0.01% 99.93% +cold_shape_64 104 20 39 16 11 0 2.02e4 0.01% 99.94% +cold_shape_65 88 13 42 8 12 0 1.94e4 0.01% 99.94% +try_reduce_fin_val_decidable_rec 149 9 58 37 8 37 1.82e4 0.01% 99.95% +cold_shape_58 67 11 34 7 13 8 1.66e4 0.01% 99.96% +ctor_at 86 2 72 3 9 0 1.26e4 0.00% 99.96% +cold_shape_63 86 12 39 6 9 6 1.26e4 0.00% 99.96% +muts_member_at 108 2 94 3 7 15 1.09e4 0.00% 99.97% +put_address 106 1 65 34 7 3 1.07e4 0.00% 99.97% +cold_shape_53 115 17 30 26 6 0 9.13e3 0.00% 99.97% +const_idxs_ctors 57 2 40 5 9 6 8.45e3 0.00% 99.98% +memory[10] 19 0 0 0 19 381 8.35e3 0.00% 99.98% +memory[47] 56 0 0 0 8 93 7.01e3 0.00% 99.98% +get_inductive 67 1 51 9 7 0 6.84e3 0.00% 99.98% +memory[36] 45 0 0 0 9 33 6.74e3 0.00% 99.98% +cold_shape_61 82 8 35 15 6 0 6.58e3 0.00% 99.99% +memory[9] 18 0 0 0 16 42 6.34e3 0.00% 99.99% +u64_byte_count 150 128 8 1 4 20 6.14e3 0.00% 99.99% +cold_shape_42 45 2 21 4 8 0 5.69e3 0.00% 99.99% +compare_rules 89 4 40 16 5 0 5.35e3 0.00% 99.99% +cold_shape_38 60 8 19 7 5 0 3.66e3 0.00% 100.00% +cold_shape_49 85 5 25 8 3 8 2.13e3 0.00% 100.00% +build_flat_block 159 7 121 12 2 0 1.66e3 0.00% 100.00% +build_minor_at_depth 65 1 25 21 3 0 1.65e3 0.00% 100.00% +cold_shape_33 60 4 15 12 3 0 1.53e3 0.00% 100.00% +check_recursor_canonical_full 125 9 50 18 2 0 1.32e3 0.00% 100.00% +memory[11] 20 0 0 0 4 10 9.44e2 0.00% 100.00% +memory[2] 11 0 0 0 5 6 8.19e2 0.00% 100.00% +cold_shape_21 71 37 10 7 2 12 7.82e2 0.00% 100.00% +cold_shape_66 144 22 44 35 1 0 7.36e2 0.00% 100.00% +memory[5] 14 0 0 0 4 24 7.04e2 0.00% 100.00% +k_is_def_eq_struct_go 58 26 13 6 2 0 6.52e2 0.00% 100.00% +load_verified_blob 46 1 36 3 2 5 5.32e2 0.00% 100.00% +cold_shape_50 90 24 26 16 1 0 4.66e2 0.00% 100.00% +memory[6] 15 0 0 0 3 25 4.65e2 0.00% 100.00% +cold_shape_01 38 26 1 2 2 23 4.52e2 0.00% 100.00% +build_succ_offset 57 2 17 16 1 0 3.01e2 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +memory[8] 17 0 0 0 1 329 1.01e2 0.00% 100.00% +klimbs_scalar_value 117 7 63 21 0 0 0 0.00% 100.00% +list_length_u64.U8_8 42 2 27 4 0 0 0 0.00% 100.00% +cold_shape_79 118 9 80 8 0 0 0 0.00% 100.00% +cold_shape_59 89 3 34 10 0 0 0 0.00% 100.00% +try_str_dispatch 128 18 47 28 0 0 0 0.00% 100.00% +list_length_u64.MutConst 79 2 64 4 0 0 0 0.00% 100.00% +list_length_u64.RecursorRule 43 2 28 4 0 0 0 0.00% 100.00% +cold_shape_81 152 23 90 14 0 0 0 0.00% 100.00% +rbtree_map_balance_fix.G 122 57 31 8 0 0 0 0.00% 100.00% +univ_succ_count 49 2 26 4 0 0 0 0.00% 100.00% +cold_shape_62 149 17 37 23 0 0 0 0.00% 100.00% +cold_shape_80 132 11 85 12 0 0 0 0.00% 100.00% +cold_shape_60 111 7 35 8 0 0 0 0.00% 100.00% +cold_shape_54 58 9 31 6 0 0 0 0.00% 100.00% +canon_addr_cmp 105 1 80 18 0 0 0 0.00% 100.00% +canon_cmp_kexpr_node_ctx 79 40 12 7 0 0 0 0.00% 100.00% +u64_mul 222 1 155 46 0 0 0 0.00% 100.00% +get_reveal_rule_list_inner 59 2 32 6 0 0 0 0.00% 100.00% +get_reveal_ctor_info 80 1 64 9 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +get_ctor_entry_list_inner 90 2 63 6 0 0 0 0.00% 100.00% +cold_shape_75 81 3 65 3 0 0 0 0.00% 100.00% +check_mut_const 127 3 1 10 0 0 0 0.00% 100.00% +nlvars_subsume 111 6 49 25 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +klimbs_mul_single 86 3 47 7 0 0 0 0.00% 100.00% diff --git a/cold-groups/kstats-grouped-String.split.txt b/cold-groups/kstats-grouped-String.split.txt new file mode 100644 index 000000000..11e7393eb --- /dev/null +++ b/cold-groups/kstats-grouped-String.split.txt @@ -0,0 +1,194 @@ +=== Circuit Statistics === +Circuits: 185 +Total width: 16311 +Total FFT cost: 62344588022 (6.23e10) +Total cache hits: 22638136 +Total saved cost: 54.10% +------------------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +------------------------------------------------------------------------------------------- +blake3_compress_inner_j 1192 1 561 497 136626 0 1.39e10 22.29% 22.29% +memory[3] 12 0 0 0 2947763 6323771 3.91e9 6.27% 28.56% +blake3_compress_chunks 29 3 7 4 1157705 0 3.42e9 5.49% 34.05% +expr_inst_many_walk 34 9 8 5 915195 0 3.11e9 4.99% 39.04% +expr_inst_many 21 2 4 4 1199626 299856 2.59e9 4.15% 43.19% +cold_shape_07 70 40 4 4 283142 47072 1.81e9 2.90% 46.09% +blake3_compress 1080 1 929 40 19518 15 1.50e9 2.41% 48.50% +get_expr 50 12 23 5 309599 20 1.42e9 2.28% 50.78% +cold_shape_32 114 31 15 8 139484 10824 1.36e9 2.19% 52.97% +convert_expr 60 12 25 7 240901 122716 1.30e9 2.09% 55.05% +k_infer_app_spine_loop 59 8 21 11 241267 677 1.28e9 2.06% 57.11% +list_drop.Ptr.Expr 20 2 6 3 592814 270333 1.16e9 1.86% 58.97% +expr_lbr 35 9 9 6 350993 2611613 1.14e9 1.84% 60.80% +list_snoc.G 22 2 6 4 521574 184967 1.11e9 1.78% 62.58% +get_tag4 37 2 22 4 311460 0 1.06e9 1.70% 64.28% +cold_shape_09 64 39 6 5 164341 166660 9.17e8 1.47% 65.76% +cold_shape_06 94 33 3 4 102822 89536 8.08e8 1.30% 67.05% +g_list_has 21 3 6 3 396339 3419 7.88e8 1.26% 68.32% +get_app_telescope 43 2 15 6 204828 0 7.84e8 1.26% 69.57% +expr_glb_walk 34 10 8 5 231083 0 7.08e8 1.14% 70.71% +cold_shape_14 89 16 7 7 89851 47335 6.61e8 1.06% 71.77% +validate_expr_well_scoped 52 9 20 8 144351 118355 6.48e8 1.04% 72.81% +cold_shape_12 74 40 7 4 103208 48896 6.40e8 1.03% 73.84% +peel_beta 32 3 12 5 221723 3113 6.38e8 1.02% 74.86% +memory[4] 13 0 0 0 497573 4533682 6.30e8 1.01% 75.87% +expr_inst_many_bvar 24 2 5 5 278974 0 6.16e8 0.99% 76.86% +expr_inst1_walk 34 9 8 5 202168 0 6.13e8 0.98% 77.84% +get_u64_le 28 2 14 3 240867 22 6.12e8 0.98% 78.82% +collect_spine 23 2 8 4 281491 197009 5.96e8 0.96% 79.78% +list_concat.Ptr.KExprNode 22 2 6 4 278551 242297 5.64e8 0.91% 80.68% +whnf_with_spine 34 6 11 5 175764 4941 5.27e8 0.85% 81.53% +expr_lower_walk 53 10 18 9 115078 0 5.17e8 0.83% 82.36% +k_infer_core 53 9 22 8 112780 54815 5.06e8 0.81% 83.17% +expr_inst1 21 2 4 4 261823 104786 5.04e8 0.81% 83.98% +const_idxs_expr 52 7 26 7 110757 166346 4.87e8 0.78% 84.76% +cold_shape_45 89 31 23 9 65208 9293 4.66e8 0.75% 85.51% +expr_glb 21 2 5 4 240811 257285 4.61e8 0.74% 86.25% +list_lookup.Ptr.KLevelNode 16 1 5 3 294825 71690 4.39e8 0.70% 86.95% +cold_shape_13 84 38 7 5 64872 6348 4.38e8 0.70% 87.65% +cold_shape_30 64 22 14 6 78610 23007 4.12e8 0.66% 88.31% +list_length.Ptr.KExprNode 18 2 5 3 249239 712085 4.11e8 0.66% 88.97% +expr_lift_walk 34 9 8 5 139072 0 4.09e8 0.66% 89.63% +safe_refs_only 43 9 19 5 111679 109780 4.07e8 0.65% 90.28% +cold_shape_39 91 36 19 14 55560 202576 4.00e8 0.64% 90.92% +expr_lift 23 3 5 4 182612 389282 3.74e8 0.60% 91.52% +bytes_to_block 265 1 193 65 18371 661 3.45e8 0.55% 92.08% +cold_shape_16 119 40 9 8 30933 1347 2.76e8 0.44% 92.52% +whnf_const_head 77 16 32 10 44889 0 2.69e8 0.43% 92.95% +cold_shape_82 213 5 100 51 17795 109 2.68e8 0.43% 93.38% +cold_shape_15 68 37 8 5 49040 5157 2.62e8 0.42% 93.80% +memory[18] 27 0 0 0 110757 606238 2.55e8 0.41% 94.21% +blake3_compress_block 211 2 169 15 17109 0 2.54e8 0.41% 94.62% +cold_shape_24 74 40 12 7 43922 5158 2.52e8 0.40% 95.02% +cold_shape_43 65 14 22 7 47013 124 2.39e8 0.38% 95.40% +cold_shape_17 71 40 9 6 37904 17301 2.06e8 0.33% 95.73% +apply_spine_expr 22 2 6 4 104043 16635 1.94e8 0.31% 96.05% +cold_shape_11 102 39 7 6 24312 1271 1.82e8 0.29% 96.34% +cold_shape_35 80 12 16 16 28108 2610 1.67e8 0.27% 96.60% +cold_shape_37 91 30 18 12 23588 1702 1.57e8 0.25% 96.86% +address_eq 82 2 66 4 22618 19841 1.35e8 0.22% 97.07% +try_reduce_projection_definition 59 3 24 13 29751 4863 1.31e8 0.21% 97.28% +whnf_apply_beta 34 3 10 7 48959 0 1.31e8 0.21% 97.49% +Bytes2 24 0 0 0 65536 0 1.28e8 0.21% 97.70% +cold_shape_36 83 33 17 10 17139 4182 1.01e8 0.16% 97.86% +cold_shape_19 64 36 10 5 20850 12719 9.65e7 0.15% 98.02% +cold_shape_52 113 40 29 16 12068 683 9.29e7 0.15% 98.17% +cold_shape_10 77 40 6 5 16471 23576 8.94e7 0.14% 98.31% +cold_shape_26 57 10 12 11 19720 0 8.09e7 0.13% 98.44% +cold_shape_84 259 19 151 9 5000 1097 7.97e7 0.13% 98.57% +pad_block 18 2 4 3 53030 230 7.68e7 0.12% 98.69% +cold_shape_18 61 14 9 9 15616 443 6.69e7 0.11% 98.80% +try_iota 108 5 39 25 9346 388 6.69e7 0.11% 98.90% +memory[32] 41 0 0 0 18539 87446 5.46e7 0.09% 98.99% +cold_shape_31 131 38 14 13 5961 6592 4.92e7 0.08% 99.07% +cold_shape_51 79 9 27 17 9011 306 4.71e7 0.08% 99.15% +cold_shape_25 60 27 12 6 9802 9887 3.93e7 0.06% 99.21% +cold_shape_22 71 21 10 9 8207 263 3.82e7 0.06% 99.27% +cold_shape_47 93 38 24 9 6278 5544 3.71e7 0.06% 99.33% +blake3_compress_layer 223 3 170 6 2324 0 2.91e7 0.05% 99.38% +cold_shape_41 92 25 20 15 4926 346 2.80e7 0.04% 99.42% +k_infer_only 93 12 45 15 4753 2955 2.72e7 0.04% 99.46% +cold_shape_46 109 27 23 15 3849 30060 2.51e7 0.04% 99.51% +cold_shape_00 60 36 1 1 6536 108063 2.51e7 0.04% 99.55% +cold_shape_68 153 17 49 14 2712 483 2.38e7 0.04% 99.58% +try_reduce_fin_val_decidable_rec 149 9 58 37 2472 9544 2.08e7 0.03% 99.62% +cold_shape_64 104 20 39 16 3069 0 1.86e7 0.03% 99.65% +cold_shape_02 60 40 2 1 4868 320964 1.81e7 0.03% 99.68% +cold_shape_28 71 38 13 7 3961 670185 1.69e7 0.03% 99.70% +cold_shape_08 75 40 5 4 3497 12395 1.56e7 0.02% 99.73% +cold_shape_23 66 38 11 5 3867 2360 1.53e7 0.02% 99.75% +cold_shape_03 66 40 2 2 3219 484594 1.25e7 0.02% 99.77% +cold_shape_57 88 6 33 6 2414 53 1.20e7 0.02% 99.79% +cold_shape_76 107 18 68 7 2002 82225 1.18e7 0.02% 99.81% +cold_shape_34 75 32 16 8 2676 20463 1.15e7 0.02% 99.83% +cold_shape_72 109 17 58 8 1860 17498 1.11e7 0.02% 99.85% +load_verified_constant 100 1 88 5 1860 2402 1.02e7 0.02% 99.86% +cold_shape_29 74 26 13 12 2304 2290845 9.61e6 0.02% 99.88% +blake3 86 1 72 8 1950 140 9.23e6 0.01% 99.89% +memory[34] 43 0 0 0 2651 7671 6.58e6 0.01% 99.90% +cold_shape_74 173 29 60 37 783 48057 6.54e6 0.01% 99.91% +cold_shape_20 56 26 10 6 2054 6432 6.40e6 0.01% 99.92% +get_constant_info_by_variant 64 8 46 2 1765 0 6.16e6 0.01% 99.93% +cold_shape_55 95 17 31 20 988 78 4.70e6 0.01% 99.94% +cold_shape_56 105 19 32 22 561 480 2.71e6 0.00% 99.95% +cold_shape_48 105 24 24 20 542 246 2.60e6 0.00% 99.95% +cold_shape_44 86 27 22 15 611 0 2.45e6 0.00% 99.95% +cold_shape_78 171 11 75 40 321 15 2.30e6 0.00% 99.96% +memory[12] 21 0 0 0 1772 97658 2.07e6 0.00% 99.96% +cold_shape_50 90 24 26 16 503 39 2.05e6 0.00% 99.97% +cold_shape_04 54 40 2 2 680 20933 1.75e6 0.00% 99.97% +cold_shape_67 80 7 48 6 483 13 1.74e6 0.00% 99.97% +cold_shape_77 145 16 71 11 287 0 1.71e6 0.00% 99.97% +k_is_def_eq_struct_go 58 26 13 6 623 0 1.70e6 0.00% 99.98% +nl_subsume_entry 121 13 54 24 311 63 1.57e6 0.00% 99.98% +cold_shape_70 80 11 51 5 375 97 1.30e6 0.00% 99.98% +cold_shape_53 115 17 30 26 257 4 1.19e6 0.00% 99.98% +cold_shape_83 153 11 110 9 190 1164 1.11e6 0.00% 99.98% +cold_shape_58 67 11 34 7 337 1254 9.60e5 0.00% 99.99% +cold_shape_71 99 15 53 7 232 94 9.11e5 0.00% 99.99% +cold_shape_73 112 14 59 8 177 13 7.47e5 0.00% 99.99% +cold_shape_69 82 15 50 4 222 221 7.17e5 0.00% 99.99% +cold_shape_05 96 40 2 2 165 12555 5.89e5 0.00% 99.99% +cold_shape_61 82 8 35 15 175 5 5.41e5 0.00% 99.99% +cold_shape_65 88 13 42 8 152 14 4.90e5 0.00% 99.99% +ctor_at 86 2 72 3 141 3 4.38e5 0.00% 99.99% +cold_shape_40 67 16 20 5 165 172 4.13e5 0.00% 99.99% +cold_shape_63 86 12 39 6 114 94 3.39e5 0.00% 99.99% +put_address 106 1 65 34 95 45 3.34e5 0.00% 99.99% +muts_member_at 108 2 94 3 92 214 3.27e5 0.00% 100.00% +const_idxs_ctors 57 2 40 5 114 91 2.26e5 0.00% 100.00% +compare_rules 89 4 40 16 77 0 2.18e5 0.00% 100.00% +get_inductive 67 1 51 9 95 0 2.13e5 0.00% 100.00% +cold_shape_38 60 8 19 7 101 0 2.05e5 0.00% 100.00% +memory[36] 45 0 0 0 114 453 1.79e5 0.00% 100.00% +cold_shape_27 58 22 13 5 91 2877 1.75e5 0.00% 100.00% +memory[47] 56 0 0 0 93 1214 1.74e5 0.00% 100.00% +cold_shape_42 45 2 21 4 109 0 1.70e5 0.00% 100.00% +memory[10] 19 0 0 0 210 59730 1.61e5 0.00% 100.00% +cold_shape_66 144 22 44 35 38 14 1.45e5 0.00% 100.00% +load_verified_blob 46 1 36 3 89 711 1.36e5 0.00% 100.00% +build_flat_block 159 7 121 12 32 0 1.28e5 0.00% 100.00% +Bytes1 11 0 0 0 256 0 1.22e5 0.00% 100.00% +check_recursor_canonical_full 125 9 50 18 32 0 1.01e5 0.00% 100.00% +build_minor_at_depth 65 1 25 21 45 0 8.19e4 0.00% 100.00% +cold_shape_33 60 4 15 12 47 0 8.00e4 0.00% 100.00% +cold_shape_21 71 37 10 7 37 211 6.98e4 0.00% 100.00% +klimbs_mul_single 86 3 47 7 27 0 5.62e4 0.00% 100.00% +u64_mul 222 1 155 46 13 0 5.39e4 0.00% 100.00% +build_succ_offset 57 2 17 16 30 0 4.30e4 0.00% 100.00% +nlvars_subsume 111 6 49 25 17 3 3.92e4 0.00% 100.00% +memory[11] 20 0 0 0 46 154 2.71e4 0.00% 100.00% +memory[9] 18 0 0 0 48 351 2.59e4 0.00% 100.00% +cold_shape_49 85 5 25 8 14 279 2.32e4 0.00% 100.00% +memory[5] 14 0 0 0 46 4726 1.94e4 0.00% 100.00% +memory[6] 15 0 0 0 33 417 1.37e4 0.00% 100.00% +memory[8] 17 0 0 0 29 40990 1.30e4 0.00% 100.00% +u64_byte_count 150 128 8 1 5 292 8.89e3 0.00% 100.00% +cold_shape_62 149 17 37 23 3 0 3.65e3 0.00% 100.00% +cold_shape_01 38 26 1 2 6 1520 3.16e3 0.00% 100.00% +memory[2] 11 0 0 0 13 99 3.11e3 0.00% 100.00% +try_str_dispatch 128 18 47 28 2 0 1.35e3 0.00% 100.00% +cold_shape_54 58 9 31 6 2 0 6.52e2 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +cold_shape_60 111 7 35 8 0 0 0 0.00% 100.00% +cold_shape_81 152 23 90 14 0 0 0 0.00% 100.00% +rbtree_map_balance_fix.G 122 57 31 8 0 0 0 0.00% 100.00% +canon_addr_cmp 105 1 80 18 0 0 0 0.00% 100.00% +cold_shape_59 89 3 34 10 0 0 0 0.00% 100.00% +cold_shape_79 118 9 80 8 0 0 0 0.00% 100.00% +get_reveal_rule_list_inner 59 2 32 6 0 0 0 0.00% 100.00% +get_reveal_ctor_info 80 1 64 9 0 0 0 0.00% 100.00% +get_ctor_entry_list_inner 90 2 63 6 0 0 0 0.00% 100.00% +cold_shape_75 81 3 65 3 0 0 0 0.00% 100.00% +check_mut_const 127 3 1 10 0 0 0 0.00% 100.00% +cold_shape_80 132 11 85 12 0 0 0 0.00% 100.00% +univ_succ_count 49 2 26 4 0 0 0 0.00% 100.00% +list_length_u64.U8_8 42 2 27 4 0 0 0 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +klimbs_scalar_value 117 7 63 21 0 0 0 0.00% 100.00% +canon_cmp_kexpr_node_ctx 79 40 12 7 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +list_length_u64.MutConst 79 2 64 4 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +list_length_u64.RecursorRule 43 2 28 4 0 0 0 0.00% 100.00% From 687e89e1399ad0774dc51b2f9a82c8633b8e6795 Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Wed, 12 Aug 2026 12:59:10 -0300 Subject: [PATCH 5/6] ixvm: aggressive shape grouping tier (730 -> 93 circuits) Loosen the kernel partition to aux within 3.5x, lookups within max(4x, +12), summed selectors <= 96, and cold threshold < 2% max share: 46 bands over 683 circuits, total committed width 33,827 -> 11,596 (-66%). Measured FFT cost 2.08x summed over the three profiling workloads (model 2.14x); all 71 pins and the shard aggregate (+65%) re-measured. The sweep (in cold-groups/kernel-shape-grouping.md) shows the cost cliff comes from raising the cold threshold, not the shape tolerances - a nearly-free 185 -> 142 tier exists at <0.5% if this proves too hot. ixvm (pins + parity), aiur-prove, multi-stark and recursive-verifier suites pass; fmt clean; no Rust change. --- Ix/IxVM/ColdGroups.lean | 268 ++++++++---------- Tests/Ix/IxVM.lean | 142 +++++----- Tests/Main.lean | 4 +- cold-groups/kernel-bands-aggr.json | 1 + cold-groups/kernel-shape-grouping.md | 22 +- .../kstats-aggr-Array.extract_append.txt | 102 +++++++ cold-groups/kstats-aggr-Nat.add_comm.txt | 102 +++++++ cold-groups/kstats-aggr-String.split.txt | 102 +++++++ 8 files changed, 525 insertions(+), 218 deletions(-) create mode 100644 cold-groups/kernel-bands-aggr.json create mode 100644 cold-groups/kstats-aggr-Array.extract_append.txt create mode 100644 cold-groups/kstats-aggr-Nat.add_comm.txt create mode 100644 cold-groups/kstats-aggr-String.split.txt diff --git a/Ix/IxVM/ColdGroups.lean b/Ix/IxVM/ColdGroups.lean index ac33a9b7f..1074ee868 100644 --- a/Ix/IxVM/ColdGroups.lean +++ b/Ix/IxVM/ColdGroups.lean @@ -13,8 +13,13 @@ public section namespace IxVM +-- Shape-proximity bands, aggressive (aux within 3.5x, lookups within +-- max(4x, +12), summed selectors <= 96, cold < 2% max share; verify_claim +-- excluded as the entry). See cold-groups/kernel-shape-grouping.md for the +-- conservative baseline and cold-groups/verifier-shape-grouping.md for the +-- sweep methodology. def coldGroups : Array (String × Array String) := #[ - ("cold_shape_00", #[ + ("k_shape_00", #[ "canon_kind_ord", "canon_sord_eq_strong", "canon_sord_gt_strong", @@ -26,15 +31,12 @@ def coldGroups : Array (String × Array String) := #[ "const_type_of", "def_safety_tag", "flatten_u64", - ]), - ("cold_shape_01", #[ "pack_def_kind_safety", "quot_kind_tag", "unpack_def_kind_safety", "check_opt_ctor_entries", "check_opt_recr_rules", - ]), - ("cold_shape_02", #[ + "check_mut_const", "canon_ord_then", "canon_sord_then", "defn_is_unsafe_ci", @@ -42,9 +44,9 @@ def coldGroups : Array (String × Array String) := #[ "is_unsafe_ci", "lbr_dec", "relaxed_u64_pred", - "relaxed_u64_succ", ]), - ("cold_shape_03", #[ + ("k_shape_01", #[ + "relaxed_u64_succ", "u64_eq", "u64_is_zero", "addr_set_member", @@ -65,8 +67,6 @@ def coldGroups : Array (String × Array String) := #[ "char_of_nat_addr", "char_type_addr", "check_parent_inductive_shape", - ]), - ("cold_shape_04", #[ "decidable_decide_addr", "decidable_is_false_addr_dec", "decidable_is_true_addr_dec", @@ -104,8 +104,6 @@ def coldGroups : Array (String × Array String) := #[ "nat_not_le_of_not_ble_eq_true_addr_dec", "nat_pow_addr", "nat_pred_addr", - ]), - ("cold_shape_05", #[ "nat_shift_left_addr", "nat_shift_right_addr", "nat_sub_addr", @@ -113,6 +111,8 @@ def coldGroups : Array (String × Array String) := #[ "nat_xor_addr", "nat_zero_addr", "punit_addr", + ]), + ("k_shape_02", #[ "punit_size_of_1_addr", "put_constant_info", "put_quot_kind", @@ -136,8 +136,6 @@ def coldGroups : Array (String × Array String) := #[ "system_platform_num_bits_addr", "unit_addr", "utf8_last_codepoint", - ]), - ("cold_shape_06", #[ "check_param_agreement", "is_defn_or_thm", "assert_safety", @@ -160,8 +158,6 @@ def coldGroups : Array (String × Array String) := #[ "run_contains", "utf8_cont", "check_inductive_shape", - ]), - ("cold_shape_07", #[ "get_opt_addr_masked", "get_opt_bool_masked", "get_opt_def_kind_masked", @@ -172,14 +168,16 @@ def coldGroups : Array (String × Array String) := #[ "k_is_def_eq_ordered", "klimbs_shl_limbs", "klimbs_sub", + "pad_block", "put_u64_le", + ]), + ("k_shape_03", #[ "try_unfold_head", "env_walk_leaves", "expr_glb_binder", + "expr_inst1", "has_bvar_in_range_let", "k_infer", - ]), - ("cold_shape_08", #[ "k_infer_lit", "klimbs_dec", "klimbs_gcd", @@ -188,6 +186,8 @@ def coldGroups : Array (String × Array String) := #[ "put_constructor_proj", "validate_univ_params_list", "get_opt_addr", + "list_length.Ptr.KExprNode", + "list_lookup.Ptr.KLevelNode", "list_lookup_or_default.Ptr.U8_32", "nl_add_const", "read_byte", @@ -201,8 +201,8 @@ def coldGroups : Array (String × Array String) := #[ "build_rec_lvls_list", "canon_ctor_ctx_entries", "check_prop_field_if_prop", - ]), - ("cold_shape_09", #[ + "expr_glb", + "expr_lift", "expr_lower", "mk_bool", "np_whnf_inner_bv", @@ -219,14 +219,16 @@ def coldGroups : Array (String × Array String) := #[ "level_equal", "count_foralls_body", "expr_inst_levels", + "g_list_has", "level_offset_of", "skip_bytes", + "apply_spine_expr", + ]), + ("k_shape_04", #[ "canon_all_singleton", "canon_flatten", "canon_ins_sort", "canon_refine_one", - ]), - ("cold_shape_10", #[ "check_field_universes", "check_rec_rules_wellscoped", "convert_definition", @@ -242,8 +244,6 @@ def coldGroups : Array (String × Array String) := #[ "env_walk_refs", "put_tag0", "put_tag2", - ]), - ("cold_shape_11", #[ "put_tag4", "try_proof_irrel", "walk_refs_transitive", @@ -261,10 +261,10 @@ def coldGroups : Array (String × Array String) := #[ "se_peel_tol", "addr_list_contains", "all_bvars_in_args", - ]), - ("cold_shape_12", #[ "char_lit_codepoint", "check_field_universes_skip_params", + ]), + ("k_shape_05", #[ "is_large_eliminator", "is_nat_zero", "k_ensure_sort", @@ -275,8 +275,6 @@ def coldGroups : Array (String × Array String) := #[ "list_take.Ptr.KExprNode", "se_addr_in", "str_lit_to_ctor_app_or_self", - ]), - ("cold_shape_13", #[ "utf8_last_go", "apply_spec_params_lifted", "canon_cmp_member_ctx", @@ -292,8 +290,6 @@ def coldGroups : Array (String × Array String) := #[ "list_lift_indices", "nl_subsumption_walk", "whnf_spine", - ]), - ("cold_shape_14", #[ "const_idxs_of", "k_is_def_eq", "try_unit_like", @@ -302,22 +298,24 @@ def coldGroups : Array (String × Array String) := #[ "mk_nat_binop_stuck", "replace_spine_major", ]), - ("cold_shape_15", #[ + ("k_shape_06", #[ "list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode", "assert_lvls_are_params", "canon_ctx_class_idx", "canon_g_list_eq", "check_large_prop_ctor", + "collect_spine", "glist_eq_len", "peel_leading_foralls_acc", "se_scan_fields", "try_prim_dispatch", "canon_build_ctx_classes", "canon_cmp_krec_rule_ctx", + "expr_glb_walk", + "expr_inst1_walk", + "expr_lift_walk", "get_expr_let", "nl_le_vars", - ]), - ("cold_shape_16", #[ "normalize_aux", "try_string_lit_one", "canon_ctx_cmp_addr", @@ -326,14 +324,14 @@ def coldGroups : Array (String × Array String) := #[ "intern_int_lit", "spec_params_lower", "try_quot_iota", + ]), + ("k_shape_07", #[ "unfold_both_and_loop", "convert_recursor", "assert_first_args_are_param_bvars", "assert_occ_param_bvars", "head_addr", "list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode", - ]), - ("cold_shape_17", #[ "peel_n_foralls_with_types", "check_rec_major_spine", "get_result_sort_level", @@ -345,8 +343,6 @@ def coldGroups : Array (String × Array String) := #[ "try_extract_nat", "whnf_get_ctor_or_none", "expr_inst_levels_walk", - ]), - ("cold_shape_18", #[ "is_inductive_prop", "k_is_def_eq_slow_nd", "level_leq", @@ -355,23 +351,19 @@ def coldGroups : Array (String × Array String) := #[ "u64_and", "u64_or", "u64_xor_kbits", - ]), - ("cold_shape_19", #[ "find_rule", "args_contain_bvar", "peel_n_lams_collect", "build_peer_recs", "canon_classes_eq", "de_args", - "expr_mentions_block", ]), - ("cold_shape_20", #[ + ("k_shape_08", #[ + "expr_mentions_block", "lazy_delta_loop", "level_eq", "level_list_eq", "canon_cmp_bytes", - ]), - ("cold_shape_21", #[ "canon_cmp_kuniv", "canon_cmp_kuniv_list", "extract_aux_spec_params", @@ -379,16 +371,15 @@ def coldGroups : Array (String × Array String) := #[ "normalize_imax_dispatch", "spec_params_dom_prefix_match", "check_native_bool", - ]), - ("cold_shape_22", #[ "is_bitvec_prim_addr", "is_int_dec_prim_addr", "lazy_delta_both_proj", + "whnf_apply_beta", + ]), + ("k_shape_09", #[ "whnf_nd_apply_beta", "canonical_rules_at_pos", "mk_nat_offset_stuck", - ]), - ("cold_shape_23", #[ "get_opt_u64_masked", "flat_find_pos", "put_refs", @@ -400,8 +391,6 @@ def coldGroups : Array (String × Array String) := #[ "level_struct_eq", "nl_skip_empty", "peel_params_subst", - ]), - ("cold_shape_24", #[ "se_mentions", "whnf_nd_with_spine", "nl_covers_var", @@ -413,22 +402,19 @@ def coldGroups : Array (String × Array String) := #[ "list_length.U8_8", "canon_cmp_kexpr_ctx", "ensure_sort_only", - ]), - ("cold_shape_25", #[ "flat_member_at", "rec_to_parent_addr", "check_param_agreement_go", + ]), + ("k_shape_10", #[ "k_is_def_eq_struct_safe", "nl_le", "nlvars_eq", - ]), - ("cold_shape_26", #[ + "canon_cmp_kexpr_node_ctx", "build_char_list", "build_motive_type_flat", "k_def_eq_rebase", "klimbs_pow", - ]), - ("cold_shape_27", #[ "get_opt_ctor_entry_list_masked", "get_opt_rule_list_masked", "klimbs_is_zero", @@ -438,13 +424,12 @@ def coldGroups : Array (String × Array String) := #[ "convert_univ", "se_parent_addr", ]), - ("cold_shape_28", #[ + ("k_shape_11", #[ + "k_is_def_eq_struct_go", "kexpr_struct_eq", "level_imax", "lbr_max", "lbr_min", - ]), - ("cold_shape_29", #[ "level_max_go", "memo_u32_less_than", "bitvec_of_nat_args_direct", @@ -453,17 +438,16 @@ def coldGroups : Array (String × Array String) := #[ "bv_to_nat_via", "nl_add_var", "check_ctor_return_type", - ]), - ("cold_shape_30", #[ "canon_member_num_ctors", + "get_u64_le", "put_recursor_rule_list", + ]), + ("k_shape_12", #[ "run_check", "get_axiom", "extract_aux_occ_us", "whnf", "whnf_nd", - ]), - ("cold_shape_31", #[ "canon_ord_cmp_g", "put_constant", "walk_fields_classify", @@ -474,8 +458,6 @@ def coldGroups : Array (String × Array String) := #[ "try_eta_expand", "klimbs_div_mod", "dec_rewrite_lt_to_le", - ]), - ("cold_shape_32", #[ "assert_return_head_is_parent", "caddr_is_peer", "canon_member_ci", @@ -487,18 +469,17 @@ def coldGroups : Array (String × Array String) := #[ "put_univ_list", "get_address_list", "get_all_telescope", + "get_app_telescope", "get_expr_list", "get_lam_telescope", "collect_index_doms", "compute_iprj_addr", "k_is_def_eq_core", - ]), - ("cold_shape_33", #[ "bitvec_prep_spine", "build_rule_rhs", - ]), - ("cold_shape_34", #[ "addr_set_build", + ]), + ("k_shape_13", #[ "struct_is_rec", "convert_rec_rules", "run_check_env", @@ -509,16 +490,12 @@ def coldGroups : Array (String × Array String) := #[ "try_def_eq_nat", "peel_ctor_params_subst", "validate_univ_params_seen", - ]), - ("cold_shape_35", #[ "bitvec_prep_spine_ult", "ctx_seek_cut", "normalize_int_dec_rebuild", "canon_cmp_u64_lex", "u64_add", "u64_sub_with_borrow", - ]), - ("cold_shape_36", #[ "flat_find_pos_kind", "canon_cmp_krec_rule_list_ctx", "check_valid_ind_app", @@ -528,22 +505,21 @@ def coldGroups : Array (String × Array String) := #[ "check_inductive_shape_ctors", "ctor_subst_param_for", "ctx_close_cut", - ]), - ("cold_shape_37", #[ + "build_succ_offset", "get_definition", "populate_rules", "char_lit_codepoint_syn", + ]), + ("k_shape_14", #[ + "expr_lower_walk", "try_def_eq_app", "level_max_offsets", "nl_eq", "try_k_synth_iota", - ]), - ("cold_shape_38", #[ "univ_succ_base", + "safe_refs_only", "struct_scan_ctors", "build_minor_doms", - ]), - ("cold_shape_39", #[ "cleanup_nat_offset_major", "nlvars_any_offset_geq", "nlvars_dominates", @@ -552,39 +528,34 @@ def coldGroups : Array (String × Array String) := #[ "is_dec_prim_addr", "is_native_prim_addr", "try_nat_offset_dispatch", - ]), - ("cold_shape_40", #[ "bytes_to_u64_limb", "list_length_u64.Ptr.Univ", + ]), + ("k_shape_15", #[ "build_rec_type", "build_succ_chain", - ]), - ("cold_shape_41", #[ + "validate_expr_well_scoped", "check_nested_ctors_positivity", "try_extract_int", "k_is_def_eq_slow2", "check_const", - ]), - ("cold_shape_42", #[ "get_constructor_proj", "put_recursor_rule", ]), - ("cold_shape_43", #[ + ("k_shape_16", #[ + "get_tag4", "expr_addr", "put_axiom", "put_quotient", "get_u64_list", "put_univ", "delta_unfold", - ]), - ("cold_shape_44", #[ + "k_infer_core", "nl_add_const_go", "try_quot_ind", "try_quot_lift", "walk_char_list_bytes", "is_str_prim_addr", - ]), - ("cold_shape_45", #[ "get_tag0", "get_tag2", "klimbs_eq", @@ -593,15 +564,13 @@ def coldGroups : Array (String × Array String) := #[ "whnf_nd_const_head", "compute_k_target", "canon_cprj_addr", - ]), - ("cold_shape_46", #[ "nat_offset_of", "projection_addr_ctor", + ]), + ("k_shape_17", #[ "projection_definition_info", "canon_cmp_ctor_pair_ctx", "try_bitvec_dispatch", - ]), - ("cold_shape_47", #[ "ctors_before_pos", "put_expr_list", "build_flat_own_params", @@ -613,31 +582,32 @@ def coldGroups : Array (String × Array String) := #[ "lazy_delta_a_const_b_proj", "lazy_delta_b_const_a_proj", "whnf_iota_major", - ]), - ("cold_shape_48", #[ "nl_covers_const", + "try_reduce_projection_definition", "canon_build_ctx_members", "check_recursor_member", "try_nat_binop_dispatch", "try_reduce_bit_vec_ult", "build_ih_doms", - ]), - ("cold_shape_49", #[ "klimbs_normalize", "put_constructor", ]), - ("cold_shape_50", #[ + ("k_shape_18", #[ + "univ_succ_count", + "const_idxs_expr", "is_nat_succ_ih_step", "try_normalize_int_decidable", "try_reduce_subtype_val", "try_str_to_byte_array", "try_dec_dispatch", + "list_length_u64.U8_8", ]), - ("cold_shape_51", #[ + ("k_shape_19", #[ "try_nat_linear_rec", "try_str_back", ]), - ("cold_shape_52", #[ + ("k_shape_20", #[ + "list_length_u64.RecursorRule", "rbtree_map_lookup_or_default.G", "whnf_nd_proj_head", "whnf_proj_head", @@ -646,91 +616,93 @@ def coldGroups : Array (String × Array String) := #[ "try_str_dec_eq", "try_reduce_size_of_unit", ]), - ("cold_shape_53", #[ + ("k_shape_21", #[ "build_rec_type_from", "k_synth_gate", "dec_build_proof", "apply_ihs_full", ]), - ("cold_shape_54", #[ + ("k_shape_22", #[ "klimbs_land", "klimbs_lor", "klimbs_xor_op", - ]), - ("cold_shape_55", #[ + "rbtree_map_balance_fix.G", "str_lit_delta_step", "glist_ordered_insert", "try_nat_dispatch_prewhnf", + "get_reveal_rule_list_inner", ]), - ("cold_shape_56", #[ + ("k_shape_23", #[ + "whnf_const_head", "glist_cmp", "glist_subset", "utf8_decode_one", "dec_finish", ]), - ("cold_shape_57", #[ + ("k_shape_24", #[ "verify_bytes_against", "get_univ", - ]), - ("cold_shape_58", #[ "canon_insert_sorted", "bytes_to_addr", "is_unit_like_type", - ]), - ("cold_shape_59", #[ "canon_cmp_ctor_range_ctx", "put_inductive", - ]), - ("cold_shape_60", #[ "all_telescope_count", "app_telescope_count", "lam_telescope_count", "check_ctor_entry", - ]), - ("cold_shape_61", #[ "canon_group_walk", - "check_positivity_aug", ]), - ("cold_shape_62", #[ + ("k_shape_25", #[ + "check_positivity_aug", + "load_verified_blob", "put_recursor", + ]), + ("k_shape_26", #[ "canon_cmp_member_same_kind_ctx", "try_native_dispatch", ]), - ("cold_shape_63", #[ + ("k_shape_27", #[ "count_ctors", "put_constructor_list", "put_all_telescope", "put_app_telescope", "put_lam_telescope", "check_recr_rules", - ]), - ("cold_shape_64", #[ "try_lazy_delta_app", "rbtree_map_ins.G", "k_infer_proj", + ]), + ("k_shape_28", #[ "try_struct_eta_iota", + "try_iota", ]), - ("cold_shape_65", #[ + ("k_shape_29", #[ + "const_idxs_ctors", + "compare_rules", "klimbs_add_carry", "get_constructor", "klimbs_sub_borrow", "put_definition", ]), - ("cold_shape_66", #[ + ("k_shape_30", #[ "str_dec_eq_build", "nlvars_add", "try_nat_binop_addr", + "k_infer_only", ]), - ("cold_shape_67", #[ + ("k_shape_31", #[ + "get_constant_info_by_variant", + "klimbs_mul_single", + ]), + ("k_shape_32", #[ "get_mut_const", "check_muts_all", "get_constructor_list", - ]), - ("cold_shape_68", #[ "try_eta_struct", "run_reveal", ]), - ("cold_shape_69", #[ + ("k_shape_33", #[ "is_muts_block", "detect_aux_from_recrs_ex", "find_peer_recursor_with_spec", @@ -738,82 +710,90 @@ def coldGroups : Array (String × Array String) := #[ "canon_indc_positions", "put_mut_const_list", ]), - ("cold_shape_70", #[ + ("k_shape_34", #[ "canon_muts_has_kind", "get_ctor_entry", "check_ctor_entries", "build_recur_addrs_walk", - ]), - ("cold_shape_71", #[ + "get_inductive", "check_block_peer_param_agreement", "ind_is_solo", "struct_block_member_addrs", "list_length_u64.Constructor", "const_idxs_muts", ]), - ("cold_shape_72", #[ + ("k_shape_35", #[ + "nl_subsume_entry", "run_check_transitive", "env_walk", ]), - ("cold_shape_73", #[ + ("k_shape_36", #[ "get_mut_const_list", "put_expr", ]), - ("cold_shape_74", #[ + ("k_shape_37", #[ "prim_family", "lazy_delta_step_const_const", ]), - ("cold_shape_75", #[ + ("k_shape_38", #[ + "get_ctor_entry_list_inner", + "klimbs_scalar_value", + ]), + ("k_shape_39", #[ + "list_length_u64.MutConst", + "get_reveal_ctor_info", "check_opt_addr", "get_mut_entry", ]), - ("cold_shape_76", #[ + ("k_shape_40", #[ "address_eq_tail", + "address_eq", "check_opt_expr_addr", "get_ci", - ]), - ("cold_shape_77", #[ "flat_originals_walk", "get_recursor", "peer_agree_walk", "run_claim", + "ctor_at", + "blake3", ]), - ("cold_shape_78", #[ + ("k_shape_41", #[ "try_reduce_decide_bitvec_lt", "check_canonical_block", ]), - ("cold_shape_79", #[ + ("k_shape_42", #[ "get_mut_entry_list_inner", "first_recr_parent_block", "list_lookup_u64.Constructor", - ]), - ("cold_shape_80", #[ + "canon_addr_cmp", "load_assumption_tree", "find_peer_rec_spec_walk", - ]), - ("cold_shape_81", #[ + "load_verified_constant", "aux_from_recrs_walk_ex", "get_reveal_info", "get_reveal_mut_const_info", ]), - ("cold_shape_82", #[ + ("k_shape_43", #[ "get_address", "utf8_encode_prepend", ]), - ("cold_shape_83", #[ + ("k_shape_44", #[ "list_lookup_u64.MutConst", "projection_addr", "get_ci_iprj", "get_ci_rprj", "get_ci_dprj", "check_muts_components", - ]), - ("cold_shape_84", #[ + "build_flat_block", "blake3_next_layer", "get_constant", "get_ci_cprj", "blake3_finish", ]), + ("k_shape_45", #[ + "u64_mul", + "blake3_compress_block", + ]), ] end IxVM diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index b596bf112..4c511d300 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -276,77 +276,77 @@ private def nameOfString (str : String) : Lean.Name := listed constant fails the suite, so a regression cannot land quietly and an improvement has to be acknowledged by re-pinning. -/ private def kernelCheckEntries : List (String × Nat) := [ - ("HEq", 129_678_983), - ("HEq.rec", 134_241_101), - ("Eq.rec", 133_581_016), - ("Nat", 129_672_949), - ("Nat.add", 173_617_348), - ("Nat.add_comm", 321_971_743), - ("Nat.decEq", 383_643_343), - ("Nat.decLe", 845_605_659), - ("Nat.sub_le_of_le_add", 2_075_355_953), - ("Nat.shiftRight_succ", 1_543_426_285), - ("Trans.mk", 137_383_223), - ("Array.append_assoc", 10_255_769_663), - ("Vector.append", 10_489_258_989), - ("IxVMPrim.nat_add_lit", 220_356_452), - ("IxVMPrim.nat_sub_lit", 239_014_330), - ("IxVMPrim.nat_mul_lit", 209_777_728), - ("IxVMPrim.nat_mul_big", 208_100_370), - ("IxVMPrim.nat_div_lit", 1_508_368_244), - ("IxVMPrim.nat_mod_lit", 1_538_202_876), - ("IxVMPrim.nat_succ_lit", 146_059_227), - ("IxVMPrim.nat_pred_lit", 170_592_080), - ("IxVMPrim.nat_gcd_lit", 2_408_943_875), - ("IxVMPrim.nat_land_lit", 3_899_609_280), - ("IxVMPrim.nat_lor_lit", 3_902_101_711), - ("IxVMPrim.nat_xor_lit", 3_923_979_646), - ("IxVMPrim.nat_shl_lit", 241_746_873), - ("IxVMPrim.nat_shr_lit", 1_524_446_380), - ("IxVMPrim.nat_pow_big", 696_489_969), - ("IxVMPrim.nat_beq_lit", 208_369_156), - ("IxVMPrim.nat_ble_lit", 202_201_769), - ("IxVMPrim.nat_cases_big", 170_304_869), - ("IxVMPrim.nat_dec_le", 865_930_198), - ("IxVMPrim.nat_dec_lt", 878_858_550), - ("IxVMPrim.nat_dec_eq", 428_043_949), - ("IxVMPrim.str_size_lit", 2_762_853_095), - ("IxVMPrim.bv_to_nat_lit", 2_291_375_200), - ("IxVMInd.Even", 213_875_569), - ("IxVMInd.Odd", 213_878_185), - ("IxVMInd.Even.rec", 234_816_859), - ("IxVMInd.Odd.rec", 234_817_781), - ("IxVMInd.Tree", 131_412_608), - ("IxVMInd.Tree.rec", 142_646_628), - ("IxVMInd.DedupM", 134_965_622), - ("IxVMInd.DedupM.rec", 150_065_976), - ("IxVMInd.DepthM", 133_250_401), - ("IxVMInd.DepthM.rec", 145_837_235), - ("String.Internal.append", 2_731_341_529), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 4_054_424_603), - ("Lean.Syntax.rec", 2_795_742_005), - ("IxVMInd.AuxTie", 342_459_468), - ("IxVMInd.AuxTie.rec", 389_232_383), - ("IxVMInd.HiddenIdx", 130_335_222), - ("IxVMInd.HiddenIdx.rec", 133_643_799), - ("IxVMInd.thmMajorUse", 559_678_932), - ("IxVMInd.partialKRec", 153_670_282), - ("IxVMInd.deepRebase", 223_487_467), - ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec", 3_808_635_812), - ("Lean.Widget.TaggedText.rec", 2_761_031_456), - ("Lean.Doc.Part.rec", 2_812_240_373), - ("Lean.Doc.Block.rec", 2_998_866_393), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_902_791), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 136_599_727), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 135_785_543), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 135_785_543), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 135_785_543), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 133_168_061), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 145_843_978), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 145_843_191), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 135_785_543), - ("strOfListFoldSize", 3_088_094_493), - ("strOfListFoldSizeAscii", 3_089_043_625), + ("HEq", 130_850_053), + ("HEq.rec", 140_582_072), + ("Eq.rec", 139_050_623), + ("Nat", 130_737_739), + ("Nat.add", 214_810_016), + ("Nat.add_comm", 487_222_091), + ("Nat.decEq", 625_603_262), + ("Nat.decLe", 1_514_901_074), + ("Nat.sub_le_of_le_add", 3_848_812_628), + ("Nat.shiftRight_succ", 2_830_431_708), + ("Trans.mk", 146_381_212), + ("Array.append_assoc", 21_704_654_625), + ("Vector.append", 22_090_977_960), + ("IxVMPrim.nat_add_lit", 294_689_656), + ("IxVMPrim.nat_sub_lit", 324_605_149), + ("IxVMPrim.nat_mul_lit", 273_968_478), + ("IxVMPrim.nat_mul_big", 270_954_146), + ("IxVMPrim.nat_div_lit", 2_765_527_084), + ("IxVMPrim.nat_mod_lit", 2_816_285_140), + ("IxVMPrim.nat_succ_lit", 158_386_193), + ("IxVMPrim.nat_pred_lit", 200_156_205), + ("IxVMPrim.nat_gcd_lit", 4_451_364_384), + ("IxVMPrim.nat_land_lit", 7_130_572_306), + ("IxVMPrim.nat_lor_lit", 7_134_904_689), + ("IxVMPrim.nat_xor_lit", 7_166_371_879), + ("IxVMPrim.nat_shl_lit", 326_756_667), + ("IxVMPrim.nat_shr_lit", 2_788_187_392), + ("IxVMPrim.nat_pow_big", 1_311_568_227), + ("IxVMPrim.nat_beq_lit", 274_868_981), + ("IxVMPrim.nat_ble_lit", 263_372_216), + ("IxVMPrim.nat_cases_big", 201_398_370), + ("IxVMPrim.nat_dec_le", 1_548_234_457), + ("IxVMPrim.nat_dec_lt", 1_568_765_805), + ("IxVMPrim.nat_dec_eq", 699_632_957), + ("IxVMPrim.str_size_lit", 5_026_071_332), + ("IxVMPrim.bv_to_nat_lit", 4_222_762_925), + ("IxVMInd.Even", 281_026_450), + ("IxVMInd.Odd", 281_036_844), + ("IxVMInd.Even.rec", 318_331_956), + ("IxVMInd.Odd.rec", 318_332_879), + ("IxVMInd.Tree", 133_804_658), + ("IxVMInd.Tree.rec", 154_276_776), + ("IxVMInd.DedupM", 139_443_159), + ("IxVMInd.DedupM.rec", 167_085_826), + ("IxVMInd.DepthM", 136_822_297), + ("IxVMInd.DepthM.rec", 161_038_286), + ("String.Internal.append", 4_973_938_372), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 7_376_304_757), + ("Lean.Syntax.rec", 5_077_468_115), + ("IxVMInd.AuxTie", 478_993_851), + ("IxVMInd.AuxTie.rec", 560_543_328), + ("IxVMInd.HiddenIdx", 131_918_968), + ("IxVMInd.HiddenIdx.rec", 138_640_334), + ("IxVMInd.thmMajorUse", 976_714_268), + ("IxVMInd.partialKRec", 174_903_958), + ("IxVMInd.deepRebase", 298_222_932), + ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec", 7_001_786_145), + ("Lean.Widget.TaggedText.rec", 5_031_325_066), + ("Lean.Doc.Part.rec", 5_120_842_709), + ("Lean.Doc.Block.rec", 5_474_016_177), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 136_019_886), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 142_313_320), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 142_990_504), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 142_990_504), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 142_990_504), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 136_650_717), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 159_593_344), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 159_592_557), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 142_990_504), + ("strOfListFoldSize", 5_575_564_216), + ("strOfListFoldSizeAscii", 5_577_318_603), ] /-- Variant of `kernelChecks`, pinned to the baseline diff --git a/Tests/Main.lean b/Tests/Main.lean index e2874a5fa..ee5dca188 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -233,8 +233,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ let actual := (Aiur.computeStats v2Env.compiled qc v2Env.shapes).totalFftCost.round.toUInt64.toNat pure (LSpec.test - s!"Shard pipeline FFT matches: expected 7785690777, got {actual}" - (actual = 7_785_690_777)) + s!"Shard pipeline FFT matches: expected 12859488135, got {actual}" + (actual = 12_859_488_135)) LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []), diff --git a/cold-groups/kernel-bands-aggr.json b/cold-groups/kernel-bands-aggr.json new file mode 100644 index 000000000..2374ae19d --- /dev/null +++ b/cold-groups/kernel-bands-aggr.json @@ -0,0 +1 @@ +[["canon_kind_ord", "canon_sord_eq_strong", "canon_sord_gt_strong", "canon_sord_lt_strong", "canon_sord_of_g", "check_opt_bool", "check_opt_u64", "const_num_lvls", "const_type_of", "def_safety_tag", "flatten_u64", "pack_def_kind_safety", "quot_kind_tag", "unpack_def_kind_safety", "check_opt_ctor_entries", "check_opt_recr_rules", "check_mut_const", "canon_ord_then", "canon_sord_then", "defn_is_unsafe_ci", "delta_rank", "is_unsafe_ci", "lbr_dec", "relaxed_u64_pred"], ["relaxed_u64_succ", "u64_eq", "u64_is_zero", "addr_set_member", "assert_wire_bool", "bit_vec_addr", "bit_vec_of_nat_addr", "bit_vec_to_nat_addr", "bit_vec_ult_addr", "bool_false_addr", "bool_true_addr", "bool_type_addr_dec", "build_all_minors", "build_all_motives", "build_recur_addrs", "byte_array_empty_addr", "canon_addr_chunk", "canon_cmp_kliteral", "char_of_nat_addr", "char_type_addr", "check_parent_inductive_shape", "decidable_decide_addr", "decidable_is_false_addr_dec", "decidable_is_true_addr_dec", "decidable_rec_addr", "eq_refl_addr_dec", "fin_addr", "int_dec_eq_addr_dec", "int_dec_le_addr_dec", "int_dec_lt_addr_dec", "int_neg_succ_addr_dec", "int_of_nat_addr_dec", "k_is_def_eq_struct", "klimbs_add", "list_cons_addr", "list_nil_addr", "literal_eq", "lt_lt_addr", "mk_nat_lit", "nat_add_addr", "nat_addr_io", "nat_beq_addr", "nat_ble_addr", "nat_dec_eq_addr_dec", "nat_dec_le_addr_dec", "nat_dec_lt_addr_dec", "nat_div_addr", "nat_eq_of_beq_eq_true_addr_dec", "nat_gcd_addr", "nat_land_addr", "nat_le_of_ble_eq_true_addr_dec", "nat_lor_addr", "nat_mod_addr", "nat_mul_addr", "nat_ne_of_beq_eq_false_addr_dec", "nat_not_le_of_not_ble_eq_true_addr_dec", "nat_pow_addr", "nat_pred_addr", "nat_shift_left_addr", "nat_shift_right_addr", "nat_sub_addr", "nat_succ_addr_iota", "nat_xor_addr", "nat_zero_addr", "punit_addr"], ["punit_size_of_1_addr", "put_constant_info", "put_quot_kind", "quot_ctor_addr", "quot_ind_addr", "quot_lift_addr_iota", "quot_type_addr", "reduce_bool_addr", "reduce_nat_addr", "size_of_size_of_addr", "str_addr", "string_append_addr", "string_back_addr", "string_dec_eq_addr", "string_legacy_back_addr", "string_of_list_addr", "string_to_byte_array_addr", "string_utf8_byte_size_addr", "subtype_val_addr", "system_platform_get_num_bits_addr", "system_platform_num_bits_addr", "unit_addr", "utf8_last_codepoint", "check_param_agreement", "is_defn_or_thm", "assert_safety", "build_ctor_app_params", "extract_aux_spec_params_from_rec", "is_rec_field", "klimbs_div", "klimbs_mod", "check_opt_def_kind", "check_opt_def_safety", "check_opt_quot_kind", "convert_axiom", "convert_quotient", "has_bvar_in_range_binder", "k_check", "klimbs_mul", "list_reverse.G", "put_definition_proj", "put_mut_const", "run_contains", "utf8_cont", "check_inductive_shape", "get_opt_addr_masked", "get_opt_bool_masked", "get_opt_def_kind_masked", "get_opt_quot_kind_masked", "list_is_empty.U8", "defn_member_recur_addrs", "expr_inst1_bvar", "k_is_def_eq_ordered", "klimbs_shl_limbs", "klimbs_sub", "pad_block", "put_u64_le"], ["try_unfold_head", "env_walk_leaves", "expr_glb_binder", "expr_inst1", "has_bvar_in_range_let", "k_infer", "k_infer_lit", "klimbs_dec", "klimbs_gcd", "mk_nat_literal_64", "mk_nat_one", "put_constructor_proj", "validate_univ_params_list", "get_opt_addr", "list_length.Ptr.KExprNode", "list_lookup.Ptr.KLevelNode", "list_lookup_or_default.Ptr.U8_32", "nl_add_const", "read_byte", "apply_indices_in_conclusion", "apply_n_projs", "build_apply_field_bvars", "build_apply_xs", "build_major_params", "build_motive_apps", "build_param_lvls_range", "build_rec_lvls_list", "canon_ctor_ctx_entries", "check_prop_field_if_prop", "expr_glb", "expr_lift", "expr_lower", "mk_bool", "np_whnf_inner_bv", "peel_leading_foralls", "unfold_a_and_loop", "unfold_b_and_loop", "check_positivity", "expr_inst1_let", "expr_inst_many_let", "expr_lift_let", "klimbs_shl", "klimbs_shr", "leaf_hash", "level_equal", "count_foralls_body", "expr_inst_levels", "g_list_has", "level_offset_of", "skip_bytes", "apply_spine_expr"], ["canon_all_singleton", "canon_flatten", "canon_ins_sort", "canon_refine_one", "check_field_universes", "check_rec_rules_wellscoped", "convert_definition", "ctx_next_cut", "level_max_subsumes", "list_reverse_acc.G", "put_address_list", "utf8_validate", "wrap_foralls", "wrap_lams", "check_positivity_fields", "check_quot", "env_walk_refs", "put_tag0", "put_tag2", "put_tag4", "try_proof_irrel", "walk_refs_transitive", "convert_constructor", "convert_inductive", "expr_glb_let", "node_hash", "rbtree_map_insert.G", "check_native_nat", "count_foralls_at_least", "level_explicit_val", "list_length.KRecRule", "peel_n_foralls", "rbtree_map_balance.G", "se_peel_tol", "addr_list_contains", "all_bvars_in_args", "char_lit_codepoint", "check_field_universes_skip_params"], ["is_large_eliminator", "is_nat_zero", "k_ensure_sort", "k_is_def_eq_slow", "level_is_not_zero", "list_any_mentions_block", "list_concat.Tup.Ptr.U8_32.G", "list_take.Ptr.KExprNode", "se_addr_in", "str_lit_to_ctor_app_or_self", "utf8_last_go", "apply_spec_params_lifted", "canon_cmp_member_ctx", "canon_group_consec", "canon_refine_classes", "check_no_dep_data_field_if_prop", "compare_struct_fields", "const_idxs_exprs", "level_inst_params", "level_list_inst", "level_reduce", "list_lift_each", "list_lift_indices", "nl_subsumption_walk", "whnf_spine", "const_idxs_of", "k_is_def_eq", "try_unit_like", "canon_cmp_klimbs", "expr_lbr_let", "mk_nat_binop_stuck", "replace_spine_major"], ["list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode", "assert_lvls_are_params", "canon_ctx_class_idx", "canon_g_list_eq", "check_large_prop_ctor", "collect_spine", "glist_eq_len", "peel_leading_foralls_acc", "se_scan_fields", "try_prim_dispatch", "canon_build_ctx_classes", "canon_cmp_krec_rule_ctx", "expr_glb_walk", "expr_inst1_walk", "expr_lift_walk", "get_expr_let", "nl_le_vars", "normalize_aux", "try_string_lit_one", "canon_ctx_cmp_addr", "canon_sort_loop", "check_field_universes_inner", "intern_int_lit", "spec_params_lower", "try_quot_iota"], ["unfold_both_and_loop", "convert_recursor", "assert_first_args_are_param_bvars", "assert_occ_param_bvars", "head_addr", "list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode", "peel_n_foralls_with_types", "check_rec_major_spine", "get_result_sort_level", "io_peel_field_loop", "level_list_struct_eq", "peel_motive_params_subst", "peel_n_alls_whnf", "spec_params_ptr_eq", "try_extract_nat", "whnf_get_ctor_or_none", "expr_inst_levels_walk", "is_inductive_prop", "k_is_def_eq_slow_nd", "level_leq", "peel_field_loop", "level_normalize", "u64_and", "u64_or", "u64_xor_kbits", "find_rule", "args_contain_bvar", "peel_n_lams_collect", "build_peer_recs", "canon_classes_eq", "de_args"], ["expr_mentions_block", "lazy_delta_loop", "level_eq", "level_list_eq", "canon_cmp_bytes", "canon_cmp_kuniv", "canon_cmp_kuniv_list", "extract_aux_spec_params", "idx_to_u64", "normalize_imax_dispatch", "spec_params_dom_prefix_match", "check_native_bool", "is_bitvec_prim_addr", "is_int_dec_prim_addr", "lazy_delta_both_proj", "whnf_apply_beta"], ["whnf_nd_apply_beta", "canonical_rules_at_pos", "mk_nat_offset_stuck", "get_opt_u64_masked", "flat_find_pos", "put_refs", "put_sharing", "put_univs", "try_eta_swap", "aux_already_in", "is_prop_type", "level_struct_eq", "nl_skip_empty", "peel_params_subst", "se_mentions", "whnf_nd_with_spine", "nl_covers_var", "parse_atree_body", "try_extract_nat_app", "try_unfold_proj_app", "klimbs_from_g", "get_inductive_proj", "list_length.U8_8", "canon_cmp_kexpr_ctx", "ensure_sort_only", "flat_member_at", "rec_to_parent_addr", "check_param_agreement_go"], ["k_is_def_eq_struct_safe", "nl_le", "nlvars_eq", "canon_cmp_kexpr_node_ctx", "build_char_list", "build_motive_type_flat", "k_def_eq_rebase", "klimbs_pow", "get_opt_ctor_entry_list_masked", "get_opt_rule_list_masked", "klimbs_is_zero", "klimbs_le", "list_snoc.U8_8", "put_u64_list", "convert_univ", "se_parent_addr"], ["k_is_def_eq_struct_go", "kexpr_struct_eq", "level_imax", "lbr_max", "lbr_min", "level_max_go", "memo_u32_less_than", "bitvec_of_nat_args_direct", "glimbs_to_klimbs", "quot_extract_arg", "bv_to_nat_via", "nl_add_var", "check_ctor_return_type", "canon_member_num_ctors", "get_u64_le", "put_recursor_rule_list"], ["run_check", "get_axiom", "extract_aux_occ_us", "whnf", "whnf_nd", "canon_ord_cmp_g", "put_constant", "walk_fields_classify", "check_large_walk_fields", "expr_lift_bvar", "dec_dispatch_le_eq", "nat_lit_to_ctor_or_self", "try_eta_expand", "klimbs_div_mod", "dec_rewrite_lt_to_le", "assert_return_head_is_parent", "caddr_is_peer", "canon_member_ci", "check_eq_type", "check_muts_member_at", "const_idxs_rules", "flat_find_matching", "get_quotient", "put_univ_list", "get_address_list", "get_all_telescope", "get_app_telescope", "get_expr_list", "get_lam_telescope", "collect_index_doms", "compute_iprj_addr", "k_is_def_eq_core", "bitvec_prep_spine", "build_rule_rhs", "addr_set_build"], ["struct_is_rec", "convert_rec_rules", "run_check_env", "collect_n_doms_whnf", "convert_univ_idxs", "is_rec_field_peel", "klimbs_mul_outer", "try_def_eq_nat", "peel_ctor_params_subst", "validate_univ_params_seen", "bitvec_prep_spine_ult", "ctx_seek_cut", "normalize_int_dec_rebuild", "canon_cmp_u64_lex", "u64_add", "u64_sub_with_borrow", "flat_find_pos_kind", "canon_cmp_krec_rule_list_ctx", "check_valid_ind_app", "level_max", "subst_param_for", "try_match_nat_add", "check_inductive_shape_ctors", "ctor_subst_param_for", "ctx_close_cut", "build_succ_offset", "get_definition", "populate_rules", "char_lit_codepoint_syn"], ["expr_lower_walk", "try_def_eq_app", "level_max_offsets", "nl_eq", "try_k_synth_iota", "univ_succ_base", "safe_refs_only", "struct_scan_ctors", "build_minor_doms", "cleanup_nat_offset_major", "nlvars_any_offset_geq", "nlvars_dominates", "nlvars_max_offset", "ctx_trim", "is_dec_prim_addr", "is_native_prim_addr", "try_nat_offset_dispatch", "bytes_to_u64_limb", "list_length_u64.Ptr.Univ"], ["build_rec_type", "build_succ_chain", "validate_expr_well_scoped", "check_nested_ctors_positivity", "try_extract_int", "k_is_def_eq_slow2", "check_const", "get_constructor_proj", "put_recursor_rule"], ["get_tag4", "expr_addr", "put_axiom", "put_quotient", "get_u64_list", "put_univ", "delta_unfold", "k_infer_core", "nl_add_const_go", "try_quot_ind", "try_quot_lift", "walk_char_list_bytes", "is_str_prim_addr", "get_tag0", "get_tag2", "klimbs_eq", "klimbs_succ", "collect_spine_of_ctor", "whnf_nd_const_head", "compute_k_target", "canon_cprj_addr", "nat_offset_of", "projection_addr_ctor"], ["projection_definition_info", "canon_cmp_ctor_pair_ctx", "try_bitvec_dispatch", "ctors_before_pos", "put_expr_list", "build_flat_own_params", "canon_cmp_klimbs_tail", "get_recursor_rule_list", "get_univ_list", "build_all_minors_walk", "build_all_motives_walk", "lazy_delta_a_const_b_proj", "lazy_delta_b_const_a_proj", "whnf_iota_major", "nl_covers_const", "try_reduce_projection_definition", "canon_build_ctx_members", "check_recursor_member", "try_nat_binop_dispatch", "try_reduce_bit_vec_ult", "build_ih_doms", "klimbs_normalize", "put_constructor"], ["univ_succ_count", "const_idxs_expr", "is_nat_succ_ih_step", "try_normalize_int_decidable", "try_reduce_subtype_val", "try_str_to_byte_array", "try_dec_dispatch", "list_length_u64.U8_8"], ["try_nat_linear_rec", "try_str_back"], ["list_length_u64.RecursorRule", "rbtree_map_lookup_or_default.G", "whnf_nd_proj_head", "whnf_proj_head", "bytes_to_limbs", "has_bvar_in_range", "try_str_dec_eq", "try_reduce_size_of_unit"], ["build_rec_type_from", "k_synth_gate", "dec_build_proof", "apply_ihs_full"], ["klimbs_land", "klimbs_lor", "klimbs_xor_op", "rbtree_map_balance_fix.G", "str_lit_delta_step", "glist_ordered_insert", "try_nat_dispatch_prewhnf", "get_reveal_rule_list_inner"], ["whnf_const_head", "glist_cmp", "glist_subset", "utf8_decode_one", "dec_finish"], ["verify_bytes_against", "get_univ", "canon_insert_sorted", "bytes_to_addr", "is_unit_like_type", "canon_cmp_ctor_range_ctx", "put_inductive", "all_telescope_count", "app_telescope_count", "lam_telescope_count", "check_ctor_entry", "canon_group_walk"], ["check_positivity_aug", "load_verified_blob", "put_recursor"], ["canon_cmp_member_same_kind_ctx", "try_native_dispatch"], ["count_ctors", "put_constructor_list", "put_all_telescope", "put_app_telescope", "put_lam_telescope", "check_recr_rules", "try_lazy_delta_app", "rbtree_map_ins.G", "k_infer_proj"], ["try_struct_eta_iota", "try_iota"], ["const_idxs_ctors", "compare_rules", "klimbs_add_carry", "get_constructor", "klimbs_sub_borrow", "put_definition"], ["str_dec_eq_build", "nlvars_add", "try_nat_binop_addr", "k_infer_only"], ["get_constant_info_by_variant", "klimbs_mul_single"], ["get_mut_const", "check_muts_all", "get_constructor_list", "try_eta_struct", "run_reveal"], ["is_muts_block", "detect_aux_from_recrs_ex", "find_peer_recursor_with_spec", "muts_indc_count_is_one", "canon_indc_positions", "put_mut_const_list"], ["canon_muts_has_kind", "get_ctor_entry", "check_ctor_entries", "build_recur_addrs_walk", "get_inductive", "check_block_peer_param_agreement", "ind_is_solo", "struct_block_member_addrs", "list_length_u64.Constructor", "const_idxs_muts"], ["nl_subsume_entry", "run_check_transitive", "env_walk"], ["get_mut_const_list", "put_expr"], ["prim_family", "lazy_delta_step_const_const"], ["get_ctor_entry_list_inner", "klimbs_scalar_value"], ["list_length_u64.MutConst", "get_reveal_ctor_info", "check_opt_addr", "get_mut_entry"], ["address_eq_tail", "address_eq", "check_opt_expr_addr", "get_ci", "flat_originals_walk", "get_recursor", "peer_agree_walk", "run_claim", "ctor_at", "blake3"], ["try_reduce_decide_bitvec_lt", "check_canonical_block"], ["get_mut_entry_list_inner", "first_recr_parent_block", "list_lookup_u64.Constructor", "canon_addr_cmp", "load_assumption_tree", "find_peer_rec_spec_walk", "load_verified_constant", "aux_from_recrs_walk_ex", "get_reveal_info", "get_reveal_mut_const_info"], ["get_address", "utf8_encode_prepend"], ["list_lookup_u64.MutConst", "projection_addr", "get_ci_iprj", "get_ci_rprj", "get_ci_dprj", "check_muts_components", "build_flat_block", "blake3_next_layer", "get_constant", "get_ci_cprj", "blake3_finish"], ["u64_mul", "blake3_compress_block"]] \ No newline at end of file diff --git a/cold-groups/kernel-shape-grouping.md b/cold-groups/kernel-shape-grouping.md index d8f47132b..0be932441 100644 --- a/cold-groups/kernel-shape-grouping.md +++ b/cold-groups/kernel-shape-grouping.md @@ -114,4 +114,24 @@ band n Wg aux-range lkp-range ungrouped grouped ## Files - `kernel-bands-shape.json` — the 85 bands (member lists, before verify_claim removal) -- `kstats-.txt` / `kstats-grouped-.txt` — per-circuit stats with Sel/Aux/Lkp \ No newline at end of file +- `kstats-.txt` / `kstats-grouped-.txt` — per-circuit stats with Sel/Aux/Lkp +## Aggressive tier (2026-08-12, superseding the 85-band partition) + +Loosened to aux within 3.5x, lookups within max(4x, +12), summed selectors +<= 96, cold < 2% max share: **46 bands over 683 circuits, 730 -> 93 +circuits, total width 33,827 -> 11,596 (-66%)**. Measured FFT: +Nat.add_comm 1.67x, String.split 2.19x, Array.extract_append 2.04x (summed +2.08x; model predicted 2.14x). Shard-pipeline aggregate +65%. Sweep: + +| config | circuits | fn width | FFT (model) | +|---|---|---|---| +| 1.6x / 40 / <0.5% (previous) | 185 | 15,744 | 1.11x | +| 2.5x / 64 / <0.5% | 142 | 13,115 | 1.18x | +| 2.5x / 64 / <2% | 119 | 12,402 | 1.74x | +| 3.5x / 96 / <2% (chosen) | 93 | 11,029 | 2.14x | +| 5.0x / 128 / <5% | 67 | 9,575 | 4.02x | + +The 2.5x / 64 / <0.5% row is notable: 43 fewer circuits than the committed +baseline for almost no FFT (+0.07x) - the conservative frontier is not +exhausted; the cost cliff comes from raising the COLD threshold (pulling +1-2% circuits into bands), not from loosening the shape tolerances. diff --git a/cold-groups/kstats-aggr-Array.extract_append.txt b/cold-groups/kstats-aggr-Array.extract_append.txt new file mode 100644 index 000000000..3eb690e09 --- /dev/null +++ b/cold-groups/kstats-aggr-Array.extract_append.txt @@ -0,0 +1,102 @@ +=== Circuit Statistics === +Circuits: 93 +Total width: 11596 +Total FFT cost: 289305029582 (2.89e11) +Total cache hits: 72393508 +Total saved cost: 62.08% +-------------------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +-------------------------------------------------------------------------------------------- +k_shape_03 134 96 6 5 5111196 5768783 7.65e10 26.44% 26.44% +k_shape_06 128 95 8 6 2354885 853572 3.20e10 11.06% 37.50% +expr_inst_many_walk 34 9 8 5 5471753 0 2.10e10 7.27% 44.76% +expr_inst_many 21 2 4 4 6975351 1584350 1.69e10 5.84% 50.61% +blake3_compress_inner_j 1192 1 561 497 151585 0 1.56e10 5.38% 55.98% +k_shape_12 190 95 16 13 673651 144271 1.24e10 4.29% 60.27% +k_shape_16 166 96 23 15 698423 130752 1.13e10 3.90% 64.17% +k_shape_05 163 90 7 7 615836 226958 9.67e9 3.34% 67.52% +memory[3] 12 0 0 0 6181533 17946311 8.59e9 2.97% 70.49% +k_shape_14 162 95 20 14 420018 641166 6.37e9 2.20% 72.69% +list_snoc.G 22 2 6 4 2593801 881702 6.17e9 2.13% 74.82% +k_shape_11 145 96 14 12 429507 10946255 5.84e9 2.02% 76.84% +peel_beta 32 3 12 5 1637758 10634 5.47e9 1.89% 78.73% +list_drop.Ptr.Expr 20 2 6 3 2151895 1151414 4.60e9 1.59% 80.32% +k_shape_02 158 96 4 4 294605 239291 4.24e9 1.47% 81.79% +k_shape_08 129 95 10 7 348901 23943 4.16e9 1.44% 83.22% +blake3_compress_chunks 29 3 7 4 1288914 0 3.84e9 1.33% 84.55% +whnf_with_spine 34 6 11 5 1108779 14944 3.82e9 1.32% 85.87% +expr_inst_many_bvar 24 2 5 5 1528825 0 3.82e9 1.32% 87.20% +list_concat.Ptr.KExprNode 22 2 6 4 1505977 731709 3.45e9 1.19% 88.39% +k_shape_17 188 84 25 20 184787 201308 3.05e9 1.05% 89.44% +expr_lbr 35 9 9 6 870475 9468745 3.04e9 1.05% 90.49% +k_shape_23 121 35 32 22 246961 456 2.69e9 0.93% 91.42% +k_infer_app_spine_loop 59 8 21 11 470161 506 2.63e9 0.91% 92.33% +memory[4] 13 0 0 0 1735873 17182092 2.40e9 0.83% 93.16% +k_shape_07 170 88 10 9 158366 178951 2.33e9 0.81% 93.96% +k_shape_09 142 90 12 9 156438 81923 1.92e9 0.66% 94.63% +k_shape_15 112 40 21 15 187002 152975 1.84e9 0.64% 95.27% +get_expr 50 12 23 5 391929 17 1.83e9 0.63% 95.90% +blake3_compress 1080 1 929 40 21655 14 1.68e9 0.58% 96.48% +convert_expr 60 12 25 7 292994 154982 1.61e9 0.56% 97.04% +k_shape_18 107 35 27 16 161400 209726 1.50e9 0.52% 97.56% +k_shape_13 157 87 18 16 74064 25486 9.43e8 0.33% 97.88% +k_shape_00 221 96 2 10 42663 544588 7.27e8 0.25% 98.13% +k_shape_28 117 14 39 25 75468 2106 7.18e8 0.25% 98.38% +k_shape_10 141 93 13 11 54272 2656 6.04e8 0.21% 98.59% +k_shape_20 115 42 29 16 56780 711 5.18e8 0.18% 98.77% +k_shape_04 156 93 7 6 42592 25513 5.12e8 0.18% 98.95% +k_shape_19 79 9 27 17 66603 305 4.24e8 0.15% 99.09% +k_shape_45 284 3 169 46 19300 0 3.91e8 0.14% 99.23% +bytes_to_block 265 1 193 65 20371 601 3.87e8 0.13% 99.36% +memory[18] 27 0 0 0 160015 742479 3.79e8 0.13% 99.49% +k_shape_40 169 39 72 11 23146 453707 2.84e8 0.10% 99.59% +k_shape_43 213 5 100 51 15781 90 2.35e8 0.08% 99.67% +k_shape_01 122 96 2 2 20012 636296 1.75e8 0.06% 99.73% +try_reduce_fin_val_decidable_rec 149 9 58 37 14010 42719 1.44e8 0.05% 99.78% +k_shape_32 160 24 49 14 12985 1307 1.42e8 0.05% 99.83% +Bytes2 24 0 0 0 65536 0 1.28e8 0.04% 99.88% +k_shape_44 283 37 151 12 5072 10620 8.85e7 0.03% 99.91% +k_shape_30 157 34 45 35 7690 13628 7.82e7 0.03% 99.93% +memory[32] 41 0 0 0 20282 85992 6.02e7 0.02% 99.95% +blake3_compress_layer 223 3 170 6 2064 0 2.54e7 0.01% 99.96% +k_shape_24 138 30 35 10 2407 6317 1.87e7 0.01% 99.97% +k_shape_35 154 30 58 24 1918 15695 1.62e7 0.01% 99.98% +k_shape_42 184 45 90 18 1621 2066 1.60e7 0.01% 99.98% +k_shape_22 175 85 32 20 1568 73 1.46e7 0.01% 99.99% +k_shape_31 94 11 47 7 1570 0 7.89e6 0.00% 99.99% +memory[34] 43 0 0 0 2815 7298 7.04e6 0.00% 99.99% +k_shape_37 173 29 60 37 724 254254 5.98e6 0.00% 99.99% +k_shape_27 111 23 39 13 997 78 5.55e6 0.00% 99.99% +k_shape_34 115 27 53 9 584 158 3.11e6 0.00% 100.00% +k_shape_21 115 17 30 26 479 5 2.47e6 0.00% 100.00% +k_shape_41 171 11 75 40 307 15 2.18e6 0.00% 100.00% +memory[12] 21 0 0 0 1548 416435 1.78e6 0.00% 100.00% +k_shape_29 110 19 42 16 305 105 1.40e6 0.00% 100.00% +k_shape_25 122 7 36 15 230 743 1.11e6 0.00% 100.00% +k_shape_36 112 14 59 8 146 12 5.93e5 0.00% 100.00% +k_shape_33 82 15 50 4 183 181 5.70e5 0.00% 100.00% +put_address 106 1 65 34 79 35 2.67e5 0.00% 100.00% +muts_member_at 108 2 94 3 77 177 2.63e5 0.00% 100.00% +memory[10] 19 0 0 0 195 108527 1.48e5 0.00% 100.00% +memory[36] 45 0 0 0 95 375 1.44e5 0.00% 100.00% +memory[47] 56 0 0 0 78 1009 1.40e5 0.00% 100.00% +Bytes1 11 0 0 0 256 0 1.22e5 0.00% 100.00% +memory[8] 17 0 0 0 151 44897 9.83e4 0.00% 100.00% +check_recursor_canonical_full 125 9 50 18 26 0 7.73e4 0.00% 100.00% +build_minor_at_depth 65 1 25 21 35 0 5.96e4 0.00% 100.00% +nlvars_subsume 111 6 49 25 17 3 3.92e4 0.00% 100.00% +memory[9] 18 0 0 0 46 304 2.45e4 0.00% 100.00% +memory[11] 20 0 0 0 36 122 1.99e4 0.00% 100.00% +memory[5] 14 0 0 0 36 17400 1.43e4 0.00% 100.00% +memory[6] 15 0 0 0 27 337 1.06e4 0.00% 100.00% +u64_byte_count 150 128 8 1 4 237 6.14e3 0.00% 100.00% +memory[2] 11 0 0 0 12 96 2.80e3 0.00% 100.00% +k_shape_26 128 16 37 23 2 0 1.35e3 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +k_shape_39 96 6 65 9 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +try_str_dispatch 128 18 47 28 0 0 0 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +k_shape_38 127 9 63 21 0 0 0 0.00% 100.00% diff --git a/cold-groups/kstats-aggr-Nat.add_comm.txt b/cold-groups/kstats-aggr-Nat.add_comm.txt new file mode 100644 index 000000000..23842b586 --- /dev/null +++ b/cold-groups/kstats-aggr-Nat.add_comm.txt @@ -0,0 +1,102 @@ +=== Circuit Statistics === +Circuits: 93 +Total width: 11596 +Total FFT cost: 487222091 (4.87e8) +Total cache hits: 86596 +Total saved cost: 39.53% +---------------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +---------------------------------------------------------------------------------------- +Bytes2 24 0 0 0 65536 0 1.28e8 26.31% 26.31% +k_shape_03 134 96 6 5 6927 4847 5.95e7 12.20% 38.51% +blake3_compress_inner_j 1192 1 561 497 973 0 5.76e7 11.82% 50.34% +k_shape_16 166 96 23 15 3125 280 3.02e7 6.20% 56.54% +k_shape_12 190 95 16 13 2423 243 2.60e7 5.33% 61.87% +k_shape_02 158 96 4 4 2471 639 2.21e7 4.53% 66.40% +k_shape_06 128 95 8 6 2652 705 1.94e7 3.98% 70.38% +memory[3] 12 0 0 0 17239 30090 1.52e7 3.12% 73.50% +k_shape_05 163 90 7 7 1603 712 1.40e7 2.87% 76.37% +blake3_compress_chunks 29 3 7 4 7303 0 1.39e7 2.84% 79.21% +k_shape_14 162 95 20 14 1543 1563 1.33e7 2.73% 81.94% +k_shape_40 169 39 72 11 1157 660 9.99e6 2.05% 83.99% +k_shape_07 170 88 10 9 1007 116 8.58e6 1.76% 85.75% +k_shape_15 112 40 21 15 1282 650 7.46e6 1.53% 87.28% +blake3_compress 1080 1 929 40 139 0 5.35e6 1.10% 88.38% +k_shape_18 107 35 27 16 801 832 4.16e6 0.85% 89.23% +k_shape_11 145 96 14 12 583 6846 3.90e6 0.80% 90.03% +convert_expr 60 12 25 7 1238 526 3.86e6 0.79% 90.82% +k_shape_04 156 93 7 6 541 171 3.85e6 0.79% 91.61% +get_expr 50 12 23 5 1443 0 3.84e6 0.79% 92.40% +k_shape_13 157 87 18 16 426 220 2.94e6 0.60% 93.01% +k_shape_09 142 90 12 9 452 118 2.85e6 0.58% 93.59% +expr_lbr 35 9 9 6 1507 6551 2.84e6 0.58% 94.17% +expr_inst_many_walk 34 9 8 5 1240 0 2.21e6 0.45% 94.63% +k_infer_app_spine_loop 59 8 21 11 713 1 2.02e6 0.41% 95.04% +expr_inst_many 21 2 4 4 1710 429 1.99e6 0.41% 95.45% +k_shape_00 221 96 2 10 224 2664 1.94e6 0.40% 95.85% +list_drop.Ptr.Expr 20 2 6 3 1623 706 1.79e6 0.37% 96.21% +memory[4] 13 0 0 0 1955 14173 1.46e6 0.30% 96.51% +bytes_to_block 265 1 193 65 139 0 1.32e6 0.27% 96.78% +k_shape_17 188 84 25 20 182 128 1.29e6 0.26% 97.05% +k_shape_10 141 93 13 11 227 88 1.26e6 0.26% 97.31% +k_shape_44 283 37 151 12 125 56 1.24e6 0.25% 97.56% +list_snoc.G 22 2 6 4 982 513 1.11e6 0.23% 97.79% +memory[18] 27 0 0 0 800 3009 1.07e6 0.22% 98.01% +k_shape_43 213 5 100 51 134 8 1.01e6 0.21% 98.22% +k_shape_08 129 95 10 7 187 42 9.17e5 0.19% 98.41% +list_concat.Ptr.KExprNode 22 2 6 4 743 1138 8.06e5 0.17% 98.57% +k_shape_45 284 3 169 46 87 0 7.99e5 0.16% 98.73% +whnf_with_spine 34 6 11 5 420 22 6.37e5 0.13% 98.87% +k_shape_23 121 35 32 22 138 50 5.98e5 0.12% 98.99% +k_shape_24 138 30 35 10 114 12 5.42e5 0.11% 99.10% +k_shape_35 154 30 58 24 101 106 5.21e5 0.11% 99.21% +expr_inst_many_bvar 24 2 5 5 472 0 5.20e5 0.11% 99.31% +peel_beta 32 3 12 5 364 8 5.09e5 0.10% 99.42% +k_shape_01 122 96 2 2 93 3154 3.74e5 0.08% 99.49% +blake3_compress_layer 223 3 170 6 52 0 3.32e5 0.07% 99.56% +memory[32] 41 0 0 0 177 2427 2.77e5 0.06% 99.62% +k_shape_32 160 24 49 14 56 0 2.62e5 0.05% 99.67% +k_shape_42 184 45 90 18 49 85 2.55e5 0.05% 99.73% +k_shape_34 115 27 53 9 53 12 1.76e5 0.04% 99.76% +k_shape_20 115 42 29 16 47 5 1.52e5 0.03% 99.79% +Bytes1 11 0 0 0 256 0 1.22e5 0.03% 99.82% +k_shape_37 173 29 60 37 28 99 1.17e5 0.02% 99.84% +k_shape_31 94 11 47 7 42 0 1.08e5 0.02% 99.86% +k_shape_22 175 85 32 20 26 3 1.08e5 0.02% 99.89% +k_shape_30 157 34 45 35 26 13 9.69e4 0.02% 99.91% +k_shape_29 110 19 42 16 26 6 6.82e4 0.01% 99.92% +memory[34] 43 0 0 0 53 155 6.72e4 0.01% 99.93% +k_shape_28 117 14 39 25 18 3 4.46e4 0.01% 99.94% +k_shape_27 111 23 39 13 17 6 3.92e4 0.01% 99.95% +k_shape_36 112 14 59 8 14 0 3.04e4 0.01% 99.96% +k_shape_33 82 15 50 4 17 13 2.91e4 0.01% 99.96% +memory[12] 21 0 0 0 42 670 2.53e4 0.01% 99.97% +k_shape_41 171 11 75 40 9 0 2.47e4 0.01% 99.97% +k_shape_19 79 9 27 17 15 0 2.37e4 0.00% 99.98% +try_reduce_fin_val_decidable_rec 149 9 58 37 8 37 1.82e4 0.00% 99.98% +k_shape_25 122 7 36 15 8 5 1.49e4 0.00% 99.99% +muts_member_at 108 2 94 3 7 15 1.09e4 0.00% 99.99% +put_address 106 1 65 34 7 3 1.07e4 0.00% 99.99% +k_shape_21 115 17 30 26 6 0 9.13e3 0.00% 99.99% +memory[10] 19 0 0 0 19 381 8.35e3 0.00% 99.99% +memory[47] 56 0 0 0 8 93 7.01e3 0.00% 99.99% +memory[36] 45 0 0 0 9 33 6.74e3 0.00% 100.00% +memory[9] 18 0 0 0 16 42 6.34e3 0.00% 100.00% +u64_byte_count 150 128 8 1 4 20 6.14e3 0.00% 100.00% +build_minor_at_depth 65 1 25 21 3 0 1.65e3 0.00% 100.00% +check_recursor_canonical_full 125 9 50 18 2 0 1.32e3 0.00% 100.00% +memory[11] 20 0 0 0 4 10 9.44e2 0.00% 100.00% +memory[2] 11 0 0 0 5 6 8.19e2 0.00% 100.00% +memory[5] 14 0 0 0 4 24 7.04e2 0.00% 100.00% +memory[6] 15 0 0 0 3 25 4.65e2 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +memory[8] 17 0 0 0 1 329 1.01e2 0.00% 100.00% +k_shape_26 128 16 37 23 0 0 0 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +nlvars_subsume 111 6 49 25 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +k_shape_38 127 9 63 21 0 0 0 0.00% 100.00% +k_shape_39 96 6 65 9 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +try_str_dispatch 128 18 47 28 0 0 0 0.00% 100.00% diff --git a/cold-groups/kstats-aggr-String.split.txt b/cold-groups/kstats-aggr-String.split.txt new file mode 100644 index 000000000..1600a4ad1 --- /dev/null +++ b/cold-groups/kstats-aggr-String.split.txt @@ -0,0 +1,102 @@ +=== Circuit Statistics === +Circuits: 93 +Total width: 11596 +Total FFT cost: 120865355043 (1.21e11) +Total cache hits: 22638136 +Total saved cost: 54.00% +------------------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +------------------------------------------------------------------------------------------- +k_shape_03 134 96 6 5 2118982 1763949 2.99e10 24.75% 24.75% +blake3_compress_inner_j 1192 1 561 497 136626 0 1.39e10 11.50% 36.25% +k_shape_06 128 95 8 6 931627 202340 1.19e10 9.81% 46.06% +k_shape_16 166 96 23 15 539270 64924 8.54e9 7.07% 53.12% +k_shape_12 190 95 16 13 428930 40423 7.64e9 6.32% 59.44% +k_shape_14 162 95 20 14 304525 314060 4.50e9 3.73% 63.17% +memory[3] 12 0 0 0 2947763 6323771 3.91e9 3.23% 66.40% +k_shape_05 163 90 7 7 257752 102579 3.79e9 3.13% 69.53% +blake3_compress_chunks 29 3 7 4 1157705 0 3.42e9 2.83% 72.37% +k_shape_11 145 96 14 12 247755 2961052 3.23e9 2.67% 75.04% +expr_inst_many_walk 34 9 8 5 915195 0 3.11e9 2.58% 77.61% +k_shape_02 158 96 4 4 217701 114708 3.06e9 2.53% 80.14% +expr_inst_many 21 2 4 4 1199626 299856 2.59e9 2.14% 82.28% +blake3_compress 1080 1 929 40 19518 15 1.50e9 1.24% 83.53% +k_shape_15 112 40 21 15 149432 118871 1.44e9 1.19% 84.72% +get_expr 50 12 23 5 309599 20 1.42e9 1.18% 85.90% +convert_expr 60 12 25 7 240901 122716 1.30e9 1.08% 86.97% +k_infer_app_spine_loop 59 8 21 11 241267 677 1.28e9 1.06% 88.03% +list_drop.Ptr.Expr 20 2 6 3 592814 270333 1.16e9 0.96% 88.99% +expr_lbr 35 9 9 6 350993 2611613 1.14e9 0.95% 89.94% +list_snoc.G 22 2 6 4 521574 184967 1.11e9 0.92% 90.86% +k_shape_07 170 88 10 9 75176 31029 1.04e9 0.86% 91.72% +k_shape_18 107 35 27 16 111260 166385 1.00e9 0.83% 92.54% +peel_beta 32 3 12 5 221723 3113 6.38e8 0.53% 93.07% +memory[4] 13 0 0 0 497573 4533682 6.30e8 0.52% 93.59% +k_shape_09 142 90 12 9 55356 17316 6.21e8 0.51% 94.11% +expr_inst_many_bvar 24 2 5 5 278974 0 6.16e8 0.51% 94.62% +k_shape_13 157 87 18 16 49553 27255 6.08e8 0.50% 95.12% +list_concat.Ptr.KExprNode 22 2 6 4 278551 242297 5.64e8 0.47% 95.59% +k_shape_17 188 84 25 20 38236 40300 5.49e8 0.45% 96.04% +k_shape_08 129 95 10 7 53380 7513 5.43e8 0.45% 96.49% +whnf_with_spine 34 6 11 5 175764 4941 5.27e8 0.44% 96.93% +k_shape_04 156 93 7 6 40962 24847 4.91e8 0.41% 97.33% +k_shape_23 121 35 32 22 45450 480 4.27e8 0.35% 97.69% +bytes_to_block 265 1 193 65 18371 661 3.45e8 0.29% 97.97% +k_shape_45 284 3 169 46 17122 0 3.43e8 0.28% 98.25% +k_shape_40 169 39 72 11 26998 102209 3.37e8 0.28% 98.53% +k_shape_10 141 93 13 11 29277 2966 3.07e8 0.25% 98.79% +k_shape_43 213 5 100 51 17795 109 2.68e8 0.22% 99.01% +memory[18] 27 0 0 0 110757 606238 2.55e8 0.21% 99.22% +k_shape_00 221 96 2 10 11382 430074 1.70e8 0.14% 99.36% +Bytes2 24 0 0 0 65536 0 1.28e8 0.11% 99.47% +k_shape_20 115 42 29 16 12068 683 9.45e7 0.08% 99.54% +k_shape_44 283 37 151 12 5222 2261 9.14e7 0.08% 99.62% +k_shape_28 117 14 39 25 11525 388 9.14e7 0.08% 99.70% +memory[32] 41 0 0 0 18539 87446 5.46e7 0.05% 99.74% +k_shape_19 79 9 27 17 9011 306 4.71e7 0.04% 99.78% +k_shape_30 157 34 45 35 4791 2969 4.62e7 0.04% 99.82% +k_shape_32 160 24 49 14 3195 496 2.99e7 0.02% 99.84% +blake3_compress_layer 223 3 170 6 2324 0 2.91e7 0.02% 99.87% +k_shape_01 122 96 2 2 3933 510973 2.88e7 0.02% 99.89% +k_shape_24 138 30 35 10 2751 1307 2.18e7 0.02% 99.91% +try_reduce_fin_val_decidable_rec 149 9 58 37 2472 9544 2.08e7 0.02% 99.93% +k_shape_42 184 45 90 18 1860 2402 1.87e7 0.02% 99.94% +k_shape_35 154 30 58 24 2171 17561 1.86e7 0.02% 99.96% +k_shape_31 94 11 47 7 1792 0 9.17e6 0.01% 99.96% +k_shape_22 175 85 32 20 990 78 8.66e6 0.01% 99.97% +memory[34] 43 0 0 0 2651 7671 6.58e6 0.01% 99.98% +k_shape_37 173 29 60 37 783 48057 6.54e6 0.01% 99.98% +k_shape_27 111 23 39 13 1004 94 5.59e6 0.00% 99.99% +k_shape_34 115 27 53 9 702 191 3.84e6 0.00% 99.99% +k_shape_41 171 11 75 40 321 15 2.30e6 0.00% 99.99% +memory[12] 21 0 0 0 1772 97658 2.07e6 0.00% 99.99% +k_shape_29 110 19 42 16 343 105 1.60e6 0.00% 100.00% +k_shape_25 122 7 36 15 264 716 1.30e6 0.00% 100.00% +k_shape_21 115 17 30 26 257 4 1.19e6 0.00% 100.00% +k_shape_36 112 14 59 8 177 13 7.47e5 0.00% 100.00% +k_shape_33 82 15 50 4 222 221 7.17e5 0.00% 100.00% +put_address 106 1 65 34 95 45 3.34e5 0.00% 100.00% +muts_member_at 108 2 94 3 92 214 3.27e5 0.00% 100.00% +memory[36] 45 0 0 0 114 453 1.79e5 0.00% 100.00% +memory[47] 56 0 0 0 93 1214 1.74e5 0.00% 100.00% +memory[10] 19 0 0 0 210 59730 1.61e5 0.00% 100.00% +Bytes1 11 0 0 0 256 0 1.22e5 0.00% 100.00% +check_recursor_canonical_full 125 9 50 18 32 0 1.01e5 0.00% 100.00% +build_minor_at_depth 65 1 25 21 45 0 8.19e4 0.00% 100.00% +nlvars_subsume 111 6 49 25 17 3 3.92e4 0.00% 100.00% +memory[11] 20 0 0 0 46 154 2.71e4 0.00% 100.00% +memory[9] 18 0 0 0 48 351 2.59e4 0.00% 100.00% +memory[5] 14 0 0 0 46 4726 1.94e4 0.00% 100.00% +memory[6] 15 0 0 0 33 417 1.37e4 0.00% 100.00% +memory[8] 17 0 0 0 29 40990 1.30e4 0.00% 100.00% +u64_byte_count 150 128 8 1 5 292 8.89e3 0.00% 100.00% +k_shape_26 128 16 37 23 3 0 3.15e3 0.00% 100.00% +memory[2] 11 0 0 0 13 99 3.11e3 0.00% 100.00% +try_str_dispatch 128 18 47 28 2 0 1.35e3 0.00% 100.00% +verify_claim 40 1 1 2 1 0 2.16e2 0.00% 100.00% +memory[19] 28 0 0 0 0 0 0 0.00% 100.00% +k_shape_38 127 9 63 21 0 0 0 0.00% 100.00% +str_lit_to_ctor 49 1 21 21 0 0 0 0.00% 100.00% +memory[50] 59 0 0 0 0 0 0 0.00% 100.00% +memory[64] 73 0 0 0 0 0 0 0.00% 100.00% +k_shape_39 96 6 65 9 0 0 0 0.00% 100.00% From f6c585cd0dd4cddd62404af35425e3ac04121ad1 Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Wed, 12 Aug 2026 12:46:41 -0300 Subject: [PATCH 6/6] recursive verifier: shape-proximity grouping, aggressive on columns (218 -> 23) Populate MultiStark.verifierColdGroups with 9 shape bands over the 204 groupable function circuits (aux within 5x, lookups within max(6x, +16), summed selectors <= 128; the entry stays out). The blake3 pair stays singleton: their shapes mismatch on both axes (561/929 aux, 497/40 lookups) and at the group chaining k = 1 pairing costs ~1e11 modeled FFT for 215 columns. Under this merge rule the width floor is ~3,000 (blake3 2,272 + invariant selector mass 451 + entry); the aggressiveness sweep trades band overhead against FFT (5,089 @ 1.67x .. 4,373 @ 2.94x on IxVM-scale heights) and this picks the 2.30x point, comparable to the previously accepted width-first ratio. Measured on the toy profile: circuits 218 -> 23, total width 11,489 -> 4,849 (-58%; the shape model predicted 4,851), toy FFT 1.46x. Sweep and analysis in cold-groups/verifier-shape-grouping.md. multi-stark, recursive-verifier (honest accept, tamper rejects) and aiur-prove suites pass; fmt clean; kernel pins untouched. --- Ix/MultiStark/VerifierColdGroups.lean | 230 ++++++++++++++++++++++- cold-groups/rvstats-grouped.txt | 46 +++++ cold-groups/rvstats-ungrouped.txt | 242 +++++++++++++++++++++++++ cold-groups/verifier-bands-shape.json | 1 + cold-groups/verifier-shape-grouping.md | 33 ++++ 5 files changed, 551 insertions(+), 1 deletion(-) create mode 100644 cold-groups/rvstats-grouped.txt create mode 100644 cold-groups/rvstats-ungrouped.txt create mode 100644 cold-groups/verifier-bands-shape.json create mode 100644 cold-groups/verifier-shape-grouping.md diff --git a/Ix/MultiStark/VerifierColdGroups.lean b/Ix/MultiStark/VerifierColdGroups.lean index 58359883b..a86da0b9d 100644 --- a/Ix/MultiStark/VerifierColdGroups.lean +++ b/Ix/MultiStark/VerifierColdGroups.lean @@ -13,7 +13,235 @@ public section namespace MultiStark -def verifierColdGroups : Array (String × Array String) := #[] +-- Shape-proximity bands (aux within 5x, lookups within max(6x, +16), +-- summed selectors <= 128), aggressive on columns: see +-- cold-groups/verifier-shape-grouping.md for the sweep. blake3 pair and +-- the entry stay singleton (pairing blake3 at k = 1 costs ~1e11 FFT for +-- 215 columns). +def verifierColdGroups : Array (String × Array String) := #[ + ("v_shape_00", #[ + "b3_to_digest", + "eg_add", + "eg_neg", + "eg_sub", + "flatten_u64", + "gl_add", + "gl_val", + "prep_count", + "gl_mul", + "gl_sq", + "recon_evals", + "relaxed_u64_succ", + "u64_is_zero", + "opt_commit_cap", + "prep_onto", + "pow2", + "read_merkle_cap_at", + "read_vk_tag", + "list_is_empty.U8", + "lookup_groups_count", + "read_vk_u8", + "pad_block", + "ood_prep_rows", + "snoc_b8", + "snoc_cap", + "eg_mul", + "gl_inverse", + "bits_to_num", + "eg_div", + "from_ext_basis", + "list_length.Ptr.ListNode.U8_8_4", + "list_lookup.U8", + "ood_fold", + "read_active", + "read_batch_opening", + "read_batch_opening_vec", + "read_claims", + "read_commit_phase_step_vec", + "read_digest_vec_at", + "read_ext_vec", + "read_ext_vec_vec", + "read_merkle_cap_vec", + "read_one_claim", + "read_opened_round", + "read_query_proof", + "read_query_proof_vec", + "read_u64_vec", + "read_u64_vec_vec", + "read_u8", + "read_vk_u16", + "read_vk_u16_limb", + "trace_vanishing", + "heights_all", + "b3_w4_onto", + "digest_onto", + ]), + ("v_shape_01", #[ + "eg_eq", + "ext_is_zero", + "gl_lt_p", + "read_preprocessed", + "assert_bits", + "ext_exp_pow2", + "list_drop.G", + "list_length.BatchOpening", + "list_lookup.BatchOpening", + "build_buckets", + "list_concat.U8", + "log_degrees_onto", + "obs_log_arities", + "points_onto", + "rev_onto", + "round_onto", + "ro_x", + "circ_has_height", + "list_drop.BatchOpening", + "list_length.CommitPhaseProofStep", + "read_active_n", + "read_commit_phase_step", + "blake3_compress_chunks", + "read_claims_n", + "read_commitments", + "read_ext_vec_vec_n", + "read_merkle_cap_vec_n", + "read_node_ids_n", + "read_opened_round_n", + "read_sys_lookup", + "read_u64_vec_vec_n", + "take_bits", + "heights_prep", + "has_height", + "list_lookup.SysNode", + "read_batch_opening_vec_n", + "read_ext_vec_n", + "read_opt_commit", + "read_opt_idx_n", + "read_query_proof_vec_n", + "read_sys_lookups_n", + "exp_by_bits", + "pcs_check_witness", + "verify", + "open_2pt_mat", + "open_batch_2pt", + "cons_shape7", + "eg_inverse", + "list_drop.SysNode", + "list_length.Bucket", + "read_commit_phase_step_vec_n", + "read_vk_u32_limb", + "open_quotient", + "b3_flatten_onto", + "cons8", + "list_length.SysCircuit", + "read_nodes_n", + "fold_roots", + "query_loop", + "open_prep", + "build_publics", + "read_count_at", + "read_count", + "read_field", + "claims_onto", + "last_acc_is_zero", + "select_active_prep", + "gl_to_bytes", + "assert_blowup_zero", + ]), + ("v_shape_02", #[ + "list_length.U8_8", + "eval_at", + "ri_apply", + "open_prep_batch", + "ch_sample_bits", + "limbs_onto", + "list_concat.U8_8", + "quotient_eval", + "reconstruct_ext_row", + "read_u64_vec_n", + "read_claim_vals_n", + "lanes_to_gl", + "claims_acc", + "bucket_update", + "select_active_circuits", + "claims_each_onto", + "pair_mul", + "seed_tag_onto", + "rollin", + "logup_fingerprint", + "read_u64", + "read_vk_u64", + "trace_selectors", + "read_fri_proof", + "fingerprint_vals", + "heights_max", + "fri_fold2", + "quotient_degree_of", + "list_length_u64.Ptr.ListNode.U8_8", + "read_node", + "digest_eq", + "ch_sample_ext", + "read_ext_at", + "ro_fold", + "ch_sample_field", + "select_rows", + "accs_onto", + "rows_pop", + "ch_sample8", + "list_length_u64.U8_8", + "ood_verify", + "read_system", + ]), + ("v_shape_03", #[ + "two_adic_gen", + "read_proof", + "compress_ordered", + "list_lookup.U8_8_4", + "verify_query", + "read_digest_at", + "list_drop.U8_8_4", + "cap_onto", + "read_vk_digest", + "read_digest_vec_at_n", + "read_vk_cap_n", + "flatten2", + "pcs_betas", + "ch_sample_byte", + ]), + ("v_shape_04", #[ + "pcs_fri_verify", + "verify_one_query", + "ood_loop", + "ood_composition", + "logup_steps_fold", + ]), + ("v_shape_05", #[ + "mmcs_compress", + "mmcs_root", + "leaf_hash_at", + "inject_maybe", + "mmcs_verify", + "read_sys_circuits_n", + "b3_rows", + "blake3", + "sample8_bits", + "read_sys_params", + "read_sys_circuit", + ]), + ("v_shape_06", #[ + "fiat_shamir", + "mmcs_fold", + ]), + ("v_shape_07", #[ + "blake3_next_layer", + "blake3_finish", + "blake3_compress_block", + "blake3_compress_layer", + ]), + ("v_shape_08", #[ + "bytes_to_block", + "b3_rows_chunks", + ]), +] end MultiStark diff --git a/cold-groups/rvstats-grouped.txt b/cold-groups/rvstats-grouped.txt new file mode 100644 index 000000000..1531a36a6 --- /dev/null +++ b/cold-groups/rvstats-grouped.txt @@ -0,0 +1,46 @@ +✔ [73/81] Built Ix.MultiStark.VerifierColdGroups (236ms) +✔ [78/81] Built Ix.MultiStark.VerifierColdGroups:c.o (193ms) +✔ [79/81] Built Benchmarks.RecursiveVerifier (913ms) +✔ [81/81] Built «bench-recursive-verifier»:exe (966ms) +params: logBlowup=2 numQueries=100 finalPoly=0 pow=0 +proving inner factorial(5)… +inner PROVE: 0.113016 s, proof 851567 bytes; inner VERIFY: 0.005042 s (ok) +executing verify_multi_stark_proof… +verifier accepted, execute 0.286703 s + +=== recursive verifier in-circuit cost === +totalFftCost = 11693296038.553404 + +=== per-circuit breakdown (top FFT contributors) === +=== Circuit Statistics === +Circuits: 23 +Total width: 4849 +Total FFT cost: 11693296039 (1.17e10) +Total cache hits: 344748 +Total saved cost: 17.54% +--------------------------------------------------------------------------------- +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +--------------------------------------------------------------------------------- +blake3_compress_inner_j 1192 1 561 497 63819 0 6.07e9 51.94% 51.94% +v_shape_01 220 127 12 10 75994 34147 1.36e9 11.61% 63.55% +v_shape_03 200 54 43 17 58959 13870 9.36e8 8.01% 71.56% +v_shape_02 248 120 30 15 45518 10120 8.75e8 7.48% 79.05% +v_shape_00 138 86 5 5 66799 75904 7.41e8 6.34% 85.38% +blake3_compress 1080 1 929 40 9117 2 6.48e8 5.54% 90.93% +v_shape_05 201 15 82 18 30015 4098 4.50e8 3.85% 94.77% +v_shape_06 247 3 135 34 19920 200 3.52e8 3.01% 97.78% +Bytes2 24 0 0 0 65536 0 1.28e8 1.10% 98.88% +v_shape_08 369 16 213 65 1680 13 3.33e7 0.28% 99.16% +memory[34] 43 0 0 0 11164 39031 3.27e7 0.28% 99.44% +memory[3] 12 0 0 0 28521 108520 2.64e7 0.23% 99.67% +v_shape_07 291 20 170 15 1572 2 2.43e7 0.21% 99.88% +memory[10] 19 0 0 0 7564 23328 9.53e6 0.08% 99.96% +memory[4] 13 0 0 0 1838 19572 1.36e6 0.01% 99.97% +memory[7] 16 0 0 0 1500 4825 1.32e6 0.01% 99.98% +memory[5] 14 0 0 0 1205 2908 9.07e5 0.01% 99.99% +v_shape_04 173 10 59 28 122 1 7.36e5 0.01% 99.99% +memory[32] 41 0 0 0 264 3159 4.45e5 0.00% 100.00% +Bytes1 11 0 0 0 256 0 1.22e5 0.00% 100.00% +memory[6] 15 0 0 0 102 201 5.47e4 0.00% 100.00% +memory[8] 17 0 0 0 7 4847 1.92e3 0.00% 100.00% +verify_multi_stark_proof 265 1 184 12 1 0 1.34e3 0.00% 100.00% diff --git a/cold-groups/rvstats-ungrouped.txt b/cold-groups/rvstats-ungrouped.txt new file mode 100644 index 000000000..b3238df85 --- /dev/null +++ b/cold-groups/rvstats-ungrouped.txt @@ -0,0 +1,242 @@ +✔ [71/79] Built Ix.MultiStark.VerifierColdGroups (179ms) +✔ [75/81] Built Ix.MultiStark.VerifierColdGroups:c.o (46ms) +✔ [78/81] Built Ix.Aiur.Statistics:c.o (418ms) +✔ [79/81] Built Benchmarks.RecursiveVerifier (818ms) +✔ [81/81] Built «bench-recursive-verifier»:exe (853ms) +params: logBlowup=2 numQueries=100 finalPoly=0 pow=0 +proving inner factorial(5)… +inner PROVE: 0.112107 s, proof 851567 bytes; inner VERIFY: 0.005112 s (ok) +executing verify_multi_stark_proof… +verifier accepted, execute 0.302648 s + +=== recursive verifier in-circuit cost === +totalFftCost = 8009534999.270286 + +=== per-circuit breakdown (top FFT contributors) === +=== Circuit Statistics === +Circuits: 218 +Total width: 11489 +Total FFT cost: 8009534999 (8.01e9) +Total cache hits: 344748 +Total saved cost: 7.36% +------------------------------------------------------------------------------------------ +Name Width Sel Aux Lkp Height Hits FFT cost % %++ +------------------------------------------------------------------------------------------ +blake3_compress_inner_j 1192 1 561 497 63819 0 6.07e9 75.83% 75.83% +blake3_compress 1080 1 929 40 9117 2 6.48e8 8.09% 83.92% +mmcs_fold 190 2 135 6 19919 200 2.71e8 3.38% 87.30% +inject_maybe 116 2 67 4 16428 2186 1.34e8 1.67% 88.97% +Bytes2 24 0 0 0 65536 0 1.28e8 1.60% 90.57% +read_digest_vec_at_n 54 2 38 4 24438 0 9.71e7 1.21% 91.79% +read_digest_at 43 1 37 1 22419 0 7.00e7 0.87% 92.66% +mmcs_compress 138 1 65 3 7425 1417 6.61e7 0.83% 93.49% +compress_ordered 109 2 34 2 8549 10065 6.12e7 0.76% 94.25% +ro_fold 56 2 22 9 13502 0 5.24e7 0.65% 94.90% +memory[34] 43 0 0 0 11164 39031 3.27e7 0.41% 95.31% +rev_onto 22 2 6 4 17408 123 2.76e7 0.34% 95.66% +memory[3] 12 0 0 0 28521 108520 2.64e7 0.33% 95.99% +rows_pop 42 3 25 4 8918 5200 2.49e7 0.31% 96.30% +b3_rows_chunks 282 15 213 22 1590 1 2.39e7 0.30% 96.60% +b3_to_digest 38 1 1 1 8823 202 2.21e7 0.28% 96.87% +eg_mul 16 1 5 1 15668 25192 1.80e7 0.23% 97.10% +blake3_compress_layer 223 3 170 6 1446 2 1.70e7 0.21% 97.31% +read_u64_vec_n 28 2 14 3 8817 0 1.65e7 0.21% 97.51% +gl_to_bytes 25 1 11 7 7323 4933 1.20e7 0.15% 97.66% +blake3_compress_chunks 29 3 7 4 5687 0 1.05e7 0.13% 97.80% +gl_lt_p 21 1 6 1 7365 0 1.02e7 0.13% 97.92% +exp_by_bits 27 3 8 5 5602 1329 9.62e6 0.12% 98.04% +memory[10] 19 0 0 0 7564 23328 9.53e6 0.12% 98.16% +gl_val 14 1 1 1 7449 14174 6.83e6 0.09% 98.25% +leaf_hash_at 78 1 66 4 1598 200 6.69e6 0.08% 98.33% +mmcs_verify 82 1 67 4 1505 95 6.57e6 0.08% 98.41% +read_count_at 19 1 11 2 5360 0 6.50e6 0.08% 98.49% +mmcs_root 80 1 66 3 1505 0 6.41e6 0.08% 98.57% +b3_rows 86 1 72 8 1398 200 6.33e6 0.08% 98.65% +eg_add 10 1 1 1 8604 6098 5.76e6 0.07% 98.72% +lanes_to_gl 31 2 14 5 3084 1088 5.65e6 0.07% 98.80% +bucket_update 38 3 15 4 2446 389 5.32e6 0.07% 98.86% +verify_query 85 2 36 17 1208 95 5.30e6 0.07% 98.93% +read_ext_vec_n 24 2 8 4 3367 0 4.86e6 0.06% 98.99% +select_rows 46 4 23 6 1834 1581 4.64e6 0.06% 99.05% +eg_sub 10 1 1 1 6888 8174 4.50e6 0.06% 99.10% +ch_sample_byte 67 2 43 8 1136 0 3.90e6 0.05% 99.15% +list_length.Ptr.ListNode.U8_8_4 18 2 5 3 3403 2380 3.72e6 0.05% 99.20% +ri_apply 35 1 12 8 1881 0 3.65e6 0.05% 99.24% +flatten2 57 1 38 10 1109 95 3.24e6 0.04% 99.28% +read_ext_at 31 1 21 3 1746 0 2.98e6 0.04% 99.32% +fri_fold2 43 1 18 12 1109 95 2.45e6 0.03% 99.35% +take_bits 23 2 7 4 1900 0 2.45e6 0.03% 99.38% +read_commit_phase_step_vec_n 25 2 9 4 1700 0 2.34e6 0.03% 99.41% +eg_div 18 1 5 3 2221 3 2.30e6 0.03% 99.44% +rollin 39 3 16 5 1106 98 2.22e6 0.03% 99.47% +list_concat.U8 22 2 6 4 1794 15 2.20e6 0.03% 99.49% +list_drop.G 20 2 6 3 1905 2190 2.14e6 0.03% 99.52% +cons8 33 1 9 9 1198 35 2.06e6 0.03% 99.55% +list_drop.BatchOpening 21 2 7 3 1677 362 1.95e6 0.02% 99.57% +list_length.BatchOpening 19 2 6 3 1809 3193 1.92e6 0.02% 99.60% +read_u64_vec_vec_n 23 2 7 4 1500 0 1.87e6 0.02% 99.62% +read_digest_vec_at 15 1 5 3 2019 0 1.74e6 0.02% 99.64% +gl_mul 11 1 2 1 2623 335 1.73e6 0.02% 99.66% +open_batch_2pt 41 2 8 7 792 0 1.59e6 0.02% 99.68% +list_lookup.BatchOpening 17 1 6 3 1677 435 1.59e6 0.02% 99.70% +read_commit_phase_step 17 1 7 3 1600 0 1.51e6 0.02% 99.72% +memory[4] 13 0 0 0 1838 19572 1.36e6 0.02% 99.74% +read_ext_vec 15 1 5 3 1621 0 1.35e6 0.02% 99.75% +eg_inverse 18 1 9 1 1360 2746 1.32e6 0.02% 99.77% +memory[7] 16 0 0 0 1500 4825 1.32e6 0.02% 99.79% +list_length.CommitPhaseProofStep 20 2 7 3 1205 98 1.28e6 0.02% 99.80% +open_2pt_mat 32 1 8 7 792 0 1.25e6 0.02% 99.82% +recon_evals 15 2 2 1 1204 0 9.67e5 0.01% 99.83% +memory[5] 14 0 0 0 1205 2908 9.07e5 0.01% 99.84% +read_u64_vec 15 1 5 3 1101 0 8.74e5 0.01% 99.85% +pad_block 18 2 4 3 918 0 8.46e5 0.01% 99.86% +open_prep 48 3 10 8 396 0 8.34e5 0.01% 99.87% +bytes_to_block 265 1 193 65 90 12 7.77e5 0.01% 99.88% +open_quotient 44 2 9 8 396 0 7.66e5 0.01% 99.89% +read_batch_opening_vec_n 24 2 8 4 500 0 5.56e5 0.01% 99.90% +blake3_compress_block 211 2 169 15 73 0 4.79e5 0.01% 99.91% +memory[32] 41 0 0 0 264 3159 4.45e5 0.01% 99.91% +read_vk_u8 12 1 4 2 673 0 4.04e5 0.01% 99.92% +list_lookup.U8 16 1 5 3 519 4718 3.93e5 0.00% 99.92% +gl_add 8 1 1 1 913 196 3.74e5 0.00% 99.93% +sample8_bits 105 1 74 18 100 0 3.52e5 0.00% 99.93% +verify_one_query 105 1 49 26 99 1 3.48e5 0.00% 99.94% +b3_w4_onto 21 1 5 5 368 0 3.43e5 0.00% 99.94% +accs_onto 46 2 24 7 165 2 2.85e5 0.00% 99.94% +read_u64_vec_vec 15 1 5 3 400 0 2.74e5 0.00% 99.95% +read_batch_opening 15 1 5 3 400 0 2.74e5 0.00% 99.95% +blake3_finish 190 11 151 9 48 0 2.56e5 0.00% 99.95% +assert_blowup_zero 27 3 12 3 223 98 2.43e5 0.00% 99.96% +ch_sample8 42 1 25 9 142 0 2.18e5 0.00% 99.96% +has_height 23 3 8 3 223 16408 2.08e5 0.00% 99.96% +eval_at 56 15 12 5 101 54 1.92e5 0.00% 99.96% +query_loop 51 2 10 5 101 0 1.75e5 0.00% 99.97% +ro_x 19 1 6 6 222 1659 1.72e5 0.00% 99.97% +open_prep_batch 51 2 12 9 99 0 1.71e5 0.00% 99.97% +read_node 49 16 20 4 101 0 1.68e5 0.00% 99.97% +read_vk_u16 15 1 5 3 245 0 1.55e5 0.00% 99.97% +Bytes1 11 0 0 0 256 0 1.22e5 0.00% 99.98% +logup_fingerprint 53 2 16 6 71 12 1.18e5 0.00% 99.98% +blake3 86 1 72 8 48 0 1.17e5 0.00% 99.98% +pair_mul 36 1 15 8 93 14 1.13e5 0.00% 99.98% +read_nodes_n 26 2 10 4 104 0 9.43e4 0.00% 99.98% +ch_sample_bits 25 1 13 4 100 0 8.66e4 0.00% 99.98% +read_query_proof_vec_n 24 2 8 4 101 0 8.43e4 0.00% 99.98% +list_drop.SysNode 23 2 9 3 101 98 8.10e4 0.00% 99.99% +read_node_ids_n 23 2 7 4 94 0 7.42e4 0.00% 99.99% +b3_flatten_onto 57 1 9 9 46 0 7.41e4 0.00% 99.99% +list_lookup.SysNode 19 1 8 3 101 0 6.75e4 0.00% 99.99% +memory[6] 15 0 0 0 102 201 5.47e4 0.00% 99.99% +read_commit_phase_step_vec 15 1 5 3 100 0 5.34e4 0.00% 99.99% +read_query_proof 15 1 5 3 100 0 5.34e4 0.00% 99.99% +read_batch_opening_vec 15 1 5 3 100 0 5.34e4 0.00% 99.99% +circ_has_height 25 3 7 3 66 0 5.22e4 0.00% 99.99% +logup_steps_fold 161 4 59 25 15 0 4.77e4 0.00% 99.99% +ch_sample_field 39 2 23 4 42 0 4.57e4 0.00% 99.99% +digest_eq 99 1 20 9 20 1485 4.35e4 0.00% 99.99% +read_vk_tag 11 1 3 2 104 0 4.21e4 0.00% 99.99% +cap_onto 53 2 37 4 23 17 2.84e4 0.00% 99.99% +limbs_onto 29 2 13 4 35 0 2.73e4 0.00% 99.99% +read_u8 18 2 5 3 48 0 2.59e4 0.00% 99.99% +list_is_empty.U8 15 2 4 2 55 89 2.58e4 0.00% 99.99% +pcs_betas 70 2 40 10 17 0 2.49e4 0.00% 100.00% +two_adic_gen 73 33 33 1 16 2113 2.39e4 0.00% 100.00% +list_drop.U8_8_4 51 2 37 3 20 0 2.28e4 0.00% 100.00% +digest_onto 49 1 5 5 20 0 2.19e4 0.00% 100.00% +list_lookup.U8_8_4 47 1 36 3 20 1485 2.10e4 0.00% 100.00% +ext_exp_pow2 21 2 6 3 34 124 1.94e4 0.00% 100.00% +read_ext_vec_vec_n 23 2 7 4 30 0 1.80e4 0.00% 100.00% +points_onto 22 2 6 4 30 0 1.73e4 0.00% 100.00% +ch_sample_ext 32 1 21 3 21 0 1.55e4 0.00% 100.00% +blake3_next_layer 221 4 136 5 5 0 1.30e4 0.00% 100.00% +pcs_check_witness 34 2 8 5 17 0 1.24e4 0.00% 100.00% +build_buckets 25 3 6 4 19 98 1.08e4 0.00% 100.00% +snoc_b8 22 1 4 4 20 0 1.02e4 0.00% 100.00% +read_sys_lookups_n 24 2 8 4 18 0 9.66e3 0.00% 100.00% +list_length.U8_8 25 2 12 3 17 0 9.30e3 0.00% 100.00% +fold_roots 45 2 10 5 11 0 8.96e3 0.00% 100.00% +read_merkle_cap_vec_n 23 2 7 4 17 0 8.60e3 0.00% 100.00% +obs_log_arities 22 2 6 4 17 0 8.26e3 0.00% 100.00% +lookup_groups_count 18 3 4 2 18 0 7.40e3 0.00% 100.00% +read_opened_round_n 23 2 7 4 15 0 7.28e3 0.00% 100.00% +round_onto 22 2 6 4 15 0 6.99e3 0.00% 100.00% +snoc_cap 15 1 4 4 18 0 6.28e3 0.00% 100.00% +flatten_u64 14 1 1 1 19 5343 5.95e3 0.00% 100.00% +read_vk_u16_limb 15 1 5 3 17 0 5.82e3 0.00% 100.00% +read_sys_lookup 17 1 7 4 15 0 5.52e3 0.00% 100.00% +ood_loop 134 2 52 28 4 0 5.50e3 0.00% 100.00% +pow2 14 2 3 2 17 2 5.48e3 0.00% 100.00% +quotient_eval 36 2 13 6 9 0 5.46e3 0.00% 100.00% +ood_fold 20 1 5 3 13 13 5.28e3 0.00% 100.00% +read_merkle_cap_at 11 1 3 2 19 0 5.12e3 0.00% 100.00% +gl_sq 10 1 2 1 18 5582 4.40e3 0.00% 100.00% +list_concat.U8_8 29 2 13 4 8 0 3.77e3 0.00% 100.00% +read_sys_circuits_n 88 2 70 5 4 0 3.66e3 0.00% 100.00% +ood_composition 135 2 55 27 3 0 3.32e3 0.00% 100.00% +read_ext_vec_vec 15 1 5 3 11 0 3.25e3 0.00% 100.00% +read_sys_circuit 122 3 82 16 3 0 3.01e3 0.00% 100.00% +log_degrees_onto 22 2 6 4 8 0 2.93e3 0.00% 100.00% +read_active_n 21 2 7 3 8 0 2.81e3 0.00% 100.00% +read_u64 33 1 17 9 6 0 2.78e3 0.00% 100.00% +list_length_u64.U8_8 42 2 27 4 5 0 2.62e3 0.00% 100.00% +fingerprint_vals 39 2 18 6 5 0 2.44e3 0.00% 100.00% +reconstruct_ext_row 32 2 13 6 5 2 2.04e3 0.00% 100.00% +cons_shape7 78 1 8 8 3 0 1.96e3 0.00% 100.00% +memory[8] 17 0 0 0 7 4847 1.92e3 0.00% 100.00% +read_claim_vals_n 30 2 14 4 5 0 1.92e3 0.00% 100.00% +select_active_circuits 34 3 15 5 4 0 1.50e3 0.00% 100.00% +read_vk_u64 33 1 17 9 4 0 1.46e3 0.00% 100.00% +select_active_prep 30 3 11 5 4 0 1.34e3 0.00% 100.00% +verify_multi_stark_proof 265 1 184 12 1 0 1.34e3 0.00% 100.00% +heights_prep 29 3 7 5 4 98 1.30e3 0.00% 100.00% +gl_inverse 13 1 5 1 6 0 1.22e3 0.00% 100.00% +heights_max 44 3 18 9 3 98 1.15e3 0.00% 100.00% +relaxed_u64_succ 25 9 2 1 4 3 1.14e3 0.00% 100.00% +read_opt_idx_n 25 3 8 4 4 0 1.14e3 0.00% 100.00% +list_length.SysCircuit 23 2 10 3 4 2 1.06e3 0.00% 100.00% +heights_all 23 2 5 4 4 296 1.06e3 0.00% 100.00% +trace_selectors 35 1 17 10 3 0 9.40e2 0.00% 100.00% +assert_bits 19 2 6 3 4 0 9.04e2 0.00% 100.00% +fiat_shamir 150 1 102 34 1 0 7.66e2 0.00% 100.00% +last_acc_is_zero 27 3 11 4 3 0 7.50e2 0.00% 100.00% +read_opened_round 15 1 5 3 4 0 7.44e2 0.00% 100.00% +u64_is_zero 25 9 2 1 3 1689 7.02e2 0.00% 100.00% +ood_prep_rows 23 3 4 4 3 0 6.55e2 0.00% 100.00% +read_vk_cap_n 54 2 38 4 2 0 6.12e2 0.00% 100.00% +read_vk_u32_limb 21 1 9 5 3 0 6.07e2 0.00% 100.00% +from_ext_basis 18 1 5 3 3 1 5.36e2 0.00% 100.00% +pcs_fri_verify 103 1 45 22 1 0 5.31e2 0.00% 100.00% +read_sys_params 101 1 79 16 1 0 5.21e2 0.00% 100.00% +eg_eq 17 1 6 1 3 99 5.12e2 0.00% 100.00% +trace_vanishing 17 1 5 3 3 0 5.12e2 0.00% 100.00% +claims_acc 41 2 14 7 2 0 4.82e2 0.00% 100.00% +ood_verify 82 1 27 14 1 0 4.26e2 0.00% 100.00% +list_length_u64.Ptr.ListNode.U8_8 35 2 20 4 2 0 4.22e2 0.00% 100.00% +claims_each_onto 35 2 15 6 2 0 4.22e2 0.00% 100.00% +build_publics 33 1 10 10 2 1 4.02e2 0.00% 100.00% +read_claims_n 23 2 7 4 2 0 3.02e2 0.00% 100.00% +read_count 21 1 11 3 2 0 2.82e2 0.00% 100.00% +read_vk_digest 49 1 37 5 1 0 2.61e2 0.00% 100.00% +read_proof 49 1 33 10 1 0 2.61e2 0.00% 100.00% +quotient_degree_of 45 19 19 1 1 2 2.41e2 0.00% 100.00% +read_system 44 1 30 8 1 0 2.36e2 0.00% 100.00% +verify 42 1 8 6 1 0 2.26e2 0.00% 100.00% +read_active 15 1 5 3 2 0 2.22e2 0.00% 100.00% +seed_tag_onto 37 1 15 15 1 0 2.01e2 0.00% 100.00% +read_fri_proof 30 1 18 5 1 0 1.66e2 0.00% 100.00% +read_opt_commit 23 2 8 4 1 0 1.31e2 0.00% 100.00% +list_length.Bucket 22 2 9 3 1 3 1.26e2 0.00% 100.00% +claims_onto 22 1 11 4 1 0 1.26e2 0.00% 100.00% +eg_neg 8 1 1 1 2 12 1.12e2 0.00% 100.00% +bits_to_num 18 2 5 3 1 1304 1.06e2 0.00% 100.00% +read_commitments 17 1 7 4 1 0 1.01e2 0.00% 100.00% +read_preprocessed 17 2 6 2 1 0 1.01e2 0.00% 100.00% +read_claims 15 1 5 3 1 0 9.10e1 0.00% 100.00% +prep_onto 15 2 2 2 1 0 9.10e1 0.00% 100.00% +read_query_proof_vec 15 1 5 3 1 0 9.10e1 0.00% 100.00% +read_one_claim 15 1 5 3 1 0 9.10e1 0.00% 100.00% +read_merkle_cap_vec 15 1 5 3 1 0 9.10e1 0.00% 100.00% +ext_is_zero 15 1 6 1 1 0 9.10e1 0.00% 100.00% +opt_commit_cap 14 2 2 2 1 0 8.60e1 0.00% 100.00% +prep_count 11 2 1 1 1 98 7.10e1 0.00% 100.00% +read_field 21 1 11 3 0 0 0 0.00% 100.00% diff --git a/cold-groups/verifier-bands-shape.json b/cold-groups/verifier-bands-shape.json new file mode 100644 index 000000000..c47875789 --- /dev/null +++ b/cold-groups/verifier-bands-shape.json @@ -0,0 +1 @@ +[["b3_to_digest", "eg_add", "eg_neg", "eg_sub", "flatten_u64", "gl_add", "gl_val", "prep_count", "gl_mul", "gl_sq", "recon_evals", "relaxed_u64_succ", "u64_is_zero", "opt_commit_cap", "prep_onto", "pow2", "read_merkle_cap_at", "read_vk_tag", "list_is_empty.U8", "lookup_groups_count", "read_vk_u8", "pad_block", "ood_prep_rows", "snoc_b8", "snoc_cap", "eg_mul", "gl_inverse", "bits_to_num", "eg_div", "from_ext_basis", "list_length.Ptr.ListNode.U8_8_4", "list_lookup.U8", "ood_fold", "read_active", "read_batch_opening", "read_batch_opening_vec", "read_claims", "read_commit_phase_step_vec", "read_digest_vec_at", "read_ext_vec", "read_ext_vec_vec", "read_merkle_cap_vec", "read_one_claim", "read_opened_round", "read_query_proof", "read_query_proof_vec", "read_u64_vec", "read_u64_vec_vec", "read_u8", "read_vk_u16", "read_vk_u16_limb", "trace_vanishing", "heights_all", "b3_w4_onto", "digest_onto"], ["eg_eq", "ext_is_zero", "gl_lt_p", "read_preprocessed", "assert_bits", "ext_exp_pow2", "list_drop.G", "list_length.BatchOpening", "list_lookup.BatchOpening", "build_buckets", "list_concat.U8", "log_degrees_onto", "obs_log_arities", "points_onto", "rev_onto", "round_onto", "ro_x", "circ_has_height", "list_drop.BatchOpening", "list_length.CommitPhaseProofStep", "read_active_n", "read_commit_phase_step", "blake3_compress_chunks", "read_claims_n", "read_commitments", "read_ext_vec_vec_n", "read_merkle_cap_vec_n", "read_node_ids_n", "read_opened_round_n", "read_sys_lookup", "read_u64_vec_vec_n", "take_bits", "heights_prep", "has_height", "list_lookup.SysNode", "read_batch_opening_vec_n", "read_ext_vec_n", "read_opt_commit", "read_opt_idx_n", "read_query_proof_vec_n", "read_sys_lookups_n", "exp_by_bits", "pcs_check_witness", "verify", "open_2pt_mat", "open_batch_2pt", "cons_shape7", "eg_inverse", "list_drop.SysNode", "list_length.Bucket", "read_commit_phase_step_vec_n", "read_vk_u32_limb", "open_quotient", "b3_flatten_onto", "cons8", "list_length.SysCircuit", "read_nodes_n", "fold_roots", "query_loop", "open_prep", "build_publics", "read_count_at", "read_count", "read_field", "claims_onto", "last_acc_is_zero", "select_active_prep", "gl_to_bytes", "assert_blowup_zero"], ["list_length.U8_8", "eval_at", "ri_apply", "open_prep_batch", "ch_sample_bits", "limbs_onto", "list_concat.U8_8", "quotient_eval", "reconstruct_ext_row", "read_u64_vec_n", "read_claim_vals_n", "lanes_to_gl", "claims_acc", "bucket_update", "select_active_circuits", "claims_each_onto", "pair_mul", "seed_tag_onto", "rollin", "logup_fingerprint", "read_u64", "read_vk_u64", "trace_selectors", "read_fri_proof", "fingerprint_vals", "heights_max", "fri_fold2", "quotient_degree_of", "list_length_u64.Ptr.ListNode.U8_8", "read_node", "digest_eq", "ch_sample_ext", "read_ext_at", "ro_fold", "ch_sample_field", "select_rows", "accs_onto", "rows_pop", "ch_sample8", "list_length_u64.U8_8", "ood_verify", "read_system"], ["two_adic_gen", "read_proof", "compress_ordered", "list_lookup.U8_8_4", "verify_query", "read_digest_at", "list_drop.U8_8_4", "cap_onto", "read_vk_digest", "read_digest_vec_at_n", "read_vk_cap_n", "flatten2", "pcs_betas", "ch_sample_byte"], ["pcs_fri_verify", "verify_one_query", "ood_loop", "ood_composition", "logup_steps_fold"], ["mmcs_compress", "mmcs_root", "leaf_hash_at", "inject_maybe", "mmcs_verify", "read_sys_circuits_n", "b3_rows", "blake3", "sample8_bits", "read_sys_params", "read_sys_circuit"], ["fiat_shamir", "mmcs_fold"], ["blake3_next_layer", "blake3_finish", "blake3_compress_block", "blake3_compress_layer"], ["bytes_to_block", "b3_rows_chunks"]] \ No newline at end of file diff --git a/cold-groups/verifier-shape-grouping.md b/cold-groups/verifier-shape-grouping.md new file mode 100644 index 000000000..00783b56e --- /dev/null +++ b/cold-groups/verifier-shape-grouping.md @@ -0,0 +1,33 @@ +# Verifier grouping by layout shape, aggressive on columns (2026-08-12, old merge rule) + +Same pipeline as the kernel (`kernel-shape-grouping.md`) applied to the +recursive-verifier toplevel, with looser thresholds per the width-first goal. +Shapes from the toy profile (workload-independent); heights for cost scoring +from the IxVM-scale `recursive-fft` stats (unmatched functions scaled by the +median real/toy height ratio, 6.0). + +## Structure of the width floor +Under this merge rule the verifier cannot go below ~3,000 columns however +aggressive the banding: the blake3 pair is 2,272 and unpairable (their shapes +mismatch 561/929 aux and 497/40 lookups, and at the group k = 1 the pair costs +~1e11 modeled FFT for 215 columns), selector mass is invariant at 451 (selectors +sum), and the entry adds 263. Banding only trades per-band overhead +(max aux + 2 max lkp + residual) against FFT. + +## Aggressiveness sweep (modeled on IxVM-scale heights) +| aux ratio | lkp tolerance | sel cap | bands | fn width | FFT ratio | +|---|---|---|---|---|---| +| 2.5x | max(3x,+8) | 64 | 16 | 5,089 | 1.67x | +| 3.5x | max(4x,+12) | 96 | 13 | 4,865 | 1.85x | +| **5.0x** | **max(6x,+16)** | **128** | **9** | **4,624** | **2.30x** (chosen) | +| 8.0x | max(8x,+24) | 192 | 7 | 4,373 | 2.94x | + +Chosen: the 2.30x point - comparable to the FFT ratio previously accepted for +the width-first verifier partition (~2.1x on the real workload). + +## Measured (toy profile) +- circuits 218 -> 23, total width 11,489 -> 4,849 (-58%); model predicted 4,851 +- toy FFT 8.0e9 -> 1.17e10 (1.46x); real-workload model 1.57e11 -> 2.62e11-ish + at config A, 2.30x at chosen config +- suites green: multi-stark, recursive-verifier e2e (honest accept, tamper + rejects), aiur-prove \ No newline at end of file