From 6e672dd9737bddbe0f69ab558e0add2d4ed49015 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sat, 15 Mar 2025 18:56:12 -0400
Subject: [PATCH 01/74] WIP: ix hash command

---
 Ix/CanonM.lean                               | 26 +++++-
 Ix/Cli/HashCmd.lean                          | 35 +++++++-
 Ix/Common.lean                               | 87 ++++++++++++++++++++
 Ix/Cronos.lean                               | 28 +++++++
 ix_test/.github/workflows/lean_action_ci.yml | 14 ++++
 ix_test/.gitignore                           |  1 +
 ix_test/IxTest.lean                          | 12 +++
 ix_test/IxTest/Basic.lean                    |  1 +
 ix_test/Main.lean                            |  4 +
 ix_test/README.md                            |  1 +
 ix_test/lake-manifest.json                   |  5 ++
 ix_test/lakefile.toml                        | 10 +++
 ix_test/lean-toolchain                       |  1 +
 13 files changed, 222 insertions(+), 3 deletions(-)
 create mode 100644 Ix/Cronos.lean
 create mode 100644 ix_test/.github/workflows/lean_action_ci.yml
 create mode 100644 ix_test/.gitignore
 create mode 100644 ix_test/IxTest.lean
 create mode 100644 ix_test/IxTest/Basic.lean
 create mode 100644 ix_test/Main.lean
 create mode 100644 ix_test/README.md
 create mode 100644 ix_test/lake-manifest.json
 create mode 100644 ix_test/lakefile.toml
 create mode 100644 ix_test/lean-toolchain

diff --git a/Ix/CanonM.lean b/Ix/CanonM.lean
index b5be8d6a..5cbbc5f8 100644
--- a/Ix/CanonM.lean
+++ b/Ix/CanonM.lean
@@ -51,6 +51,9 @@ structure CanonMState where
   commits: RBMap Ix.Const (Address × Address) compare
   blocks : RBSet (Address × Address) compare
 
+def CanonMState.init : CanonMState :=
+  ⟨default, default, default, default, default⟩
+
 structure CanonMCtx where
   constMap: Lean.ConstMap
   univCtx : List Lean.Name
@@ -59,6 +62,9 @@ structure CanonMCtx where
   --quick : Bool
   --persist : Bool
 
+def CanonMCtx.init (constMap : Lean.ConstMap) : CanonMCtx :=
+  ⟨constMap, default, default, default⟩
+
 abbrev CanonM := ReaderT CanonMCtx $ ExceptT CanonMError $ StateT CanonMState IO
 
 def withBinder (name : Lean.Name) : CanonM α → CanonM α :=
@@ -381,7 +387,7 @@ Content-addresses a Lean expression and adds it to the store.
 
 Constants are the tricky case, for which there are two possibilities:
 * The constant belongs to `recrCtx`, representing a recursive call. Those are
-encoded as variables with indexes that go beyond the bind indexes
+encoded as `.rec_` with indexes based on order in the mutual definition
 * The constant doesn't belong to `recrCtx`, meaning that it's not a recursion
 and thus we can canon the actual constant right away
 -/
@@ -544,4 +550,22 @@ partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
 
 end
 
+/-- Iterates over a list of `Lean.ConstantInfo`, triggering their content-addressing -/
+def canonDelta (delta : List Lean.ConstantInfo) : CanonM Unit := do
+  delta.forM fun c => if !c.isUnsafe then discard $ canonConst c else pure ()
+
+/--
+Content-addresses the "delta" of an environment, that is, the content that is
+added on top of the imports.
+
+Important: constants with open references in their expressions are filtered out.
+Open references are variables that point to names which aren't present in the
+`Lean.ConstMap`.
+-/
+def canon (constMap : Lean.ConstMap) (delta : List Lean.ConstantInfo)
+  : IO $ Except CanonMError CanonMState := do
+  match ← StateT.run (ReaderT.run (canonDelta delta) (.init constMap)) CanonMState.init with
+  | (.ok _, stt) => return .ok stt
+  | (.error e, _) => return .error e
+
 end Ix.CanonM
diff --git a/Ix/Cli/HashCmd.lean b/Ix/Cli/HashCmd.lean
index e8f5bb92..e941c011 100644
--- a/Ix/Cli/HashCmd.lean
+++ b/Ix/Cli/HashCmd.lean
@@ -1,8 +1,39 @@
 import Cli
+import Ix.Cronos
+import Ix.Common
+import Ix.CanonM
+import Lean
 
 def runHash (p : Cli.Parsed) : IO UInt32 := do
-  let input   : String       := p.positionalArg! "input" |>.as! String
-  IO.println <| "Input: " ++ input
+  -- Get Lean source file name
+  let source  : String       := p.positionalArg! "input" |>.as! String
+  IO.println <| "Source: " ++ source
+  -- Run Lean frontend
+  let mut cronos ← Cronos.new.clock "Run Lean frontend"
+  Lean.setLibsPaths source
+  --IO.println <| "setlibs"
+  let path := ⟨source⟩
+  let leanEnv ← Lean.runFrontend (← IO.FS.readFile path) path
+  leanEnv.constants.forM fun n y => do
+    IO.println <| s!"constant {n}"
+  let (constMap, delta) := leanEnv.getConstsAndDelta
+  IO.println <| "delta"
+  IO.println <| s!"delta len {delta.length}"
+  delta.forM fun x => do
+     IO.println <| s!"constant'' {x.name}"
+  --cronos ← cronos.clock "Run Lean frontend"
+
+  IO.println <| "content-address"
+  -- Start content-addressing
+  cronos ← cronos.clock "Content-address"
+  let stt ← match ← Ix.CanonM.canon constMap delta with
+    | .error err => IO.eprintln err; return 1
+    | .ok stt => pure stt
+  cronos ← cronos.clock "Content-address"
+  stt.store.forM fun adr _ => do
+     IO.println <| s!"{adr}"
+
+  IO.println cronos.summary
   return 0
 
 def hashCmd : Cli.Cmd := `[Cli|
diff --git a/Ix/Common.lean b/Ix/Common.lean
index b361d8f6..688ef842 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -1,4 +1,5 @@
 import Lean
+import Batteries
 
 -- TODO: move to a utils namespace
 def compareList [Ord α] : List α -> List α -> Ordering
@@ -110,6 +111,12 @@ end List
 
 namespace Lean
 
+def ConstantInfo.formatAll (c : ConstantInfo) : String :=
+  match c.all with
+  | [ ]
+  | [_] => ""
+  | all => " " ++ all.toString
+
 def ConstantInfo.ctorName : ConstantInfo → String
   | .axiomInfo  _ => "axiom"
   | .defnInfo   _ => "definition"
@@ -127,4 +134,84 @@ def ConstMap.childrenOfWith (map : ConstMap) (name : Name)
   | .num n .. => if n == name && p c then c :: acc else acc
   | _ => acc
 
+--def ConstMap.patchUnsafeRec (cs : ConstMap) : ConstMap :=
+--  let unsafes : Batteries.RBSet Name compare := cs.fold (init := .empty)
+--    fun acc n _ => match n with
+--      | .str n "_unsafe_rec" => acc.insert n
+--      | _ => acc
+--  cs.map fun c => match c with
+--    | .opaqueInfo o =>
+--      if unsafes.contains o.name then
+--        .opaqueInfo ⟨
+--          o.toConstantVal, mkConst (o.name ++ `_unsafe_rec),
+--          o.isUnsafe, o.levelParams ⟩
+--      else .opaqueInfo o
+--    | _ => c
+
+def PersistentHashMap.filter [BEq α] [Hashable α]
+    (map : PersistentHashMap α β) (p : α → β → Bool) : PersistentHashMap α β :=
+  map.foldl (init := .empty) fun acc x y =>
+    match p x y with
+    | true => acc.insert x y
+    | false => acc
+
+-- TODO: figure out why map₁ vs map₂ matters here
+def Environment.getConstsAndDelta (env : Environment) : ConstMap × List ConstantInfo :=
+  let constants := env.constants
+  let delta := constants.map₁.filter (fun n _ => !n.isInternal)
+  (constants, delta.toList.map (·.2))
+
+/--
+Sets the directories where `olean` files can be found.
+
+This function must be called before `runFrontend` if the file to be compiled has
+imports (the automatic imports from `Init` also count).
+-/
+
+-- TODO: parse JSON properly
+-- TODO: Get import of Init and Std working
+def setLibsPaths (s: String) : IO Unit := do
+  let out ← IO.Process.output {
+    cmd := "lake"
+    args := #["setup-file", s]
+  }
+  IO.println s!"setup-file {out.stdout}"
+  IO.println s!"setup-file {out.stderr}"
+  let split := out.stdout.splitOn "\"oleanPath\":[" |>.getD 1 ""
+  let split := split.splitOn "],\"loadDynlibPaths\":[" |>.getD 0 ""
+  let paths := split.replace "\"" "" |>.splitOn ","|>.map System.FilePath.mk
+  IO.println s!"paths {paths}"
+  Lean.initSearchPath (← Lean.findSysroot) paths
+
+def runCmd' (cmd : String) (args : Array String) : IO $ Except String String := do
+  let out ← IO.Process.output { cmd := cmd, args := args }
+  return if out.exitCode != 0 then .error out.stderr
+    else .ok out.stdout
+
+def checkToolchain : IO Unit := do
+  match ← runCmd' "lake" #["--version"] with
+  | .error e => throw $ IO.userError e
+  | .ok out =>
+    let version := out.splitOn "(Lean version " |>.get! 1
+    let version := version.splitOn ")" |>.head!
+    let expectedVersion := Lean.versionString
+    if version != expectedVersion then
+      IO.println s!"Warning: expected toolchain '{expectedVersion}' but got '{version}'"
+
+open Elab in
+open System (FilePath) in
+def runFrontend (input : String) (filePath : FilePath) : IO Environment := do
+  checkToolchain
+  let inputCtx := Parser.mkInputContext input filePath.toString
+  let (header, parserState, messages) ← Parser.parseHeader inputCtx
+  let (env, messages) ← processHeader header default messages inputCtx 0
+  let env := env.setMainModule default
+  let commandState := Command.mkState env messages default
+  let s ← IO.processCommands inputCtx parserState commandState
+  let msgs := s.commandState.messages
+  if msgs.hasErrors then
+    throw $ IO.userError $ "\n\n".intercalate $
+      (← msgs.toList.mapM (·.toString)).map String.trim
+  else return s.commandState.env
+
 end Lean
diff --git a/Ix/Cronos.lean b/Ix/Cronos.lean
new file mode 100644
index 00000000..a5dd7c27
--- /dev/null
+++ b/Ix/Cronos.lean
@@ -0,0 +1,28 @@
+import Batteries
+
+open Batteries (RBMap)
+
+structure Cronos where
+  refs : RBMap String Nat compare
+  data : RBMap String Nat compare
+  deriving Inhabited
+
+namespace Cronos
+
+def new : Cronos :=
+  default
+
+def clock (c: Cronos) (tag : String) : IO Cronos := do
+  let now ← IO.monoNanosNow
+  match c.refs.find? tag with
+  | none => return { c with refs := c.refs.insert tag now }
+  | some ref => return {
+    refs := c.refs.insert tag now,
+    data := c.data.insert tag (now - ref) }
+
+def summary (c: Cronos) : String :=
+  let timings := c.data.foldl (init := "")
+    fun acc tag time => s!"{acc}\n  {tag} | {(Float.ofNat time) / 1000000000}s"
+  s!"Timings:{timings}"
+
+end Cronos
diff --git a/ix_test/.github/workflows/lean_action_ci.yml b/ix_test/.github/workflows/lean_action_ci.yml
new file mode 100644
index 00000000..09cd4ca6
--- /dev/null
+++ b/ix_test/.github/workflows/lean_action_ci.yml
@@ -0,0 +1,14 @@
+name: Lean Action CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: leanprover/lean-action@v1
diff --git a/ix_test/.gitignore b/ix_test/.gitignore
new file mode 100644
index 00000000..bfb30ec8
--- /dev/null
+++ b/ix_test/.gitignore
@@ -0,0 +1 @@
+/.lake
diff --git a/ix_test/IxTest.lean b/ix_test/IxTest.lean
new file mode 100644
index 00000000..94be327c
--- /dev/null
+++ b/ix_test/IxTest.lean
@@ -0,0 +1,12 @@
+-- This module serves as the root of the `IxTest` library.
+-- Import modules here that should be built as part of the library.
+import IxTest.Basic
+import Init
+import Std
+
+def id' (A: Type) (x: A) := x
+--def ref (A: Type) (x y: A) := hello
+
+--def one : Nat := 1
+
+
diff --git a/ix_test/IxTest/Basic.lean b/ix_test/IxTest/Basic.lean
new file mode 100644
index 00000000..1d48bfba
--- /dev/null
+++ b/ix_test/IxTest/Basic.lean
@@ -0,0 +1 @@
+def hello (A: Type) (x y : A) : A := x
diff --git a/ix_test/Main.lean b/ix_test/Main.lean
new file mode 100644
index 00000000..1c8c23e9
--- /dev/null
+++ b/ix_test/Main.lean
@@ -0,0 +1,4 @@
+import IxTest
+
+def main : IO Unit :=
+  IO.println s!"Hello, world!"
diff --git a/ix_test/README.md b/ix_test/README.md
new file mode 100644
index 00000000..afd8772b
--- /dev/null
+++ b/ix_test/README.md
@@ -0,0 +1 @@
+# ix_test
\ No newline at end of file
diff --git a/ix_test/lake-manifest.json b/ix_test/lake-manifest.json
new file mode 100644
index 00000000..9a82a6ac
--- /dev/null
+++ b/ix_test/lake-manifest.json
@@ -0,0 +1,5 @@
+{"version": "1.1.0",
+ "packagesDir": ".lake/packages",
+ "packages": [],
+ "name": "ix_test",
+ "lakeDir": ".lake"}
diff --git a/ix_test/lakefile.toml b/ix_test/lakefile.toml
new file mode 100644
index 00000000..ff2fd985
--- /dev/null
+++ b/ix_test/lakefile.toml
@@ -0,0 +1,10 @@
+name = "ix_test"
+version = "0.1.0"
+defaultTargets = ["ix_test"]
+
+[[lean_lib]]
+name = "IxTest"
+
+[[lean_exe]]
+name = "ix_test"
+root = "Main"
diff --git a/ix_test/lean-toolchain b/ix_test/lean-toolchain
new file mode 100644
index 00000000..db29c97c
--- /dev/null
+++ b/ix_test/lean-toolchain
@@ -0,0 +1 @@
+leanprover/lean4:4.17.0

From 8271d540e6c6e5c8318446c742a1150e328537c7 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 17 Mar 2025 10:38:25 -0400
Subject: [PATCH 02/74] make Proof serialize as an Ixon Const

---
 Ix/Ixon/Const.lean | 78 ++++++++++++++++++++++------------------------
 Ix/Ixon/Expr.lean  |  8 +++++
 Ix/Prove.lean      | 16 +++++-----
 Ix/TransportM.lean |  3 ++
 4 files changed, 55 insertions(+), 50 deletions(-)

diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index cf9a85ff..7f9dcece 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -1,4 +1,5 @@
 import Ix.Address
+import Ix.Prove
 import Lean.Declaration
 import Ix.Ixon.Serialize
 import Ix.Ixon.Metadata
@@ -112,48 +113,37 @@ inductive Const where
   -- 0xC4
   | quot : Quotient -> Const
   -- 0xC5
-  --| ctor : Constructor -> Const
-  ---- 0xC6
-  --| recr : Recursor -> Const
-  ---- 0xC7
-  --| indc : Inductive -> Const
-  -- 0xC8
   | ctorProj : ConstructorProj -> Const
-  -- 0xC9
+  -- 0xC6
   | recrProj : RecursorProj -> Const
-  -- 0xCA
+  -- 0xC7
   | indcProj : InductiveProj -> Const
-  -- 0xCB
+  -- 0xC8
   | defnProj : DefinitionProj -> Const
-  -- 0xCC
+  -- 0xC9
   | mutDef : List Definition -> Const
-  -- 0xCD
+  -- 0xCA
   | mutInd : List Inductive -> Const
-  -- 0xCE
+  -- 0xCB
   | meta   : Metadata -> Const
+  -- 0xCC
+  | proof : Proof -> Const
   deriving BEq, Repr, Inhabited
 
-def putDefn (x: Definition) : PutM :=
-  putUInt8 0xC3 *>
-
-  putNatl x.lvls *> putExpr x.type *> putExpr x.value *> putBool x.part
-
 def putConst : Const → PutM
 | .axio x => putUInt8 0xC0 *> putNatl x.lvls *> putExpr x.type
 | .theo x => putUInt8 0xC1 *> putNatl x.lvls *> putExpr x.type *> putExpr x.value
 | .opaq x => putUInt8 0xC2 *> putNatl x.lvls *> putExpr x.type *> putExpr x.value
 | .defn x => putUInt8 0xC3 *> putDefn x
 | .quot x => putUInt8 0xC4 *> putNatl x.lvls *> putExpr x.type *> putQuotKind x.kind
---| .ctor x => putUInt8 0xC5 *> putCtor x
---| .recr x => putUInt8 0xC6 *> putRecr x
---| .indc x => putUInt8 0xC7 *> putIndc x
-| .ctorProj x => putUInt8 0xC8 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.cidx
-| .recrProj x => putUInt8 0xC9 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
-| .indcProj x => putUInt8 0xCA *> putBytes x.block.hash *> putNatl x.idx
-| .defnProj x => putUInt8 0xCB *> putBytes x.block.hash *> putNatl x.idx
-| .mutDef xs => putUInt8 0xCC *> putArray (putDefn <$> xs)
-| .mutInd xs => putUInt8 0xCD *> putArray (putIndc <$> xs)
-| .meta m => putUInt8 0xCE *> putMetadata m
+| .ctorProj x => putUInt8 0xC5 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.cidx
+| .recrProj x => putUInt8 0xC6 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
+| .indcProj x => putUInt8 0xC7 *> putBytes x.block.hash *> putNatl x.idx
+| .defnProj x => putUInt8 0xC8 *> putBytes x.block.hash *> putNatl x.idx
+| .mutDef xs => putUInt8 0xC9 *> putArray (putDefn <$> xs)
+| .mutInd xs => putUInt8 0xCA *> putArray (putIndc <$> xs)
+| .meta m => putUInt8 0xCB *> putMetadata m
+| .proof p => putUInt8 0xCC *> putProof p
   where
     putDefn (x: Definition) :=
       putNatl x.lvls *> putExpr x.type *> putExpr x.value *> putBool x.part
@@ -171,8 +161,9 @@ def putConst : Const → PutM
         *> putNatl x.params *> putNatl x.indices
         *> putArray (putCtor <$> x.ctors) *> putArray (putRecr <$> x.recrs)
         *> putBools [x.recr, x.refl, x.struct, x.unit]
-
-def getDefn : GetM Definition := .mk <$> getNatl <*> getExpr <*> getExpr <*> getBool
+    putProof (p: Proof) : PutM :=
+      putBytes p.inp.hash *> putBytes p.out.hash *> putBytes p.typ.hash
+      *> putByteArray p.bin
 
 def getConst : GetM Const := do
   let tag ← getUInt8
@@ -182,20 +173,22 @@ def getConst : GetM Const := do
   | 0xC2 => .opaq <$> (.mk <$> getNatl <*> getExpr <*> getExpr)
   | 0xC3 => .defn <$> getDefn
   | 0xC4 => .quot <$> (.mk <$> getNatl <*> getExpr <*> getQuotKind)
- -- | 0xC5 => .ctor <$> getCtor
- -- | 0xC6 => .recr <$> getRecr
- -- | 0xC7 => .indc <$> getIndc
-  | 0xC8 => .ctorProj <$> (.mk <$> (.mk <$> getBytes 32) <*> getNatl <*> getNatl)
-  | 0xC9 => .recrProj <$> (.mk <$> (.mk <$> getBytes 32) <*> getNatl <*> getNatl)
-  | 0xCA => .indcProj <$> (.mk <$> (.mk <$> getBytes 32) <*> getNatl)
-  | 0xCB => .defnProj <$> (.mk <$> (.mk <$> getBytes 32) <*> getNatl)
-  | 0xCC => .mutDef <$> getArray getDefn
-  | 0xCD => .mutInd <$> getArray getIndc
-  | 0xCE => .meta <$> getMetadata
+  | 0xC5 => .ctorProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
+  | 0xC6 => .recrProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
+  | 0xC7 => .indcProj <$> (.mk <$> getAddr <*> getNatl)
+  | 0xC8 => .defnProj <$> (.mk <$> getAddr <*> getNatl)
+  | 0xC9 => .mutDef <$> getArray getDefn
+  | 0xCA => .mutInd <$> getArray getIndc
+  | 0xCB => .meta <$> getMetadata
+  | 0xCC => .proof <$> getProof
   | e => throw s!"expected Const tag, got {e}"
   where
-    getCtor := .mk <$> getNatl <*> getExpr <*> getNatl <*> getNatl <*> getNatl
-    getRecrRule := RecursorRule.mk <$> getNatl <*> getExpr
+    getDefn : GetM Definition :=
+      .mk <$> getNatl <*> getExpr <*> getExpr <*> getBool
+    getCtor : GetM Constructor :=
+      .mk <$> getNatl <*> getExpr <*> getNatl <*> getNatl <*> getNatl
+    getRecrRule : GetM RecursorRule := 
+      RecursorRule.mk <$> getNatl <*> getExpr
     getRecr : GetM Recursor := do
       let f ← Recursor.mk <$> getNatl <*> getExpr <*> getNatl
         <*> getNatl <*> getNatl <*> getNatl <*> getArray getRecrRule
@@ -208,6 +201,9 @@ def getConst : GetM Const := do
       match ← getBools 4 with
       | [w, x, y, z] => return f w x y z
       | _ => throw s!"unreachable"
+    getAddr : GetM Address := .mk <$> getBytes 32
+    getProof : GetM Proof :=
+      .mk <$> getAddr <*> getAddr <*> getAddr <*> getByteArray
 
 instance : Serialize Const where
   put := runPut ∘ putConst
diff --git a/Ix/Ixon/Expr.lean b/Ix/Ixon/Expr.lean
index cfb93c11..e5a1464a 100644
--- a/Ix/Ixon/Expr.lean
+++ b/Ix/Ixon/Expr.lean
@@ -136,6 +136,10 @@ def putArray (xs : List PutM) := do
   putExprTag 0xB (UInt64.ofNat xs.length)
   List.forM xs id
 
+def putByteArray (x: ByteArray) := do
+  putExprTag 0xB (UInt64.ofNat x.size)
+  x.toList.forM putUInt8
+
 def getArray (getM: GetM A) : GetM (List A) := do
   let tagByte ← getUInt8
   let tag := UInt8.shiftRight tagByte 4
@@ -147,6 +151,10 @@ def getArray (getM: GetM A) : GetM (List A) := do
     List.mapM (λ _ => getM) (List.range len) 
   | e => throw s!"expected Array with tag 0xB, got {e}"
 
+def getByteArray : GetM ByteArray := do
+  let xs <- getArray getUInt8
+  return ⟨xs.toArray⟩
+
 
 def putOption (putM: A -> PutM): Option A → PutM
 | .none => putArray []
diff --git a/Ix/Prove.lean b/Ix/Prove.lean
index 72ef3a8c..1ceb24d3 100644
--- a/Ix/Prove.lean
+++ b/Ix/Prove.lean
@@ -1,5 +1,6 @@
 import Ix.Address
 import Ix.Ixon.Serialize
+import Ix.Common
 
 inductive ProveError
   | todo
@@ -14,16 +15,13 @@ structure Proof where
   typ : Address
   /-- Bytes of the Binius proof -/
   bin : ByteArray
-  deriving Inhabited
+  deriving Inhabited, BEq
 
-instance : Ixon.Serialize Proof where
-  put proof := proof.inp.hash ++ proof.out.hash ++ proof.typ.hash ++ proof.bin
-  get bytes :=
-    let inpBytes := bytes.extract 0 32
-    let outBytes := bytes.extract 32 64
-    let typBytes := bytes.extract 64 96
-    let binBytes := bytes.extract 96 bytes.size
-    .ok ⟨⟨inpBytes⟩, ⟨outBytes⟩, ⟨typBytes⟩, binBytes⟩
+instance : ToString Proof where
+  toString p := s!"<#{p.inp} ~> #{p.out} : #{p.typ}>"
+
+instance : Repr Proof where
+  reprPrec p _ := toString p
 
 def prove (_hash : Address) : ProveM Proof :=
   default -- TODO
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index ab2ecc16..000ef2df 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -8,6 +8,7 @@ import Ix.Common
 import Ix.Address
 import Ix.Ixon.Metadata
 import Ix.Ixon.Serialize
+import Ix.Prove
 import Batteries.Data.RBMap
 
 namespace Ix.TransportM
@@ -25,6 +26,7 @@ inductive TransportError
   | unknownIndex (idx: Nat) (m: Ixon.Metadata)
   | unexpectedNode (idx: Nat) (m: Ixon.Metadata)
   | rawMetadata (m: Ixon.Metadata)
+  | rawProof (m: Proof)
   deriving Repr
 
 abbrev DematM := EStateM TransportError DematState
@@ -279,6 +281,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
 | .mutDef xs => .mutDefBlock <$> (xs.mapM rematDefn)
 | .mutInd xs => .mutIndBlock <$> (xs.mapM rematInd)
 | .meta m => throw (.rawMetadata m)
+| .proof p => throw (.rawProof p)
   where
     rematDefn : Ixon.Definition -> RematM Ix.Definition
     | x => .mk x.lvls <$> rematExpr x.type <*> rematExpr x.value <*> pure x.part

From d34dc40cae7bce75c7dc8e842ecb1ec6a1f1d48f Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 17 Mar 2025 11:31:08 -0400
Subject: [PATCH 03/74] broken: connect canonicalizer to Ix.Meta

---
 Ix/BuiltIn.lean    | 12 ++++-----
 Ix/CanonM.lean     | 64 +++++++++++++++++++++++++++-------------------
 Ix/Meta.lean       | 14 +++++++---
 Ix/TransportM.lean |  1 +
 lakefile.lean      |  1 +
 5 files changed, 56 insertions(+), 36 deletions(-)

diff --git a/Ix/BuiltIn.lean b/Ix/BuiltIn.lean
index bad427c9..c52bb803 100644
--- a/Ix/BuiltIn.lean
+++ b/Ix/BuiltIn.lean
@@ -20,9 +20,9 @@ opaque secret (comm : Commitment α) : Address
 opaque reveal [Inhabited α] (comm : Commitment α) : α
 opaque revealThen [Inhabited β] (comm : Commitment α) (f : β) : β
 
-def commitIO (secret : Address) (payload : α) : IO $ Commitment α :=
-  let payloadAdr := ix_adr payload
-  let bytes := secret.hash ++ payloadAdr.hash
-  let commAdr := Blake3.hash bytes
-  -- TODO: persist commitment preimages as private data
-  return ⟨⟨commAdr.val⟩⟩
+--def commitIO (secret : Address) (payload : α) : IO $ Commitment α :=
+--  let payloadAdr := ix_adr payload
+--  let bytes := secret.hash ++ payloadAdr.hash
+--  let commAdr := Blake3.hash bytes
+--  -- TODO: persist commitment preimages as private data
+--  return ⟨⟨commAdr.val⟩⟩
diff --git a/Ix/CanonM.lean b/Ix/CanonM.lean
index 5cbbc5f8..8bbb2f81 100644
--- a/Ix/CanonM.lean
+++ b/Ix/CanonM.lean
@@ -33,7 +33,7 @@ instance : ToString CanonMError where toString
   | .unfilledExprMetavariable e => s!"Unfilled level metavariable on expression '{e}'"
   | .invalidBVarIndex idx => s!"Invalid index {idx} for bound variable context"
   | .freeVariableExpr e => s!"Free variable in expression '{e}'"
-  | .metaVariableExpr e => s!"Meta variable in expression '{e}'"
+  | .metaVariableExpr e => s!"Metavariable in expression '{e}'"
   | .metaDataExpr e => s!"Meta data in expression '{e}'"
   | .levelNotFound n ns => s!"'{n}' not found in '{ns}'"
   | .invalidConstantKind n ex gt =>
@@ -81,7 +81,7 @@ def withRecrs (recrCtx : RBMap Lean.Name Nat compare) :
 def withLevels (lvls : List Lean.Name) : CanonM α → CanonM α :=
   withReader $ fun c => { c with univCtx := lvls }
 
-def commit (const : Ix.Const) : CanonM (Address × Address) := do
+def commitConst (const : Ix.Const) : CanonM (Address × Address) := do
   match (← get).commits.find? const with
   | some (contAddr, metaAddr) => pure (contAddr, metaAddr)
   | none => do
@@ -198,14 +198,14 @@ partial def canonConst (const : Lean.ConstantInfo) : CanonM (Address × Address)
             ← withRecrs recrs $ canonExpr val.value⟩
         | .quotInfo val =>
           pure $ .quotient ⟨val.levelParams.length, ← canonExpr val.type, val.kind⟩
-      let (constAddr, metaAddr) ← commit obj
+      let (constAddr, metaAddr) ← commitConst obj
       addConstToStt const.name constAddr metaAddr
       return (constAddr, metaAddr)
 
 partial def canonDefinition (struct : Lean.DefinitionVal) : CanonM (Address × Address):= do
   -- If the mutual size is one, simply content address the single definition
   if struct.all matches [_] then
-    let (constAddr, metaAddr) ← commit $ .definition
+    let (constAddr, metaAddr) ← commitConst $ .definition
       (← withRecrs (.single struct.name 0) $ definitionToIR struct)
     addConstToStt struct.name constAddr metaAddr
     return (constAddr, metaAddr)
@@ -228,7 +228,7 @@ partial def canonDefinition (struct : Lean.DefinitionVal) : CanonM (Address × A
   -- Building and storing the block
   let definitionsIr := (definitions.map (match ·.head? with
     | some d => [d] | none => [])).flatten
-  let (blockContAddr, blockMetaAddr) ← commit $ .mutDefBlock definitionsIr
+  let (blockContAddr, blockMetaAddr) ← commitConst $ .mutDefBlock definitionsIr
   addBlockToStt blockContAddr blockMetaAddr
 
   -- While iterating on the definitions from the mutual block, we need to track
@@ -240,7 +240,7 @@ partial def canonDefinition (struct : Lean.DefinitionVal) : CanonM (Address × A
     -- Also adds the constant to the array of constants
     let some idx := recrCtx.find? name | throw $ .cantFindMutDefIndex name
     let (constAddr, metaAddr) ←
-      commit $ .definitionProj ⟨blockContAddr, blockMetaAddr, idx⟩
+      commitConst $ .definitionProj ⟨blockContAddr, blockMetaAddr, idx⟩
     addConstToStt name constAddr metaAddr
     if struct.name == name then ret? := some (constAddr, metaAddr)
 
@@ -290,7 +290,7 @@ partial def canonInductive (initInd : Lean.InductiveVal) : CanonM (Address × Ad
   let irInds ← initInd.all.mapM fun name => do match ← getLeanConstant name with
     | .inductInfo ind => withRecrs recrCtx do pure $ (← inductiveToIR ind)
     | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
-  let (blockContAddr, blockMetaAddr) ← commit $ .mutIndBlock irInds
+  let (blockContAddr, blockMetaAddr) ← commitConst $ .mutIndBlock irInds
   addBlockToStt blockContAddr blockMetaAddr
 
   -- While iterating on the inductives from the mutual block, we need to track
@@ -300,7 +300,7 @@ partial def canonInductive (initInd : Lean.InductiveVal) : CanonM (Address × Ad
     -- Store and cache inductive projections
     let name := indName
     let (constAddr, metaAddr) ←
-      commit $ .inductiveProj ⟨blockContAddr, blockMetaAddr, indIdx⟩
+      commitConst $ .inductiveProj ⟨blockContAddr, blockMetaAddr, indIdx⟩
     addConstToStt name constAddr metaAddr
     if name == initInd.name then ret? := some (constAddr, metaAddr)
 
@@ -310,13 +310,13 @@ partial def canonInductive (initInd : Lean.InductiveVal) : CanonM (Address × Ad
     for (ctorName, ctorIdx) in ctors.zipIdx do
       -- Store and cache constructor projections
       let (constAddr, metaAddr) ←
-        commit $ .constructorProj ⟨blockContAddr, blockMetaAddr, indIdx, ctorIdx⟩
+        commitConst $ .constructorProj ⟨blockContAddr, blockMetaAddr, indIdx, ctorIdx⟩
       addConstToStt ctorName constAddr metaAddr
 
     for (recrName, recrIdx) in recrs.zipIdx do
       -- Store and cache recursor projections
       let (constAddr, metaAddr) ←
-        commit $ .recursorProj ⟨blockContAddr, blockMetaAddr, indIdx, recrIdx⟩
+        commitConst $ .recursorProj ⟨blockContAddr, blockMetaAddr, indIdx, recrIdx⟩
       addConstToStt recrName constAddr metaAddr
 
   match ret? with
@@ -336,7 +336,9 @@ partial def inductiveToIR (ind : Lean.InductiveVal) : CanonM Ix.Inductive := do
           let thisRec ← externalRecToIR r
           pure (thisRec :: recs, ctors)
       | _ => throw $ .nonRecursorExtractedFromChildren r.name
-  let (struct, unit) ← if ind.isRec || ind.numIndices != 0 then pure (false, false) else
+  let (struct, unit) ← if ind.isRec || ind.numIndices != 0 
+  then pure (false, false)
+  else
     match ctors with
     -- Structures can only have one constructor
     | [ctor] => pure (true, ctor.fields == 0)
@@ -550,22 +552,30 @@ partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
 
 end
 
-/-- Iterates over a list of `Lean.ConstantInfo`, triggering their content-addressing -/
-def canonDelta (delta : List Lean.ConstantInfo) : CanonM Unit := do
-  delta.forM fun c => if !c.isUnsafe then discard $ canonConst c else pure ()
-
-/--
-Content-addresses the "delta" of an environment, that is, the content that is
-added on top of the imports.
-
-Important: constants with open references in their expressions are filtered out.
-Open references are variables that point to names which aren't present in the
-`Lean.ConstMap`.
--/
-def canon (constMap : Lean.ConstMap) (delta : List Lean.ConstantInfo)
-  : IO $ Except CanonMError CanonMState := do
-  match ← StateT.run (ReaderT.run (canonDelta delta) (.init constMap)) CanonMState.init with
-  | (.ok _, stt) => return .ok stt
+--/-- Iterates over a list of `Lean.ConstantInfo`, triggering their content-addressing -/
+--def canonDelta (delta : List Lean.ConstantInfo) : CanonM Unit := do
+--  delta.forM fun c => if !c.isUnsafe then discard $ canonConst c else pure ()
+
+--/--
+--Content-addresses the "delta" of an environment, that is, the content that is
+--added on top of the imports.
+--
+--Important: constants with open references in their expressions are filtered out.
+--Open references are variables that point to names which aren't present in the
+--`Lean.ConstMap`.
+---/
+--def canon (constMap : Lean.ConstMap) (delta : List Lean.ConstantInfo)
+--  : IO $ Except CanonMError CanonMState := do
+--  match ← StateT.run (ReaderT.run (canonDelta delta) (.init constMap)) CanonMState.init with
+--  | (.ok _, stt) => return .ok stt
+--  | (.error e, _) => return .error e
+
+def canonicalize (constMap : Lean.ConstMap) (const: Lean.ConstantInfo)
+  : IO $ Except CanonMError Address := do
+  let canon <-
+    StateT.run (ReaderT.run (canonConst const) (.init constMap)) CanonMState.init
+  match canon with
+  | (.ok (a, _), _) => return .ok a
   | (.error e, _) => return .error e
 
 end Ix.CanonM
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index f40586db..9d9ee005 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -1,15 +1,17 @@
 import Lean
 import Ix.Address
+import Ix.CanonM
 
 open Lean
 
-def computeIxAddress (_const : ConstantInfo) (_constMap: ConstMap) : Address :=
-  default -- TODO
+def computeIxAddress (const : ConstantInfo) (constMap: ConstMap) : IO Address := do
+  IO.ofExcept (<- Ix.CanonM.canonicalize constMap const)
 
 /-- Computes the Ix address of an anonymous definition whose value is provided as input -/
 elab "ix_adr" stx:term : term => do
   let value ← Elab.Term.elabTerm stx none >>= instantiateExprMVars
   Meta.check value
+--  let type ← Meta.inferType value >>= instantiateExprMVars
   let type ← Meta.inferType value
   let const := .defnInfo {
     name        := .anonymous
@@ -19,4 +21,10 @@ elab "ix_adr" stx:term : term => do
     hints       := .opaque
     safety      := .safe
   }
-  return toExpr $ computeIxAddress const (← getEnv).constants
+  IO.println s!"{type}"
+  let adr <- computeIxAddress const (← getEnv).constants
+  return toExpr $ adr
+
+def id' (A: Type) (x: A) := x
+
+--#eval (ix_adr id')
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index 000ef2df..203309c0 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -281,6 +281,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
 | .mutDef xs => .mutDefBlock <$> (xs.mapM rematDefn)
 | .mutInd xs => .mutIndBlock <$> (xs.mapM rematInd)
 | .meta m => throw (.rawMetadata m)
+-- TODO: This could return a Proof inductive, since proofs have no metadata
 | .proof p => throw (.rawProof p)
   where
     rematDefn : Ixon.Definition -> RematM Ix.Definition
diff --git a/lakefile.lean b/lakefile.lean
index 43039434..fbc76204 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -9,6 +9,7 @@ lean_lib Ix
 
 lean_exe ix where
   root := `Main
+  supportInterpreter := true
 
 require LSpec from git
   "https://github.com/argumentcomputer/LSpec" @ "0f9008e70927c4afac8ad2bc32f2f4fbda044096"

From 4b3cfbea5b38a21facd6cf7462247a01f8a15690 Mon Sep 17 00:00:00 2001
From: Samuel Burnham <45365069+samuelburnham@users.noreply.github.com>
Date: Tue, 18 Mar 2025 10:11:27 -0400
Subject: [PATCH 04/74] fix: Nix devShell & light refactor (#55)

---
 .github/workflows/nix.yml |  9 ++++++---
 Ix/Cli/HashCmd.lean       | 20 ++++++++++----------
 flake.nix                 | 25 +++++++++----------------
 ix.nix                    | 38 ++++++++++++++++++++++++++------------
 ix_test/IxTest.lean       |  4 +---
 5 files changed, 52 insertions(+), 44 deletions(-)

diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml
index 50acb80f..cfb6a91e 100644
--- a/.github/workflows/nix.yml
+++ b/.github/workflows/nix.yml
@@ -38,6 +38,9 @@ jobs:
         with:
           nix_path: nixpkgs=channel:nixos-unstable
           github_access_token: ${{ secrets.GITHUB_TOKEN }}
-      # Installs `elan` and `lake` via Nix, which then downloads the Lean toolchain binary
-      # from https://github.com/leanprover/lean4/releases
-      - run: nix develop .#ci --command bash -c "lake build && lake test"
+      - uses: cachix/cachix-action@v15
+        with:
+          name: argumentcomputer
+          authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+      # Builds and runs tests using Lake as a Nix package
+      - run: nix develop --command bash -c "lake build && lake test"
diff --git a/Ix/Cli/HashCmd.lean b/Ix/Cli/HashCmd.lean
index e941c011..31c784a3 100644
--- a/Ix/Cli/HashCmd.lean
+++ b/Ix/Cli/HashCmd.lean
@@ -23,17 +23,17 @@ def runHash (p : Cli.Parsed) : IO UInt32 := do
      IO.println <| s!"constant'' {x.name}"
   --cronos ← cronos.clock "Run Lean frontend"
 
-  IO.println <| "content-address"
-  -- Start content-addressing
-  cronos ← cronos.clock "Content-address"
-  let stt ← match ← Ix.CanonM.canon constMap delta with
-    | .error err => IO.eprintln err; return 1
-    | .ok stt => pure stt
-  cronos ← cronos.clock "Content-address"
-  stt.store.forM fun adr _ => do
-     IO.println <| s!"{adr}"
+ -- IO.println <| "content-address"
+ -- -- Start content-addressing
+ -- cronos ← cronos.clock "Content-address"
+ -- let stt ← match ← Ix.CanonM.canon constMap delta with
+ --   | .error err => IO.eprintln err; return 1
+ --   | .ok stt => pure stt
+ -- cronos ← cronos.clock "Content-address"
+ -- stt.store.forM fun adr _ => do
+ --    IO.println <| s!"{adr}"
 
-  IO.println cronos.summary
+ -- IO.println cronos.summary
   return 0
 
 def hashCmd : Cli.Cmd := `[Cli|
diff --git a/flake.nix b/flake.nix
index c382c58a..7822f90b 100644
--- a/flake.nix
+++ b/flake.nix
@@ -45,15 +45,6 @@
       perSystem = { system, pkgs, ... }:
       let
         lib = (import ./ix.nix { inherit system pkgs fenix crane lean4-nix blake3-lean; }).lib;
-
-        devShellPkgs = with pkgs; [
-          pkg-config
-          openssl
-          ocl-icd
-          gcc
-          clang
-          lib.rustToolchain
-        ];
       in {
         # Lean overlay
         _module.args.pkgs = import nixpkgs {
@@ -68,15 +59,17 @@
 
         # Provide a unified dev shell with Lean + Rust
         devShells.default = pkgs.mkShell {
-          packages = with pkgs; devShellPkgs ++ [
+          LEAN_SYSROOT="${pkgs.lean.lean-all}";
+          packages = with pkgs; [
+            pkg-config
+            openssl
+            ocl-icd
+            gcc
+            clang
+            lib.rustToolchain
+            rust-analyzer
             lean.lean         # Lean compiler
             lean.lean-all     # Includes Lake, stdlib, etc.
-            pkgs.rust-analyzer
-          ];
-        };
-        devShells.ci = pkgs.mkShell {
-          packages = with pkgs; devShellPkgs ++ [
-            elan
           ];
         };
       };
diff --git a/ix.nix b/ix.nix
index 6cef6aa5..4c4a10c6 100644
--- a/ix.nix
+++ b/ix.nix
@@ -28,23 +28,37 @@ let
   });
 
   # C Package
-  cPkg = pkgs.stdenv.mkDerivation {
+  cPkg = let
+    # Function to get all files in `./c` ending with given extension
+    getFiles = ext: builtins.filter (file: builtins.match (".*" + ext) file != null) (builtins.attrNames (builtins.readDir "${toString ./c}"));
+    # Gets all C files in `./c`, without the extension
+    cFiles = let ext = ".c"; in builtins.map (file: builtins.replaceStrings [ext] [""] file) (getFiles ext);
+    # Creates `gcc -c` command for each C file
+    buildCmd = builtins.map (file: "gcc -Wall -Werror -Wextra -c ${file}.c -o ${file}.o") cFiles;
+    # Final `buildPhase` instructions
+    buildSteps = buildCmd ++
+    [
+      "ar rcs libix_c.a ${builtins.concatStringsSep " " (builtins.map (file: "-o ${file}.o") cFiles)}"
+    ];
+    # Gets all header files in `./c`
+    hFiles = getFiles ".h";
+    # Final `installPhase` instructions
+    installSteps =
+    [
+      "mkdir -p $out/lib $out/include"
+      "cp libix_c.a $out/lib/"
+      "cp ${builtins.concatStringsSep " " hFiles} $out/include/"
+    ];
+  in
+  pkgs.stdenv.mkDerivation {
     pname = "ix_c";
     version = "0.1.0";
     src = ./c;
     buildInputs = [ pkgs.gcc pkgs.lean.lean-all rustPkg ];
-    # Builds the C file
-    buildPhase = ''
-      gcc -Wall -Werror -Wextra -c binius.c -o binius.o
-      gcc -Wall -Werror -Wextra -c unsigned.c -o unsigned.o
-      ar rcs libix_c.a binius.o unsigned.o
-    '';
+    # Builds the C files
+    buildPhase = builtins.concatStringsSep "\n" buildSteps;
     # Installs the library files
-    installPhase = ''
-      mkdir -p $out/lib $out/include
-      cp libix_c.a $out/lib/
-      cp rust.h linear.h common.h $out/include/
-    '';
+    installPhase = builtins.concatStringsSep "\n" installSteps;
   };
 
   # Blake3.lean C FFI dependency, needed for explicit static lib linking
diff --git a/ix_test/IxTest.lean b/ix_test/IxTest.lean
index 94be327c..795208bd 100644
--- a/ix_test/IxTest.lean
+++ b/ix_test/IxTest.lean
@@ -7,6 +7,4 @@ import Std
 def id' (A: Type) (x: A) := x
 --def ref (A: Type) (x y: A) := hello
 
---def one : Nat := 1
-
-
+def one : Nat := 1

From 5938727aa3bc3191c3495ee0c982031842d3bf18 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 25 Mar 2025 19:45:32 -0400
Subject: [PATCH 05/74] ix store cli command

---
 Ix/Address.lean      | 93 +++++++++++++++++++++++++++++++++++---------
 Ix/BuiltIn.lean      |  2 +-
 Ix/Cli/StoreCmd.lean | 46 ++++++++++++++++++++++
 Ix/Cli/TestCmd.lean  | 10 ++---
 Ix/Store.lean        |  8 +---
 Main.lean            |  4 +-
 lake-manifest.json   |  4 +-
 lakefile.lean        |  2 +-
 8 files changed, 135 insertions(+), 34 deletions(-)
 create mode 100644 Ix/Cli/StoreCmd.lean

diff --git a/Ix/Address.lean b/Ix/Address.lean
index 147bacf5..eff4134a 100644
--- a/Ix/Address.lean
+++ b/Ix/Address.lean
@@ -9,30 +9,64 @@ structure Address where
   hash : ByteArray
   deriving Inhabited, Lean.ToExpr, BEq, Hashable
 
-def Address.ofChars (_adrChars : List Char) : Option Address :=
-  some default -- TODO
-
-def Address.ofString (adrStr: String) : Option Address :=
-  Address.ofChars adrStr.data
-
 def Address.blake3 (x: ByteArray) : Address := ⟨(Blake3.hash x).val⟩
 
-open Lean
+def hexOfNat : Nat -> Option Char
+| 0 => .some '0'
+| 1 => .some '1'
+| 2 => .some '2'
+| 3 => .some '3'
+| 4 => .some '4'
+| 5 => .some '5'
+| 6 => .some '6'
+| 7 => .some '7'
+| 8 => .some '8'
+| 9 => .some '9'
+| 10 => .some 'a'
+| 11 => .some 'b'
+| 12 => .some 'c'
+| 13 => .some 'd'
+| 14 => .some 'e'
+| 15 => .some 'f'
+|  _ => .none
 
-/-- Convert a byte (UInt8) to a two‐digit hex string. -/
-def byteToHex (b : UInt8) : String :=
-  let hexDigits := 
-    #['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
-  let hi := hexDigits.get! (UInt8.toNat (b >>> 4))
-  let lo := hexDigits.get! (UInt8.toNat (b &&& 0xF))
-  String.mk [hi, lo]
+def natOfHex : Char -> Option Nat
+| '0' => .some 0
+| '1' => .some 1
+| '2' => .some 2
+| '3' => .some 3
+| '4' => .some 4
+| '5' => .some 5
+| '6' => .some 6
+| '7' => .some 7
+| '8' => .some 8
+| '9' => .some 9
+| 'a' => .some 10
+| 'b' => .some 11
+| 'c' => .some 12
+| 'd' => .some 13
+| 'e' => .some 14
+| 'f' => .some 15
+| 'A' => .some 10
+| 'B' => .some 11
+| 'C' => .some 12
+| 'D' => .some 13
+| 'E' => .some 14
+| 'F' => .some 15
+|  _ => .none
 
-/-- Convert a ByteArray to a hexadecimal string. -/
-def byteArrayToHex (ba : ByteArray) : String :=
-  (ba.toList.map byteToHex).foldl (· ++ ·) ""
+/-- Convert a byte (UInt8) to a two‐digit big-endian hexadecimal string. -/
+def hexOfByte (b : UInt8) : String :=
+  let hi := hexOfNat (UInt8.toNat (b >>> 4))
+  let lo := hexOfNat (UInt8.toNat (b &&& 0xF))
+  String.mk [hi.get!, lo.get!]
+
+/-- Convert a ByteArray to a big-endian hexadecimal string. -/
+def hexOfBytes (ba : ByteArray) : String :=
+  (ba.toList.map hexOfByte).foldl (· ++ ·) ""
 
 instance : ToString Address where
-  toString adr := byteArrayToHex adr.hash
+  toString adr := hexOfBytes adr.hash
 
 instance : Repr Address where
   reprPrec a _ := "#" ++ (toString a).toFormat
@@ -40,3 +74,26 @@ instance : Repr Address where
 instance : Ord Address where
   compare a b := compare a.hash.data.toList b.hash.data.toList
 
+def byteOfHex : Char -> Char -> Option UInt8
+| hi, lo => do
+  let hi <- natOfHex hi
+  let lo <- natOfHex lo
+  UInt8.ofNat (hi <<< 4 + lo)
+
+def bytesOfHex (s: String) : Option ByteArray := do
+  let bs <- go s.toList
+  return ⟨bs.toArray⟩
+  where
+    go : List Char -> Option (List UInt8)
+    | hi::lo::rest => do
+      let b <- byteOfHex hi lo
+      let bs <- go rest
+      b :: bs
+    | [] => return []
+    | _ => .none
+
+def Address.fromString (s: String) : Option Address := do
+  let ba <- bytesOfHex s
+  if ba.size == 32 then .some ⟨ba⟩ else .none
+
+
diff --git a/Ix/BuiltIn.lean b/Ix/BuiltIn.lean
index aec6596f..e5de36b2 100644
--- a/Ix/BuiltIn.lean
+++ b/Ix/BuiltIn.lean
@@ -11,7 +11,7 @@ instance : ToString (Commitment α) where
 
 def Commitment.ofString (s : String) : Option $ Commitment α :=
   match s.data with
-  | 'c' :: adrChars => .mk <$> Address.ofChars adrChars
+  | 'c' :: adrChars => .mk <$> Address.fromString ⟨adrChars⟩
   | _ => none
 
 -- TODO: secrets should be 32-bytes long
diff --git a/Ix/Cli/StoreCmd.lean b/Ix/Cli/StoreCmd.lean
new file mode 100644
index 00000000..f883bf66
--- /dev/null
+++ b/Ix/Cli/StoreCmd.lean
@@ -0,0 +1,46 @@
+import Cli
+import Ix.Cronos
+import Ix.Common
+import Ix.CanonM
+import Ix.Store
+import Ix.Address
+import Lean
+
+-- ix store <lean file>
+-- ix store get <address>
+
+def runStore (p : Cli.Parsed) : IO UInt32 := do
+  return 0
+
+def runGet (p : Cli.Parsed) : IO UInt32 := do
+  let input : String       := p.positionalArg! "input" |>.as! String
+  IO.println <| "Input: " ++ input
+  let address : Address <- IO.ofExcept $
+    match Address.fromString input with
+    | .some a => .ok a
+    | .none => .error "bad address"
+  let const <- EIO.toIO storeErrorToIOError (readConst address)
+  IO.println <| s!"{repr const}"
+  return 0
+
+def storeGetCmd : Cli.Cmd := `[Cli|
+  get VIA runGet;
+  "print a store entry"
+  ARGS:
+    input  : String; "Source file input"
+]
+
+def storeCmd : Cli.Cmd := `[Cli|
+  store VIA runStore;
+  "Interact with the Ix store"
+
+  FLAGS:
+    e, "example"   : String; "Example flag"
+
+  ARGS:
+input  : String; "Source file input"
+
+  SUBCOMMANDS:
+    storeGetCmd
+]
+
diff --git a/Ix/Cli/TestCmd.lean b/Ix/Cli/TestCmd.lean
index 33b3f1f3..c4afd81b 100644
--- a/Ix/Cli/TestCmd.lean
+++ b/Ix/Cli/TestCmd.lean
@@ -13,22 +13,22 @@ def runTest (p : Cli.Parsed) : IO UInt32 := do
   let input   : String       := p.positionalArg! "input" |>.as! String
   IO.println s!"Input: {input}"
   let inputBA := input.toUTF8
-  IO.println s!"Input UTF8: {byteArrayToHex inputBA}"
+  IO.println s!"Input UTF8: {hexOfBytes inputBA}"
   let const : Ixon.Const := .defn
     { lvls := 0, type := .strl "BAD", value := .strl input, part := .true}
   IO.println s!"Const: {repr const}"
   let bytes := Ixon.Serialize.put const
-  IO.println s!"Bytes: {byteArrayToHex bytes}"
+  IO.println s!"Bytes: {hexOfBytes bytes}"
   let addr := Address.blake3 bytes
-  IO.println s!"Address: {byteArrayToHex addr.hash}"
+  IO.println s!"Address: {hexOfBytes addr.hash}"
   let home ← EIO.toIO storeErrorToIOError getHomeDir
   IO.println s!"HOME at {home}"
   let store ← EIO.toIO storeErrorToIOError storeDir
   IO.println s!"Store at {store}"
   EIO.toIO storeErrorToIOError ensureStoreDir
-  IO.println s!"write entry at {store / (byteArrayToHex addr.hash)}"
+  IO.println s!"write entry at {store / (hexOfBytes addr.hash)}"
   EIO.toIO storeErrorToIOError (writeConst const)
-  IO.println s!"read entry at {store / (byteArrayToHex addr.hash)}"
+  IO.println s!"read entry at {store / (hexOfBytes addr.hash)}"
   let const' ← EIO.toIO storeErrorToIOError (readConst addr)
   IO.println s!"Const': {repr const'}"
   IO.println s!"matching {const == const'}"
diff --git a/Ix/Store.lean b/Ix/Store.lean
index 60b70302..fea70f4a 100644
--- a/Ix/Store.lean
+++ b/Ix/Store.lean
@@ -1,7 +1,3 @@
-
---
--- ix/store/f942e5170f2493c9bd65471871d0d0ce89097c08c42b73a108515eab1ff4dc48
-
 import Ix.Address
 import Ix.Ixon
 import Ix.Ixon.Serialize
@@ -44,12 +40,12 @@ def writeConst (x: Ixon.Const) : StoreIO Unit := do
   let bytes := Ixon.Serialize.put x
   let addr  := Address.blake3 bytes
   let store ← storeDir
-  let path := store / byteArrayToHex addr.hash
+  let path := store / hexOfBytes addr.hash
   IO.toEIO .ioError (IO.FS.writeBinFile path bytes)
 
 def readConst (a: Address) : StoreIO Ixon.Const := do
   let store ← storeDir
-  let path := store / byteArrayToHex a.hash
+  let path := store / hexOfBytes a.hash
   let bytes ← IO.toEIO .ioError (IO.FS.readBinFile path)
   match Ixon.Serialize.get bytes with
   | .ok c => return c
diff --git a/Main.lean b/Main.lean
index dd6b3b93..b014999f 100644
--- a/Main.lean
+++ b/Main.lean
@@ -1,6 +1,7 @@
 import Ix.Cli.ProveCmd
 import Ix.Cli.HashCmd
 import Ix.Cli.TestCmd
+import Ix.Cli.StoreCmd
 import Ix
 
 def VERSION : String :=
@@ -13,7 +14,8 @@ def ixCmd : Cli.Cmd := `[Cli|
   SUBCOMMANDS:
     proveCmd;
     hashCmd;
-    testCmd
+    testCmd;
+    storeCmd
 ]
 
 def main (args : List String) : IO UInt32 := do
diff --git a/lake-manifest.json b/lake-manifest.json
index f77db27a..b91a07c1 100644
--- a/lake-manifest.json
+++ b/lake-manifest.json
@@ -25,10 +25,10 @@
    "type": "git",
    "subDir": null,
    "scope": "",
-   "rev": "b996cd9f48f44a1522530859d84622bb69df79df",
+   "rev": "a5478a88f4e67c87904faa99882c5d2cec86cf8e",
    "name": "Blake3",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "b996cd9f48f44a1522530859d84622bb69df79df",
+   "inputRev": "a5478a88f4e67c87904faa99882c5d2cec86cf8e",
    "inherited": false,
    "configFile": "lakefile.lean"},
   {"url": "https://github.com/argumentcomputer/LSpec",
diff --git a/lakefile.lean b/lakefile.lean
index 3219a9da..a2eda207 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -15,7 +15,7 @@ require LSpec from git
   "https://github.com/argumentcomputer/LSpec" @ "0f9008e70927c4afac8ad2bc32f2f4fbda044096"
 
 require Blake3 from git
-  "https://github.com/argumentcomputer/Blake3.lean" @ "b996cd9f48f44a1522530859d84622bb69df79df"
+  "https://github.com/argumentcomputer/Blake3.lean" @ "a5478a88f4e67c87904faa99882c5d2cec86cf8e"
 
 require Cli from git
   "https://github.com/leanprover/lean4-cli" @ "e7fd1a415c80985ade02a021172834ca2139b0ca"

From 52431bf9e2a887489c67ebc70df9232d76302909 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 28 Mar 2025 15:25:50 -0400
Subject: [PATCH 06/74] WIP: store command and new IxM structure

---
 Ix.lean                           |   1 +
 Ix/CanonM.lean                    |  45 ++++----
 Ix/Cli/HashCmd.lean               |  96 ++++++++--------
 Ix/Cli/StoreCmd.lean              |  41 ++++++-
 Ix/Cli/TestCmd.lean               |  10 +-
 Ix/Common.lean                    |  12 +-
 Ix/IxM.lean                       | 174 +++++++++++++++++++++++++++++
 Ix/Ixon/Const.lean                |  18 ++-
 Ix/Meta.lean                      |   2 +-
 Ix/Prove.lean                     |  13 ++-
 Ix/Store.lean                     |   8 +-
 Ix/TransportM.lean                |   2 +
 Main.lean                         |   2 -
 Tests/Ix/Canon.lean               | 107 ++++++++++++++++++
 Tests/Ix/Fixtures.lean            | 176 ++++++++++++++++++++++++++++++
 Tests/Ix/Fixtures/Export.lean     |   3 +
 Tests/Ix/Fixtures/Inductives.lean |   0
 17 files changed, 617 insertions(+), 93 deletions(-)
 create mode 100644 Ix/IxM.lean
 create mode 100644 Tests/Ix/Canon.lean
 create mode 100644 Tests/Ix/Fixtures.lean
 create mode 100644 Tests/Ix/Fixtures/Export.lean
 create mode 100644 Tests/Ix/Fixtures/Inductives.lean

diff --git a/Ix.lean b/Ix.lean
index 5ed23ad6..9cf6294c 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -7,3 +7,4 @@ import Ix.TransportM
 import Ix.IR
 import Ix.Meta
 import Ix.Prove
+import Ix.IxM
diff --git a/Ix/CanonM.lean b/Ix/CanonM.lean
index 8bbb2f81..7345b16c 100644
--- a/Ix/CanonM.lean
+++ b/Ix/CanonM.lean
@@ -552,25 +552,9 @@ partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
 
 end
 
---/-- Iterates over a list of `Lean.ConstantInfo`, triggering their content-addressing -/
---def canonDelta (delta : List Lean.ConstantInfo) : CanonM Unit := do
---  delta.forM fun c => if !c.isUnsafe then discard $ canonConst c else pure ()
-
---/--
---Content-addresses the "delta" of an environment, that is, the content that is
---added on top of the imports.
---
---Important: constants with open references in their expressions are filtered out.
---Open references are variables that point to names which aren't present in the
---`Lean.ConstMap`.
----/
---def canon (constMap : Lean.ConstMap) (delta : List Lean.ConstantInfo)
---  : IO $ Except CanonMError CanonMState := do
---  match ← StateT.run (ReaderT.run (canonDelta delta) (.init constMap)) CanonMState.init with
---  | (.ok _, stt) => return .ok stt
---  | (.error e, _) => return .error e
-
-def canonicalize (constMap : Lean.ConstMap) (const: Lean.ConstantInfo)
+
+
+def canonicalizeConst (constMap : Lean.ConstMap) (const: Lean.ConstantInfo)
   : IO $ Except CanonMError Address := do
   let canon <-
     StateT.run (ReaderT.run (canonConst const) (.init constMap)) CanonMState.init
@@ -578,4 +562,27 @@ def canonicalize (constMap : Lean.ConstMap) (const: Lean.ConstantInfo)
   | (.ok (a, _), _) => return .ok a
   | (.error e, _) => return .error e
 
+/-- Iterates over a list of `Lean.ConstantInfo`, triggering their content-addressing -/
+def canonDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
+  : CanonM Unit := do
+  delta.forM fun _ c => if !c.isUnsafe then discard $ canonConst c else pure ()
+
+/--
+Content-addresses the "delta" of an environment, that is, the content that is
+added on top of the imports.
+
+Important: constants with open references in their expressions are filtered out.
+Open references are variables that point to names which aren't present in the
+`Lean.ConstMap`.
+-/
+def canonicalizeDelta
+  (constMap : Lean.ConstMap) (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
+  : IO $ Except CanonMError CanonMState := do
+  match ← StateT.run (ReaderT.run (canonDelta delta) (.init constMap)) CanonMState.init with
+  | (.ok _, stt) => return .ok stt
+  | (.error e, _) => return .error e
+
+def canonicalizeEnv (env : Lean.Environment) : IO $ Except CanonMError CanonMState :=
+  canonicalizeDelta env.constants env.getDelta
+
 end Ix.CanonM
diff --git a/Ix/Cli/HashCmd.lean b/Ix/Cli/HashCmd.lean
index 31c784a3..3efbd27e 100644
--- a/Ix/Cli/HashCmd.lean
+++ b/Ix/Cli/HashCmd.lean
@@ -1,48 +1,48 @@
-import Cli
-import Ix.Cronos
-import Ix.Common
-import Ix.CanonM
-import Lean
-
-def runHash (p : Cli.Parsed) : IO UInt32 := do
-  -- Get Lean source file name
-  let source  : String       := p.positionalArg! "input" |>.as! String
-  IO.println <| "Source: " ++ source
-  -- Run Lean frontend
-  let mut cronos ← Cronos.new.clock "Run Lean frontend"
-  Lean.setLibsPaths source
-  --IO.println <| "setlibs"
-  let path := ⟨source⟩
-  let leanEnv ← Lean.runFrontend (← IO.FS.readFile path) path
-  leanEnv.constants.forM fun n y => do
-    IO.println <| s!"constant {n}"
-  let (constMap, delta) := leanEnv.getConstsAndDelta
-  IO.println <| "delta"
-  IO.println <| s!"delta len {delta.length}"
-  delta.forM fun x => do
-     IO.println <| s!"constant'' {x.name}"
-  --cronos ← cronos.clock "Run Lean frontend"
-
- -- IO.println <| "content-address"
- -- -- Start content-addressing
- -- cronos ← cronos.clock "Content-address"
- -- let stt ← match ← Ix.CanonM.canon constMap delta with
- --   | .error err => IO.eprintln err; return 1
- --   | .ok stt => pure stt
- -- cronos ← cronos.clock "Content-address"
- -- stt.store.forM fun adr _ => do
- --    IO.println <| s!"{adr}"
-
- -- IO.println cronos.summary
-  return 0
-
-def hashCmd : Cli.Cmd := `[Cli|
-  hash VIA runHash;
-  "Hashes a given Lean source file"
-
-  FLAGS:
-    e, "example"   : String; "Example flag"
-
-  ARGS:
-    input  : String; "Source file input"
-]
+--import Cli
+--import Ix.Cronos
+--import Ix.Common
+--import Ix.CanonM
+--import Lean
+--
+--def runHash (p : Cli.Parsed) : IO UInt32 := do
+--  -- Get Lean source file name
+--  let source  : String       := p.positionalArg! "input" |>.as! String
+--  IO.println <| "Source: " ++ source
+--  -- Run Lean frontend
+--  let mut cronos ← Cronos.new.clock "Run Lean frontend"
+--  Lean.setLibsPaths source
+--  --IO.println <| "setlibs"
+--  let path := ⟨source⟩
+--  let leanEnv ← Lean.runFrontend (← IO.FS.readFile path) path
+--  IO.println <| s!"constant len {leanEnv.constants.toList.length}"
+--  leanEnv.constants.forM fun n _info => do
+--    IO.println <| s!"constants {n}"
+--  let (constMap, delta) := leanEnv.getConstsAndDelta
+--  IO.println <| s!"constMap len {constMap.toList.length}"
+--  constMap.forM (fun n _info => IO.println <| s!"constMap {n}")
+--  IO.println <| s!"delta len {delta.length}"
+--  delta.forM fun x => do
+--     IO.println <| s!"delta {x.name}"
+--
+-- -- IO.println <| "content-address"
+-- -- -- Start content-addressing
+-- -- cronos ← cronos.clock "Content-address"
+-- -- let stt ← match ← Ix.CanonM.canon constMap delta with
+-- --   | .error err => IO.eprintln err; return 1
+-- --   | .ok stt => pure stt
+-- -- cronos ← cronos.clock "Content-address"
+-- -- stt.store.forM fun adr _ => do
+-- --    IO.println <| s!"{adr}"
+--
+--  return 0
+--
+--def hashCmd : Cli.Cmd := `[Cli|
+--  hash VIA runHash;
+--  "Hashes a given Lean source file"
+--
+--  FLAGS:
+--    e, "example"   : String; "Example flag"
+--
+--  ARGS:
+--    input  : String; "Source file input"
+--]
diff --git a/Ix/Cli/StoreCmd.lean b/Ix/Cli/StoreCmd.lean
index f883bf66..eab61026 100644
--- a/Ix/Cli/StoreCmd.lean
+++ b/Ix/Cli/StoreCmd.lean
@@ -10,16 +10,45 @@ import Lean
 -- ix store get <address>
 
 def runStore (p : Cli.Parsed) : IO UInt32 := do
+  let source : String       := p.positionalArg! "source" |>.as! String
+  let mut cronos ← Cronos.new.clock "Lean-frontend"
+  Lean.setLibsPaths source
+  --StoreIO.toIO ensureStoreDir
+  let path := ⟨source⟩
+  let leanEnv ← Lean.runFrontend (← IO.FS.readFile path) path
+  let delta := leanEnv.getDelta
+  cronos ← cronos.clock "Lean-frontend"
+  -- Start content-addressing
+  cronos ← cronos.clock "content-address"
+  let stt ← match ← Ix.CanonM.canonicalizeDelta leanEnv.constants delta with
+    | .error err => IO.eprintln err; return 1
+    | .ok stt => pure stt
+  stt.names.forM fun name (const, meta) => do
+     IO.println <| s!"{name}:"
+     IO.println <| s!"  #{const}"
+     IO.println <| s!"  {repr <| stt.store.find! const}"
+     IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! const))}"
+     IO.println <| s!"  #{meta}"
+     IO.println <| s!"  {repr <| stt.store.find! meta}"
+     IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! meta))}"
+  --stt.store.forM fun adr const => do
+  --   IO.println <| s!"adr' {adr}"
+  --   IO.println <| s!"const {repr const}"
+  --   let adr' <- StoreIO.toIO (writeConst const)
+  --   IO.println <| s!"adr' {adr}"
+  --   let const' <- StoreIO.toIO (readConst adr')
+  --   IO.println <| s!"const' {repr const'}"
+  cronos ← cronos.clock "content-address"
+  IO.println cronos.summary
   return 0
 
 def runGet (p : Cli.Parsed) : IO UInt32 := do
-  let input : String       := p.positionalArg! "input" |>.as! String
-  IO.println <| "Input: " ++ input
+  let input : String       := p.positionalArg! "address" |>.as! String
   let address : Address <- IO.ofExcept $
     match Address.fromString input with
     | .some a => .ok a
     | .none => .error "bad address"
-  let const <- EIO.toIO storeErrorToIOError (readConst address)
+  let const <- StoreIO.toIO (readConst address)
   IO.println <| s!"{repr const}"
   return 0
 
@@ -27,7 +56,7 @@ def storeGetCmd : Cli.Cmd := `[Cli|
   get VIA runGet;
   "print a store entry"
   ARGS:
-    input  : String; "Source file input"
+    address  : String; "Ix address"
 ]
 
 def storeCmd : Cli.Cmd := `[Cli|
@@ -35,10 +64,10 @@ def storeCmd : Cli.Cmd := `[Cli|
   "Interact with the Ix store"
 
   FLAGS:
-    e, "example"   : String; "Example flag"
+    cron, "cronos"   : String; "enable Cronos timings"
 
   ARGS:
-input  : String; "Source file input"
+    source : String; "Source file input"
 
   SUBCOMMANDS:
     storeGetCmd
diff --git a/Ix/Cli/TestCmd.lean b/Ix/Cli/TestCmd.lean
index c4afd81b..57b9eea1 100644
--- a/Ix/Cli/TestCmd.lean
+++ b/Ix/Cli/TestCmd.lean
@@ -21,15 +21,15 @@ def runTest (p : Cli.Parsed) : IO UInt32 := do
   IO.println s!"Bytes: {hexOfBytes bytes}"
   let addr := Address.blake3 bytes
   IO.println s!"Address: {hexOfBytes addr.hash}"
-  let home ← EIO.toIO storeErrorToIOError getHomeDir
+  let home ← StoreIO.toIO getHomeDir
   IO.println s!"HOME at {home}"
-  let store ← EIO.toIO storeErrorToIOError storeDir
+  let store ← StoreIO.toIO storeDir
   IO.println s!"Store at {store}"
-  EIO.toIO storeErrorToIOError ensureStoreDir
+  StoreIO.toIO ensureStoreDir
   IO.println s!"write entry at {store / (hexOfBytes addr.hash)}"
-  EIO.toIO storeErrorToIOError (writeConst const)
+  let _ <- StoreIO.toIO (writeConst const)
   IO.println s!"read entry at {store / (hexOfBytes addr.hash)}"
-  let const' ← EIO.toIO storeErrorToIOError (readConst addr)
+  let const' ← StoreIO.toIO (readConst addr)
   IO.println s!"Const': {repr const'}"
   IO.println s!"matching {const == const'}"
   return 0
diff --git a/Ix/Common.lean b/Ix/Common.lean
index 688ef842..c3da7fce 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -155,11 +155,13 @@ def PersistentHashMap.filter [BEq α] [Hashable α]
     | true => acc.insert x y
     | false => acc
 
--- TODO: figure out why map₁ vs map₂ matters here
-def Environment.getConstsAndDelta (env : Environment) : ConstMap × List ConstantInfo :=
-  let constants := env.constants
-  let delta := constants.map₁.filter (fun n _ => !n.isInternal)
-  (constants, delta.toList.map (·.2))
+def Environment.getDelta (env : Environment)
+  : PersistentHashMap Name ConstantInfo :=
+  env.constants.map₂.filter (fun n _ => !n.isInternal)
+
+def Environment.getConstMap (env : Environment)
+  : Std.HashMap Name ConstantInfo :=
+  env.constants.map₁.filter (fun n _ => !n.isInternal)
 
 /--
 Sets the directories where `olean` files can be found.
diff --git a/Ix/IxM.lean b/Ix/IxM.lean
new file mode 100644
index 00000000..d3429793
--- /dev/null
+++ b/Ix/IxM.lean
@@ -0,0 +1,174 @@
+import Blake3
+import Ix.Address
+import Ix.Ixon
+import Ix.Ixon.Serialize
+import Ix.Meta
+import Ix.CanonM
+import Batteries.Data.RBMap
+import Lean
+import Ix.Prove
+
+open Batteries (RBMap)
+
+namespace Ix
+
+inductive IxError
+| todo
+
+instance : ToString IxError where
+  toString p := s!"todo"
+
+--instance : ToString Proof where
+--  toString p := s!"<#{p.inp} ~> #{p.out} : #{p.typ}>"
+
+--inductive IxVMOp where
+--| commit (payload secret comm: Address) : IxVMOp
+--| reveal (payload secret comm: Address) : IxVMOp
+
+structure IxMEnv where
+  names : RBMap Lean.Name (Address × Address) compare
+  consts: RBMap Address Ixon.Const compare
+  secret: Address
+
+structure IxMState where
+  comms : RBMap Address Ixon.Comm compare
+  -- transcript : List IxVMOp
+  main : Option (Address × Ixon.Const)
+  deriving Inhabited
+
+abbrev IxM := ReaderT IxMEnv $ ExceptT IxError $ StateT IxMState Id
+
+def IxM.run (env: Lean.Environment) (secret: Lean.Name) (ixm: IxM Claim)
+  : IO (Claim × IxMState × IxMEnv) := do
+  let stt <- IO.ofExcept (<- Ix.CanonM.canonicalizeEnv env)
+  let (secret, _) := stt.names.find! secret
+  let env := IxMEnv.mk stt.names stt.store secret
+  let (res, stt) := Id.run (StateT.run (ReaderT.run ixm env) default)
+  let claim <- IO.ofExcept res
+  return (claim, stt, env)
+
+def IxM.commit (payload: Address): IxM Address := do
+  let secret <- (·.secret) <$> read
+  let comm := Ixon.Comm.mk secret payload
+  let addr := Address.blake3 (Ixon.Serialize.put (Ixon.Const.comm comm))
+  modify (fun stt => { stt with 
+    comms := stt.comms.insert addr comm 
+    -- transcript := (.commit payload secret addr)::stt.transcript
+  })
+  return addr
+
+def IxM.byName (name: Lean.Name) : IxM Address := do
+  let env <- read
+  match env.names.find? name with
+  | .none => throw .todo
+  | .some (addr, _) => return addr
+
+def IxM.reveal (comm: Address) : IxM Address := do
+  let stt <- get
+  match stt.comms.find? comm with
+  | .some c => return c.payload
+  | .none => throw .todo
+
+def IxM.secret (comm: Address) : IxM Address := do
+  let stt <- get
+  match stt.comms.find? comm with
+  | .some c => return c.secret
+  | .none => throw .todo
+
+def IxM.mkMainConst (type func: Address) (args: List Address): Ixon.Const :=
+  match args with
+  | [] =>
+    Ixon.Const.defn {
+      lvls := 0,
+      type := Ixon.Expr.cnst type [],
+      value := Ixon.Expr.cnst func [],
+      part := .true,
+    }
+  | a::as => 
+    let as':= as.map (fun a => Ixon.Expr.cnst a [])
+    Ixon.Const.defn {
+      lvls := 0,
+      type := Ixon.Expr.cnst type [],
+      value := Ixon.Expr.apps (Ixon.Expr.cnst func []) (Ixon.Expr.cnst a []) as' ,
+      part := .true,
+    }
+
+def IxM.mkMain (type func: Address) (args: List Address): IxM Address := do
+  let mainConst := IxM.mkMainConst type func args
+  let bytes := Ixon.Serialize.put mainConst
+  let addr := Address.blake3 bytes
+  modify (fun stt => { stt with main := .some (addr, mainConst) })
+  return addr
+
+def IxM.evaluate (type input: Address) : IxM Address := sorry
+
+def IxM.prove (claim : Claim) (stt: IxMState) (env: IxMEnv) : IO Proof :=
+  sorry
+
+end Ix
+
+namespace ZKVoting
+
+def secret : Nat := 42
+
+inductive Candidate
+   | alice | bob | charlie
+   deriving Inhabited, Lean.ToExpr, Repr
+
+inductive Result
+| winner : Candidate -> Result
+| tie : List Candidate -> Result
+deriving Repr
+
+def privateVotes : List Candidate := [.alice, .alice, .bob]
+
+def runElection (votes: List Candidate) : Result :=
+  let (a, b, c) := votes.foldr tally (0,0,0)
+  if a > b && a > c
+  then .winner .alice
+  else if b > a && b > c
+  then .winner .bob
+  else if c > a && c > b
+  then .winner .charlie
+  else if a == b && b == c
+  then .tie [.alice, .bob, .charlie]
+  else if a == b
+  then .tie [.alice, .bob]
+  else if a == c
+  then .tie [.alice, .charlie]
+  else .tie [.bob, .charlie]
+    where
+      tally : Candidate -> (Nat × Nat × Nat) -> (Nat × Nat × Nat)
+      | .alice, (a, b, c) => (a+1, b, c)
+      | .bob, (a, b, c) => (a, b+1, c)
+      | .charlie, (a, b, c) => (a, b, c+1)
+
+def claim : Ix.IxM Claim := do
+  let func <- Ix.IxM.byName `ZKVoting.runElection
+  let type <- Ix.IxM.byName `ZKVoting.Result
+  let argm <- Ix.IxM.byName `ZKVoting.privateVotes >>= Ix.IxM.commit
+  let main <- Ix.IxM.mkMain type func [argm]
+  let output <- Ix.IxM.evaluate type main
+  return Claim.mk main output type
+
+def main : IO Proof := do
+  let env <- get_env!
+  let (claim, stt, env) <- Ix.IxM.run env `ZKVoting.secret claim
+  Ix.IxM.prove claim stt env
+
+end ZKVoting
+
+-- IxVM
+-- ingress : Address -> Ptr
+-- eval    : Ptr -> Ptr
+-- check   : Ptr -> Ptr -> Bool
+-- commit  : Ptr -> Ptr -> Comm
+-- reveal  : Comm -> Ptr
+-- egress  : Ptr -> Address
+
+-- IxM
+-- eval    : Address -> Address
+-- check   : Address -> Bool
+-- commit  : Address -> Address -> Comm
+-- reveal  : Comm -> Address
+
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index 7f9dcece..a537b057 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -101,6 +101,11 @@ structure DefinitionProj where
   idx   : Nat
   deriving BEq, Repr
 
+structure Comm where
+  secret: Address
+  payload: Address
+  deriving BEq, Repr
+
 inductive Const where
   -- 0xC0
   | axio : Axiom -> Const
@@ -128,6 +133,7 @@ inductive Const where
   | meta   : Metadata -> Const
   -- 0xCC
   | proof : Proof -> Const
+  | comm: Comm -> Const
   deriving BEq, Repr, Inhabited
 
 def putConst : Const → PutM
@@ -144,6 +150,7 @@ def putConst : Const → PutM
 | .mutInd xs => putUInt8 0xCA *> putArray (putIndc <$> xs)
 | .meta m => putUInt8 0xCB *> putMetadata m
 | .proof p => putUInt8 0xCC *> putProof p
+| .comm c => putUInt8 0xCD *> putComm c
   where
     putDefn (x: Definition) :=
       putNatl x.lvls *> putExpr x.type *> putExpr x.value *> putBool x.part
@@ -162,8 +169,12 @@ def putConst : Const → PutM
         *> putArray (putCtor <$> x.ctors) *> putArray (putRecr <$> x.recrs)
         *> putBools [x.recr, x.refl, x.struct, x.unit]
     putProof (p: Proof) : PutM :=
-      putBytes p.inp.hash *> putBytes p.out.hash *> putBytes p.typ.hash
+      putBytes p.claim.inp.hash
+      *> putBytes p.claim.out.hash
+      *> putBytes p.claim.typ.hash
       *> putByteArray p.bin
+    putComm (c: Comm) : PutM :=
+      putBytes c.secret.hash *> putBytes c.payload.hash
 
 def getConst : GetM Const := do
   let tag ← getUInt8
@@ -181,6 +192,7 @@ def getConst : GetM Const := do
   | 0xCA => .mutInd <$> getArray getIndc
   | 0xCB => .meta <$> getMetadata
   | 0xCC => .proof <$> getProof
+  | 0xCD => .comm <$> getComm
   | e => throw s!"expected Const tag, got {e}"
   where
     getDefn : GetM Definition :=
@@ -203,7 +215,9 @@ def getConst : GetM Const := do
       | _ => throw s!"unreachable"
     getAddr : GetM Address := .mk <$> getBytes 32
     getProof : GetM Proof :=
-      .mk <$> getAddr <*> getAddr <*> getAddr <*> getByteArray
+      .mk <$> (.mk <$> getAddr <*> getAddr <*> getAddr) <*> getByteArray
+    getComm : GetM Comm :=
+      .mk <$> getAddr <*> getAddr
 
 instance : Serialize Const where
   put := runPut ∘ putConst
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index 26a5e41a..ed076a8e 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -5,7 +5,7 @@ import Ix.CanonM
 open Lean
 
 def computeIxAddress (const : ConstantInfo) (constMap: ConstMap) : IO Address := do
-  IO.ofExcept (<- Ix.CanonM.canonicalize constMap const)
+  IO.ofExcept (<- Ix.CanonM.canonicalizeConst constMap const)
 
 open System (FilePath)
 
diff --git a/Ix/Prove.lean b/Ix/Prove.lean
index 1ceb24d3..34101209 100644
--- a/Ix/Prove.lean
+++ b/Ix/Prove.lean
@@ -9,19 +9,26 @@ instance : ToString ProveError := ⟨fun _ => "TODO"⟩
 
 abbrev ProveM := ExceptT ProveError IO
 
-structure Proof where
+structure Claim where
   inp : Address
   out : Address
   typ : Address
+  deriving Inhabited, BEq
+
+instance : ToString Claim where
+  toString c := s!"#{c.inp} ~> #{c.out} : #{c.typ}"
+
+structure Proof where
+  claim: Claim
   /-- Bytes of the Binius proof -/
   bin : ByteArray
   deriving Inhabited, BEq
 
 instance : ToString Proof where
-  toString p := s!"<#{p.inp} ~> #{p.out} : #{p.typ}>"
+  toString p := s!"<{toString p.claim} := {hexOfBytes p.bin}>"
 
 instance : Repr Proof where
   reprPrec p _ := toString p
 
-def prove (_hash : Address) : ProveM Proof :=
+def prove (claim : Claim) : ProveM Proof :=
   default -- TODO
diff --git a/Ix/Store.lean b/Ix/Store.lean
index fea70f4a..dbf3afb0 100644
--- a/Ix/Store.lean
+++ b/Ix/Store.lean
@@ -23,6 +23,9 @@ def storeErrorToIOError : StoreError -> IO.Error
 
 abbrev StoreIO := EIO StoreError
 
+def StoreIO.toIO (sio: StoreIO α) : IO α :=
+  EIO.toIO storeErrorToIOError sio
+
 def getHomeDir : StoreIO FilePath := do
   match ← IO.getEnv "HOME" with
   | .some path => return ⟨path⟩
@@ -36,12 +39,13 @@ def ensureStoreDir : StoreIO Unit := do
   let store ← storeDir
   IO.toEIO .ioError (IO.FS.createDirAll store)
 
-def writeConst (x: Ixon.Const) : StoreIO Unit := do
+def writeConst (x: Ixon.Const) : StoreIO Address := do
   let bytes := Ixon.Serialize.put x
   let addr  := Address.blake3 bytes
   let store ← storeDir
   let path := store / hexOfBytes addr.hash
-  IO.toEIO .ioError (IO.FS.writeBinFile path bytes)
+  let _ <- IO.toEIO .ioError (IO.FS.writeBinFile path bytes)
+  return addr
 
 def readConst (a: Address) : StoreIO Ixon.Const := do
   let store ← storeDir
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index 203309c0..05a70796 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -27,6 +27,7 @@ inductive TransportError
   | unexpectedNode (idx: Nat) (m: Ixon.Metadata)
   | rawMetadata (m: Ixon.Metadata)
   | rawProof (m: Proof)
+  | rawComm (m: Ixon.Comm)
   deriving Repr
 
 abbrev DematM := EStateM TransportError DematState
@@ -283,6 +284,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
 | .meta m => throw (.rawMetadata m)
 -- TODO: This could return a Proof inductive, since proofs have no metadata
 | .proof p => throw (.rawProof p)
+| .comm p => throw (.rawComm p)
   where
     rematDefn : Ixon.Definition -> RematM Ix.Definition
     | x => .mk x.lvls <$> rematExpr x.type <*> rematExpr x.value <*> pure x.part
diff --git a/Main.lean b/Main.lean
index b014999f..2716a3a8 100644
--- a/Main.lean
+++ b/Main.lean
@@ -1,5 +1,4 @@
 import Ix.Cli.ProveCmd
-import Ix.Cli.HashCmd
 import Ix.Cli.TestCmd
 import Ix.Cli.StoreCmd
 import Ix
@@ -13,7 +12,6 @@ def ixCmd : Cli.Cmd := `[Cli|
 
   SUBCOMMANDS:
     proveCmd;
-    hashCmd;
     testCmd;
     storeCmd
 ]
diff --git a/Tests/Ix/Canon.lean b/Tests/Ix/Canon.lean
new file mode 100644
index 00000000..28a4d3df
--- /dev/null
+++ b/Tests/Ix/Canon.lean
@@ -0,0 +1,107 @@
+import LSpec
+
+import Ix.Ixon
+import Ix.Address
+import Ix.Common
+import Ix.CanonM
+import Ix.Meta
+import Lean
+import Tests.Ix.Fixtures
+
+@[specialize]
+def withExceptOkM 
+  [Monad m] (descr : String) (exc : Except ε α) [ToString ε] (f : α → m LSpec.TestSeq)
+  : m LSpec.TestSeq :=
+  match exc with
+  | .error e => return LSpec.test descr (LSpec.ExpectationFailure "ok _" s!"error {e}")
+  | .ok    a => return LSpec.test descr true $ ← f a
+
+--abbrev CanonTest := Ix.CanonM.CanonMState → LSpec.TestSeq
+--abbrev IOCanonTest := Ix.CanonM.CanonMState → IO LSpec.TestSeq
+
+
+def Test.Ix.Canon.wellfounded : IO LSpec.TestSeq := do
+  let env <- get_env!
+  let stt <- match <- Ix.CanonM.canonicalizeDelta env.constants env.getDelta with
+    | .error e => return LSpec.test "canonicalizeFailure" (LSpec.ExpectationFailure "ok _" s!"error {e}")
+    | .ok stt => pure stt
+  let (a,_) := stt.names.find! `WellFounded.A
+  let (b,_) := stt.names.find! `WellFounded.A'
+  return LSpec.test "A == A'" (a == b)
+
+-- `WellFounded.A == `WellFounded.A'
+
+--def Tests.Ix.Canon.suite : List LSpec.TestSeq :=
+--  [ 
+--
+--  ]
+
+--/-- Run tests from extractors given a Lean source file -/
+--def canonTestsFromFile (source : FilePath)
+--  (canon : List Extractor) (ioExtractors : List IOExtractor)
+--    (setPaths quick : Bool := true) : IO TestSeq := do
+--  if setPaths then Lean.setLibsPaths
+--  let leanEnv ← Lean.runFrontend (← IO.FS.readFile source) source
+--  let (constMap, delta) := leanEnv.getConstsAndDelta
+--  withExceptOkM s!"Content-addresses {source}"
+--      (← contAddr constMap delta quick false) fun stt => do
+--    let pureTests := extractors.foldl (init := .done)
+--      fun acc ext => acc ++ (ext stt)
+--    ioExtractors.foldlM (init := pureTests) fun acc ext =>
+--      do pure $ acc ++ (← ext stt)
+
+--/-- Calls `ensembleTestExtractors` for multiple sources -/
+--def ensembleTestExtractors' (sources : List FilePath)
+--  (extractors : List Extractor) (ioExtractors : List IOExtractor)
+--    (setPaths : Bool := true) : IO TestSeq :=
+--  sources.foldlM (init := .done) fun acc source => do
+--    let g := group s!"Tests for {source}" $
+--      ← ensembleTestExtractors source extractors ioExtractors setPaths
+--    pure $ acc ++ g
+--
+--/-- Asserts that all constants typechecks -/
+--def extractTypecheckingTests : Extractor := fun stt =>
+--  withExceptOk "Typechecking succeeds" (typecheckAll stt.store stt.env.constNames)
+--    fun _ => .done
+--
+--/-- Asserts that some constant doesn't typecheck -/
+--def extractNonTypecheckingTests : Extractor := fun stt =>
+--  withExceptError "Typechecking fails" (typecheckAll stt.store stt.env.constNames)
+--    fun _ => .done
+--
+--section AnonHashGroups
+--
+--/-
+--This section defines an extractor that consumes a list of groups of names and
+--creates tests that assert that:
+--1. Each pair of constants in the same group has the same anon hash
+--2. Each pair of constants in different groups has different anon hashes
+---/
+--
+--def extractAnonGroups (groups : List (List Name)) (stt : ContAddrState) :
+--    Except String (Array (Array $ Name × Lurk.F)) := Id.run do
+--  let mut notFound : Array Name := #[]
+--  let mut hashGroups : Array (Array $ Name × Lurk.F) := #[]
+--  for group in groups do
+--    let mut hashGroup : Array (Name × Lurk.F) := #[]
+--    for name in group do
+--      match stt.env.consts.find? name with
+--      | none   => notFound  := notFound.push name
+--      | some h => hashGroup := hashGroup.push (name, h)
+--    hashGroups := hashGroups.push hashGroup
+--  if notFound.isEmpty then
+--    return .ok hashGroups
+--  else
+--    return .error s!"Not found: {", ".intercalate $ notFound.data.map toString}"
+--
+--def extractAnonGroupsTests (groups : List $ List Name) : Extractor := fun stt =>
+--  withExceptOk "All constants can be found" (extractAnonGroups groups stt)
+--    fun anonGroups =>
+--      let anonEqTests := anonGroups.foldl (init := .done) fun tSeq anonGroup =>
+--        anonGroup.data.pairwise.foldl (init := tSeq) fun tSeq (x, y) =>
+--          tSeq ++ test s!"{x.1}ₐₙₒₙ = {y.1}ₐₙₒₙ" (x.2 == y.2)
+--      anonGroups.data.pairwise.foldl (init := anonEqTests) fun tSeq (g, g') =>
+--        (g.data.cartesian g'.data).foldl (init := tSeq) fun tSeq (x, y) =>
+--          tSeq ++ test s!"{x.1}ₐₙₒₙ ≠ {y.1}ₐₙₒₙ" (x.2 != y.2)
+--
+--end AnonHashGroups
diff --git a/Tests/Ix/Fixtures.lean b/Tests/Ix/Fixtures.lean
new file mode 100644
index 00000000..721a93ef
--- /dev/null
+++ b/Tests/Ix/Fixtures.lean
@@ -0,0 +1,176 @@
+import Tests.Ix.Fixtures.Export
+
+set_option linter.all false -- prevent error messages from runFrontend
+namespace WellFounded
+
+mutual
+
+  def A : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + C n + 1
+
+  def C : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + F n + A n + 1
+
+  def E : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + A n + F n + 1
+
+  def F : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + C n + E n + 1
+
+  def B : Nat → Nat
+  | 0 => 0
+  | n + 1 => C n + 2
+
+  def G : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + F n + H n + 2
+
+  def H : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+
+end
+
+mutual
+
+  def A' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + E' n + C' n + 1
+
+  def C' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + F' n + A' n + 1
+
+  def E' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + A' n + F' n + 1
+
+  def F' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + C' n + E' n + 1
+
+  def B' : Nat → Nat
+  | 0 => 0
+  | n + 1 => C' n + 2
+
+  def G' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + F' n + H' n + 2
+
+  def H' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + E' n + G' n + 2
+
+end
+
+mutual
+  def I : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+end
+
+def I' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+
+end WellFounded
+
+namespace Partial
+
+mutual
+
+  partial def A : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + C n + 1
+
+  partial def C : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + F n + A n + 1
+
+  partial def E : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + A n + F n + 1
+
+  partial def F : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + C n + E n + 1
+
+  partial def B : Nat → Nat
+  | 0 => 0
+  | n + 1 => C n + 2
+
+  partial def G : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + F n + H n + 2
+
+  partial def H : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+
+end
+
+partial def I : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+
+end Partial
+
+
+namespace Inductives
+
+inductive BLA
+  | nil
+  | bla : BLA → BLA → BLA
+
+-- an inductive with a differently named constructor but all else equal should be the same
+inductive BLU
+  | nil
+  | blu : BLU → BLU → BLU
+
+-- an inductive with a different constructor order should be distinct
+inductive BLA'
+  | bla : BLA' → BLA' → BLA'
+  | nil
+
+mutual
+  -- BLE and BLI should be distinct because we don't group by weak equality
+  inductive BLE | bli : BLI → BLE
+  inductive BLI | ble : BLE → BLI
+  inductive BLO | blea : BLE → BLI → BLO
+end
+
+mutual
+  inductive BLE' | bli : BLI' → BLE'
+  inductive BLI' | ble : BLE' → BLI'
+  inductive BLO' | blea : BLE' → BLI' → BLO'
+end
+
+mutual
+  -- BLE and BLI should be distinct because we don't group by weak equality
+  inductive BLE'' | bli : BLI'' → BLE''
+  inductive BLO'' | blea : BLE'' → BLA' → BLO''
+  inductive BLI'' | ble : BLE'' → BLI''
+end
+
+-- testing external reference into mutual
+inductive BLEH
+  | bleh : BLE → BLEH
+  | bloh : BLO → BLEH
+
+end Inductives
+
+namespace Import
+
+
+def Foo := MyNat -- triggering the compilation of `MyNat`
+def Bar := Nat   -- triggering the compilation of `Nat`
+
+inductive MyOtherNat
+  | nada
+  | mais : MyOtherNat → MyOtherNat
+
+end Import
diff --git a/Tests/Ix/Fixtures/Export.lean b/Tests/Ix/Fixtures/Export.lean
new file mode 100644
index 00000000..bc637a05
--- /dev/null
+++ b/Tests/Ix/Fixtures/Export.lean
@@ -0,0 +1,3 @@
+inductive MyNat
+  | nill
+  | next : MyNat → MyNat
diff --git a/Tests/Ix/Fixtures/Inductives.lean b/Tests/Ix/Fixtures/Inductives.lean
new file mode 100644
index 00000000..e69de29b

From e6a212c6ee988583f98e5351c23c5be2ccd6c44b Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sun, 13 Apr 2025 20:14:17 -0400
Subject: [PATCH 07/74] megacommit implementing Ix commitment API

---
 Apps/Test.lean                |  78 ++++
 Apps/ZKVoting/Common.lean     |  10 -
 Apps/ZKVoting/Prover.lean     | 118 +++--
 Apps/ZKVoting/ProverInit.lean |   9 -
 Apps/ZKVoting/Verifier.lean   |  26 +-
 Ix.lean                       |   4 +-
 Ix/Address.lean               |   9 +
 Ix/BuiltIn.lean               | 124 ++++--
 Ix/CanonM.lean                | 588 -------------------------
 Ix/Claim.lean                 |  14 +
 Ix/Cli/StoreCmd.lean          |  15 +-
 Ix/Commitment.lean            |  24 ++
 Ix/Common.lean                |   6 +-
 Ix/CompileM.lean              | 783 ++++++++++++++++++++++++++++++++++
 Ix/IxM.lean                   | 281 +++++-------
 Ix/Ixon/Const.lean            |  26 +-
 Ix/Ixon/Expr.lean             |   1 +
 Ix/Ixon/Serialize.lean        |   9 +
 Ix/Meta.lean                  |  13 +-
 Ix/Prove.lean                 |  27 +-
 Ix/TransportM.lean            |  10 +-
 Ix/ZKVoting.lean              |  77 ++++
 Tests/Ix/Compile.lean         |  46 ++
 Tests/Main.lean               |  25 +-
 lakefile.lean                 |   3 +-
 25 files changed, 1395 insertions(+), 931 deletions(-)
 create mode 100644 Apps/Test.lean
 delete mode 100644 Apps/ZKVoting/Common.lean
 delete mode 100644 Apps/ZKVoting/ProverInit.lean
 delete mode 100644 Ix/CanonM.lean
 create mode 100644 Ix/Claim.lean
 create mode 100644 Ix/Commitment.lean
 create mode 100644 Ix/CompileM.lean
 create mode 100644 Ix/ZKVoting.lean
 create mode 100644 Tests/Ix/Compile.lean

diff --git a/Apps/Test.lean b/Apps/Test.lean
new file mode 100644
index 00000000..337dcf83
--- /dev/null
+++ b/Apps/Test.lean
@@ -0,0 +1,78 @@
+--import Ix.Claim
+--import Ix.Address
+--import Ix.Meta
+--import Ix.CompileM
+--
+--inductive Candidate
+--   | alice | bob | charlie
+--   deriving Inhabited, Lean.ToExpr, Repr
+--
+--inductive Result
+--| winner : Candidate -> Result
+--| tie : List Candidate -> Result
+--deriving Repr, Lean.ToExpr
+--
+--def privateVotes : List Candidate := 
+--  [.alice, .alice, .bob]
+--
+--def runElection (votes: List Candidate) : Result :=
+--  let (a, b, c) := votes.foldr tally (0,0,0)
+--  if a > b && a > c
+--  then .winner .alice
+--  else if b > a && b > c
+--  then .winner .bob
+--  else if c > a && c > b
+--  then .winner .charlie
+--  else if a == b && b == c
+--  then .tie [.alice, .bob, .charlie]
+--  else if a == b
+--  then .tie [.alice, .bob]
+--  else if a == c
+--  then .tie [.alice, .charlie]
+--  else .tie [.bob, .charlie]
+--    where
+--      tally (comm: Candidate) (acc: (Nat × Nat × Nat)): (Nat × Nat × Nat) :=
+--      match comm, acc with
+--      | .alice, (a, b, c) => (a+1, b, c)
+--      | .bob, (a, b, c) => (a, b+1, c)
+--      | .charlie, (a, b, c) => (a, b, c+1)
+--
+--def main : IO UInt32 := do
+--  let mut stt : Ix.Compile.CompileState := .init (<- get_env!)
+--  -- simulate getting the votes from somewhere
+--  let votes : List Candidate <- pure [.alice, .alice, .bob]
+--  let mut as : List Lean.Name := []
+--  -- default maxHeartBeats
+--  let ticks : USize := 200000
+--  -- the type of each vote to commit
+--  let voteType := Lean.toTypeExpr Candidate
+--  -- loop over the votes
+--  for v in votes do
+--    let voteExpr := Lean.toExpr v
+--    -- add each vote to our environment as a commitment
+--    let ((addr, _), stt') <-
+--      (Ix.Compile.addCommitment [] voteType voteExpr).runIO' ticks stt
+--    stt := stt'
+--    -- collect each commitment addresses as names
+--    as := (Address.toUniqueName addr)::as
+--  IO.println s!"{repr as}"
+--  -- identify our function
+--  let func := ``runElection
+--  -- build a Lean list of our commitments as the argument to runElection
+--  let arg : Lean.Expr <- runMeta (metaMkList voteType as) stt.env
+--  let argType <- runMeta (Lean.Meta.inferType arg) stt.env
+--  -- inputs to commit to the type of the output
+--  let type := Lean.toTypeExpr Result
+--  let sort <- runMeta (Lean.Meta.inferType type) stt.env
+--  -- evaluate the output (both methods should be the same)
+--  let output := Lean.toExpr (runElection votes)
+--  IO.println s!"output1 {repr output}"
+--  let output' <- runMeta (Lean.Meta.reduce (.app (Lean.mkConst func) arg)) stt.env
+--  IO.println s!"output2 {repr output'}"
+--  -- build the evaluation claim
+--  let ((claim,_,_,_), _stt') <-
+--     (Ix.Compile.evalClaimWithArgs func [(arg, argType)] output type sort [] true).runIO' ticks stt
+--  IO.println s!"{claim}"
+--  -- Ix.prove claim stt
+--  return 0
+--
diff --git a/Apps/ZKVoting/Common.lean b/Apps/ZKVoting/Common.lean
deleted file mode 100644
index 2a3d0120..00000000
--- a/Apps/ZKVoting/Common.lean
+++ /dev/null
@@ -1,10 +0,0 @@
-import Ix.BuiltIn
-
-inductive Candidate
-  | abe | bam | cot
-  deriving Inhabited, Lean.ToExpr
-
-abbrev Vote := Commitment Candidate
-
-abbrev proofPath : System.FilePath :=
-  "Apps" / "ZKVoting" / "proof"
diff --git a/Apps/ZKVoting/Prover.lean b/Apps/ZKVoting/Prover.lean
index 9f5a4415..9059d9e4 100644
--- a/Apps/ZKVoting/Prover.lean
+++ b/Apps/ZKVoting/Prover.lean
@@ -1,52 +1,78 @@
-import Ix
-import Apps.ZKVoting.ProverInit
-import Apps.ZKVoting.Common
+import Ix.Claim
+import Ix.Address
+import Ix.Meta
+import Ix.CompileM
 
-open Lean
+inductive Candidate
+   | alice | bob | charlie
+   deriving Inhabited, Lean.ToExpr, Repr
 
-partial def collectVotes (env : Environment) : IO $ List Vote :=
-  collectVotesLoop [] initSecret (0 : UInt64)
-where
-  collectVotesLoop votes secret count := do
-    let input := (← (← IO.getStdin).getLine).trim
-    let consts := env.constants
-    let voteAbe ← mkCommit secret Candidate.abe consts
-    let voteBam ← mkCommit secret Candidate.bam consts
-    let voteCot ← mkCommit secret Candidate.cot consts
-    IO.println s!"a: Abe | {voteAbe}"
-    IO.println s!"b: Bam | {voteBam}"
-    IO.println s!"b: Cot | {voteCot}"
-    IO.println "_: End voting"
-    let vote ← match input with
-      | "a" => pure voteAbe | "b" => pure voteBam | "c" => pure voteCot
-      | _ => return votes
-    let secret' := (← mkCommit secret count consts).adr
-    IO.println vote
-    collectVotesLoop (vote :: votes) secret' (count + 1)
+inductive Result
+| winner : Candidate -> Result
+| tie : List Candidate -> Result
+deriving Repr, Lean.ToExpr
 
-structure VoteCounts where
-  abe : UInt64
-  bam : UInt64
-  cot : UInt64
-  deriving ToExpr
+def privateVotes : List Candidate := 
+  [.alice, .alice, .bob]
 
-def countVotes : List Vote → VoteCounts
-  | [] => ⟨0, 0, 0⟩
-  | vote :: votes =>
-    let counts := countVotes votes
-    match (reveal vote : Candidate) with
-    | .abe => { counts with abe := counts.abe + 1 }
-    | .bam => { counts with bam := counts.bam + 1 }
-    | .cot => { counts with cot := counts.cot + 1 }
+def runElection (votes: List Candidate) : Result :=
+  let (a, b, c) := votes.foldr tally (0,0,0)
+  if a > b && a > c
+  then .winner .alice
+  else if b > a && b > c
+  then .winner .bob
+  else if c > a && c > b
+  then .winner .charlie
+  else if a == b && b == c
+  then .tie [.alice, .bob, .charlie]
+  else if a == b
+  then .tie [.alice, .bob]
+  else if a == c
+  then .tie [.alice, .charlie]
+  else .tie [.bob, .charlie]
+    where
+      tally (comm: Candidate) (acc: (Nat × Nat × Nat)): (Nat × Nat × Nat) :=
+      match comm, acc with
+      | .alice, (a, b, c) => (a+1, b, c)
+      | .bob, (a, b, c) => (a, b+1, c)
+      | .charlie, (a, b, c) => (a, b, c+1)
 
 def main : IO UInt32 := do
-  let env ← get_env!
-  let votes ← collectVotes env
-  let .defnInfo countVotesDefn ← runCore (getConstInfo ``countVotes) env
-    | unreachable!
-  let claimValue := .app countVotesDefn.value (toExpr votes)
-  let claimType ← runMeta (Meta.inferType claimValue) env
-  let claimAdr := computeIxAddress (mkAnonDefInfoRaw claimType claimValue) env.constants
-  match ← prove claimAdr with
-  | .ok proof => IO.FS.writeBinFile proofPath $ Ixon.Serialize.put proof; return 0
-  | .error err => IO.eprintln $ toString err; return 1
+  let mut stt : Ix.Compile.CompileState := .init (<- get_env!)
+  -- simulate getting the votes from somewhere
+  let votes : List Candidate <- pure [.alice, .alice, .bob]
+  let mut as : List Lean.Name := []
+  -- default maxHeartBeats
+  let ticks : USize := 200000
+  -- the type of each vote to commit
+  let voteType := Lean.toTypeExpr Candidate
+  -- loop over the votes
+  for v in votes do
+    let voteExpr := Lean.toExpr v
+    -- add each vote to our environment as a commitment
+    let ((addr, _), stt') <-
+      (Ix.Compile.addCommitment [] voteType voteExpr).runIO' ticks stt
+    stt := stt'
+    -- collect each commitment addresses as names
+    as := (Address.toUniqueName addr)::as
+  IO.println s!"{repr as}"
+  -- identify our function
+  let func := ``runElection
+  -- build a Lean list of our commitments as the argument to runElection
+  let arg : Lean.Expr <- runMeta (metaMkList voteType as) stt.env
+  let argType <- runMeta (Lean.Meta.inferType arg) stt.env
+  -- inputs to commit to the type of the output
+  let type := Lean.toTypeExpr Result
+  let sort <- runMeta (Lean.Meta.inferType type) stt.env
+  -- evaluate the output (both methods should be the same)
+  let output := Lean.toExpr (runElection votes)
+  IO.println s!"output1 {repr output}"
+  let output' <- runMeta (Lean.Meta.reduce (.app (Lean.mkConst func) arg)) stt.env
+  IO.println s!"output2 {repr output'}"
+  -- build the evaluation claim
+  let ((claim,_,_,_), _stt') <-
+     (Ix.Compile.evalClaimWithArgs func [(arg, argType)] output type sort [] true).runIO' ticks stt
+  IO.println s!"{claim}"
+  -- Ix.prove claim stt
+  return 0
+
diff --git a/Apps/ZKVoting/ProverInit.lean b/Apps/ZKVoting/ProverInit.lean
deleted file mode 100644
index 5e5ce063..00000000
--- a/Apps/ZKVoting/ProverInit.lean
+++ /dev/null
@@ -1,9 +0,0 @@
-import Ix.Address
-
-initialize initSecret : Address ← do
-  IO.setRandSeed (← IO.monoNanosNow)
-  let mut secret : ByteArray := default
-  for _ in [:32] do
-    let rand ← IO.rand 0 (UInt8.size - 1)
-    secret := secret.push rand.toUInt8
-  return ⟨secret⟩
diff --git a/Apps/ZKVoting/Verifier.lean b/Apps/ZKVoting/Verifier.lean
index 16a6e52b..eee11247 100644
--- a/Apps/ZKVoting/Verifier.lean
+++ b/Apps/ZKVoting/Verifier.lean
@@ -1,18 +1,18 @@
 import Ix.Ixon.Serialize
 import Ix.Prove
-import Apps.ZKVoting.Common
 
 def main (args : List String) : IO UInt32 := do
-  let mut votes := #[]
-  for commStr in args do
-    match Commitment.ofString commStr with
-    | none => IO.eprintln s!"Couldn't parse {commStr} as a commitment"; return 1
-    | some (comm : Vote) => votes := votes.push comm
-  let proofBytes ← IO.FS.readBinFile proofPath
-  match Ixon.Serialize.get proofBytes with
-  | .error err => IO.eprintln s!"Proof deserialization error: {err}"; return 1
-  | .ok (_proof : Proof) =>
-    -- TODO: print the resulting vote counts in the claim
-    -- TODO: assert that every vote in `votes` is in the proof claim
-    -- TODO: verify proof
+--  TODO
+--  let mut votes := #[]
+--  for commStr in args do
+--    match Commitment.ofString commStr with
+--    | none => IO.eprintln s!"Couldn't parse {commStr} as a commitment"; return 1
+--    | some (comm : Vote) => votes := votes.push comm
+--  let proofBytes ← IO.FS.readBinFile proofPath
+--  match Ixon.Serialize.get proofBytes with
+--  | .error err => IO.eprintln s!"Proof deserialization error: {err}"; return 1
+--  | .ok (_proof : Proof) =>
+--    -- TODO: print the resulting vote counts in the claim
+--    -- TODO: assert that every vote in `votes` is in the proof claim
+--    -- TODO: verify proof
     return 0
diff --git a/Ix.lean b/Ix.lean
index 9cf6294c..afe906cd 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -2,9 +2,9 @@
 -- Import modules here that should be built as part of the library.
 import Ix.BuiltIn
 import Ix.Ixon
-import Ix.CanonM
 import Ix.TransportM
 import Ix.IR
 import Ix.Meta
+import Ix.CompileM
+import Ix.Claim
 import Ix.Prove
-import Ix.IxM
diff --git a/Ix/Address.lean b/Ix/Address.lean
index eff4134a..d5e927b6 100644
--- a/Ix/Address.lean
+++ b/Ix/Address.lean
@@ -96,4 +96,13 @@ def Address.fromString (s: String) : Option Address := do
   let ba <- bytesOfHex s
   if ba.size == 32 then .some ⟨ba⟩ else .none
 
+def Address.toUniqueName (addr: Address): Lean.Name :=
+  .str (.str (.str .anonymous "Ix") "_#") (hexOfBytes addr.hash)
+
+def Address.fromUniqueName (name: Lean.Name) : Option Address :=
+  match name with
+  | .str (.str (.str .anonymous "Ix") "_#") s => Address.fromString s
+  | _ => .none
+
+
 
diff --git a/Ix/BuiltIn.lean b/Ix/BuiltIn.lean
index e5de36b2..bd952d6f 100644
--- a/Ix/BuiltIn.lean
+++ b/Ix/BuiltIn.lean
@@ -1,38 +1,86 @@
-import Blake3
-import Ix.Address
-import Ix.Meta
-
-structure Commitment (α : Type _) where
-  adr : Address
-  deriving Inhabited, Lean.ToExpr
-
-instance : ToString (Commitment α) where
-  toString comm := "c" ++ toString comm.adr
-
-def Commitment.ofString (s : String) : Option $ Commitment α :=
-  match s.data with
-  | 'c' :: adrChars => .mk <$> Address.fromString ⟨adrChars⟩
-  | _ => none
-
--- TODO: secrets should be 32-bytes long
-opaque commit (secret : Address) (payload : α) : Commitment α
-opaque secret (comm : Commitment α) : Address
-opaque reveal [Inhabited α] (comm : Commitment α) : α
-opaque revealThen [Inhabited β] (comm : Commitment α) (f : β) : β
-
-def persistCommit (secret : Address) (payload : Address) : IO $ Commitment α :=
-  let commAdr := Blake3.hash $ secret.hash ++ payload.hash
-  -- TODO: persist commitment preimages as private data
-  return ⟨⟨commAdr.val⟩⟩
-
-def mkCommitRaw 
-  (secret : Address) (type : Lean.Expr) (value : Lean.Expr)
-  (consts : Lean.ConstMap)
-  : IO (Commitment α) := do
-  let adr <- computeIxAddress (mkAnonDefInfoRaw type value) consts
-  persistCommit secret adr
-
-def mkCommit [Lean.ToExpr α] (secret : Address) (a : α) (consts : Lean.ConstMap) 
-  : IO (Commitment α) := do
-  let adr <- (computeIxAddress (mkAnonDefInfo a) consts)
-  persistCommit secret adr
+
+namespace Ix
+
+inductive BuiltIn where
+| commit
+| reveal
+deriving Inhabited, Repr, BEq, Ord, Hashable
+
+end Ix
+
+--structure Commitment (α : Type _) where
+--  adr : Address
+--  deriving Inhabited, Lean.ToExpr
+--
+--instance : ToString (Commitment α) where
+--  toString comm := "c" ++ toString comm.adr
+
+--def Commitment.ofString (s : String) : Option $ Commitment α :=
+--  match s.data with
+--  | 'c' :: adrChars => .mk <$> Address.fromString ⟨adrChars⟩
+--  | _ => none
+--
+---- TODO: secrets should be 32-bytes long
+--opaque commit (secret : Address) (payload : α) : Commitment α
+--opaque secret (comm : Commitment α) : Address
+--opaque reveal [Inhabited α] (comm : Commitment α) : α
+--opaque revealThen [Inhabited β] (comm : Commitment α) (f : β) : β
+
+--def persistCommit (secret : Address) (payload : Address) : IO $ Commitment α :=
+--  let commAdr := Blake3.hash $ secret.hash ++ payload.hash
+--  -- TODO: persist commitment preimages as private data
+--  return ⟨⟨commAdr.val⟩⟩
+--
+--def mkCommitRaw 
+--  (secret : Address) (type : Lean.Expr) (value : Lean.Expr)
+--  (consts : Lean.ConstMap)
+--  : IO (Commitment α) := do
+--  let adr <- computeIxAddress (mkAnonDefInfoRaw type value) consts
+--  persistCommit secret adr
+--
+--def mkCommit [Lean.ToExpr α] (secret : Address) (a : α) (consts : Lean.ConstMap) 
+--  : IO (Commitment α) := do
+--  let adr <- (computeIxAddress (mkAnonDefInfo a) consts)
+--  persistCommit secret adr
+
+--namespace Ix.BuiltIn
+
+--inductive Commitment (A: Type _) where
+--| comm
+--
+--opaque commit : Nat -> 
+
+--structure TypeProof where
+--  value : Address
+--  type : Address
+--  bin : ByteArray
+--  deriving Inhabited
+
+--structure TypeProofD (A: Type) where
+--  value : AddressD A
+--  type : AddressD Type
+--  bin : ByteArray
+--  proof: Validates bin type value
+--  deriving Inhabited
+--
+--opaque TypeProof.commit.{u} (α : Type u) (a : α) (secret: Nat := 0)  : TypeProof
+--opaque TypeProof.reveal.{u} (α : Type u) (t: TypeProof) (secret: Nat := 0) : Option α
+--opaque TypeProof.verify (t: TypeProof) : Bool
+--
+--opaque TypeProof.revealD.{u} (α : Type u) (t: TypeProofD) (secret: Nat := 0) : α
+
+--structure EvalProof where
+--  input : TypeProof
+--  output: TypeProof
+--  bin: ByteArray
+--  deriving Inhabited
+--
+--opaque EvalProof.prove (input output: TypeProof) (secret: Nat := 0) : EvalProof
+--opaque EvalProof.verify (p: Proof) : Bool
+--opaque EvalProof.eval.{u} (α: Type u) (p: EvalProof) (a: α) : Option α
+
+-- def f x := if x == 1 then 42 else 0
+-- let p := EvalProof { <f 1 ~> 42> }
+-- p.eval 1 ~> 42
+
+--end Ix.BuiltIn
diff --git a/Ix/CanonM.lean b/Ix/CanonM.lean
deleted file mode 100644
index 7345b16c..00000000
--- a/Ix/CanonM.lean
+++ /dev/null
@@ -1,588 +0,0 @@
-import Batteries.Data.RBMap
-import Ix.TransportM
-import Ix.Ixon.Metadata
-import Ix.Ixon.Const
-import Ix.Ixon.Serialize
-import Ix.Common
-
-open Batteries (RBMap)
-open Batteries (RBSet)
-open Ix.TransportM
-
-namespace Ix.CanonM
-
-inductive CanonMError
-  | unknownConstant : Lean.Name → CanonMError
-  | unfilledLevelMetavariable : Lean.Level → CanonMError
-  | unfilledExprMetavariable : Lean.Expr → CanonMError
-  | invalidBVarIndex : Nat → CanonMError
-  | freeVariableExpr : Lean.Expr → CanonMError
-  | metaVariableExpr : Lean.Expr → CanonMError
-  | metaDataExpr : Lean.Expr → CanonMError
-  | levelNotFound : Lean.Name → List Lean.Name → CanonMError
-  | invalidConstantKind : Lean.Name → String → String → CanonMError
-  | constantNotContentAddressed : Lean.Name → CanonMError
-  | nonRecursorExtractedFromChildren : Lean.Name → CanonMError
-  | cantFindMutDefIndex : Lean.Name → CanonMError
-  | transportError : TransportError → CanonMError
-  deriving Inhabited
-
-instance : ToString CanonMError where toString
-  | .unknownConstant n => s!"Unknown constant '{n}'"
-  | .unfilledLevelMetavariable l => s!"Unfilled level metavariable on universe '{l}'"
-  | .unfilledExprMetavariable e => s!"Unfilled level metavariable on expression '{e}'"
-  | .invalidBVarIndex idx => s!"Invalid index {idx} for bound variable context"
-  | .freeVariableExpr e => s!"Free variable in expression '{e}'"
-  | .metaVariableExpr e => s!"Metavariable in expression '{e}'"
-  | .metaDataExpr e => s!"Meta data in expression '{e}'"
-  | .levelNotFound n ns => s!"'{n}' not found in '{ns}'"
-  | .invalidConstantKind n ex gt =>
-    s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
-  | .constantNotContentAddressed n => s!"Constant '{n}' wasn't content-addressed"
-  | .nonRecursorExtractedFromChildren n =>
-    s!"Non-recursor '{n}' extracted from children"
-  | .cantFindMutDefIndex n => s!"Can't find index for mutual definition '{n}'"
-  | .transportError n => s!"Transport error '{repr n}'"
-
-structure CanonMState where
-  names  : RBMap Lean.Name (Address × Address) compare
-  store  : RBMap Address Ixon.Const compare
-  consts : RBMap Address (RBMap Address Ix.Const compare) compare
-  commits: RBMap Ix.Const (Address × Address) compare
-  blocks : RBSet (Address × Address) compare
-
-def CanonMState.init : CanonMState :=
-  ⟨default, default, default, default, default⟩
-
-structure CanonMCtx where
-  constMap: Lean.ConstMap
-  univCtx : List Lean.Name
-  bindCtx : List Lean.Name
-  recrCtx : RBMap Lean.Name Nat compare
-  --quick : Bool
-  --persist : Bool
-
-def CanonMCtx.init (constMap : Lean.ConstMap) : CanonMCtx :=
-  ⟨constMap, default, default, default⟩
-
-abbrev CanonM := ReaderT CanonMCtx $ ExceptT CanonMError $ StateT CanonMState IO
-
-def withBinder (name : Lean.Name) : CanonM α → CanonM α :=
-  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
-
-def withLevelsAndReset (levels : List Lean.Name) : CanonM α → CanonM α :=
-  withReader $ fun c =>
-    { c with univCtx := levels, bindCtx := [], recrCtx := .empty }
-
-def withRecrs (recrCtx : RBMap Lean.Name Nat compare) :
-    CanonM α → CanonM α :=
-  withReader $ fun c => { c with recrCtx := recrCtx }
-
-def withLevels (lvls : List Lean.Name) : CanonM α → CanonM α :=
-  withReader $ fun c => { c with univCtx := lvls }
-
-def commitConst (const : Ix.Const) : CanonM (Address × Address) := do
-  match (← get).commits.find? const with
-  | some (contAddr, metaAddr) => pure (contAddr, metaAddr)
-  | none => do
-    let (ixon, meta) <- match constToIxon const with
-      | .ok (i, m) => pure (i, m)
-      | .error e => throw (.transportError e)
-    let contAddr := Address.blake3 (Ixon.Serialize.put ixon)
-    let metaAddr := Address.blake3 (Ixon.Serialize.put meta)
-    modifyGet fun stt => ((contAddr, metaAddr), { stt with
-      commits := stt.commits.insert const (contAddr, metaAddr)
-      store := (stt.store.insert contAddr ixon).insert metaAddr meta
-      consts := stt.consts.modify contAddr (fun m => m.insert metaAddr const)
-    })
-
-@[inline] def addConstToStt (name : Lean.Name) (constAddr metaAddr: Address) : CanonM Unit :=
-  modify fun stt =>
-    { stt with names := stt.names.insert name (constAddr, metaAddr) }
-
-@[inline] def addBlockToStt (blockAddr blockMeta : Address) : CanonM Unit :=
-  modify fun stt => { stt with blocks := stt.blocks.insert (blockAddr, blockMeta) }
-
-scoped instance : HMul Ordering Ordering Ordering where hMul
-  | .gt, _ => .gt
-  | .lt, _ => .lt
-  | .eq, x => x
-
-def concatOrds : List Ordering → Ordering :=
-  List.foldl (· * ·) .eq
-
-/-- Defines an ordering for Lean universes -/
-def cmpLevel (x : Lean.Level) (y : Lean.Level) : CanonM Ordering :=
-  match x, y with
-  | .mvar .., _ => throw $ .unfilledLevelMetavariable x
-  | _, .mvar .. => throw $ .unfilledLevelMetavariable y
-  | .zero, .zero => return .eq
-  | .zero, _ => return .lt
-  | _, .zero => return .gt
-  | .succ x, .succ y => cmpLevel x y
-  | .succ .., _ => return .lt
-  | _, .succ .. => return .gt
-  | .max lx ly, .max rx ry => (· * ·) <$> cmpLevel lx rx <*> cmpLevel ly ry
-  | .max .., _ => return .lt
-  | _, .max .. => return .gt
-  | .imax lx ly, .imax rx ry => (· * ·) <$> cmpLevel lx rx <*> cmpLevel ly ry
-  | .imax .., _ => return .lt
-  | _, .imax .. => return .gt
-  | .param x, .param y => do
-    let lvls := (← read).univCtx
-    match (lvls.idxOf? x), (lvls.idxOf? y) with
-    | some xi, some yi => return (compare xi yi)
-    | none,    _       => throw $ .levelNotFound x lvls
-    | _,       none    => throw $ .levelNotFound y lvls
-
-/-- Canonicalizes a Lean universe level and adds it to the store -/
-def canonUniv : Lean.Level → CanonM Ix.Univ
-  | .zero => pure .zero
-  | .succ u => return .succ (← canonUniv u)
-  | .max a b  => return .max  (← canonUniv a) (← canonUniv b)
-  | .imax a b => return .imax (← canonUniv a) (← canonUniv b)
-  | .param name => do
-    let lvls := (← read).univCtx
-    match lvls.idxOf? name with
-    | some n => pure $ .var name n
-    | none   => throw $ .levelNotFound name lvls
-  | l@(.mvar ..) => throw $ .unfilledLevelMetavariable l
-
-
-/-- Retrieves a Lean constant from the environment by its name -/
-def getLeanConstant (name : Lean.Name) : CanonM Lean.ConstantInfo := do
-  match (← read).constMap.find? name with
-  | some const => pure const
-  | none => throw $ .unknownConstant name
-
-def isInternalRec (expr : Lean.Expr) (name : Lean.Name) : Bool :=
-  match expr with
-  | .forallE _ t e _  => match e with
-    | .forallE ..  => isInternalRec e name
-    | _ => isInternalRec t name -- t is the major premise
-  | .app e .. => isInternalRec e name
-  | .const n .. => n == name
-  | _ => false
-
-mutual
-
-partial def canonConst (const : Lean.ConstantInfo) : CanonM (Address × Address) := do
-  match (← get).names.find? const.name with
-  | some (constAddr, metaAddr) => pure (constAddr, metaAddr)
-  | none => match const with
-    | .defnInfo val => withLevelsAndReset val.levelParams $ canonDefinition val
-    | .inductInfo val => withLevelsAndReset val.levelParams $ canonInductive val
-    | .ctorInfo val => do
-      match ← getLeanConstant val.induct with
-      | .inductInfo ind => discard $ canonConst (.inductInfo ind)
-      | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
-      canonConst const
-    | .recInfo val => do
-      match ← getLeanConstant val.getMajorInduct with
-      | .inductInfo ind => discard $ canonConst (.inductInfo ind)
-      | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
-      canonConst const
-    -- The rest adds the constants to the cache one by one
-    | const => withLevelsAndReset const.levelParams do
-      let obj ← match const with
-        | .defnInfo _ | .inductInfo _ | .ctorInfo _ | .recInfo _ => unreachable!
-        | .axiomInfo val =>
-          pure $ .axiom ⟨val.levelParams.length, ← canonExpr val.type⟩
-        | .thmInfo val =>
-          -- Theorems are never truly recursive
-          pure $ .theorem ⟨val.levelParams.length, ← canonExpr val.type,
-            ← canonExpr val.value⟩
-        | .opaqueInfo val =>
-          let recrs := .single val.name 0
-          pure $ .opaque ⟨val.levelParams.length, ← canonExpr val.type,
-            ← withRecrs recrs $ canonExpr val.value⟩
-        | .quotInfo val =>
-          pure $ .quotient ⟨val.levelParams.length, ← canonExpr val.type, val.kind⟩
-      let (constAddr, metaAddr) ← commitConst obj
-      addConstToStt const.name constAddr metaAddr
-      return (constAddr, metaAddr)
-
-partial def canonDefinition (struct : Lean.DefinitionVal) : CanonM (Address × Address):= do
-  -- If the mutual size is one, simply content address the single definition
-  if struct.all matches [_] then
-    let (constAddr, metaAddr) ← commitConst $ .definition
-      (← withRecrs (.single struct.name 0) $ definitionToIR struct)
-    addConstToStt struct.name constAddr metaAddr
-    return (constAddr, metaAddr)
-
-  -- Collecting and sorting all definitions in the mutual block
-  let mutualDefs ← struct.all.mapM fun name => do
-    match ← getLeanConstant name with
-    | .defnInfo defn => pure defn
-    | const => throw $ .invalidConstantKind const.name "definition" const.ctorName
-  let mutualDefs ← sortDefs [mutualDefs]
-
-  -- Building the `recrCtx`
-  let mut recrCtx := default
-  for (ds, i) in List.zipIdx mutualDefs do
-    for d in ds do
-      recrCtx := recrCtx.insert d.name i
-
-  let definitions ← withRecrs recrCtx $ mutualDefs.mapM (·.mapM definitionToIR)
-
-  -- Building and storing the block
-  let definitionsIr := (definitions.map (match ·.head? with
-    | some d => [d] | none => [])).flatten
-  let (blockContAddr, blockMetaAddr) ← commitConst $ .mutDefBlock definitionsIr
-  addBlockToStt blockContAddr blockMetaAddr
-
-  -- While iterating on the definitions from the mutual block, we need to track
-  -- the correct objects to return
-  let mut ret? : Option (Address × Address) := none
-
-  for name in struct.all do
-    -- Storing and caching the definition projection
-    -- Also adds the constant to the array of constants
-    let some idx := recrCtx.find? name | throw $ .cantFindMutDefIndex name
-    let (constAddr, metaAddr) ←
-      commitConst $ .definitionProj ⟨blockContAddr, blockMetaAddr, idx⟩
-    addConstToStt name constAddr metaAddr
-    if struct.name == name then ret? := some (constAddr, metaAddr)
-
-  match ret? with
-  | some ret => return ret
-  | none => throw $ .constantNotContentAddressed struct.name
-
-partial def definitionToIR (defn : Lean.DefinitionVal) : CanonM Ix.Definition :=
-  return ⟨defn.levelParams.length, ← canonExpr defn.type,
-    ← canonExpr defn.value, defn.safety == .partial⟩
-
-/--
-Content-addresses an inductive and all inductives in the mutual block as a
-mutual block, even if the inductive itself is not in a mutual block.
-
-Content-addressing an inductive involves content-addressing its associated
-constructors and recursors, hence the length of this function.
--/
-partial def canonInductive (initInd : Lean.InductiveVal) : CanonM (Address × Address):= do
-  -- `mutualConsts` is the list of the names of all constants associated with an inductive block
-  -- it has the form: ind₁ ++ ctors₁ ++ recrs₁ ++ ... ++ indₙ ++ ctorsₙ ++ recrsₙ
-  let mut inds := []
-  let mut indCtors := []
-  let mut indRecs := []
-  let mut nameData : RBMap Lean.Name (List Lean.Name × List Lean.Name) compare
-    := .empty
-  for indName in initInd.all do
-    match ← getLeanConstant indName with
-    | .inductInfo ind =>
-      let indRecrs := ((← read).constMap.childrenOfWith ind.name
-        fun c => match c with | .recInfo _ => true | _ => false).map (·.name)
-      inds := inds ++ [indName]
-      indCtors := indCtors ++ ind.ctors
-      indRecs := indRecs ++ indRecrs
-      nameData := nameData.insert indName (ind.ctors, indRecrs)
-    | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
-
-  -- `mutualConsts` is the list of the names of all constants associated with an
-  -- inductive block: the inductives themselves, the constructors and the recursors
-  let mutualConsts := inds ++ indCtors ++ indRecs
-
-  let recrCtx := mutualConsts.zipIdx.foldl (init := default)
-    fun acc (n, i) => acc.insert n i
-
-  -- This part will build the inductive block and add all inductives,
-  -- constructors and recursors to `consts`
-  let irInds ← initInd.all.mapM fun name => do match ← getLeanConstant name with
-    | .inductInfo ind => withRecrs recrCtx do pure $ (← inductiveToIR ind)
-    | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
-  let (blockContAddr, blockMetaAddr) ← commitConst $ .mutIndBlock irInds
-  addBlockToStt blockContAddr blockMetaAddr
-
-  -- While iterating on the inductives from the mutual block, we need to track
-  -- the correct objects to return
-  let mut ret? : Option (Address × Address) := none
-  for (indName, indIdx) in initInd.all.zipIdx do
-    -- Store and cache inductive projections
-    let name := indName
-    let (constAddr, metaAddr) ←
-      commitConst $ .inductiveProj ⟨blockContAddr, blockMetaAddr, indIdx⟩
-    addConstToStt name constAddr metaAddr
-    if name == initInd.name then ret? := some (constAddr, metaAddr)
-
-    let some (ctors, recrs) := nameData.find? indName
-      | throw $ .cantFindMutDefIndex indName
-
-    for (ctorName, ctorIdx) in ctors.zipIdx do
-      -- Store and cache constructor projections
-      let (constAddr, metaAddr) ←
-        commitConst $ .constructorProj ⟨blockContAddr, blockMetaAddr, indIdx, ctorIdx⟩
-      addConstToStt ctorName constAddr metaAddr
-
-    for (recrName, recrIdx) in recrs.zipIdx do
-      -- Store and cache recursor projections
-      let (constAddr, metaAddr) ←
-        commitConst $ .recursorProj ⟨blockContAddr, blockMetaAddr, indIdx, recrIdx⟩
-      addConstToStt recrName constAddr metaAddr
-
-  match ret? with
-  | some ret => return ret
-  | none => throw $ .constantNotContentAddressed initInd.name
-
-partial def inductiveToIR (ind : Lean.InductiveVal) : CanonM Ix.Inductive := do
-  let leanRecs := (← read).constMap.childrenOfWith ind.name
-    fun c => match c with | .recInfo _ => true | _ => false
-  let (recs, ctors) ← leanRecs.foldrM (init := ([], []))
-    fun r (recs, ctors) => match r with
-      | .recInfo rv =>
-        if isInternalRec rv.type ind.name then do
-          let (thisRec, thisCtors) := ← internalRecToIR ind.ctors r
-          pure (thisRec :: recs, thisCtors)
-        else do
-          let thisRec ← externalRecToIR r
-          pure (thisRec :: recs, ctors)
-      | _ => throw $ .nonRecursorExtractedFromChildren r.name
-  let (struct, unit) ← if ind.isRec || ind.numIndices != 0 
-  then pure (false, false)
-  else
-    match ctors with
-    -- Structures can only have one constructor
-    | [ctor] => pure (true, ctor.fields == 0)
-    | _ => pure (false, false)
-  return ⟨ind.levelParams.length, ← canonExpr ind.type, ind.numParams, ind.numIndices,
-    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
-    -- match the order used in `recrCtx`
-    ctors, recs, ind.isRec, ind.isReflexive, struct, unit⟩
-
-partial def internalRecToIR (ctors : List Lean.Name)
-  : Lean.ConstantInfo → CanonM (Ix.Recursor × List Ix.Constructor)
-  | .recInfo rec => withLevels rec.levelParams do
-    let typ ← canonExpr rec.type
-    let (retCtors, retRules) ← rec.rules.foldrM (init := ([], []))
-      fun r (retCtors, retRules) => do
-        if ctors.contains r.ctor then
-          let (ctor, rule) ← recRuleToIR r
-          pure $ (ctor :: retCtors, rule :: retRules)
-        else pure (retCtors, retRules) -- this is an external recursor rule
-    let recr := ⟨rec.levelParams.length, typ, rec.numParams, rec.numIndices,
-      rec.numMotives, rec.numMinors, retRules, rec.k, true⟩
-    return (recr, retCtors)
-  | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
-
-partial def recRuleToIR (rule : Lean.RecursorRule)
-  : CanonM (Ix.Constructor × Ix.RecursorRule) := do
-  let rhs ← canonExpr rule.rhs
-  match ← getLeanConstant rule.ctor with
-  | .ctorInfo ctor => withLevels ctor.levelParams do
-    let typ ← canonExpr ctor.type
-    let ctor := ⟨ctor.levelParams.length, typ, ctor.cidx, ctor.numParams, ctor.numFields⟩
-    pure (ctor, ⟨rule.nfields, rhs⟩)
-  | const => throw $ .invalidConstantKind const.name "constructor" const.ctorName
-
-partial def externalRecToIR : Lean.ConstantInfo → CanonM Recursor
-  | .recInfo rec => withLevels rec.levelParams do
-    let typ ← canonExpr rec.type
-    let rules ← rec.rules.mapM externalRecRuleToIR
-    return ⟨rec.levelParams.length, typ, rec.numParams, rec.numIndices,
-      rec.numMotives, rec.numMinors, rules, rec.k, false⟩
-  | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
-
-partial def externalRecRuleToIR (rule : Lean.RecursorRule) : CanonM RecursorRule :=
-  return ⟨rule.nfields, ← canonExpr rule.rhs⟩
-
-/--
-Content-addresses a Lean expression and adds it to the store.
-
-Constants are the tricky case, for which there are two possibilities:
-* The constant belongs to `recrCtx`, representing a recursive call. Those are
-encoded as `.rec_` with indexes based on order in the mutual definition
-* The constant doesn't belong to `recrCtx`, meaning that it's not a recursion
-and thus we can canon the actual constant right away
--/
-partial def canonExpr : Lean.Expr → CanonM Expr
-  | .mdata _ e => canonExpr e
-  | expr => match expr with
-    | .bvar idx => do match (← read).bindCtx.get? idx with
-      -- Bound variables must be in the bind context
-      | some _ => return .var idx
-      | none => throw $ .invalidBVarIndex idx
-    | .sort lvl => return .sort $ ← canonUniv lvl
-    | .const name lvls => do
-      let univs ← lvls.mapM canonUniv
-      match (← read).recrCtx.find? name with
-      | some i => -- recursing!
-        return .rec_ i univs
-      | none => do
-        let (contAddr, metaAddr) ← canonConst (← getLeanConstant name)
-        return .const name contAddr metaAddr univs
-    | .app fnc arg => return .app (← canonExpr fnc) (← canonExpr arg)
-    | .lam name typ bod info =>
-      return .lam name info (← canonExpr typ) (← withBinder name $ canonExpr bod)
-    | .forallE name dom img info =>
-      return .pi name info (← canonExpr dom) (← withBinder name $ canonExpr img)
-    | .letE name typ exp bod nD =>
-      return .letE name (← canonExpr typ) (← canonExpr exp)
-        (← withBinder name $ canonExpr bod) nD
-    | .lit lit => return .lit lit
-    | .proj name idx exp => do
-      let (contAddr, metaAddr) ← canonConst (← getLeanConstant name)
-      return .proj name contAddr metaAddr idx (← canonExpr exp)
-    | .fvar ..  => throw $ .freeVariableExpr expr
-    | .mvar ..  => throw $ .metaVariableExpr expr
-    | .mdata .. => throw $ .metaDataExpr expr
-
-/--
-A name-irrelevant ordering of Lean expressions.
-`weakOrd` contains the best known current mutual ordering
--/
-partial def cmpExpr (weakOrd : RBMap Lean.Name Nat compare) :
-    Lean.Expr → Lean.Expr → CanonM Ordering
-  | e@(.mvar ..), _ => throw $ .unfilledExprMetavariable e
-  | _, e@(.mvar ..) => throw $ .unfilledExprMetavariable e
-  | e@(.fvar ..), _ => throw $ .freeVariableExpr e
-  | _, e@(.fvar ..) => throw $ .freeVariableExpr e
-  | .mdata _ x, .mdata _ y  => cmpExpr weakOrd x y
-  | .mdata _ x, y  => cmpExpr weakOrd x y
-  | x, .mdata _ y  => cmpExpr weakOrd x y
-  | .bvar x, .bvar y => return (compare x y)
-  | .bvar .., _ => return .lt
-  | _, .bvar .. => return .gt
-  | .sort x, .sort y => cmpLevel x y
-  | .sort .., _ => return .lt
-  | _, .sort .. => return .gt
-  | .const x xls, .const y yls => do
-    let univs ← concatOrds <$> (xls.zip yls).mapM fun (x,y) => cmpLevel x y
-    if univs != .eq then return univs
-    match weakOrd.find? x, weakOrd.find? y with
-    | some nx, some ny => return compare nx ny
-    | none, some _ => return .gt
-    | some _, none => return .lt
-    | none, none =>
-      return compare (← canonConst $ ← getLeanConstant x)
-        (← canonConst $ ← getLeanConstant y)
-  | .const .., _ => return .lt
-  | _, .const .. => return .gt
-  | .app xf xa, .app yf ya =>
-    (· * ·) <$> cmpExpr weakOrd xf yf <*> cmpExpr weakOrd xa ya
-  | .app .., _ => return .lt
-  | _, .app .. => return .gt
-  | .lam _ xt xb _, .lam _ yt yb _ =>
-    (· * ·) <$> cmpExpr weakOrd xt yt <*> cmpExpr weakOrd xb yb
-  | .lam .., _ => return .lt
-  | _, .lam .. => return .gt
-  | .forallE _ xt xb _, .forallE _ yt yb _ =>
-    (· * ·) <$> cmpExpr weakOrd xt yt <*> cmpExpr weakOrd xb yb
-  | .forallE .., _ => return .lt
-  | _, .forallE .. => return .gt
-  | .letE _ xt xv xb _, .letE _ yt yv yb _ =>
-    (· * · * ·) <$> cmpExpr weakOrd xt yt <*> cmpExpr weakOrd xv yv <*> cmpExpr weakOrd xb yb
-  | .letE .., _ => return .lt
-  | _, .letE .. => return .gt
-  | .lit x, .lit y =>
-    return if x < y then .lt else if x == y then .eq else .gt
-  | .lit .., _ => return .lt
-  | _, .lit .. => return .gt
-  | .proj _ nx tx, .proj _ ny ty => do
-    let ts ← cmpExpr weakOrd tx ty
-    return concatOrds [compare nx ny, ts]
-
-/-- AST comparison of two Lean definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-partial def cmpDef (weakOrd : RBMap Lean.Name Nat compare)
-  (x : Lean.DefinitionVal) (y : Lean.DefinitionVal) :
-    CanonM Ordering := do
-  let ls := compare x.levelParams.length y.levelParams.length
-  let ts ← cmpExpr weakOrd x.type y.type
-  let vs ← cmpExpr weakOrd x.value y.value
-  return concatOrds [ls, ts, vs]
-
-/-- AST equality between two Lean definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-@[inline] partial def eqDef (weakOrd : RBMap Lean.Name Nat compare)
-    (x y : Lean.DefinitionVal) : CanonM Bool :=
-  return (← cmpDef weakOrd x y) == .eq
-
-/--
-`sortDefs` recursively sorts a list of mutual definitions into weakly equal blocks.
-At each stage, we take as input the current best approximation of known weakly equal
-blocks as a List of blocks, hence the `List (List DefinitionVal)` as the argument type.
-We recursively take the input blocks and resort to improve the approximate known
-weakly equal blocks, obtaining a sequence of list of blocks:
-```
-dss₀ := [startDefs]
-dss₁ := sortDefs dss₀
-dss₂ := sortDefs dss₁
-dss₍ᵢ₊₁₎ := sortDefs dssᵢ ...
-```
-Initially, `startDefs` is simply the list of definitions we receive from `DefinitionVal.all`;
-since there is no order yet, we treat it as one block all weakly equal. On the other hand,
-at the end, there is some point where `dss₍ᵢ₊₁₎ := dssᵢ`, then we have hit a fixed point
-and we may end the sorting process. (We claim that such a fixed point exists, although
-technically we don't really have a proof.)
-
-On each iteration, we hope to improve our knowledge of weakly equal blocks and use that
-knowledge in the next iteration. e.g. We start with just one block with everything in it,
-but the first sort may differentiate the one block into 3 blocks. Then in the second
-iteration, we have more information than than first, since the relationship of the 3 blocks
-gives us more information; this information may then be used to sort again, turning 3 blocks
-into 4 blocks, and again 4 blocks into 6 blocks, etc, until we have hit a fixed point.
-This step is done in the computation of `newDss` and then comparing it to the original `dss`.
-
-Two optimizations:
-
-1. `names := enum dss` records the ordering information in a map for faster access.
-    Directly using `List.findIdx?` on dss is slow and introduces `Option` everywhere.
-    `names` is used as a custom comparison in `ds.sortByM (cmpDef names)`.
-2. `normDss/normNewDss`. We want to compare if two lists of blocks are equal.
-    Technically blocks are sets and their order doesn't matter, but we have encoded
-    them as lists. To fix this, we sort the list by name before comparing. Note we
-    could maybe also use `List (RBTree ..)` everywhere, but it seemed like a hassle.
--/
-partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
-    CanonM (List (List Lean.DefinitionVal)) := do
-  let enum (ll : List (List Lean.DefinitionVal)) :=
-    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
-  let weakOrd := enum dss _
-  let newDss ← (← dss.mapM fun ds =>
-    match ds with
-    | []  => unreachable!
-    | [d] => pure [[d]]
-    | ds  => do pure $ (← List.groupByM (eqDef weakOrd) $
-      ← ds.sortByM (cmpDef weakOrd))).joinM
-
-  -- must normalize, see comments
-  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
-  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
-  if normDss == normNewDss then return newDss
-  else sortDefs newDss
-
-end
-
-
-
-def canonicalizeConst (constMap : Lean.ConstMap) (const: Lean.ConstantInfo)
-  : IO $ Except CanonMError Address := do
-  let canon <-
-    StateT.run (ReaderT.run (canonConst const) (.init constMap)) CanonMState.init
-  match canon with
-  | (.ok (a, _), _) => return .ok a
-  | (.error e, _) => return .error e
-
-/-- Iterates over a list of `Lean.ConstantInfo`, triggering their content-addressing -/
-def canonDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
-  : CanonM Unit := do
-  delta.forM fun _ c => if !c.isUnsafe then discard $ canonConst c else pure ()
-
-/--
-Content-addresses the "delta" of an environment, that is, the content that is
-added on top of the imports.
-
-Important: constants with open references in their expressions are filtered out.
-Open references are variables that point to names which aren't present in the
-`Lean.ConstMap`.
--/
-def canonicalizeDelta
-  (constMap : Lean.ConstMap) (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
-  : IO $ Except CanonMError CanonMState := do
-  match ← StateT.run (ReaderT.run (canonDelta delta) (.init constMap)) CanonMState.init with
-  | (.ok _, stt) => return .ok stt
-  | (.error e, _) => return .error e
-
-def canonicalizeEnv (env : Lean.Environment) : IO $ Except CanonMError CanonMState :=
-  canonicalizeDelta env.constants env.getDelta
-
-end Ix.CanonM
diff --git a/Ix/Claim.lean b/Ix/Claim.lean
new file mode 100644
index 00000000..6fba1369
--- /dev/null
+++ b/Ix/Claim.lean
@@ -0,0 +1,14 @@
+import Ix.Address
+import Ix.Commitment
+
+inductive Claim where
+| checks (lvls type value: Address) : Claim
+| evals (lvls input output type: Address) : Claim
+deriving Inhabited, BEq
+
+instance : ToString Claim where
+  toString
+  | .checks lvls type value => s!"#{value} : {type} @ {lvls}"
+  | .evals lvls inp out type => s!"#{inp} ~> #{out} : {type} @ {lvls}"
+
+
diff --git a/Ix/Cli/StoreCmd.lean b/Ix/Cli/StoreCmd.lean
index eab61026..b710c8a8 100644
--- a/Ix/Cli/StoreCmd.lean
+++ b/Ix/Cli/StoreCmd.lean
@@ -1,14 +1,13 @@
 import Cli
 import Ix.Cronos
 import Ix.Common
-import Ix.CanonM
+import Ix.CompileM
 import Ix.Store
 import Ix.Address
 import Lean
 
 -- ix store <lean file>
 -- ix store get <address>
-
 def runStore (p : Cli.Parsed) : IO UInt32 := do
   let source : String       := p.positionalArg! "source" |>.as! String
   let mut cronos ← Cronos.new.clock "Lean-frontend"
@@ -20,17 +19,15 @@ def runStore (p : Cli.Parsed) : IO UInt32 := do
   cronos ← cronos.clock "Lean-frontend"
   -- Start content-addressing
   cronos ← cronos.clock "content-address"
-  let stt ← match ← Ix.CanonM.canonicalizeDelta leanEnv.constants delta with
-    | .error err => IO.eprintln err; return 1
-    | .ok stt => pure stt
+  let stt ← Ix.Compile.compileDeltaIO leanEnv delta
   stt.names.forM fun name (const, meta) => do
      IO.println <| s!"{name}:"
      IO.println <| s!"  #{const}"
-     IO.println <| s!"  {repr <| stt.store.find! const}"
-     IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! const))}"
+     --IO.println <| s!"  {repr <| stt.store.find! const}"
+     --IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! const))}"
      IO.println <| s!"  #{meta}"
-     IO.println <| s!"  {repr <| stt.store.find! meta}"
-     IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! meta))}"
+     --IO.println <| s!"  {repr <| stt.store.find! meta}"
+     --IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! meta))}"
   --stt.store.forM fun adr const => do
   --   IO.println <| s!"adr' {adr}"
   --   IO.println <| s!"const {repr const}"
diff --git a/Ix/Commitment.lean b/Ix/Commitment.lean
new file mode 100644
index 00000000..870abb45
--- /dev/null
+++ b/Ix/Commitment.lean
@@ -0,0 +1,24 @@
+import Lean
+import Ix.Address
+
+namespace Ix
+
+structure Comm (α : Type 0) where
+  value : Lean.Expr
+  deriving Inhabited
+
+end Ix
+
+--inductive CommError where
+--| openTerm
+--| openCommitment
+--| unknownConst (n: Lean.Name)
+--
+--structure CommCtx where
+--  env : Lean.ConstMap
+--
+--structure CommState where
+--  comms: RBMap Address 
+--
+--abbrev CommM := ReaderT CommCtx <| ExceptT CommError <| StateT CommState
+----abbrev IxM := ReaderT IxMEnv $ ExceptT IxError $ StateT IxMState Id
diff --git a/Ix/Common.lean b/Ix/Common.lean
index c3da7fce..da9234f0 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -177,12 +177,12 @@ def setLibsPaths (s: String) : IO Unit := do
     cmd := "lake"
     args := #["setup-file", s]
   }
-  IO.println s!"setup-file {out.stdout}"
-  IO.println s!"setup-file {out.stderr}"
+  --IO.println s!"setup-file {out.stdout}"
+  --IO.println s!"setup-file {out.stderr}"
   let split := out.stdout.splitOn "\"oleanPath\":[" |>.getD 1 ""
   let split := split.splitOn "],\"loadDynlibPaths\":[" |>.getD 0 ""
   let paths := split.replace "\"" "" |>.splitOn ","|>.map System.FilePath.mk
-  IO.println s!"paths {paths}"
+  --IO.println s!"paths {paths}"
   Lean.initSearchPath (← Lean.findSysroot) paths
 
 def runCmd' (cmd : String) (args : Array String) : IO $ Except String String := do
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
new file mode 100644
index 00000000..4adddb8a
--- /dev/null
+++ b/Ix/CompileM.lean
@@ -0,0 +1,783 @@
+import Batteries.Data.RBMap
+import Ix.TransportM
+import Ix.Ixon.Metadata
+import Ix.Ixon.Const
+import Ix.Ixon.Serialize
+import Ix.Common
+
+open Batteries (RBMap)
+open Batteries (RBSet)
+open Ix.TransportM
+
+namespace Ix.Compile
+
+inductive CompileError
+| unknownConstant : Lean.Name → CompileError
+| unfilledLevelMetavariable : Lean.Level → CompileError
+| unfilledExprMetavariable : Lean.Expr → CompileError
+| invalidBVarIndex : Nat → CompileError
+| freeVariableExpr : Lean.Expr → CompileError
+| metaVariableExpr : Lean.Expr → CompileError
+| metaDataExpr : Lean.Expr → CompileError
+| levelNotFound : Lean.Name → List Lean.Name → CompileError
+| invalidConstantKind : Lean.Name → String → String → CompileError
+| constantNotContentAddressed : Lean.Name → CompileError
+| nonRecursorExtractedFromChildren : Lean.Name → CompileError
+| cantFindMutDefIndex : Lean.Name → CompileError
+| transportError : TransportError → CompileError
+| kernelException : String → CompileError
+| todo
+
+instance : ToString CompileError where toString
+| .unknownConstant n => s!"Unknown constant '{n}'"
+| .unfilledLevelMetavariable l => s!"Unfilled level metavariable on universe '{l}'"
+| .unfilledExprMetavariable e => s!"Unfilled level metavariable on expression '{e}'"
+| .invalidBVarIndex idx => s!"Invalid index {idx} for bound variable context"
+| .freeVariableExpr e => s!"Free variable in expression '{e}'"
+| .metaVariableExpr e => s!"Metavariable in expression '{e}'"
+| .metaDataExpr e => s!"Meta data in expression '{e}'"
+| .levelNotFound n ns => s!"'Level {n}' not found in '{ns}'"
+| .invalidConstantKind n ex gt =>
+  s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
+| .constantNotContentAddressed n => s!"Constant '{n}' wasn't content-addressed"
+| .nonRecursorExtractedFromChildren n =>
+  s!"Non-recursor '{n}' extracted from children"
+| .cantFindMutDefIndex n => s!"Can't find index for mutual definition '{n}'"
+| .transportError n => s!"Transport error '{repr n}'"
+| .kernelException e => e
+| _ => s!"todo"
+
+structure CompileEnv where
+  univCtx : List Lean.Name
+  bindCtx : List Lean.Name
+  mutCtx  : RBMap Lean.Name Nat compare
+  maxHeartBeats: USize
+
+def CompileEnv.init (maxHeartBeats: USize): CompileEnv :=
+  ⟨default, default, default, maxHeartBeats⟩
+
+structure CompileState where
+  env: Lean.Environment
+  names: RBMap Lean.Name (Address × Address) compare
+  store: RBMap Address Ixon.Const compare
+  cache: RBMap Ix.Const (Address × Address) compare
+  comms: RBMap Lean.Name (Address × Address) compare
+  axioms: RBMap Lean.Name (Address × Address) compare
+  blocks: RBSet (Address × Address) compare
+
+def CompileState.init (env: Lean.Environment): CompileState :=
+  ⟨env, default, default, default, default, default, default⟩
+
+abbrev CompileM :=
+  ReaderT CompileEnv <| ExceptT CompileError <| StateT CompileState IO
+
+def CompileM.runIO (maxHeartBeats: USize) (stt: CompileState) (c : CompileM α)
+  : IO (Except CompileError α × CompileState) := do
+  StateT.run (ReaderT.run c (.init maxHeartBeats)) stt
+
+def CompileM.runIO' (maxHeartBeats: USize) (stt: CompileState) (c : CompileM α)
+  : IO (α × CompileState) := do
+  let (res, stt) <- c.runIO maxHeartBeats stt
+  let res <- IO.ofExcept res
+  return (res, stt)
+
+def CompileM.liftIO (io: IO α): CompileM α :=
+  monadLift io
+
+def IO.freshSecret : IO Address := do
+  IO.setRandSeed (← IO.monoNanosNow)
+  let mut secret : ByteArray := default
+  for _ in [:32] do
+    let rand ← IO.rand 0 (UInt8.size - 1)
+    secret := secret.push rand.toUInt8
+  return ⟨secret⟩
+
+def freshSecret : CompileM Address := do
+  CompileM.liftIO IO.freshSecret
+
+-- add binding name to local context
+def withBinder (name: Lean.Name) : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
+
+-- add levels to local context
+def withLevels (lvls : List Lean.Name) : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with univCtx := lvls }
+
+-- add mutual recursion info to local context
+def withMutCtx (mutCtx : RBMap Lean.Name Nat compare) : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with mutCtx := mutCtx }
+
+-- reset local context
+def resetCtx : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := .empty }
+
+def resetCtxWithLevels (lvls: List Lean.Name) : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := .empty }
+
+-- lookup or compute the addresses of a constant
+def hashConst (const: Ix.Const) : CompileM (Address × Address) := do
+  match (<- get).cache.find? const with
+  | some (anonAddr, metaAddr) => pure (anonAddr, metaAddr)
+  | none => do
+    let (anonIxon, metaIxon) <- match constToIxon const with
+    | .ok (a, m) => pure (a, m)
+    | .error e => throw (.transportError e)
+    let anonAddr := Address.blake3 (Ixon.Serialize.put anonIxon)
+    let metaAddr := Address.blake3 (Ixon.Serialize.put metaIxon)
+    modifyGet fun stt => ((anonAddr, metaAddr), { stt with
+      cache := stt.cache.insert const (anonAddr, metaAddr)
+      store := (stt.store.insert anonAddr anonIxon).insert metaAddr metaIxon
+    })
+
+scoped instance : HMul Ordering Ordering Ordering where hMul
+  | .gt, _ => .gt
+  | .lt, _ => .lt
+  | .eq, x => x
+
+def concatOrds : List Ordering → Ordering :=
+  List.foldl (· * ·) .eq
+
+/-- Defines an ordering for Lean universes -/
+def compareLevel (x : Lean.Level) (y : Lean.Level) : CompileM Ordering :=
+  match x, y with
+  | .mvar .., _ => throw $ .unfilledLevelMetavariable x
+  | _, .mvar .. => throw $ .unfilledLevelMetavariable y
+  | .zero, .zero => return .eq
+  | .zero, _ => return .lt
+  | _, .zero => return .gt
+  | .succ x, .succ y => compareLevel x y
+  | .succ .., _ => return .lt
+  | _, .succ .. => return .gt
+  | .max lx ly, .max rx ry => 
+    (· * ·) <$> compareLevel lx rx <*> compareLevel ly ry
+  | .max .., _ => return .lt
+  | _, .max .. => return .gt
+  | .imax lx ly, .imax rx ry => 
+    (· * ·) <$> compareLevel lx rx <*> compareLevel ly ry
+  | .imax .., _ => return .lt
+  | _, .imax .. => return .gt
+  | .param x, .param y => do
+    let lvls := (← read).univCtx
+    match (lvls.idxOf? x), (lvls.idxOf? y) with
+    | some xi, some yi => return (compare xi yi)
+    | none,    _       => throw $ .levelNotFound x lvls
+    | _,       none    => throw $ .levelNotFound y lvls
+
+/-- Canonicalizes a Lean universe level and adds it to the store -/
+def compileLevel : Lean.Level → CompileM Ix.Univ
+| .zero => pure .zero
+| .succ u => return .succ (← compileLevel u)
+| .max a b  => return .max (← compileLevel a) (← compileLevel b)
+| .imax a b => return .imax (← compileLevel a) (← compileLevel b)
+| .param name => do
+  let lvls := (← read).univCtx
+  match lvls.idxOf? name with
+  | some n => pure $ .var name n
+  | none   => throw $ .levelNotFound name lvls
+| l@(.mvar ..) => throw $ .unfilledLevelMetavariable l
+
+/-- Retrieves a Lean constant from the environment by its name -/
+def findLeanConst (name : Lean.Name) : CompileM Lean.ConstantInfo := do
+  match (← get).env.constants.find? name with
+  | some const => pure const
+  | none => throw $ .unknownConstant name
+
+/-- Check if expression is an internal recursor --/
+def isInternalRec (expr : Lean.Expr) (name : Lean.Name) : Bool :=
+  match expr with
+  | .forallE _ t e _  => match e with
+    | .forallE ..  => isInternalRec e name
+    | _ => isInternalRec t name -- t is the major premise
+  | .app e .. => isInternalRec e name
+  | .const n .. => n == name
+  | _ => false
+
+mutual
+
+/-- compile Lean Constant --/
+partial def compileConst (const : Lean.ConstantInfo)
+  : CompileM (Address × Address) := do
+  match (← get).names.find? const.name with
+  | some (anonAddr, metaAddr) => pure (anonAddr, metaAddr)
+  | none => match const with
+    | .defnInfo val =>
+      resetCtxWithLevels val.levelParams $ compileDefinition val
+    | .inductInfo val => 
+      resetCtxWithLevels val.levelParams $ compileInductive val
+    | .ctorInfo val => do
+      match ← findLeanConst val.induct with
+      | .inductInfo ind => discard $ compileConst (.inductInfo ind)
+      | const =>
+        throw $ .invalidConstantKind const.name "inductive" const.ctorName
+      -- this should return by finding the ctor in names via the above some case
+      compileConst const
+    | .recInfo val => do
+      match ← findLeanConst val.getMajorInduct with
+      | .inductInfo ind => discard $ compileConst (.inductInfo ind)
+      | const =>
+        throw $ .invalidConstantKind const.name "inductive" const.ctorName
+      -- this should return by finding the recr in names via the above some case
+      compileConst const
+    -- The rest adds the constants to the cache one by one
+    | .axiomInfo val => resetCtxWithLevels const.levelParams do
+      let c := .axiom ⟨val.levelParams.length, ← compileExpr val.type⟩
+      let (anonAddr, metaAddr) ← hashConst c
+      modify fun stt => { stt with
+        axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
+        names := stt.names.insert const.name (anonAddr, metaAddr)
+      }
+      return (metaAddr, metaAddr)
+    | .thmInfo val => resetCtxWithLevels const.levelParams do
+      let type <- compileExpr val.type
+      let value <- compileExpr val.value
+      let c := .theorem ⟨val.levelParams.length, type, value⟩
+      let (anonAddr, metaAddr) ← hashConst c
+      modify fun stt => { stt with
+        names := stt.names.insert const.name (anonAddr, metaAddr)
+      }
+      return (metaAddr, metaAddr)
+    | .opaqueInfo val => resetCtxWithLevels const.levelParams do
+      let mutCtx := .single val.name 0
+      let type <- compileExpr val.type
+      let value <- withMutCtx mutCtx $ compileExpr val.value
+      let c := .opaque ⟨val.levelParams.length, type, value⟩
+      let (anonAddr, metaAddr) ← hashConst c
+      modify fun stt => { stt with
+        names := stt.names.insert const.name (anonAddr, metaAddr)
+      }
+      return (metaAddr, metaAddr)
+    | .quotInfo val => resetCtxWithLevels const.levelParams do
+      let type <- compileExpr val.type
+      let c := .quotient ⟨val.levelParams.length, type, val.kind⟩
+      let (anonAddr, metaAddr) ← hashConst c
+      modify fun stt => { stt with
+        axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
+        names := stt.names.insert const.name (anonAddr, metaAddr)
+      }
+      return (metaAddr, metaAddr)
+
+/-- compile possibly mutual Lean definition --/
+partial def compileDefinition (struct: Lean.DefinitionVal)
+  : CompileM (Address × Address) := do
+  -- If the mutual size is one, simply content address the single definition
+  if struct.all matches [_] then
+    let defn <- withMutCtx (.single struct.name 0) $ definitionToIR struct
+    let (anonAddr, metaAddr) <- hashConst $ .definition defn
+    modify fun stt => { stt with
+      names := stt.names.insert struct.name (anonAddr, metaAddr)
+    }
+    return (anonAddr, metaAddr)
+  -- Collecting and sorting all definitions in the mutual block
+  let mutualDefs <- struct.all.mapM fun name => do
+    match <- findLeanConst name with
+      | .defnInfo defn => pure defn
+      | const => 
+        throw $ .invalidConstantKind const.name "definition" const.ctorName
+  let mutualDefs <- sortDefs [mutualDefs]
+  -- Building the `mutCtx`
+  let mut mutCtx := default
+  for (ds, i) in List.zipIdx mutualDefs do
+    for d in ds do
+      mutCtx := mutCtx.insert d.name i
+  let definitions ← withMutCtx mutCtx $ mutualDefs.mapM (·.mapM definitionToIR)
+  -- Building and storing the block
+  -- TODO: check if this flatten call actually makes sense
+  let definitionsIR := (definitions.map (match ·.head? with
+    | some d => [d] | none => [])).flatten
+  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .mutDefBlock definitionsIR
+  modify fun stt =>
+    { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
+  -- While iterating on the definitions from the mutual block, we need to track
+  -- the correct objects to return
+  let mut ret? : Option (Address × Address) := none
+  for name in struct.all do
+    -- Storing and caching the definition projection
+    -- Also adds the constant to the array of constants
+    let some idx := mutCtx.find? name | throw $ .cantFindMutDefIndex name
+    let (anonAddr, metaAddr) ←
+      hashConst $ .definitionProj ⟨blockAnonAddr, blockMetaAddr, idx⟩
+    modify fun stt => { stt with
+      names := stt.names.insert name (anonAddr, metaAddr)
+    }
+    if struct.name == name then ret? := some (anonAddr, metaAddr)
+  match ret? with
+  | some ret => return ret
+  | none => throw $ .constantNotContentAddressed struct.name
+
+
+partial def definitionToIR (defn: Lean.DefinitionVal)
+  : CompileM Ix.Definition := do
+  let type <- compileExpr defn.type
+  let value <- compileExpr defn.value
+  return ⟨defn.levelParams.length, type, value, defn.safety == .partial⟩
+
+/--
+Content-addresses an inductive and all inductives in the mutual block as a
+mutual block, even if the inductive itself is not in a mutual block.
+
+Content-addressing an inductive involves content-addressing its associated
+constructors and recursors, hence the complexity of this function.
+-/
+partial def compileInductive (initInd: Lean.InductiveVal) 
+  : CompileM (Address × Address) := do
+  let mut inds := []
+  let mut indCtors := []
+  let mut indRecs := []
+  let mut nameData : RBMap Lean.Name (List Lean.Name × List Lean.Name) compare
+    := .empty
+  for indName in initInd.all do
+    match ← findLeanConst indName with
+    | .inductInfo ind =>
+      let indRecrs := ((← get).env.constants.childrenOfWith ind.name
+        fun c => match c with | .recInfo _ => true | _ => false).map (·.name)
+      inds := inds ++ [indName]
+      indCtors := indCtors ++ ind.ctors
+      indRecs := indRecs ++ indRecrs
+      nameData := nameData.insert indName (ind.ctors, indRecrs)
+    | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
+  -- `mutualConsts` is the list of the names of all constants associated with an
+  -- inductive block: the inductives themselves, the constructors and the recursors
+  let mutualConsts := inds ++ indCtors ++ indRecs
+  let mutCtx := mutualConsts.zipIdx.foldl (init := default)
+    fun acc (n, i) => acc.insert n i
+  -- This part builds the inductive block
+  -- and adds all inductives, constructors and recursors to `consts`
+  let irInds ← initInd.all.mapM fun name => do match ← findLeanConst name with
+    | .inductInfo ind => withMutCtx mutCtx do pure $ (← inductiveToIR ind)
+    | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
+  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .mutIndBlock irInds
+  modify fun stt =>
+    { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
+  -- While iterating on the inductives from the mutual block, we need to track
+  -- the correct objects to return
+  let mut ret? : Option (Address × Address) := none
+  for (indName, indIdx) in initInd.all.zipIdx do
+    -- Store and cache inductive projections
+    let name := indName
+    let (anonAddr, metaAddr) ←
+      hashConst $ .inductiveProj ⟨blockAnonAddr, blockMetaAddr, indIdx⟩
+    modify fun stt => { stt with
+      names := stt.names.insert name (anonAddr, metaAddr)
+    }
+    if name == initInd.name then ret? := some (anonAddr, metaAddr)
+    let some (ctors, recrs) := nameData.find? indName
+      | throw $ .cantFindMutDefIndex indName
+    for (ctorName, ctorIdx) in ctors.zipIdx do
+      -- Store and cache constructor projections
+      let (anonAddr, metaAddr) ←
+        hashConst $ .constructorProj
+          ⟨blockAnonAddr, blockMetaAddr, indIdx, ctorIdx⟩
+      modify fun stt => { stt with
+        names := stt.names.insert ctorName (anonAddr, metaAddr)
+      }
+    for (recrName, recrIdx) in recrs.zipIdx do
+      -- Store and cache recursor projections
+      let (anonAddr, metaAddr) ←
+        hashConst $ .recursorProj
+          ⟨blockAnonAddr, blockMetaAddr, indIdx, recrIdx⟩
+      modify fun stt => { stt with
+        names := stt.names.insert recrName (anonAddr, metaAddr)
+      }
+  match ret? with
+  | some ret => return ret
+  | none => throw $ .constantNotContentAddressed initInd.name
+
+partial def inductiveToIR (ind : Lean.InductiveVal) : CompileM Ix.Inductive := do
+  let leanRecs := (← get).env.constants.childrenOfWith ind.name
+    fun c => match c with | .recInfo _ => true | _ => false
+  let (recs, ctors) ← leanRecs.foldrM (init := ([], []))
+    fun r (recs, ctors) => match r with
+      | .recInfo rv =>
+        if isInternalRec rv.type ind.name then do
+          let (thisRec, thisCtors) := ← internalRecToIR ind.ctors r
+          pure (thisRec :: recs, thisCtors)
+        else do
+          let thisRec ← externalRecToIR r
+          pure (thisRec :: recs, ctors)
+      | _ => throw $ .nonRecursorExtractedFromChildren r.name
+  let (struct, unit) ← if ind.isRec || ind.numIndices != 0 
+  then pure (false, false)
+  else
+    match ctors with
+    -- Structures can only have one constructor
+    | [ctor] => pure (true, ctor.fields == 0)
+    | _ => pure (false, false)
+  return ⟨ind.levelParams.length, ← compileExpr ind.type, ind.numParams, ind.numIndices,
+    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
+    -- match the order used in `recrCtx`
+    ctors, recs, ind.isRec, ind.isReflexive, struct, unit⟩
+
+partial def internalRecToIR (ctors : List Lean.Name)
+  : Lean.ConstantInfo → CompileM (Ix.Recursor × List Ix.Constructor)
+  | .recInfo rec => withLevels rec.levelParams do
+    let typ ← compileExpr rec.type
+    let (retCtors, retRules) ← rec.rules.foldrM (init := ([], []))
+      fun r (retCtors, retRules) => do
+        if ctors.contains r.ctor then
+          let (ctor, rule) ← recRuleToIR r
+          pure $ (ctor :: retCtors, rule :: retRules)
+        else pure (retCtors, retRules) -- this is an external recursor rule
+    let recr := ⟨rec.levelParams.length, typ, rec.numParams, rec.numIndices,
+      rec.numMotives, rec.numMinors, retRules, rec.k, true⟩
+    return (recr, retCtors)
+  | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
+
+partial def recRuleToIR (rule : Lean.RecursorRule)
+  : CompileM (Ix.Constructor × Ix.RecursorRule) := do
+  let rhs ← compileExpr rule.rhs
+  match ← findLeanConst rule.ctor with
+  | .ctorInfo ctor => withLevels ctor.levelParams do
+    let typ ← compileExpr ctor.type
+    let ctor :=
+      ⟨ctor.levelParams.length, typ, ctor.cidx, ctor.numParams, ctor.numFields⟩
+    pure (ctor, ⟨rule.nfields, rhs⟩)
+  | const =>
+    throw $ .invalidConstantKind const.name "constructor" const.ctorName
+
+partial def externalRecToIR : Lean.ConstantInfo → CompileM Recursor
+  | .recInfo rec => withLevels rec.levelParams do
+    let typ ← compileExpr rec.type
+    let rules ← rec.rules.mapM externalRecRuleToIR
+    return ⟨rec.levelParams.length, typ, rec.numParams, rec.numIndices,
+      rec.numMotives, rec.numMinors, rules, rec.k, false⟩
+  | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
+
+partial def externalRecRuleToIR (rule : Lean.RecursorRule) 
+  : CompileM RecursorRule :=
+  return ⟨rule.nfields, ← compileExpr rule.rhs⟩
+
+/--
+Content-addresses a Lean expression and adds it to the store.
+
+Constants are the tricky case, for which there are two possibilities:
+* The constant belongs to `mutCtx`, representing a recursive call. Those are
+encoded as `.rec_` with indexes based on order in the mutual definition
+* The constant doesn't belong to `mutCtx`, meaning that it's not a recursion
+and thus we can canon the actual constant right away
+-/
+partial def compileExpr : Lean.Expr → CompileM Expr
+| .mdata _ e => compileExpr e
+| expr => match expr with
+  | .bvar idx => do match (← read).bindCtx.get? idx with
+    -- Bound variables must be in the bind context
+    | some _ => return .var idx
+    | none => throw $ .invalidBVarIndex idx
+  | .sort lvl => return .sort $ ← compileLevel lvl
+  | .const name lvls => do
+    let univs ← lvls.mapM compileLevel
+    match (← read).mutCtx.find? name with
+    -- recursing!
+    | some i => return .rec_ i univs
+    | none => match (<- get).comms.find? name with
+      | some (commAddr, metaAddr) => do
+        return .const name commAddr metaAddr univs
+      | none => do
+        let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
+        return .const name contAddr metaAddr univs
+  | .app fnc arg => return .app (← compileExpr fnc) (← compileExpr arg)
+  | .lam name typ bod info =>
+    return .lam name info (← compileExpr typ) (← withBinder name $ compileExpr bod)
+  | .forallE name dom img info =>
+    return .pi name info (← compileExpr dom) (← withBinder name $ compileExpr img)
+  | .letE name typ exp bod nD =>
+    return .letE name (← compileExpr typ) (← compileExpr exp)
+      (← withBinder name $ compileExpr bod) nD
+  | .lit lit => return .lit lit
+  | .proj name idx exp => do
+    let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
+    return .proj name contAddr metaAddr idx (← compileExpr exp)
+  | .fvar ..  => throw $ .freeVariableExpr expr
+  | .mvar ..  => throw $ .metaVariableExpr expr
+  | .mdata .. => throw $ .metaDataExpr expr
+
+partial def makeLeanDef
+  (name: Lean.Name) (levelParams: List Lean.Name) (type value: Lean.Expr) 
+  : Lean.DefinitionVal :=
+  { name, levelParams, type, value, hints := .opaque, safety := .safe }
+
+partial def tryAddLeanDecl (defn: Lean.DefinitionVal) : CompileM Unit := do
+  match (<- get).env.constants.find? defn.name with
+  | some _ => pure ()
+  | none => do
+    let env <- (·.env) <$> get
+    let maxHeartBeats <- (·.maxHeartBeats) <$> read
+    let decl := Lean.Declaration.defnDecl defn
+    match Lean.Environment.addDeclCore env maxHeartBeats decl .none with
+    | .ok e => do
+      modify fun stt => { stt with env := e }
+      return ()
+    | .error e => do
+      let x <- (e.toMessageData .empty).format
+      throw $ .kernelException (x.pretty 80)
+
+partial def addDef (lvls: List Lean.Name) (typ val: Lean.Expr)
+  : CompileM (Address × Address) := do
+  let typ' <- compileExpr typ
+  let val' <- compileExpr val
+  let (a, m) <- hashConst $ Ix.Const.definition ⟨lvls.length, typ', val', true⟩
+  tryAddLeanDecl (makeLeanDef a.toUniqueName lvls typ val)
+  return (a, m)
+
+partial def commitConst (anon meta: Address)
+  : CompileM (Address × Address) := do
+  let secret <- freshSecret
+  let comm := .comm ⟨secret, anon⟩
+  let commAddr := Address.blake3 (Ixon.Serialize.put comm)
+  let commMeta := .comm ⟨secret, meta⟩
+  let commMetaAddr := Address.blake3 (Ixon.Serialize.put commMeta)
+  modify fun stt => { stt with
+    store := (stt.store.insert commAddr comm).insert commMetaAddr commMeta
+    comms := stt.comms.insert commAddr.toUniqueName (commAddr, commMetaAddr)
+  }
+  return (commAddr, commMetaAddr)
+
+partial def addCommitment (lvls: List Lean.Name) (typ val: Lean.Expr)
+  : CompileM (Address × Address) := do
+  let (a, m) <- addDef lvls typ val
+  let (ca, cm) <- commitConst a m
+  tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ val)
+  return (ca, cm)
+
+/--
+A name-irrelevant ordering of Lean expressions.
+`weakOrd` contains the best known current mutual ordering
+-/
+partial def compareExpr (weakOrd : RBMap Lean.Name Nat compare)
+  : Lean.Expr → Lean.Expr → CompileM Ordering
+  | e@(.mvar ..), _ => throw $ .unfilledExprMetavariable e
+  | _, e@(.mvar ..) => throw $ .unfilledExprMetavariable e
+  | e@(.fvar ..), _ => throw $ .freeVariableExpr e
+  | _, e@(.fvar ..) => throw $ .freeVariableExpr e
+  | .mdata _ x, .mdata _ y  => compareExpr weakOrd x y
+  | .mdata _ x, y  => compareExpr weakOrd x y
+  | x, .mdata _ y  => compareExpr weakOrd x y
+  | .bvar x, .bvar y => return (compare x y)
+  | .bvar .., _ => return .lt
+  | _, .bvar .. => return .gt
+  | .sort x, .sort y => compareLevel x y
+  | .sort .., _ => return .lt
+  | _, .sort .. => return .gt
+  | .const x xls, .const y yls => do
+    let univs ← concatOrds <$> (xls.zip yls).mapM fun (x,y) => compareLevel x y
+    if univs != .eq then return univs
+    match weakOrd.find? x, weakOrd.find? y with
+    | some nx, some ny => return compare nx ny
+    | none, some _ => return .gt
+    | some _, none => return .lt
+    | none, none =>
+      return compare
+        (← compileConst $ ← findLeanConst x)
+        (← compileConst $ ← findLeanConst y)
+  | .const .., _ => return .lt
+  | _, .const .. => return .gt
+  | .app xf xa, .app yf ya =>
+    (· * ·) <$> compareExpr weakOrd xf yf <*> compareExpr weakOrd xa ya
+  | .app .., _ => return .lt
+  | _, .app .. => return .gt
+  | .lam _ xt xb _, .lam _ yt yb _ =>
+    (· * ·) <$> compareExpr weakOrd xt yt <*> compareExpr weakOrd xb yb
+  | .lam .., _ => return .lt
+  | _, .lam .. => return .gt
+  | .forallE _ xt xb _, .forallE _ yt yb _ =>
+    (· * ·) <$> compareExpr weakOrd xt yt <*> compareExpr weakOrd xb yb
+  | .forallE .., _ => return .lt
+  | _, .forallE .. => return .gt
+  | .letE _ xt xv xb _, .letE _ yt yv yb _ =>
+    (· * · * ·) <$> compareExpr weakOrd xt yt <*> compareExpr weakOrd xv yv <*> compareExpr weakOrd xb yb
+  | .letE .., _ => return .lt
+  | _, .letE .. => return .gt
+  | .lit x, .lit y =>
+    return if x < y then .lt else if x == y then .eq else .gt
+  | .lit .., _ => return .lt
+  | _, .lit .. => return .gt
+  | .proj _ nx tx, .proj _ ny ty => do
+    let ts ← compareExpr weakOrd tx ty
+    return concatOrds [compare nx ny, ts]
+
+/-- AST comparison of two Lean definitions.
+  `weakOrd` contains the best known current mutual ordering -/
+partial def compareDef
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (x : Lean.DefinitionVal) 
+  (y : Lean.DefinitionVal) 
+  : CompileM Ordering := do
+  let ls := compare x.levelParams.length y.levelParams.length
+  let ts ← compareExpr weakOrd x.type y.type
+  let vs ← compareExpr weakOrd x.value y.value
+  return concatOrds [ls, ts, vs]
+
+/-- AST equality between two Lean definitions.
+  `weakOrd` contains the best known current mutual ordering -/
+@[inline] partial def eqDef
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (x y : Lean.DefinitionVal) 
+  : CompileM Bool :=
+  return (← compareDef weakOrd x y) == .eq
+
+/--
+`sortDefs` recursively sorts a list of mutual definitions into weakly equal blocks.
+At each stage, we take as input the current best approximation of known weakly equal
+blocks as a List of blocks, hence the `List (List DefinitionVal)` as the argument type.
+We recursively take the input blocks and resort to improve the approximate known
+weakly equal blocks, obtaining a sequence of list of blocks:
+```
+dss₀ := [startDefs]
+dss₁ := sortDefs dss₀
+dss₂ := sortDefs dss₁
+dss₍ᵢ₊₁₎ := sortDefs dssᵢ ...
+```
+Initially, `startDefs` is simply the list of definitions we receive from `DefinitionVal.all`;
+since there is no order yet, we treat it as one block all weakly equal. On the other hand,
+at the end, there is some point where `dss₍ᵢ₊₁₎ := dssᵢ`, then we have hit a fixed point
+and we may end the sorting process. (We claim that such a fixed point exists, although
+technically we don't really have a proof.)
+
+On each iteration, we hope to improve our knowledge of weakly equal blocks and use that
+knowledge in the next iteration. e.g. We start with just one block with everything in it,
+but the first sort may differentiate the one block into 3 blocks. Then in the second
+iteration, we have more information than than first, since the relationship of the 3 blocks
+gives us more information; this information may then be used to sort again, turning 3 blocks
+into 4 blocks, and again 4 blocks into 6 blocks, etc, until we have hit a fixed point.
+This step is done in the computation of `newDss` and then comparing it to the original `dss`.
+
+Two optimizations:
+
+1. `names := enum dss` records the ordering information in a map for faster access.
+    Directly using `List.findIdx?` on dss is slow and introduces `Option` everywhere.
+    `names` is used as a custom comparison in `ds.sortByM (cmpDef names)`.
+2. `normDss/normNewDss`. We want to compare if two lists of blocks are equal.
+    Technically blocks are sets and their order doesn't matter, but we have encoded
+    them as lists. To fix this, we sort the list by name before comparing. Note we
+    could maybe also use `List (RBTree ..)` everywhere, but it seemed like a hassle.
+-/
+partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
+    CompileM (List (List Lean.DefinitionVal)) := do
+  let enum (ll : List (List Lean.DefinitionVal)) :=
+    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
+  let weakOrd := enum dss _
+  let newDss ← (← dss.mapM fun ds =>
+    match ds with
+    | []  => unreachable!
+    | [d] => pure [[d]]
+    | ds  => do pure $ (← List.groupByM (eqDef weakOrd) $
+      ← ds.sortByM (compareDef weakOrd))).joinM
+
+  -- must normalize, see comments
+  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
+  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
+  if normDss == normNewDss then return newDss
+  else sortDefs newDss
+
+end
+
+partial def packLevel (lvls: Nat) (commit: Bool): CompileM Address :=
+  match Ixon.natPackAsAddress lvls with
+  | some lvlsAddr => do
+    if commit then
+      let secret <- freshSecret
+      let comm := Ixon.Comm.mk secret lvlsAddr
+      let commAddr := Address.blake3 (Ixon.Serialize.put (Ixon.Const.comm comm))
+      modify fun stt => { stt with
+        store := stt.store.insert commAddr (Ixon.Const.comm comm)
+        comms := stt.comms.insert commAddr.toUniqueName (commAddr, commAddr)
+      }
+      return commAddr
+    else return lvlsAddr
+  | .none => throw .todo
+
+partial def checkClaim
+  (const: Lean.Name)
+  (type: Lean.Expr)
+  (sort: Lean.Expr)
+  (lvls: List Lean.Name)
+  (commit: Bool)
+  : CompileM (Claim × Address × Address) := do
+  let leanConst <- findLeanConst const
+  let (value, valMeta) <- compileConst leanConst >>= comm
+  let (type, typeMeta) <- addDef lvls sort type >>= comm
+  let lvls <- packLevel lvls.length commit
+  return (Claim.checks lvls type value, typeMeta, valMeta)
+  where
+    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
+
+partial def evalClaimByName
+  (input: Lean.Name)
+  (output: Lean.Expr)
+  (type: Lean.Expr)
+  (sort: Lean.Expr)
+  (lvls: List Lean.Name)
+  (commit: Bool)
+  : CompileM (Claim × Address × Address × Address) := do
+  let leanConst <- findLeanConst input
+  let (input, inputMeta) <- compileConst leanConst >>= comm
+  let (output, outputMeta) <- addDef lvls type output >>= comm
+  let (type, typeMeta) <- addDef lvls sort type >>= comm
+  let lvlsAddr <- packLevel lvls.length commit
+  return (Claim.evals lvlsAddr input output type, inputMeta, outputMeta, typeMeta)
+  where
+    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
+
+partial def makeEvalInput
+  (lvls: List Lean.Name)
+  (typeAnon typeMeta funcAnon funcMeta: Address) 
+  (args : List (Address × Address))
+  : CompileM (Address × Address) := do
+  let univs := lvls.zipIdx.map (fun (n, i) => Ix.Univ.var n i)
+  let type := Ix.Expr.const typeAnon.toUniqueName typeAnon typeMeta univs
+  let func := Ix.Expr.const funcAnon.toUniqueName funcAnon funcMeta univs
+  let argConsts := args.map $ fun (a,m) => Ix.Expr.const a.toUniqueName a m univs
+  let val := argConsts.foldl Expr.app func
+  hashConst $ Ix.Const.definition ⟨lvls.length, type, val, true⟩
+
+
+partial def evalClaimWithArgs
+  (func: Lean.Name)
+  (args: List (Lean.Expr × Lean.Expr))
+  (output: Lean.Expr)
+  (type: Lean.Expr)
+  (sort: Lean.Expr)
+  (lvls: List Lean.Name)
+  (commit: Bool)
+  : CompileM (Claim × Address × Address × Address) := do
+  let leanConst <- findLeanConst func
+  let (funcAnon, funcMeta) <- compileConst leanConst >>= comm
+  let (typeAnon, typeMeta) <- addDef lvls sort type >>= comm
+  let (outputAnon, outputMeta) <- addDef lvls type output >>= comm
+  let args <- args.mapM $ fun (arg, argType) => 
+    addDef lvls argType arg >>= comm
+  let (inputAnon, inputMeta) <-
+    makeEvalInput lvls typeAnon typeMeta funcAnon funcMeta args
+  let lvlsAddr <- packLevel lvls.length false
+  return (Claim.evals lvlsAddr inputAnon outputAnon typeAnon, inputMeta, outputMeta, typeMeta)
+  where
+    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
+
+def compileConstIO (env : Lean.Environment ) (const: Lean.ConstantInfo)
+  : IO $ (Address × Address) × CompileState := do
+  let (a, s) <- (compileConst const).runIO 200000 (.init env)
+  let a <- IO.ofExcept a
+  return (a, s)
+
+def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
+  : CompileM Unit := do
+  delta.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
+
+/--
+Content-addresses the "delta" of an environment, that is, the content that is
+added on top of the imports.
+
+Important: constants with open references in their expressions are filtered out.
+Open references are variables that point to names which aren't present in the
+`Lean.ConstMap`.
+-/
+def compileDeltaIO
+  (env: Lean.Environment)
+  (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
+  : IO CompileState := do
+  let (res, stt) <- (compileDelta delta).runIO 200000 (.init env)
+  IO.ofExcept res
+  return stt
+
+def compileEnvIO (env: Lean.Environment) : IO CompileState := do
+  compileDeltaIO env env.getDelta
+
diff --git a/Ix/IxM.lean b/Ix/IxM.lean
index d3429793..ddcc82ea 100644
--- a/Ix/IxM.lean
+++ b/Ix/IxM.lean
@@ -1,174 +1,107 @@
-import Blake3
-import Ix.Address
-import Ix.Ixon
-import Ix.Ixon.Serialize
-import Ix.Meta
-import Ix.CanonM
-import Batteries.Data.RBMap
-import Lean
-import Ix.Prove
-
-open Batteries (RBMap)
-
-namespace Ix
-
-inductive IxError
-| todo
-
-instance : ToString IxError where
-  toString p := s!"todo"
-
---instance : ToString Proof where
---  toString p := s!"<#{p.inp} ~> #{p.out} : #{p.typ}>"
-
---inductive IxVMOp where
---| commit (payload secret comm: Address) : IxVMOp
---| reveal (payload secret comm: Address) : IxVMOp
-
-structure IxMEnv where
-  names : RBMap Lean.Name (Address × Address) compare
-  consts: RBMap Address Ixon.Const compare
-  secret: Address
-
-structure IxMState where
-  comms : RBMap Address Ixon.Comm compare
-  -- transcript : List IxVMOp
-  main : Option (Address × Ixon.Const)
-  deriving Inhabited
-
-abbrev IxM := ReaderT IxMEnv $ ExceptT IxError $ StateT IxMState Id
-
-def IxM.run (env: Lean.Environment) (secret: Lean.Name) (ixm: IxM Claim)
-  : IO (Claim × IxMState × IxMEnv) := do
-  let stt <- IO.ofExcept (<- Ix.CanonM.canonicalizeEnv env)
-  let (secret, _) := stt.names.find! secret
-  let env := IxMEnv.mk stt.names stt.store secret
-  let (res, stt) := Id.run (StateT.run (ReaderT.run ixm env) default)
-  let claim <- IO.ofExcept res
-  return (claim, stt, env)
-
-def IxM.commit (payload: Address): IxM Address := do
-  let secret <- (·.secret) <$> read
-  let comm := Ixon.Comm.mk secret payload
-  let addr := Address.blake3 (Ixon.Serialize.put (Ixon.Const.comm comm))
-  modify (fun stt => { stt with 
-    comms := stt.comms.insert addr comm 
-    -- transcript := (.commit payload secret addr)::stt.transcript
-  })
-  return addr
-
-def IxM.byName (name: Lean.Name) : IxM Address := do
-  let env <- read
-  match env.names.find? name with
-  | .none => throw .todo
-  | .some (addr, _) => return addr
-
-def IxM.reveal (comm: Address) : IxM Address := do
-  let stt <- get
-  match stt.comms.find? comm with
-  | .some c => return c.payload
-  | .none => throw .todo
-
-def IxM.secret (comm: Address) : IxM Address := do
-  let stt <- get
-  match stt.comms.find? comm with
-  | .some c => return c.secret
-  | .none => throw .todo
-
-def IxM.mkMainConst (type func: Address) (args: List Address): Ixon.Const :=
-  match args with
-  | [] =>
-    Ixon.Const.defn {
-      lvls := 0,
-      type := Ixon.Expr.cnst type [],
-      value := Ixon.Expr.cnst func [],
-      part := .true,
-    }
-  | a::as => 
-    let as':= as.map (fun a => Ixon.Expr.cnst a [])
-    Ixon.Const.defn {
-      lvls := 0,
-      type := Ixon.Expr.cnst type [],
-      value := Ixon.Expr.apps (Ixon.Expr.cnst func []) (Ixon.Expr.cnst a []) as' ,
-      part := .true,
-    }
-
-def IxM.mkMain (type func: Address) (args: List Address): IxM Address := do
-  let mainConst := IxM.mkMainConst type func args
-  let bytes := Ixon.Serialize.put mainConst
-  let addr := Address.blake3 bytes
-  modify (fun stt => { stt with main := .some (addr, mainConst) })
-  return addr
-
-def IxM.evaluate (type input: Address) : IxM Address := sorry
-
-def IxM.prove (claim : Claim) (stt: IxMState) (env: IxMEnv) : IO Proof :=
-  sorry
-
-end Ix
-
-namespace ZKVoting
-
-def secret : Nat := 42
-
-inductive Candidate
-   | alice | bob | charlie
-   deriving Inhabited, Lean.ToExpr, Repr
-
-inductive Result
-| winner : Candidate -> Result
-| tie : List Candidate -> Result
-deriving Repr
-
-def privateVotes : List Candidate := [.alice, .alice, .bob]
-
-def runElection (votes: List Candidate) : Result :=
-  let (a, b, c) := votes.foldr tally (0,0,0)
-  if a > b && a > c
-  then .winner .alice
-  else if b > a && b > c
-  then .winner .bob
-  else if c > a && c > b
-  then .winner .charlie
-  else if a == b && b == c
-  then .tie [.alice, .bob, .charlie]
-  else if a == b
-  then .tie [.alice, .bob]
-  else if a == c
-  then .tie [.alice, .charlie]
-  else .tie [.bob, .charlie]
-    where
-      tally : Candidate -> (Nat × Nat × Nat) -> (Nat × Nat × Nat)
-      | .alice, (a, b, c) => (a+1, b, c)
-      | .bob, (a, b, c) => (a, b+1, c)
-      | .charlie, (a, b, c) => (a, b, c+1)
-
-def claim : Ix.IxM Claim := do
-  let func <- Ix.IxM.byName `ZKVoting.runElection
-  let type <- Ix.IxM.byName `ZKVoting.Result
-  let argm <- Ix.IxM.byName `ZKVoting.privateVotes >>= Ix.IxM.commit
-  let main <- Ix.IxM.mkMain type func [argm]
-  let output <- Ix.IxM.evaluate type main
-  return Claim.mk main output type
-
-def main : IO Proof := do
-  let env <- get_env!
-  let (claim, stt, env) <- Ix.IxM.run env `ZKVoting.secret claim
-  Ix.IxM.prove claim stt env
-
-end ZKVoting
-
--- IxVM
--- ingress : Address -> Ptr
--- eval    : Ptr -> Ptr
--- check   : Ptr -> Ptr -> Bool
--- commit  : Ptr -> Ptr -> Comm
--- reveal  : Comm -> Ptr
--- egress  : Ptr -> Address
-
--- IxM
--- eval    : Address -> Address
--- check   : Address -> Bool
--- commit  : Address -> Address -> Comm
--- reveal  : Comm -> Address
-
+--import Blake3
+
+--import Ix.Address
+--import Ix.Ixon
+--import Ix.Ixon.Serialize
+--import Ix.Meta
+--import Ix.CanonM
+--import Batteries.Data.RBMap
+--import Lean
+--import Ix.Prove
+
+--open Batteries (RBMap)
+
+--namespace Ix
+--
+--inductive IxError
+--| todo
+--
+--instance : ToString IxError where
+--  toString p := s!"todo"
+--
+----instance : ToString Proof where
+----  toString p := s!"<#{p.inp} ~> #{p.out} : #{p.typ}>"
+--
+--structure IxMEnv where
+--  names : RBMap Lean.Name (Address × Address) compare
+--  consts: RBMap Address Ixon.Const compare
+--  secret: Address
+--
+--structure IxMState where
+--  comms : RBMap Address Ixon.Comm compare
+--  -- transcript : List IxVMOp
+--  main : Option (Address × Ixon.Const)
+--  deriving Inhabited
+--
+--abbrev IxM := ReaderT IxMEnv $ ExceptT IxError $ StateT IxMState Id
+--
+--def IxM.run (env: Lean.Environment) (secret: Lean.Name) (ixm: IxM Claim)
+--  : IO (Claim × IxMState × IxMEnv) := do
+--  let stt <- IO.ofExcept (<- Ix.CanonM.canonicalizeEnv env)
+--  let (secret, _) := stt.names.find! secret
+--  let env := IxMEnv.mk stt.names stt.store secret
+--  let (res, stt) := Id.run (StateT.run (ReaderT.run ixm env) default)
+--  let claim <- IO.ofExcept res
+--  return (claim, stt, env)
+--
+--def IxM.commit (payload: Address): IxM Address := do
+--  let secret <- (·.secret) <$> read
+--  let comm := Ixon.Comm.mk secret payload
+--  let addr := Address.blake3 (Ixon.Serialize.put (Ixon.Const.comm comm))
+--  modify (fun stt => { stt with
+--    comms := stt.comms.insert addr comm
+--    -- transcript := (.commit payload secret addr)::stt.transcript
+--  })
+--  return addr
+--
+--def IxM.byName (name: Lean.Name) : IxM Address := do
+--  let env <- read
+--  match env.names.find? name with
+--  | .none => throw .todo
+--  | .some (addr, _) => return addr
+--
+--def IxM.reveal (comm: Address) : IxM Address := do
+--  let stt <- get
+--  match stt.comms.find? comm with
+--  | .some c => return c.payload
+--  | .none => throw .todo
+--
+--def IxM.secret (comm: Address) : IxM Address := do
+--  let stt <- get
+--  match stt.comms.find? comm with
+--  | .some c => return c.secret
+--  | .none => throw .todo
+--
+---- TODO: handle universe arguments
+--def IxM.mkMainConst (type func: Address) (args: List Address): Ixon.Const :=
+--  match args with
+--  | [] =>
+--    Ixon.Const.defn {
+--      lvls := 0,
+--      type := Ixon.Expr.cnst type [],
+--      value := Ixon.Expr.cnst func [],
+--      part := .true,
+--    }
+--  | a::as =>
+--    let as':= as.map (fun a => Ixon.Expr.cnst a [])
+--    Ixon.Const.defn {
+--      lvls := 0,
+--      type := Ixon.Expr.cnst type [],
+--      value := Ixon.Expr.apps (Ixon.Expr.cnst func []) (Ixon.Expr.cnst a []) as' ,
+--      part := .true,
+--    }
+--
+--def IxM.mkMain (type func: Address) (args: List Address): IxM Address := do
+--  let mainConst := IxM.mkMainConst type func args
+--  let bytes := Ixon.Serialize.put mainConst
+--  let addr := Address.blake3 bytes
+--  modify (fun stt => { stt with main := .some (addr, mainConst) })
+--  return addr
+--
+--def IxM.evaluate (type input: Address) : IxM Address := sorry
+--
+--def IxM.prove (claim : Claim) (stt: IxMState) (env: IxMEnv) : IO Proof :=
+--  sorry
+--
+--end Ix
+--
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index a537b057..962f7ef3 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -133,6 +133,7 @@ inductive Const where
   | meta   : Metadata -> Const
   -- 0xCC
   | proof : Proof -> Const
+  -- 0xCD
   | comm: Comm -> Const
   deriving BEq, Repr, Inhabited
 
@@ -169,10 +170,20 @@ def putConst : Const → PutM
         *> putArray (putCtor <$> x.ctors) *> putArray (putRecr <$> x.recrs)
         *> putBools [x.recr, x.refl, x.struct, x.unit]
     putProof (p: Proof) : PutM :=
-      putBytes p.claim.inp.hash
-      *> putBytes p.claim.out.hash
-      *> putBytes p.claim.typ.hash
-      *> putByteArray p.bin
+      match p.claim with
+      | .checks lvls type value => 
+          putUInt8 0
+          *> putBytes lvls.hash
+          *> putBytes type.hash 
+          *> putBytes value.hash
+          *> putByteArray p.bin
+      | .evals lvls inp out type =>
+          putUInt8 1
+          *> putBytes lvls.hash
+          *> putBytes inp.hash
+          *> putBytes out.hash
+          *> putBytes type.hash 
+          *> putByteArray p.bin
     putComm (c: Comm) : PutM :=
       putBytes c.secret.hash *> putBytes c.payload.hash
 
@@ -214,8 +225,11 @@ def getConst : GetM Const := do
       | [w, x, y, z] => return f w x y z
       | _ => throw s!"unreachable"
     getAddr : GetM Address := .mk <$> getBytes 32
-    getProof : GetM Proof :=
-      .mk <$> (.mk <$> getAddr <*> getAddr <*> getAddr) <*> getByteArray
+    getProof : GetM Proof := do
+      match (<- getUInt8) with
+      | 0 => .mk <$> (.checks <$> getAddr <*> getAddr <*> getAddr) <*> getByteArray
+      | 1 => .mk <$> (.evals <$> getAddr <*> getAddr <*> getAddr <*> getAddr) <*> getByteArray
+      | e => throw s!"expect proof variant tag, got {e}"
     getComm : GetM Comm :=
       .mk <$> getAddr <*> getAddr
 
diff --git a/Ix/Ixon/Expr.lean b/Ix/Ixon/Expr.lean
index e5a1464a..8db1c7e8 100644
--- a/Ix/Ixon/Expr.lean
+++ b/Ix/Ixon/Expr.lean
@@ -32,6 +32,7 @@ inductive Expr where
 -- array: 0xB
 -- const: 0xC
 
+
 def putExprTag (tag: UInt8) (val: UInt64) : PutM :=
   let t := UInt8.shiftLeft tag 4
   if val < 8
diff --git a/Ix/Ixon/Serialize.lean b/Ix/Ixon/Serialize.lean
index 88215b5e..13acf07e 100644
--- a/Ix/Ixon/Serialize.lean
+++ b/Ix/Ixon/Serialize.lean
@@ -1,4 +1,5 @@
 import Lean.Declaration
+import Ix.Address
 
 namespace Ixon
 
@@ -88,6 +89,14 @@ def natToBytesLE (x: Nat) : Array UInt8 :=
 def natFromBytesLE (xs: Array UInt8) : Nat :=
   (xs.toList.zipIdx 0).foldl (fun acc (b, i) => acc + (UInt8.toNat b) * 256 ^ i) 0
 
+def natPackAsAddress (x: Nat) : Option Address := 
+  let bytes := natToBytesLE x
+  if bytes.size > 32 then .none
+  else .some (Address.mk ⟨bytes.append (mkArray (32 - bytes.size) 0)⟩)
+
+def natUnpackFromAddress (x: Address) : Nat := 
+  natFromBytesLE x.hash.data
+
 def fromTrimmedLE (xs: Array UInt8) : UInt64 := List.foldr step 0 xs.toList
   where
     step byte acc := UInt64.shiftLeft acc 8 + (UInt8.toUInt64 byte)
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index ed076a8e..f4be0df3 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -1,12 +1,9 @@
 import Lean
 import Ix.Address
-import Ix.CanonM
+import Ix.CompileM
 
 open Lean
 
-def computeIxAddress (const : ConstantInfo) (constMap: ConstMap) : IO Address := do
-  IO.ofExcept (<- Ix.CanonM.canonicalizeConst constMap const)
-
 open System (FilePath)
 
 open Elab in
@@ -41,6 +38,10 @@ elab "this_file!" : term => do
 macro "get_env!" : term =>
   `(getFileEnv this_file!)
 
+def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO Address := do
+  let ((a, _), _) <- Ix.Compile.compileConstIO env const
+  return a
+
 def mkAnonDefInfoRaw (type : Expr) (value : Expr) : ConstantInfo :=
   .defnInfo {
     name        := .anonymous
@@ -59,3 +60,7 @@ def runCore (f : CoreM α) (env : Environment) : IO α :=
 
 def runMeta (f : MetaM α) (env : Environment) : IO α :=
   Prod.fst <$> f.toIO { fileName := default, fileMap := default } { env }
+
+def metaMkList (α: Lean.Expr) (names: List Lean.Name) : MetaM Expr := do
+  let nil <- Meta.mkAppOptM ``List.nil #[.some α]
+  names.foldrM (fun n t => Meta.mkAppOptM ``List.cons #[.some α, mkConst n, t]) nil
diff --git a/Ix/Prove.lean b/Ix/Prove.lean
index 34101209..423d1d95 100644
--- a/Ix/Prove.lean
+++ b/Ix/Prove.lean
@@ -1,22 +1,15 @@
 import Ix.Address
 import Ix.Ixon.Serialize
+import Ix.Claim
 import Ix.Common
 
-inductive ProveError
-  | todo
+--inductive ProveError
+--  | todo
+--
+--instance : ToString ProveError := ⟨fun _ => "TODO"⟩
+--
+--abbrev ProveM := ExceptT ProveError IO
 
-instance : ToString ProveError := ⟨fun _ => "TODO"⟩
-
-abbrev ProveM := ExceptT ProveError IO
-
-structure Claim where
-  inp : Address
-  out : Address
-  typ : Address
-  deriving Inhabited, BEq
-
-instance : ToString Claim where
-  toString c := s!"#{c.inp} ~> #{c.out} : #{c.typ}"
 
 structure Proof where
   claim: Claim
@@ -29,6 +22,6 @@ instance : ToString Proof where
 
 instance : Repr Proof where
   reprPrec p _ := toString p
-
-def prove (claim : Claim) : ProveM Proof :=
-  default -- TODO
+--
+--def prove (claim : Claim) : ProveM Proof :=
+--  default -- TODO
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index 05a70796..aebcf6c1 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -28,7 +28,15 @@ inductive TransportError
   | rawMetadata (m: Ixon.Metadata)
   | rawProof (m: Proof)
   | rawComm (m: Ixon.Comm)
-  deriving Repr
+  deriving BEq, Repr
+
+instance : ToString TransportError where toString
+| .natTooBig idx x => s!"At index {idx}, natural number {x} too big to fit in UInt64"
+| .unknownIndex idx x => s!"Unknown index {idx} with metadata {repr x}"
+| .unexpectedNode idx x => s!"Unexpected node at {idx} with metadata {repr x}"
+| .rawMetadata x => s!"Can't rematerialize raw metadata {repr x}"
+| .rawProof x => s!"Can't rematerialize raw proof {repr x}"
+| .rawComm x => s!"Can't rematerialize raw commitment {repr x}"
 
 abbrev DematM := EStateM TransportError DematState
 
diff --git a/Ix/ZKVoting.lean b/Ix/ZKVoting.lean
new file mode 100644
index 00000000..c0fb7bde
--- /dev/null
+++ b/Ix/ZKVoting.lean
@@ -0,0 +1,77 @@
+import Ix.Claim
+import Ix.Address
+import Ix.Meta
+import Ix.CompileM
+
+namespace ZKVoting
+
+inductive Candidate
+   | alice | bob | charlie
+   deriving Inhabited, Lean.ToExpr, Repr
+
+inductive Result
+| winner : Candidate -> Result
+| tie : List Candidate -> Result
+deriving Repr, Lean.ToExpr
+
+def privateVotes : List Candidate := 
+  [.alice, .alice, .bob]
+
+def runElection (votes: List Candidate) : Result :=
+  let (a, b, c) := votes.foldr tally (0,0,0)
+  if a > b && a > c
+  then .winner .alice
+  else if b > a && b > c
+  then .winner .bob
+  else if c > a && c > b
+  then .winner .charlie
+  else if a == b && b == c
+  then .tie [.alice, .bob, .charlie]
+  else if a == b
+  then .tie [.alice, .bob]
+  else if a == c
+  then .tie [.alice, .charlie]
+  else .tie [.bob, .charlie]
+    where
+      tally (comm: Candidate) (acc: (Nat × Nat × Nat)): (Nat × Nat × Nat) :=
+      match comm, acc with
+      | .alice, (a, b, c) => (a+1, b, c)
+      | .bob, (a, b, c) => (a, b+1, c)
+      | .charlie, (a, b, c) => (a, b, c+1)
+
+
+--def claim (argT: Type) (argVal: argT) : Ix.IxM Claim := do
+--  let func <- Ix.IxM.byName `ZKVoting.runElection
+--  let type <- Ix.IxM.byName `ZKVoting.Result
+--  let argm <- Ix.IxM.byName `ZKVoting.privateVotes >>= Ix.IxM.commit
+--  let main <- Ix.IxM.mkMain type func [argm]
+--  let output <- Ix.IxM.evaluate type main
+--  return Claim.mk main output type
+
+--def addr : Ix.Comm Nat := Ix.Comm.mk (toString (Address.blake3 ⟨#[]⟩))
+--def unAddr (a: Ix.Comm Nat) : String := a.value
+--
+--#eval Lean.toExpr [Candidate.alice]
+-- .app (.app (.const `List.cons) (.const `.alice)) (.const `List.nil)
+-- .app (.app (.const `List.cons) (.const `<comm-hash>)) (.const `List.nil)
+-- ixon
+-- def vote1 := .alice
+-- .apps (.cnst <List.cons-hash>) [.cnst `<vote1-comm-hash>, .cnst <List.nil-hash>]
+--def spliceComm : Lean.Expr
+
+--def main : IO Proof := do
+--  let env <- get_env!
+--  let votes : List Candidate <- pure [.alice, .alice, .bob]
+--  let args := [
+--    (Lean.toExpr $ Ix.Compile.Comm.mk <$> votes, Lean.toTypeExpr (Ix.Compile.Comm Candidate))
+--  ]
+--  let func := `ZKVoting.runElection
+--  let type := Lean.toTypeExpr ZKVoting.Result
+--  let sort := Lean.Expr.sort (.succ .zero)
+--  let output := Lean.toExpr (runElection votes)
+--  let (claim, stt) <-
+--    (Ix.Compile.evalClaimWithArgs func args output type sort [] true).runIO' env
+--  --let 
+--  return default
+--
+--end ZKVoting
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
new file mode 100644
index 00000000..39f2f995
--- /dev/null
+++ b/Tests/Ix/Compile.lean
@@ -0,0 +1,46 @@
+import LSpec
+
+import Ix.Ixon
+import Ix.Address
+import Ix.Common
+import Ix.CompileM
+import Ix.Meta
+import Lean
+import Tests.Ix.Fixtures
+import Lean
+
+open LSpec
+open Ix.Compile
+
+--def testCompileExpr (env: Lean.Environment)
+--  (msg: String) (commit: Bool) (input: Lean.Expr) (expected: Ix.Expr)
+--  : IO TestSeq := do
+--  let (out, _) <- 
+--  CompileM.runIO' env (compileExpr commit input)
+--  return test msg (out == expected)
+--
+--def threeIO : IO TestSeq := do
+--  return test "one isn't two" (1 == 2)
+--
+--def foo : IO Lean.Expr := do
+--  runMeta (Lean.Meta.whnf (Lean.toExpr 3)) (<- get_env!)
+--
+--def bar : IO Ix.Expr := do
+--  let env <- get_env!
+--  let .defnInfo defn ← runCore (Lean.getConstInfo ``id) env
+--    | unreachable!
+--  let input <- runMeta (Lean.Meta.whnf defn.value) env
+--  --let (out, _) <- CompileM.runIO' env (compileExpr false input)
+--  return out
+
+--#eval bar
+
+def test1 : IO TestSeq := do
+  let env <- get_env!
+  let input <- runMeta (Lean.Meta.whnf (Lean.toExpr 3)) env
+  let expected := Lean.Expr.lit (Lean.Literal.natVal 3)
+  return test "expected 3" (input == expected)
+
+def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
+  test1
+]
diff --git a/Tests/Main.lean b/Tests/Main.lean
index dedf37bd..ce620518 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -4,14 +4,19 @@ import Tests.Boundary
 import Tests.ByteArray
 import Tests.Unsigned
 import Tests.Ix
+import Tests.Ix.Compile
 
-def main := LSpec.lspecIO (.ofList [
-    ("arith-expr", Tests.ArithExpr.suite),
-    ("boundary", Tests.Boundary.suite),
-    ("binius-bindings", Tests.Binius.bindingsSuite),
-    ("binius-witness", Tests.Binius.witnessSuite),
-    ("binius-transparent", Tests.Binius.transparentSuite),
-    ("byte-array", Tests.ByteArray.suite),
-    ("unsigned", Tests.Unsigned.suite),
-    ("ix", Tests.Ix.suite),
-  ])
+def main (args: List String) : IO UInt32 := do
+  if args.contains "compile"
+  then LSpec.lspecEachIO Tests.Ix.Compile.suiteIO id
+  else
+    LSpec.lspecIO (.ofList [
+      ("arith-expr", Tests.ArithExpr.suite),
+      ("boundary", Tests.Boundary.suite),
+      ("binius-bindings", Tests.Binius.bindingsSuite),
+      ("binius-witness", Tests.Binius.witnessSuite),
+      ("binius-transparent", Tests.Binius.transparentSuite),
+      ("byte-array", Tests.ByteArray.suite),
+      ("unsigned", Tests.Unsigned.suite),
+      ("ix", Tests.Ix.suite),
+    ]) args
diff --git a/lakefile.lean b/lakefile.lean
index a2eda207..5735a8c5 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -29,7 +29,8 @@ section Tests
 lean_lib Tests
 
 @[test_driver]
-lean_exe Tests.Main
+lean_exe Tests.Main where
+  supportInterpreter := true
 
 end Tests
 

From 35d1311f74ab32f1eaf13f61cd209395146c6a71 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sun, 13 Apr 2025 21:50:59 -0400
Subject: [PATCH 08/74] fixup merge

---
 Ix/BuiltIn.lean  | 86 ------------------------------------------------
 Ix/Common.lean   |  2 +-
 Ix/CompileM.lean |  2 +-
 Main.lean        |  2 +-
 4 files changed, 3 insertions(+), 89 deletions(-)
 delete mode 100644 Ix/BuiltIn.lean

diff --git a/Ix/BuiltIn.lean b/Ix/BuiltIn.lean
deleted file mode 100644
index bd952d6f..00000000
--- a/Ix/BuiltIn.lean
+++ /dev/null
@@ -1,86 +0,0 @@
-
-namespace Ix
-
-inductive BuiltIn where
-| commit
-| reveal
-deriving Inhabited, Repr, BEq, Ord, Hashable
-
-end Ix
-
---structure Commitment (α : Type _) where
---  adr : Address
---  deriving Inhabited, Lean.ToExpr
---
---instance : ToString (Commitment α) where
---  toString comm := "c" ++ toString comm.adr
-
---def Commitment.ofString (s : String) : Option $ Commitment α :=
---  match s.data with
---  | 'c' :: adrChars => .mk <$> Address.fromString ⟨adrChars⟩
---  | _ => none
---
----- TODO: secrets should be 32-bytes long
---opaque commit (secret : Address) (payload : α) : Commitment α
---opaque secret (comm : Commitment α) : Address
---opaque reveal [Inhabited α] (comm : Commitment α) : α
---opaque revealThen [Inhabited β] (comm : Commitment α) (f : β) : β
-
---def persistCommit (secret : Address) (payload : Address) : IO $ Commitment α :=
---  let commAdr := Blake3.hash $ secret.hash ++ payload.hash
---  -- TODO: persist commitment preimages as private data
---  return ⟨⟨commAdr.val⟩⟩
---
---def mkCommitRaw 
---  (secret : Address) (type : Lean.Expr) (value : Lean.Expr)
---  (consts : Lean.ConstMap)
---  : IO (Commitment α) := do
---  let adr <- computeIxAddress (mkAnonDefInfoRaw type value) consts
---  persistCommit secret adr
---
---def mkCommit [Lean.ToExpr α] (secret : Address) (a : α) (consts : Lean.ConstMap) 
---  : IO (Commitment α) := do
---  let adr <- (computeIxAddress (mkAnonDefInfo a) consts)
---  persistCommit secret adr
-
---namespace Ix.BuiltIn
-
---inductive Commitment (A: Type _) where
---| comm
---
---opaque commit : Nat -> 
-
---structure TypeProof where
---  value : Address
---  type : Address
---  bin : ByteArray
---  deriving Inhabited
-
---structure TypeProofD (A: Type) where
---  value : AddressD A
---  type : AddressD Type
---  bin : ByteArray
---  proof: Validates bin type value
---  deriving Inhabited
---
---opaque TypeProof.commit.{u} (α : Type u) (a : α) (secret: Nat := 0)  : TypeProof
---opaque TypeProof.reveal.{u} (α : Type u) (t: TypeProof) (secret: Nat := 0) : Option α
---opaque TypeProof.verify (t: TypeProof) : Bool
---
---opaque TypeProof.revealD.{u} (α : Type u) (t: TypeProofD) (secret: Nat := 0) : α
-
---structure EvalProof where
---  input : TypeProof
---  output: TypeProof
---  bin: ByteArray
---  deriving Inhabited
---
---opaque EvalProof.prove (input output: TypeProof) (secret: Nat := 0) : EvalProof
---opaque EvalProof.verify (p: Proof) : Bool
---opaque EvalProof.eval.{u} (α: Type u) (p: EvalProof) (a: α) : Option α
-
--- def f x := if x == 1 then 42 else 0
--- let p := EvalProof { <f 1 ~> 42> }
--- p.eval 1 ~> 42
-
---end Ix.BuiltIn
diff --git a/Ix/Common.lean b/Ix/Common.lean
index da9234f0..266fe2f7 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -194,7 +194,7 @@ def checkToolchain : IO Unit := do
   match ← runCmd' "lake" #["--version"] with
   | .error e => throw $ IO.userError e
   | .ok out =>
-    let version := out.splitOn "(Lean version " |>.get! 1
+    let version := (out.splitOn "(Lean version ")[1]!
     let version := version.splitOn ")" |>.head!
     let expectedVersion := Lean.versionString
     if version != expectedVersion then
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 4adddb8a..33f5b6b1 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -458,7 +458,7 @@ and thus we can canon the actual constant right away
 partial def compileExpr : Lean.Expr → CompileM Expr
 | .mdata _ e => compileExpr e
 | expr => match expr with
-  | .bvar idx => do match (← read).bindCtx.get? idx with
+  | .bvar idx => do match (← read).bindCtx[idx]? with
     -- Bound variables must be in the bind context
     | some _ => return .var idx
     | none => throw $ .invalidBVarIndex idx
diff --git a/Main.lean b/Main.lean
index eeb408bd..22056fb0 100644
--- a/Main.lean
+++ b/Main.lean
@@ -15,7 +15,7 @@ def ixCmd : Cli.Cmd := `[Cli|
   SUBCOMMANDS:
     proveCmd;
     testCmd;
-    storeCmd
+    storeCmd;
     sendCmd;
     recvCmd
 ]

From 685f5652f30a49a7f0ff6bd3bcaf1ef048fbb8ea Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sun, 13 Apr 2025 21:51:18 -0400
Subject: [PATCH 09/74] fixup merge 2

---
 Ix.lean | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Ix.lean b/Ix.lean
index afe906cd..3da4f8da 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -1,6 +1,5 @@
 -- This module serves as the root of the `Ix` library.
 -- Import modules here that should be built as part of the library.
-import Ix.BuiltIn
 import Ix.Ixon
 import Ix.TransportM
 import Ix.IR

From 93309c81ab0c60c70f7a7229a522da8d7230adde Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 14 Apr 2025 11:48:10 -0400
Subject: [PATCH 10/74] ix prove check command

---
 Apps/ZKVoting/Prover.lean | 15 +++++---
 Ix/Claim.lean             |  4 +-
 Ix/Cli/ProveCmd.lean      | 54 ++++++++++++++++++++++++++-
 Ix/CompileM.lean          |  2 +-
 Ix/ZKVoting.lean          | 77 ---------------------------------------
 5 files changed, 66 insertions(+), 86 deletions(-)
 delete mode 100644 Ix/ZKVoting.lean

diff --git a/Apps/ZKVoting/Prover.lean b/Apps/ZKVoting/Prover.lean
index 9059d9e4..32599374 100644
--- a/Apps/ZKVoting/Prover.lean
+++ b/Apps/ZKVoting/Prover.lean
@@ -40,7 +40,7 @@ def runElection (votes: List Candidate) : Result :=
 def main : IO UInt32 := do
   let mut stt : Ix.Compile.CompileState := .init (<- get_env!)
   -- simulate getting the votes from somewhere
-  let votes : List Candidate <- pure [.alice, .alice, .bob]
+  let votes : List Candidate <- pure [.alice, .alice, .bob, .bob]
   let mut as : List Lean.Name := []
   -- default maxHeartBeats
   let ticks : USize := 200000
@@ -55,7 +55,8 @@ def main : IO UInt32 := do
     stt := stt'
     -- collect each commitment addresses as names
     as := (Address.toUniqueName addr)::as
-  IO.println s!"{repr as}"
+    IO.println s!"vote: {repr v}, commitment: {addr}"
+  IO.println s!"{repr as.reverse}"
   -- identify our function
   let func := ``runElection
   -- build a Lean list of our commitments as the argument to runElection
@@ -66,9 +67,13 @@ def main : IO UInt32 := do
   let sort <- runMeta (Lean.Meta.inferType type) stt.env
   -- evaluate the output (both methods should be the same)
   let output := Lean.toExpr (runElection votes)
-  IO.println s!"output1 {repr output}"
-  let output' <- runMeta (Lean.Meta.reduce (.app (Lean.mkConst func) arg)) stt.env
-  IO.println s!"output2 {repr output'}"
+  let outputPretty <- runMeta (Lean.Meta.ppExpr output) stt.env
+  IO.println s!"output1 {outputPretty}"
+  --IO.println s!"output1 {repr output}"
+  let output2 <- runMeta (Lean.Meta.reduce (.app (Lean.mkConst func) arg)) stt.env
+  let output2Pretty <- runMeta (Lean.Meta.ppExpr output2) stt.env
+  IO.println s!"output1 {output2Pretty}"
+  --IO.println s!"output2 {repr output2}"
   -- build the evaluation claim
   let ((claim,_,_,_), _stt') <-
      (Ix.Compile.evalClaimWithArgs func [(arg, argType)] output type sort [] true).runIO' ticks stt
diff --git a/Ix/Claim.lean b/Ix/Claim.lean
index 6fba1369..83e13b26 100644
--- a/Ix/Claim.lean
+++ b/Ix/Claim.lean
@@ -8,7 +8,7 @@ deriving Inhabited, BEq
 
 instance : ToString Claim where
   toString
-  | .checks lvls type value => s!"#{value} : {type} @ {lvls}"
-  | .evals lvls inp out type => s!"#{inp} ~> #{out} : {type} @ {lvls}"
+  | .checks lvls type value => s!"#{value} : #{type} @ #{lvls}"
+  | .evals lvls inp out type => s!"#{inp} ~> #{out} : #{type} @ #{lvls}"
 
 
diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean
index a1f40698..7861e2e7 100644
--- a/Ix/Cli/ProveCmd.lean
+++ b/Ix/Cli/ProveCmd.lean
@@ -1,17 +1,69 @@
 import Cli
+import Ix.Cronos
+import Ix.Common
+import Ix.CompileM
+import Ix.Store
+import Ix.Address
+import Ix.Meta
+import Lean
+
+-- ix prove eval AcmeInput
+-- ix prove eval --address deadbeef
+-- ix prove eval AcmeFun AcmeArg1 AcmeArg2
+-- ix prove eval --address abcde 1234 5678
+-- ix prove check --name AcmeTheo
+-- ix prove check --address deadbeef
 
 def runProve (p : Cli.Parsed) : IO UInt32 := do
   let input   : String       := p.positionalArg! "input" |>.as! String
+  --if p.hasFlag "name" then
   IO.println <| "Input: " ++ input
   return 0
 
+def runProveCheck (p: Cli.Parsed): IO UInt32 := do
+  let input : String       := p.positionalArg! "input" |>.as! String
+  let const : String       := p.positionalArg! "const" |>.as! String
+  let path := ⟨input⟩
+  Lean.setLibsPaths input
+  let env ← Lean.runFrontend (← IO.FS.readFile path) path
+  let constInfo <- match env.constants.find? const.toName with
+    | some c => pure c
+    | none => throw $ IO.userError s!"unknown constant {const.toName}"
+  let constTypeSort <- runMeta (Lean.Meta.inferType constInfo.type) env
+  let commit := p.hasFlag "commit"
+  let ((claim, _, _), _) <- 
+    (Ix.Compile.checkClaim const.toName constInfo.type constTypeSort
+    constInfo.levelParams commit).runIO' 200000 (.init env)
+  IO.println $ s!"checking {const.toName} in {input}"
+  IO.println $ s!"claim {claim}"
+  return 0
+
+
+def proveCheckCmd : Cli.Cmd := `[Cli|
+  check VIA runProveCheck;
+  "prove typechecking"
+
+  FLAGS:
+    cron, "cronos"; "enable Cronos timings"
+    address, "address"; "lookup inputs by address"
+    commit, "commit"; "commit inputs"
+
+  ARGS:
+   input  : String; "Source file input"
+   const  : String; "constant name"
+]
+
 def proveCmd : Cli.Cmd := `[Cli|
   prove VIA runProve;
   "Generates a ZK proof of a given Lean source file"
 
   FLAGS:
-    e, "example"   : String; "Example flag"
+    cron, "cronos"   : String; "enable Cronos timings"
+    address, "address"   : String; "lookup inputs by address"
 
   ARGS:
    input  : String; "Source file input"
+
+  SUBCOMMANDS:
+    proveCheckCmd
 ]
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 33f5b6b1..6a116ffe 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -747,7 +747,7 @@ partial def evalClaimWithArgs
     addDef lvls argType arg >>= comm
   let (inputAnon, inputMeta) <-
     makeEvalInput lvls typeAnon typeMeta funcAnon funcMeta args
-  let lvlsAddr <- packLevel lvls.length false
+  let lvlsAddr <- packLevel lvls.length commit
   return (Claim.evals lvlsAddr inputAnon outputAnon typeAnon, inputMeta, outputMeta, typeMeta)
   where
     comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
diff --git a/Ix/ZKVoting.lean b/Ix/ZKVoting.lean
deleted file mode 100644
index c0fb7bde..00000000
--- a/Ix/ZKVoting.lean
+++ /dev/null
@@ -1,77 +0,0 @@
-import Ix.Claim
-import Ix.Address
-import Ix.Meta
-import Ix.CompileM
-
-namespace ZKVoting
-
-inductive Candidate
-   | alice | bob | charlie
-   deriving Inhabited, Lean.ToExpr, Repr
-
-inductive Result
-| winner : Candidate -> Result
-| tie : List Candidate -> Result
-deriving Repr, Lean.ToExpr
-
-def privateVotes : List Candidate := 
-  [.alice, .alice, .bob]
-
-def runElection (votes: List Candidate) : Result :=
-  let (a, b, c) := votes.foldr tally (0,0,0)
-  if a > b && a > c
-  then .winner .alice
-  else if b > a && b > c
-  then .winner .bob
-  else if c > a && c > b
-  then .winner .charlie
-  else if a == b && b == c
-  then .tie [.alice, .bob, .charlie]
-  else if a == b
-  then .tie [.alice, .bob]
-  else if a == c
-  then .tie [.alice, .charlie]
-  else .tie [.bob, .charlie]
-    where
-      tally (comm: Candidate) (acc: (Nat × Nat × Nat)): (Nat × Nat × Nat) :=
-      match comm, acc with
-      | .alice, (a, b, c) => (a+1, b, c)
-      | .bob, (a, b, c) => (a, b+1, c)
-      | .charlie, (a, b, c) => (a, b, c+1)
-
-
---def claim (argT: Type) (argVal: argT) : Ix.IxM Claim := do
---  let func <- Ix.IxM.byName `ZKVoting.runElection
---  let type <- Ix.IxM.byName `ZKVoting.Result
---  let argm <- Ix.IxM.byName `ZKVoting.privateVotes >>= Ix.IxM.commit
---  let main <- Ix.IxM.mkMain type func [argm]
---  let output <- Ix.IxM.evaluate type main
---  return Claim.mk main output type
-
---def addr : Ix.Comm Nat := Ix.Comm.mk (toString (Address.blake3 ⟨#[]⟩))
---def unAddr (a: Ix.Comm Nat) : String := a.value
---
---#eval Lean.toExpr [Candidate.alice]
--- .app (.app (.const `List.cons) (.const `.alice)) (.const `List.nil)
--- .app (.app (.const `List.cons) (.const `<comm-hash>)) (.const `List.nil)
--- ixon
--- def vote1 := .alice
--- .apps (.cnst <List.cons-hash>) [.cnst `<vote1-comm-hash>, .cnst <List.nil-hash>]
---def spliceComm : Lean.Expr
-
---def main : IO Proof := do
---  let env <- get_env!
---  let votes : List Candidate <- pure [.alice, .alice, .bob]
---  let args := [
---    (Lean.toExpr $ Ix.Compile.Comm.mk <$> votes, Lean.toTypeExpr (Ix.Compile.Comm Candidate))
---  ]
---  let func := `ZKVoting.runElection
---  let type := Lean.toTypeExpr ZKVoting.Result
---  let sort := Lean.Expr.sort (.succ .zero)
---  let output := Lean.toExpr (runElection votes)
---  let (claim, stt) <-
---    (Ix.Compile.evalClaimWithArgs func args output type sort [] true).runIO' env
---  --let 
---  return default
---
---end ZKVoting

From b90fd9b1fbcb5b41d21ac0e043cf46240e17f02c Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sun, 20 Apr 2025 18:15:00 -0400
Subject: [PATCH 11/74] implement ix prove CLI and simplify metaprogramming

- CompileM is now persistent with the filemapped store
- constructing evaluation claims is done through MetaM rather than CompileM
- CLI now features the Prove command
---
 Apps/ZKVoting/Prover.lean | 40 +++++++-----------
 Ix/Cli/ProveCmd.lean      | 87 +++++++++++++++++++++++++--------------
 Ix/Cli/StoreCmd.lean      |  2 +-
 Ix/Cli/TestCmd.lean       | 44 ++++++++++----------
 Ix/CompileM.lean          | 84 ++++++++++++++-----------------------
 Ix/Meta.lean              | 32 +++++++-------
 Ix/Store.lean             |  5 ++-
 7 files changed, 148 insertions(+), 146 deletions(-)

diff --git a/Apps/ZKVoting/Prover.lean b/Apps/ZKVoting/Prover.lean
index 32599374..5f09d860 100644
--- a/Apps/ZKVoting/Prover.lean
+++ b/Apps/ZKVoting/Prover.lean
@@ -37,10 +37,12 @@ def runElection (votes: List Candidate) : Result :=
       | .bob, (a, b, c) => (a, b+1, c)
       | .charlie, (a, b, c) => (a, b, c+1)
 
+open Ix.Compile
+
 def main : IO UInt32 := do
-  let mut stt : Ix.Compile.CompileState := .init (<- get_env!)
+  let mut stt : CompileState := .init (<- get_env!)
   -- simulate getting the votes from somewhere
-  let votes : List Candidate <- pure [.alice, .alice, .bob, .bob]
+  let votes : List Candidate <- pure [.alice, .alice, .bob]
   let mut as : List Lean.Name := []
   -- default maxHeartBeats
   let ticks : USize := 200000
@@ -48,35 +50,25 @@ def main : IO UInt32 := do
   let voteType := Lean.toTypeExpr Candidate
   -- loop over the votes
   for v in votes do
-    let voteExpr := Lean.toExpr v
     -- add each vote to our environment as a commitment
-    let ((addr, _), stt') <-
-      (Ix.Compile.addCommitment [] voteType voteExpr).runIO' ticks stt
+    let (lvls, typ, val) <- runMeta (metaMakeDef v) stt.env
+    let ((addr, _), stt') <- (commitDef lvls typ val).runIO' ticks stt
     stt := stt'
-    -- collect each commitment addresses as names
     as := (Address.toUniqueName addr)::as
     IO.println s!"vote: {repr v}, commitment: {addr}"
-  IO.println s!"{repr as.reverse}"
-  -- identify our function
-  let func := ``runElection
   -- build a Lean list of our commitments as the argument to runElection
-  let arg : Lean.Expr <- runMeta (metaMkList voteType as) stt.env
-  let argType <- runMeta (Lean.Meta.inferType arg) stt.env
-  -- inputs to commit to the type of the output
-  let type := Lean.toTypeExpr Result
-  let sort <- runMeta (Lean.Meta.inferType type) stt.env
-  -- evaluate the output (both methods should be the same)
-  let output := Lean.toExpr (runElection votes)
+  let arg : Lean.Expr <- runMeta (metaMakeList voteType as) stt.env
+  let (lvls, input, output, type, sort) <-
+    runMeta (metaMakeEvalClaim ``runElection [arg]) stt.env
+  let inputPretty <- runMeta (Lean.Meta.ppExpr input) stt.env
   let outputPretty <- runMeta (Lean.Meta.ppExpr output) stt.env
-  IO.println s!"output1 {outputPretty}"
-  --IO.println s!"output1 {repr output}"
-  let output2 <- runMeta (Lean.Meta.reduce (.app (Lean.mkConst func) arg)) stt.env
-  let output2Pretty <- runMeta (Lean.Meta.ppExpr output2) stt.env
-  IO.println s!"output1 {output2Pretty}"
-  --IO.println s!"output2 {repr output2}"
-  -- build the evaluation claim
+  let typePretty <- runMeta (Lean.Meta.ppExpr type) stt.env
+  IO.println s!"claim: {inputPretty}"
+  IO.println s!"  ~> {outputPretty}"
+  IO.println s!"  : {typePretty}"
+  IO.println s!"  @ {repr lvls}"
   let ((claim,_,_,_), _stt') <-
-     (Ix.Compile.evalClaimWithArgs func [(arg, argType)] output type sort [] true).runIO' ticks stt
+     (evalClaim lvls input output type sort true).runIO' ticks stt
   IO.println s!"{claim}"
   -- Ix.prove claim stt
   return 0
diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean
index 7861e2e7..91f3d2e5 100644
--- a/Ix/Cli/ProveCmd.lean
+++ b/Ix/Cli/ProveCmd.lean
@@ -14,13 +14,59 @@ import Lean
 -- ix prove check --name AcmeTheo
 -- ix prove check --address deadbeef
 
-def runProve (p : Cli.Parsed) : IO UInt32 := do
-  let input   : String       := p.positionalArg! "input" |>.as! String
-  --if p.hasFlag "name" then
-  IO.println <| "Input: " ++ input
+
+def runProveCheck 
+  (env: Lean.Environment)
+  (constInfo: Lean.ConstantInfo)
+  (commit: Bool)
+  : IO UInt32
+  := do
+  let constSort <- runMeta (Lean.Meta.inferType constInfo.type) env
+  let signature <- runMeta (Lean.PrettyPrinter.ppSignature constInfo.name) env
+  IO.println "typechecking:"
+  IO.println signature.fmt.pretty
+  let ((claim, _, _), _stt) <- 
+    (Ix.Compile.checkClaim constInfo.name constInfo.type constSort
+    constInfo.levelParams commit).runIO' 200000 (.init env)
+  IO.println $ s!"claim: {claim}"
+  -- TODO: prove
+  return 0
+
+def mkConst' (constName : Lean.Name) : Lean.MetaM Lean.Expr := do
+  return Lean.mkConst constName (← (← Lean.getConstInfo constName).levelParams.mapM fun _ => Lean.Meta.mkFreshLevelMVar)
+
+def runProveEval
+  (env: Lean.Environment)
+  (constInfo: Lean.ConstantInfo)
+  (args: Array String)
+  (commit: Bool)
+  : IO UInt32
+  := do
+  let signature <- runMeta (Lean.PrettyPrinter.ppSignature constInfo.name) env
+  let args : Array Lean.Expr <- args.mapM $ fun a => do
+    let argInfo <- match env.constants.find? a.toName with
+      | some c => runMeta (mkConst' c.name) env
+      | none => throw $ IO.userError s!"unknown constant {a.toName}"
+  let (lvls, input, output, type, sort) <- 
+    runMeta (metaMakeEvalClaim constInfo.name (args.toList)) env
+  IO.println "evaluating:"
+  IO.println signature.fmt.pretty
+  let inputPretty <- runMeta (Lean.Meta.ppExpr input) env
+  let outputPretty <- runMeta (Lean.Meta.ppExpr output) env
+  let typePretty <- runMeta (Lean.Meta.ppExpr type) env
+  IO.println s!"{inputPretty}"
+  IO.println s!"  ~> {outputPretty}"
+  IO.println s!"  : {typePretty}"
+  IO.println s!"  @ {repr lvls}"
+  let ((claim, _, _), _stt) <- 
+    (Ix.Compile.evalClaim lvls input output type sort commit).runIO' 200000 (.init env)
+  IO.println $ s!"claim: {claim}"
+  -- TODO: prove
   return 0
 
-def runProveCheck (p: Cli.Parsed): IO UInt32 := do
+
+
+def runProve (p: Cli.Parsed): IO UInt32 := do
   let input : String       := p.positionalArg! "input" |>.as! String
   let const : String       := p.positionalArg! "const" |>.as! String
   let path := ⟨input⟩
@@ -29,41 +75,22 @@ def runProveCheck (p: Cli.Parsed): IO UInt32 := do
   let constInfo <- match env.constants.find? const.toName with
     | some c => pure c
     | none => throw $ IO.userError s!"unknown constant {const.toName}"
-  let constTypeSort <- runMeta (Lean.Meta.inferType constInfo.type) env
   let commit := p.hasFlag "commit"
-  let ((claim, _, _), _) <- 
-    (Ix.Compile.checkClaim const.toName constInfo.type constTypeSort
-    constInfo.levelParams commit).runIO' 200000 (.init env)
-  IO.println $ s!"checking {const.toName} in {input}"
-  IO.println $ s!"claim {claim}"
+  if let some evalArgs := p.flag? "eval"
+  then runProveEval env constInfo (evalArgs.as! (Array String)) commit
+  else runProveCheck env constInfo commit
   return 0
 
 
-def proveCheckCmd : Cli.Cmd := `[Cli|
-  check VIA runProveCheck;
-  "prove typechecking"
-
-  FLAGS:
-    cron, "cronos"; "enable Cronos timings"
-    address, "address"; "lookup inputs by address"
-    commit, "commit"; "commit inputs"
-
-  ARGS:
-   input  : String; "Source file input"
-   const  : String; "constant name"
-]
-
 def proveCmd : Cli.Cmd := `[Cli|
   prove VIA runProve;
-  "Generates a ZK proof of a given Lean source file"
+  "Generates a ZK proof of a given Lean constant"
 
   FLAGS:
     cron, "cronos"   : String; "enable Cronos timings"
-    address, "address"   : String; "lookup inputs by address"
+    eval, "eval"     : Array String; "prove evaluation with arguments"
 
   ARGS:
    input  : String; "Source file input"
-
-  SUBCOMMANDS:
-    proveCheckCmd
+   const  : String; "constant name"
 ]
diff --git a/Ix/Cli/StoreCmd.lean b/Ix/Cli/StoreCmd.lean
index b710c8a8..40ef5196 100644
--- a/Ix/Cli/StoreCmd.lean
+++ b/Ix/Cli/StoreCmd.lean
@@ -45,7 +45,7 @@ def runGet (p : Cli.Parsed) : IO UInt32 := do
     match Address.fromString input with
     | .some a => .ok a
     | .none => .error "bad address"
-  let const <- StoreIO.toIO (readConst address)
+  let const <- StoreIO.toIO (Store.readConst address)
   IO.println <| s!"{repr const}"
   return 0
 
diff --git a/Ix/Cli/TestCmd.lean b/Ix/Cli/TestCmd.lean
index 57b9eea1..d2624a9b 100644
--- a/Ix/Cli/TestCmd.lean
+++ b/Ix/Cli/TestCmd.lean
@@ -10,28 +10,28 @@ import Init.System.IO
 import Init.System.IOError
 
 def runTest (p : Cli.Parsed) : IO UInt32 := do
-  let input   : String       := p.positionalArg! "input" |>.as! String
-  IO.println s!"Input: {input}"
-  let inputBA := input.toUTF8
-  IO.println s!"Input UTF8: {hexOfBytes inputBA}"
-  let const : Ixon.Const := .defn
-    { lvls := 0, type := .strl "BAD", value := .strl input, part := .true}
-  IO.println s!"Const: {repr const}"
-  let bytes := Ixon.Serialize.put const
-  IO.println s!"Bytes: {hexOfBytes bytes}"
-  let addr := Address.blake3 bytes
-  IO.println s!"Address: {hexOfBytes addr.hash}"
-  let home ← StoreIO.toIO getHomeDir
-  IO.println s!"HOME at {home}"
-  let store ← StoreIO.toIO storeDir
-  IO.println s!"Store at {store}"
-  StoreIO.toIO ensureStoreDir
-  IO.println s!"write entry at {store / (hexOfBytes addr.hash)}"
-  let _ <- StoreIO.toIO (writeConst const)
-  IO.println s!"read entry at {store / (hexOfBytes addr.hash)}"
-  let const' ← StoreIO.toIO (readConst addr)
-  IO.println s!"Const': {repr const'}"
-  IO.println s!"matching {const == const'}"
+--  let input   : String       := p.positionalArg! "input" |>.as! String
+--  IO.println s!"Input: {input}"
+--  let inputBA := input.toUTF8
+--  IO.println s!"Input UTF8: {hexOfBytes inputBA}"
+--  let const : Ixon.Const := .defn
+--    { lvls := 0, type := .strl "BAD", value := .strl input, part := .true}
+--  IO.println s!"Const: {repr const}"
+--  let bytes := Ixon.Serialize.put const
+--  IO.println s!"Bytes: {hexOfBytes bytes}"
+--  let addr := Address.blake3 bytes
+--  IO.println s!"Address: {hexOfBytes addr.hash}"
+--  let home ← StoreIO.toIO getHomeDir
+--  IO.println s!"HOME at {home}"
+--  let store ← StoreIO.toIO storeDir
+--  IO.println s!"Store at {store}"
+--  StoreIO.toIO ensureStoreDir
+--  IO.println s!"write entry at {store / (hexOfBytes addr.hash)}"
+--  let _ <- StoreIO.toIO (writeConst const)
+--  IO.println s!"read entry at {store / (hexOfBytes addr.hash)}"
+--  let const' ← StoreIO.toIO (readConst addr)
+--  IO.println s!"Const': {repr const'}"
+--  IO.println s!"matching {const == const'}"
   return 0
 
 def testCmd : Cli.Cmd := `[Cli|
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 6a116ffe..761a3a18 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -4,6 +4,7 @@ import Ix.Ixon.Metadata
 import Ix.Ixon.Const
 import Ix.Ixon.Serialize
 import Ix.Common
+import Ix.Store
 
 open Batteries (RBMap)
 open Batteries (RBSet)
@@ -26,6 +27,7 @@ inductive CompileError
 | cantFindMutDefIndex : Lean.Name → CompileError
 | transportError : TransportError → CompileError
 | kernelException : String → CompileError
+| storeError : StoreError → CompileError
 | todo
 
 instance : ToString CompileError where toString
@@ -52,9 +54,10 @@ structure CompileEnv where
   bindCtx : List Lean.Name
   mutCtx  : RBMap Lean.Name Nat compare
   maxHeartBeats: USize
+  persist : Bool
 
 def CompileEnv.init (maxHeartBeats: USize): CompileEnv :=
-  ⟨default, default, default, maxHeartBeats⟩
+  ⟨default, default, default, maxHeartBeats, true⟩
 
 structure CompileState where
   env: Lean.Environment
@@ -84,6 +87,19 @@ def CompileM.runIO' (maxHeartBeats: USize) (stt: CompileState) (c : CompileM α)
 def CompileM.liftIO (io: IO α): CompileM α :=
   monadLift io
 
+def liftStoreIO (io: StoreIO α): CompileM α := do
+  match <- CompileM.liftIO (EIO.toIO' io) with
+  | .ok a => return a
+  | .error e => throw (.storeError e)
+
+def writeToStore (const: Ixon.Const): CompileM Address := do
+  let addr <- if (<- read).persist 
+    then liftStoreIO (Store.writeConst const)
+    else pure (Address.blake3 (Ixon.Serialize.put const))
+  modifyGet fun stt => (addr, { stt with
+    store := stt.store.insert addr const
+  })
+
 def IO.freshSecret : IO Address := do
   IO.setRandSeed (← IO.monoNanosNow)
   let mut secret : ByteArray := default
@@ -120,13 +136,12 @@ def hashConst (const: Ix.Const) : CompileM (Address × Address) := do
   | some (anonAddr, metaAddr) => pure (anonAddr, metaAddr)
   | none => do
     let (anonIxon, metaIxon) <- match constToIxon const with
-    | .ok (a, m) => pure (a, m)
-    | .error e => throw (.transportError e)
-    let anonAddr := Address.blake3 (Ixon.Serialize.put anonIxon)
-    let metaAddr := Address.blake3 (Ixon.Serialize.put metaIxon)
+      | .ok (a, m) => pure (a, m)
+      | .error e => throw (.transportError e)
+    let anonAddr <- writeToStore anonIxon
+    let metaAddr <- writeToStore metaIxon
     modifyGet fun stt => ((anonAddr, metaAddr), { stt with
       cache := stt.cache.insert const (anonAddr, metaAddr)
-      store := (stt.store.insert anonAddr anonIxon).insert metaAddr metaIxon
     })
 
 scoped instance : HMul Ordering Ordering Ordering where hMul
@@ -522,20 +537,20 @@ partial def commitConst (anon meta: Address)
   : CompileM (Address × Address) := do
   let secret <- freshSecret
   let comm := .comm ⟨secret, anon⟩
-  let commAddr := Address.blake3 (Ixon.Serialize.put comm)
+  let commAddr <- writeToStore comm
   let commMeta := .comm ⟨secret, meta⟩
-  let commMetaAddr := Address.blake3 (Ixon.Serialize.put commMeta)
+  let commMetaAddr <- writeToStore commMeta
   modify fun stt => { stt with
-    store := (stt.store.insert commAddr comm).insert commMetaAddr commMeta
     comms := stt.comms.insert commAddr.toUniqueName (commAddr, commMetaAddr)
   }
   return (commAddr, commMetaAddr)
 
-partial def addCommitment (lvls: List Lean.Name) (typ val: Lean.Expr)
+partial def commitDef (lvls: List Lean.Name) (typ val: Lean.Expr)
   : CompileM (Address × Address) := do
   let (a, m) <- addDef lvls typ val
   let (ca, cm) <- commitConst a m
   tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ val)
+  --tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ (mkConst a.toUniqueName []))
   return (ca, cm)
 
 /--
@@ -675,10 +690,9 @@ partial def packLevel (lvls: Nat) (commit: Bool): CompileM Address :=
   | some lvlsAddr => do
     if commit then
       let secret <- freshSecret
-      let comm := Ixon.Comm.mk secret lvlsAddr
-      let commAddr := Address.blake3 (Ixon.Serialize.put (Ixon.Const.comm comm))
+      let comm := .comm (Ixon.Comm.mk secret lvlsAddr)
+      let commAddr <- writeToStore comm
       modify fun stt => { stt with
-        store := stt.store.insert commAddr (Ixon.Const.comm comm)
         comms := stt.comms.insert commAddr.toUniqueName (commAddr, commAddr)
       }
       return commAddr
@@ -700,16 +714,15 @@ partial def checkClaim
   where
     comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
 
-partial def evalClaimByName
-  (input: Lean.Name)
+partial def evalClaim
+  (lvls: List Lean.Name)
+  (input: Lean.Expr)
   (output: Lean.Expr)
   (type: Lean.Expr)
   (sort: Lean.Expr)
-  (lvls: List Lean.Name)
   (commit: Bool)
   : CompileM (Claim × Address × Address × Address) := do
-  let leanConst <- findLeanConst input
-  let (input, inputMeta) <- compileConst leanConst >>= comm
+  let (input, inputMeta) <- addDef lvls type input >>= comm
   let (output, outputMeta) <- addDef lvls type output >>= comm
   let (type, typeMeta) <- addDef lvls sort type >>= comm
   let lvlsAddr <- packLevel lvls.length commit
@@ -717,41 +730,6 @@ partial def evalClaimByName
   where
     comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
 
-partial def makeEvalInput
-  (lvls: List Lean.Name)
-  (typeAnon typeMeta funcAnon funcMeta: Address) 
-  (args : List (Address × Address))
-  : CompileM (Address × Address) := do
-  let univs := lvls.zipIdx.map (fun (n, i) => Ix.Univ.var n i)
-  let type := Ix.Expr.const typeAnon.toUniqueName typeAnon typeMeta univs
-  let func := Ix.Expr.const funcAnon.toUniqueName funcAnon funcMeta univs
-  let argConsts := args.map $ fun (a,m) => Ix.Expr.const a.toUniqueName a m univs
-  let val := argConsts.foldl Expr.app func
-  hashConst $ Ix.Const.definition ⟨lvls.length, type, val, true⟩
-
-
-partial def evalClaimWithArgs
-  (func: Lean.Name)
-  (args: List (Lean.Expr × Lean.Expr))
-  (output: Lean.Expr)
-  (type: Lean.Expr)
-  (sort: Lean.Expr)
-  (lvls: List Lean.Name)
-  (commit: Bool)
-  : CompileM (Claim × Address × Address × Address) := do
-  let leanConst <- findLeanConst func
-  let (funcAnon, funcMeta) <- compileConst leanConst >>= comm
-  let (typeAnon, typeMeta) <- addDef lvls sort type >>= comm
-  let (outputAnon, outputMeta) <- addDef lvls type output >>= comm
-  let args <- args.mapM $ fun (arg, argType) => 
-    addDef lvls argType arg >>= comm
-  let (inputAnon, inputMeta) <-
-    makeEvalInput lvls typeAnon typeMeta funcAnon funcMeta args
-  let lvlsAddr <- packLevel lvls.length commit
-  return (Claim.evals lvlsAddr inputAnon outputAnon typeAnon, inputMeta, outputMeta, typeMeta)
-  where
-    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
-
 def compileConstIO (env : Lean.Environment ) (const: Lean.ConstantInfo)
   : IO $ (Address × Address) × CompileState := do
   let (a, s) <- (compileConst const).runIO 200000 (.init env)
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index f4be0df3..d439e56f 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -42,25 +42,29 @@ def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO Address
   let ((a, _), _) <- Ix.Compile.compileConstIO env const
   return a
 
-def mkAnonDefInfoRaw (type : Expr) (value : Expr) : ConstantInfo :=
-  .defnInfo {
-    name        := .anonymous
-    levelParams := []
-    type
-    value
-    hints       := .opaque
-    safety      := .safe
-  }
-
-def mkAnonDefInfo [inst : ToExpr α] (a : α) : ConstantInfo :=
-  mkAnonDefInfoRaw inst.toTypeExpr (toExpr a)
-
 def runCore (f : CoreM α) (env : Environment) : IO α :=
   Prod.fst <$> f.toIO { fileName := default, fileMap := default } { env }
 
 def runMeta (f : MetaM α) (env : Environment) : IO α :=
   Prod.fst <$> f.toIO { fileName := default, fileMap := default } { env }
 
-def metaMkList (α: Lean.Expr) (names: List Lean.Name) : MetaM Expr := do
+def metaMakeList (α: Lean.Expr) (names: List Lean.Name) : MetaM Expr := do
   let nil <- Meta.mkAppOptM ``List.nil #[.some α]
   names.foldrM (fun n t => Meta.mkAppOptM ``List.cons #[.some α, mkConst n, t]) nil
+
+def metaMakeDef [Lean.ToExpr α] (a: α) : MetaM (List Lean.Name × Lean.Expr × Lean.Expr) := do
+  let val := Lean.toExpr a
+  let typ <- Meta.inferType val
+  let lvls := (Lean.collectLevelParams default typ).params.toList
+  return (lvls, typ, val)
+
+def metaMakeEvalClaim (func: Lean.Name) (args : List Lean.Expr)
+  : MetaM (List Lean.Name × Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) := do
+  let input <- Meta.mkAppM func args.toArray
+  let output <- Meta.reduce input
+  let type <- Meta.inferType output
+  let sort <- Meta.inferType type
+  let lvls := (Lean.collectLevelParams default input).params.toList
+  return (lvls, input, output, type, sort)
+
+
diff --git a/Ix/Store.lean b/Ix/Store.lean
index dbf3afb0..9f5da80c 100644
--- a/Ix/Store.lean
+++ b/Ix/Store.lean
@@ -20,12 +20,13 @@ def storeErrorToIOError : StoreError -> IO.Error
 | .ixonError e => IO.Error.userError s!"ixon error {e}"
 | .noHome => IO.Error.userError s!"no HOME environment variable"
 
-
 abbrev StoreIO := EIO StoreError
 
 def StoreIO.toIO (sio: StoreIO α) : IO α :=
   EIO.toIO storeErrorToIOError sio
 
+namespace Store
+
 def getHomeDir : StoreIO FilePath := do
   match ← IO.getEnv "HOME" with
   | .some path => return ⟨path⟩
@@ -55,4 +56,4 @@ def readConst (a: Address) : StoreIO Ixon.Const := do
   | .ok c => return c
   | .error e => throw (.ixonError e)
 
-
+end Store

From 221f352f072932f8d3c1ff6078052d01c63302a0 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sun, 20 Apr 2025 18:19:18 -0400
Subject: [PATCH 12/74] provecmd examples

---
 Ix/Cli/ProveCmd.lean | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean
index 91f3d2e5..20a9e7c4 100644
--- a/Ix/Cli/ProveCmd.lean
+++ b/Ix/Cli/ProveCmd.lean
@@ -7,14 +7,10 @@ import Ix.Address
 import Ix.Meta
 import Lean
 
--- ix prove eval AcmeInput
--- ix prove eval --address deadbeef
--- ix prove eval AcmeFun AcmeArg1 AcmeArg2
--- ix prove eval --address abcde 1234 5678
--- ix prove check --name AcmeTheo
--- ix prove check --address deadbeef
-
-
+--❯ ix prove IxTest.lean "id'"
+--typechecking:
+--id' (A : Type) (x : A) : A
+--claim: #bbd740022aa44acd553c52e156807a5571428220a926377fe3c57d63b06a99f4 : #ba33b735b743386477f7a0e6802c67d388c165cab0e34b04880b50270205f265 @ #0000000000000000000000000000000000000000000000000000000000000000
 def runProveCheck 
   (env: Lean.Environment)
   (constInfo: Lean.ConstantInfo)
@@ -35,6 +31,14 @@ def runProveCheck
 def mkConst' (constName : Lean.Name) : Lean.MetaM Lean.Expr := do
   return Lean.mkConst constName (← (← Lean.getConstInfo constName).levelParams.mapM fun _ => Lean.Meta.mkFreshLevelMVar)
 
+--ix prove IxTest.lean "id'" --eval=Nat,one
+--evaluating:
+--id' (A : Type) (x : A) : A
+--id' Nat one
+--  ~> 1
+--  : Nat
+--  @ []
+--claim: #88ba2a7b099ce94a030eef202dc26ee3d9eb088057830049b926c7e88044bba1 ~> #d5ea7e6e7a3ee02780ba254a0becfe1fe712436a5a30832095ab71f7c64e25cd : #41ba41a9691e8167a387046f736a82ce0ec1601e7fb996c58d5930887c4b7764 @ #0000000000000000000000000000000000000000000000000000000000000000
 def runProveEval
   (env: Lean.Environment)
   (constInfo: Lean.ConstantInfo)

From 5aa0fc47232f8d5843d7bb291d07085852ca5803 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sun, 20 Apr 2025 22:10:18 -0400
Subject: [PATCH 13/74] cleanup repo

---
 Apps/Test.lean      |  78 --------------------------------
 Ix/Claim.lean       |   1 -
 Ix/Cli/TestCmd.lean |  46 -------------------
 Ix/Commitment.lean  |  24 ----------
 Ix/IxM.lean         | 107 --------------------------------------------
 Main.lean           |   2 -
 6 files changed, 258 deletions(-)
 delete mode 100644 Apps/Test.lean
 delete mode 100644 Ix/Cli/TestCmd.lean
 delete mode 100644 Ix/Commitment.lean
 delete mode 100644 Ix/IxM.lean

diff --git a/Apps/Test.lean b/Apps/Test.lean
deleted file mode 100644
index 337dcf83..00000000
--- a/Apps/Test.lean
+++ /dev/null
@@ -1,78 +0,0 @@
---import Ix.Claim
---import Ix.Address
---import Ix.Meta
---import Ix.CompileM
---
---inductive Candidate
---   | alice | bob | charlie
---   deriving Inhabited, Lean.ToExpr, Repr
---
---inductive Result
---| winner : Candidate -> Result
---| tie : List Candidate -> Result
---deriving Repr, Lean.ToExpr
---
---def privateVotes : List Candidate := 
---  [.alice, .alice, .bob]
---
---def runElection (votes: List Candidate) : Result :=
---  let (a, b, c) := votes.foldr tally (0,0,0)
---  if a > b && a > c
---  then .winner .alice
---  else if b > a && b > c
---  then .winner .bob
---  else if c > a && c > b
---  then .winner .charlie
---  else if a == b && b == c
---  then .tie [.alice, .bob, .charlie]
---  else if a == b
---  then .tie [.alice, .bob]
---  else if a == c
---  then .tie [.alice, .charlie]
---  else .tie [.bob, .charlie]
---    where
---      tally (comm: Candidate) (acc: (Nat × Nat × Nat)): (Nat × Nat × Nat) :=
---      match comm, acc with
---      | .alice, (a, b, c) => (a+1, b, c)
---      | .bob, (a, b, c) => (a, b+1, c)
---      | .charlie, (a, b, c) => (a, b, c+1)
---
---def main : IO UInt32 := do
---  let mut stt : Ix.Compile.CompileState := .init (<- get_env!)
---  -- simulate getting the votes from somewhere
---  let votes : List Candidate <- pure [.alice, .alice, .bob]
---  let mut as : List Lean.Name := []
---  -- default maxHeartBeats
---  let ticks : USize := 200000
---  -- the type of each vote to commit
---  let voteType := Lean.toTypeExpr Candidate
---  -- loop over the votes
---  for v in votes do
---    let voteExpr := Lean.toExpr v
---    -- add each vote to our environment as a commitment
---    let ((addr, _), stt') <-
---      (Ix.Compile.addCommitment [] voteType voteExpr).runIO' ticks stt
---    stt := stt'
---    -- collect each commitment addresses as names
---    as := (Address.toUniqueName addr)::as
---  IO.println s!"{repr as}"
---  -- identify our function
---  let func := ``runElection
---  -- build a Lean list of our commitments as the argument to runElection
---  let arg : Lean.Expr <- runMeta (metaMkList voteType as) stt.env
---  let argType <- runMeta (Lean.Meta.inferType arg) stt.env
---  -- inputs to commit to the type of the output
---  let type := Lean.toTypeExpr Result
---  let sort <- runMeta (Lean.Meta.inferType type) stt.env
---  -- evaluate the output (both methods should be the same)
---  let output := Lean.toExpr (runElection votes)
---  IO.println s!"output1 {repr output}"
---  let output' <- runMeta (Lean.Meta.reduce (.app (Lean.mkConst func) arg)) stt.env
---  IO.println s!"output2 {repr output'}"
---  -- build the evaluation claim
---  let ((claim,_,_,_), _stt') <-
---     (Ix.Compile.evalClaimWithArgs func [(arg, argType)] output type sort [] true).runIO' ticks stt
---  IO.println s!"{claim}"
---  -- Ix.prove claim stt
---  return 0
---
diff --git a/Ix/Claim.lean b/Ix/Claim.lean
index 83e13b26..19b43b00 100644
--- a/Ix/Claim.lean
+++ b/Ix/Claim.lean
@@ -1,5 +1,4 @@
 import Ix.Address
-import Ix.Commitment
 
 inductive Claim where
 | checks (lvls type value: Address) : Claim
diff --git a/Ix/Cli/TestCmd.lean b/Ix/Cli/TestCmd.lean
deleted file mode 100644
index d2624a9b..00000000
--- a/Ix/Cli/TestCmd.lean
+++ /dev/null
@@ -1,46 +0,0 @@
-import Cli
-import Blake3
-import Ix.Address
-import Ix.Store
-import Ix.Ixon.Expr
-import Ix.Ixon.Const
-import Ix.Ixon.Serialize
-import Init.System.FilePath
-import Init.System.IO
-import Init.System.IOError
-
-def runTest (p : Cli.Parsed) : IO UInt32 := do
---  let input   : String       := p.positionalArg! "input" |>.as! String
---  IO.println s!"Input: {input}"
---  let inputBA := input.toUTF8
---  IO.println s!"Input UTF8: {hexOfBytes inputBA}"
---  let const : Ixon.Const := .defn
---    { lvls := 0, type := .strl "BAD", value := .strl input, part := .true}
---  IO.println s!"Const: {repr const}"
---  let bytes := Ixon.Serialize.put const
---  IO.println s!"Bytes: {hexOfBytes bytes}"
---  let addr := Address.blake3 bytes
---  IO.println s!"Address: {hexOfBytes addr.hash}"
---  let home ← StoreIO.toIO getHomeDir
---  IO.println s!"HOME at {home}"
---  let store ← StoreIO.toIO storeDir
---  IO.println s!"Store at {store}"
---  StoreIO.toIO ensureStoreDir
---  IO.println s!"write entry at {store / (hexOfBytes addr.hash)}"
---  let _ <- StoreIO.toIO (writeConst const)
---  IO.println s!"read entry at {store / (hexOfBytes addr.hash)}"
---  let const' ← StoreIO.toIO (readConst addr)
---  IO.println s!"Const': {repr const'}"
---  IO.println s!"matching {const == const'}"
-  return 0
-
-def testCmd : Cli.Cmd := `[Cli|
-  test VIA runTest;
-  "run a test"
-
-  FLAGS:
-    e, "example"   : String; "Example flag"
-
-  ARGS:
-    input  : String; "Source file input"
-]
diff --git a/Ix/Commitment.lean b/Ix/Commitment.lean
deleted file mode 100644
index 870abb45..00000000
--- a/Ix/Commitment.lean
+++ /dev/null
@@ -1,24 +0,0 @@
-import Lean
-import Ix.Address
-
-namespace Ix
-
-structure Comm (α : Type 0) where
-  value : Lean.Expr
-  deriving Inhabited
-
-end Ix
-
---inductive CommError where
---| openTerm
---| openCommitment
---| unknownConst (n: Lean.Name)
---
---structure CommCtx where
---  env : Lean.ConstMap
---
---structure CommState where
---  comms: RBMap Address 
---
---abbrev CommM := ReaderT CommCtx <| ExceptT CommError <| StateT CommState
-----abbrev IxM := ReaderT IxMEnv $ ExceptT IxError $ StateT IxMState Id
diff --git a/Ix/IxM.lean b/Ix/IxM.lean
deleted file mode 100644
index ddcc82ea..00000000
--- a/Ix/IxM.lean
+++ /dev/null
@@ -1,107 +0,0 @@
---import Blake3
-
---import Ix.Address
---import Ix.Ixon
---import Ix.Ixon.Serialize
---import Ix.Meta
---import Ix.CanonM
---import Batteries.Data.RBMap
---import Lean
---import Ix.Prove
-
---open Batteries (RBMap)
-
---namespace Ix
---
---inductive IxError
---| todo
---
---instance : ToString IxError where
---  toString p := s!"todo"
---
-----instance : ToString Proof where
-----  toString p := s!"<#{p.inp} ~> #{p.out} : #{p.typ}>"
---
---structure IxMEnv where
---  names : RBMap Lean.Name (Address × Address) compare
---  consts: RBMap Address Ixon.Const compare
---  secret: Address
---
---structure IxMState where
---  comms : RBMap Address Ixon.Comm compare
---  -- transcript : List IxVMOp
---  main : Option (Address × Ixon.Const)
---  deriving Inhabited
---
---abbrev IxM := ReaderT IxMEnv $ ExceptT IxError $ StateT IxMState Id
---
---def IxM.run (env: Lean.Environment) (secret: Lean.Name) (ixm: IxM Claim)
---  : IO (Claim × IxMState × IxMEnv) := do
---  let stt <- IO.ofExcept (<- Ix.CanonM.canonicalizeEnv env)
---  let (secret, _) := stt.names.find! secret
---  let env := IxMEnv.mk stt.names stt.store secret
---  let (res, stt) := Id.run (StateT.run (ReaderT.run ixm env) default)
---  let claim <- IO.ofExcept res
---  return (claim, stt, env)
---
---def IxM.commit (payload: Address): IxM Address := do
---  let secret <- (·.secret) <$> read
---  let comm := Ixon.Comm.mk secret payload
---  let addr := Address.blake3 (Ixon.Serialize.put (Ixon.Const.comm comm))
---  modify (fun stt => { stt with
---    comms := stt.comms.insert addr comm
---    -- transcript := (.commit payload secret addr)::stt.transcript
---  })
---  return addr
---
---def IxM.byName (name: Lean.Name) : IxM Address := do
---  let env <- read
---  match env.names.find? name with
---  | .none => throw .todo
---  | .some (addr, _) => return addr
---
---def IxM.reveal (comm: Address) : IxM Address := do
---  let stt <- get
---  match stt.comms.find? comm with
---  | .some c => return c.payload
---  | .none => throw .todo
---
---def IxM.secret (comm: Address) : IxM Address := do
---  let stt <- get
---  match stt.comms.find? comm with
---  | .some c => return c.secret
---  | .none => throw .todo
---
----- TODO: handle universe arguments
---def IxM.mkMainConst (type func: Address) (args: List Address): Ixon.Const :=
---  match args with
---  | [] =>
---    Ixon.Const.defn {
---      lvls := 0,
---      type := Ixon.Expr.cnst type [],
---      value := Ixon.Expr.cnst func [],
---      part := .true,
---    }
---  | a::as =>
---    let as':= as.map (fun a => Ixon.Expr.cnst a [])
---    Ixon.Const.defn {
---      lvls := 0,
---      type := Ixon.Expr.cnst type [],
---      value := Ixon.Expr.apps (Ixon.Expr.cnst func []) (Ixon.Expr.cnst a []) as' ,
---      part := .true,
---    }
---
---def IxM.mkMain (type func: Address) (args: List Address): IxM Address := do
---  let mainConst := IxM.mkMainConst type func args
---  let bytes := Ixon.Serialize.put mainConst
---  let addr := Address.blake3 bytes
---  modify (fun stt => { stt with main := .some (addr, mainConst) })
---  return addr
---
---def IxM.evaluate (type input: Address) : IxM Address := sorry
---
---def IxM.prove (claim : Claim) (stt: IxMState) (env: IxMEnv) : IO Proof :=
---  sorry
---
---end Ix
---
diff --git a/Main.lean b/Main.lean
index 22056fb0..2288ac76 100644
--- a/Main.lean
+++ b/Main.lean
@@ -1,5 +1,4 @@
 import Ix.Cli.ProveCmd
-import Ix.Cli.TestCmd
 import Ix.Cli.StoreCmd
 import Ix.Cli.SendCmd
 import Ix.Cli.RecvCmd
@@ -14,7 +13,6 @@ def ixCmd : Cli.Cmd := `[Cli|
 
   SUBCOMMANDS:
     proveCmd;
-    testCmd;
     storeCmd;
     sendCmd;
     recvCmd

From ed79280213857bc419507d063a7462fdbd80b07d Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 21 Apr 2025 16:34:09 -0400
Subject: [PATCH 14/74] simplify ZKVoting example app

---
 Apps/ZKVoting/Prover.lean | 37 +++++++++++++------------------------
 1 file changed, 13 insertions(+), 24 deletions(-)

diff --git a/Apps/ZKVoting/Prover.lean b/Apps/ZKVoting/Prover.lean
index 5f09d860..c09760dc 100644
--- a/Apps/ZKVoting/Prover.lean
+++ b/Apps/ZKVoting/Prover.lean
@@ -2,47 +2,36 @@ import Ix.Claim
 import Ix.Address
 import Ix.Meta
 import Ix.CompileM
+import Batteries
 
 inductive Candidate
    | alice | bob | charlie
-   deriving Inhabited, Lean.ToExpr, Repr
+   deriving Inhabited, Lean.ToExpr, Repr, BEq, Ord
 
-inductive Result
-| winner : Candidate -> Result
-| tie : List Candidate -> Result
+structure Result where
+  aliceVotes: Nat
+  bobVotes: Nat
+  charlieVotes: Nat
 deriving Repr, Lean.ToExpr
 
 def privateVotes : List Candidate := 
   [.alice, .alice, .bob]
 
 def runElection (votes: List Candidate) : Result :=
-  let (a, b, c) := votes.foldr tally (0,0,0)
-  if a > b && a > c
-  then .winner .alice
-  else if b > a && b > c
-  then .winner .bob
-  else if c > a && c > b
-  then .winner .charlie
-  else if a == b && b == c
-  then .tie [.alice, .bob, .charlie]
-  else if a == b
-  then .tie [.alice, .bob]
-  else if a == c
-  then .tie [.alice, .charlie]
-  else .tie [.bob, .charlie]
+  votes.foldr tally ⟨0,0,0⟩
     where
-      tally (comm: Candidate) (acc: (Nat × Nat × Nat)): (Nat × Nat × Nat) :=
-      match comm, acc with
-      | .alice, (a, b, c) => (a+1, b, c)
-      | .bob, (a, b, c) => (a, b+1, c)
-      | .charlie, (a, b, c) => (a, b, c+1)
+      tally (comm: Candidate) (res: Result): Result :=
+      match comm, res with
+      | .alice, ⟨a, b, c⟩ => ⟨a+1, b, c⟩
+      | .bob, ⟨a, b, c⟩ => ⟨a, b+1, c⟩
+      | .charlie, ⟨a, b, c⟩ => ⟨a, b, c+1⟩
 
 open Ix.Compile
 
 def main : IO UInt32 := do
   let mut stt : CompileState := .init (<- get_env!)
   -- simulate getting the votes from somewhere
-  let votes : List Candidate <- pure [.alice, .alice, .bob]
+  let votes : List Candidate <- pure privateVotes
   let mut as : List Lean.Name := []
   -- default maxHeartBeats
   let ticks : USize := 200000

From 5e806e7bd01ec471a9a830025bb040928bf96f8f Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 23 Apr 2025 17:06:16 -0400
Subject: [PATCH 15/74] remove IO from the compiler core

---
 Apps/ZKVoting/Prover.lean |  24 ++--
 Ix/Cli/ProveCmd.lean      |   8 +-
 Ix/Cli/StoreCmd.lean      |   3 +-
 Ix/CompileM.lean          | 252 +++++++++++++++++++-------------------
 Ix/IR/Const.lean          |  28 ++---
 Ix/Meta.lean              |   6 +-
 Ix/Store.lean             |   8 ++
 7 files changed, 166 insertions(+), 163 deletions(-)

diff --git a/Apps/ZKVoting/Prover.lean b/Apps/ZKVoting/Prover.lean
index c09760dc..8a8e3ecf 100644
--- a/Apps/ZKVoting/Prover.lean
+++ b/Apps/ZKVoting/Prover.lean
@@ -29,35 +29,33 @@ def runElection (votes: List Candidate) : Result :=
 open Ix.Compile
 
 def main : IO UInt32 := do
-  let mut stt : CompileState := .init (<- get_env!)
+  let mut env : Lean.Environment := <- get_env!
   -- simulate getting the votes from somewhere
   let votes : List Candidate <- pure privateVotes
   let mut as : List Lean.Name := []
-  -- default maxHeartBeats
-  let ticks : USize := 200000
   -- the type of each vote to commit
   let voteType := Lean.toTypeExpr Candidate
   -- loop over the votes
   for v in votes do
     -- add each vote to our environment as a commitment
-    let (lvls, typ, val) <- runMeta (metaMakeDef v) stt.env
-    let ((addr, _), stt') <- (commitDef lvls typ val).runIO' ticks stt
-    stt := stt'
+    let (lvls, typ, val) <- runMeta (metaMakeDef v) env
+    let ((addr, _), stt) <- (commitDef lvls typ val).runIO env
+    env := stt.env
     as := (Address.toUniqueName addr)::as
     IO.println s!"vote: {repr v}, commitment: {addr}"
   -- build a Lean list of our commitments as the argument to runElection
-  let arg : Lean.Expr <- runMeta (metaMakeList voteType as) stt.env
+  let arg : Lean.Expr <- runMeta (metaMakeList voteType as) env
   let (lvls, input, output, type, sort) <-
-    runMeta (metaMakeEvalClaim ``runElection [arg]) stt.env
-  let inputPretty <- runMeta (Lean.Meta.ppExpr input) stt.env
-  let outputPretty <- runMeta (Lean.Meta.ppExpr output) stt.env
-  let typePretty <- runMeta (Lean.Meta.ppExpr type) stt.env
+    runMeta (metaMakeEvalClaim ``runElection [arg]) env
+  let inputPretty <- runMeta (Lean.Meta.ppExpr input) env
+  let outputPretty <- runMeta (Lean.Meta.ppExpr output) env
+  let typePretty <- runMeta (Lean.Meta.ppExpr type) env
   IO.println s!"claim: {inputPretty}"
   IO.println s!"  ~> {outputPretty}"
   IO.println s!"  : {typePretty}"
   IO.println s!"  @ {repr lvls}"
-  let ((claim,_,_,_), _stt') <-
-     (evalClaim lvls input output type sort true).runIO' ticks stt
+  let ((claim,_,_,_), _stt') <- 
+    (evalClaim lvls input output type sort true).runIO env
   IO.println s!"{claim}"
   -- Ix.prove claim stt
   return 0
diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean
index 20a9e7c4..0e2a6052 100644
--- a/Ix/Cli/ProveCmd.lean
+++ b/Ix/Cli/ProveCmd.lean
@@ -7,6 +7,8 @@ import Ix.Address
 import Ix.Meta
 import Lean
 
+open Ix.Compile
+
 --❯ ix prove IxTest.lean "id'"
 --typechecking:
 --id' (A : Type) (x : A) : A
@@ -22,8 +24,7 @@ def runProveCheck
   IO.println "typechecking:"
   IO.println signature.fmt.pretty
   let ((claim, _, _), _stt) <- 
-    (Ix.Compile.checkClaim constInfo.name constInfo.type constSort
-    constInfo.levelParams commit).runIO' 200000 (.init env)
+    (checkClaim constInfo.name constInfo.type constSort constInfo.levelParams commit).runIO env
   IO.println $ s!"claim: {claim}"
   -- TODO: prove
   return 0
@@ -62,8 +63,7 @@ def runProveEval
   IO.println s!"  ~> {outputPretty}"
   IO.println s!"  : {typePretty}"
   IO.println s!"  @ {repr lvls}"
-  let ((claim, _, _), _stt) <- 
-    (Ix.Compile.evalClaim lvls input output type sort commit).runIO' 200000 (.init env)
+  let ((claim, _, _), _stt) <- (evalClaim lvls input output type sort commit).runIO env
   IO.println $ s!"claim: {claim}"
   -- TODO: prove
   return 0
diff --git a/Ix/Cli/StoreCmd.lean b/Ix/Cli/StoreCmd.lean
index 40ef5196..a7da186a 100644
--- a/Ix/Cli/StoreCmd.lean
+++ b/Ix/Cli/StoreCmd.lean
@@ -15,11 +15,10 @@ def runStore (p : Cli.Parsed) : IO UInt32 := do
   --StoreIO.toIO ensureStoreDir
   let path := ⟨source⟩
   let leanEnv ← Lean.runFrontend (← IO.FS.readFile path) path
-  let delta := leanEnv.getDelta
   cronos ← cronos.clock "Lean-frontend"
   -- Start content-addressing
   cronos ← cronos.clock "content-address"
-  let stt ← Ix.Compile.compileDeltaIO leanEnv delta
+  let stt ← Ix.Compile.compileEnvIO leanEnv
   stt.names.forM fun name (const, meta) => do
      IO.println <| s!"{name}:"
      IO.println <| s!"  #{const}"
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 761a3a18..2efdb5e8 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -12,6 +12,7 @@ open Ix.TransportM
 
 namespace Ix.Compile
 
+
 inductive CompileError
 | unknownConstant : Lean.Name → CompileError
 | unfilledLevelMetavariable : Lean.Level → CompileError
@@ -26,41 +27,41 @@ inductive CompileError
 | nonRecursorExtractedFromChildren : Lean.Name → CompileError
 | cantFindMutDefIndex : Lean.Name → CompileError
 | transportError : TransportError → CompileError
-| kernelException : String → CompileError
-| storeError : StoreError → CompileError
+| kernelException : Lean.Kernel.Exception → CompileError
+--| storeError : StoreError → CompileError
 | todo
 
-instance : ToString CompileError where toString
-| .unknownConstant n => s!"Unknown constant '{n}'"
-| .unfilledLevelMetavariable l => s!"Unfilled level metavariable on universe '{l}'"
-| .unfilledExprMetavariable e => s!"Unfilled level metavariable on expression '{e}'"
-| .invalidBVarIndex idx => s!"Invalid index {idx} for bound variable context"
-| .freeVariableExpr e => s!"Free variable in expression '{e}'"
-| .metaVariableExpr e => s!"Metavariable in expression '{e}'"
-| .metaDataExpr e => s!"Meta data in expression '{e}'"
-| .levelNotFound n ns => s!"'Level {n}' not found in '{ns}'"
-| .invalidConstantKind n ex gt =>
-  s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
-| .constantNotContentAddressed n => s!"Constant '{n}' wasn't content-addressed"
-| .nonRecursorExtractedFromChildren n =>
-  s!"Non-recursor '{n}' extracted from children"
-| .cantFindMutDefIndex n => s!"Can't find index for mutual definition '{n}'"
-| .transportError n => s!"Transport error '{repr n}'"
-| .kernelException e => e
-| _ => s!"todo"
+--instance : ToString CompileError where toString
+--| .unknownConstant n => s!"Unknown constant '{n}'"
+--| .unfilledLevelMetavariable l => s!"Unfilled level metavariable on universe '{l}'"
+--| .unfilledExprMetavariable e => s!"Unfilled level metavariable on expression '{e}'"
+--| .invalidBVarIndex idx => s!"Invalid index {idx} for bound variable context"
+--| .freeVariableExpr e => s!"Free variable in expression '{e}'"
+--| .metaVariableExpr e => s!"Metavariable in expression '{e}'"
+--| .metaDataExpr e => s!"Meta data in expression '{e}'"
+--| .levelNotFound n ns => s!"'Level {n}' not found in '{ns}'"
+--| .invalidConstantKind n ex gt =>
+--  s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
+--| .constantNotContentAddressed n => s!"Constant '{n}' wasn't content-addressed"
+--| .nonRecursorExtractedFromChildren n =>
+--  s!"Non-recursor '{n}' extracted from children"
+--| .cantFindMutDefIndex n => s!"Can't find index for mutual definition '{n}'"
+--| .transportError n => s!"Transport error '{repr n}'"
+--| .kernelException e => e
+--| _ => s!"todo"
 
 structure CompileEnv where
   univCtx : List Lean.Name
   bindCtx : List Lean.Name
   mutCtx  : RBMap Lean.Name Nat compare
   maxHeartBeats: USize
-  persist : Bool
 
 def CompileEnv.init (maxHeartBeats: USize): CompileEnv :=
-  ⟨default, default, default, maxHeartBeats, true⟩
+  ⟨default, default, default, maxHeartBeats⟩
 
 structure CompileState where
   env: Lean.Environment
+  prng: StdGen
   names: RBMap Lean.Name (Address × Address) compare
   store: RBMap Address Ixon.Const compare
   cache: RBMap Ix.Const (Address × Address) compare
@@ -68,49 +69,34 @@ structure CompileState where
   axioms: RBMap Lean.Name (Address × Address) compare
   blocks: RBSet (Address × Address) compare
 
-def CompileState.init (env: Lean.Environment): CompileState :=
-  ⟨env, default, default, default, default, default, default⟩
+def CompileState.init (env: Lean.Environment) (seed: Nat): CompileState :=
+  ⟨env, mkStdGen seed, default, default, default, default, default, default⟩
 
-abbrev CompileM :=
-  ReaderT CompileEnv <| ExceptT CompileError <| StateT CompileState IO
+abbrev CompileM := ReaderT CompileEnv <| EStateM CompileError CompileState
 
-def CompileM.runIO (maxHeartBeats: USize) (stt: CompileState) (c : CompileM α)
-  : IO (Except CompileError α × CompileState) := do
-  StateT.run (ReaderT.run c (.init maxHeartBeats)) stt
+def CompileM.run (env: CompileEnv) (stt: CompileState) (c : CompileM α)
+  : EStateM.Result CompileError CompileState α
+  := EStateM.run (ReaderT.run c env) stt
 
-def CompileM.runIO' (maxHeartBeats: USize) (stt: CompileState) (c : CompileM α)
-  : IO (α × CompileState) := do
-  let (res, stt) <- c.runIO maxHeartBeats stt
-  let res <- IO.ofExcept res
-  return (res, stt)
-
-def CompileM.liftIO (io: IO α): CompileM α :=
-  monadLift io
-
-def liftStoreIO (io: StoreIO α): CompileM α := do
-  match <- CompileM.liftIO (EIO.toIO' io) with
-  | .ok a => return a
-  | .error e => throw (.storeError e)
-
-def writeToStore (const: Ixon.Const): CompileM Address := do
-  let addr <- if (<- read).persist 
-    then liftStoreIO (Store.writeConst const)
-    else pure (Address.blake3 (Ixon.Serialize.put const))
+
+def storeConst (const: Ixon.Const): CompileM Address := do
+  let addr := Address.blake3 (Ixon.Serialize.put const)
   modifyGet fun stt => (addr, { stt with
     store := stt.store.insert addr const
   })
 
-def IO.freshSecret : IO Address := do
-  IO.setRandSeed (← IO.monoNanosNow)
-  let mut secret : ByteArray := default
+def randByte (lo hi: Nat): CompileM Nat := do
+  modifyGet fun s => 
+  let (res, g') := randNat s.prng lo hi
+  (res, {s with prng := g'})
+
+def freshSecret : CompileM Address := do
+  let mut secret: ByteArray := default
   for _ in [:32] do
-    let rand ← IO.rand 0 (UInt8.size - 1)
+    let rand <- randByte 0 255
     secret := secret.push rand.toUInt8
   return ⟨secret⟩
 
-def freshSecret : CompileM Address := do
-  CompileM.liftIO IO.freshSecret
-
 -- add binding name to local context
 def withBinder (name: Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
@@ -138,8 +124,8 @@ def hashConst (const: Ix.Const) : CompileM (Address × Address) := do
     let (anonIxon, metaIxon) <- match constToIxon const with
       | .ok (a, m) => pure (a, m)
       | .error e => throw (.transportError e)
-    let anonAddr <- writeToStore anonIxon
-    let metaAddr <- writeToStore metaIxon
+    let anonAddr <- storeConst anonIxon
+    let metaAddr <- storeConst metaIxon
     modifyGet fun stt => ((anonAddr, metaAddr), { stt with
       cache := stt.cache.insert const (anonAddr, metaAddr)
     })
@@ -241,7 +227,7 @@ partial def compileConst (const : Lean.ConstantInfo)
         axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
         names := stt.names.insert const.name (anonAddr, metaAddr)
       }
-      return (metaAddr, metaAddr)
+      return (anonAddr, metaAddr)
     | .thmInfo val => resetCtxWithLevels const.levelParams do
       let type <- compileExpr val.type
       let value <- compileExpr val.value
@@ -250,7 +236,7 @@ partial def compileConst (const : Lean.ConstantInfo)
       modify fun stt => { stt with
         names := stt.names.insert const.name (anonAddr, metaAddr)
       }
-      return (metaAddr, metaAddr)
+      return (anonAddr, metaAddr)
     | .opaqueInfo val => resetCtxWithLevels const.levelParams do
       let mutCtx := .single val.name 0
       let type <- compileExpr val.type
@@ -260,7 +246,7 @@ partial def compileConst (const : Lean.ConstantInfo)
       modify fun stt => { stt with
         names := stt.names.insert const.name (anonAddr, metaAddr)
       }
-      return (metaAddr, metaAddr)
+      return (anonAddr, metaAddr)
     | .quotInfo val => resetCtxWithLevels const.levelParams do
       let type <- compileExpr val.type
       let c := .quotient ⟨val.levelParams.length, type, val.kind⟩
@@ -269,7 +255,7 @@ partial def compileConst (const : Lean.ConstantInfo)
         axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
         names := stt.names.insert const.name (anonAddr, metaAddr)
       }
-      return (metaAddr, metaAddr)
+      return (anonAddr, metaAddr)
 
 /-- compile possibly mutual Lean definition --/
 partial def compileDefinition (struct: Lean.DefinitionVal)
@@ -505,54 +491,6 @@ partial def compileExpr : Lean.Expr → CompileM Expr
   | .mvar ..  => throw $ .metaVariableExpr expr
   | .mdata .. => throw $ .metaDataExpr expr
 
-partial def makeLeanDef
-  (name: Lean.Name) (levelParams: List Lean.Name) (type value: Lean.Expr) 
-  : Lean.DefinitionVal :=
-  { name, levelParams, type, value, hints := .opaque, safety := .safe }
-
-partial def tryAddLeanDecl (defn: Lean.DefinitionVal) : CompileM Unit := do
-  match (<- get).env.constants.find? defn.name with
-  | some _ => pure ()
-  | none => do
-    let env <- (·.env) <$> get
-    let maxHeartBeats <- (·.maxHeartBeats) <$> read
-    let decl := Lean.Declaration.defnDecl defn
-    match Lean.Environment.addDeclCore env maxHeartBeats decl .none with
-    | .ok e => do
-      modify fun stt => { stt with env := e }
-      return ()
-    | .error e => do
-      let x <- (e.toMessageData .empty).format
-      throw $ .kernelException (x.pretty 80)
-
-partial def addDef (lvls: List Lean.Name) (typ val: Lean.Expr)
-  : CompileM (Address × Address) := do
-  let typ' <- compileExpr typ
-  let val' <- compileExpr val
-  let (a, m) <- hashConst $ Ix.Const.definition ⟨lvls.length, typ', val', true⟩
-  tryAddLeanDecl (makeLeanDef a.toUniqueName lvls typ val)
-  return (a, m)
-
-partial def commitConst (anon meta: Address)
-  : CompileM (Address × Address) := do
-  let secret <- freshSecret
-  let comm := .comm ⟨secret, anon⟩
-  let commAddr <- writeToStore comm
-  let commMeta := .comm ⟨secret, meta⟩
-  let commMetaAddr <- writeToStore commMeta
-  modify fun stt => { stt with
-    comms := stt.comms.insert commAddr.toUniqueName (commAddr, commMetaAddr)
-  }
-  return (commAddr, commMetaAddr)
-
-partial def commitDef (lvls: List Lean.Name) (typ val: Lean.Expr)
-  : CompileM (Address × Address) := do
-  let (a, m) <- addDef lvls typ val
-  let (ca, cm) <- commitConst a m
-  tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ val)
-  --tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ (mkConst a.toUniqueName []))
-  return (ca, cm)
-
 /--
 A name-irrelevant ordering of Lean expressions.
 `weakOrd` contains the best known current mutual ordering
@@ -685,13 +623,60 @@ partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
 
 end
 
+partial def makeLeanDef
+  (name: Lean.Name) (levelParams: List Lean.Name) (type value: Lean.Expr) 
+  : Lean.DefinitionVal :=
+  { name, levelParams, type, value, hints := .opaque, safety := .safe }
+
+partial def tryAddLeanDecl (defn: Lean.DefinitionVal) : CompileM Unit := do
+  match (<- get).env.constants.find? defn.name with
+  | some _ => pure ()
+  | none => do
+    let env <- (·.env) <$> get
+    let maxHeartBeats <- (·.maxHeartBeats) <$> read
+    let decl := Lean.Declaration.defnDecl defn
+    match Lean.Environment.addDeclCore env maxHeartBeats decl .none with
+    | .ok e => do
+      modify fun stt => { stt with env := e }
+      return ()
+    | .error e => throw $ .kernelException e
+
+partial def addDef (lvls: List Lean.Name) (typ val: Lean.Expr)
+  : CompileM (Address × Address) := do
+  let typ' <- compileExpr typ
+  let val' <- compileExpr val
+  let (a, m) <- hashConst $ Ix.Const.definition ⟨lvls.length, typ', val', true⟩
+  tryAddLeanDecl (makeLeanDef a.toUniqueName lvls typ val)
+  return (a, m)
+
+partial def commitConst (anon meta: Address)
+  : CompileM (Address × Address) := do
+  let secret <- freshSecret
+  let comm := .comm ⟨secret, anon⟩
+  let commAddr <- storeConst comm
+  let commMeta := .comm ⟨secret, meta⟩
+  let commMetaAddr <- storeConst commMeta
+  modify fun stt => { stt with
+    comms := stt.comms.insert commAddr.toUniqueName (commAddr, commMetaAddr)
+  }
+  return (commAddr, commMetaAddr)
+
+partial def commitDef (lvls: List Lean.Name) (typ val: Lean.Expr)
+  : CompileM (Address × Address) := do
+  let (a, m) <- addDef lvls typ val
+  let (ca, cm) <- commitConst a m
+  tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ val)
+  --tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ (mkConst a.toUniqueName []))
+  return (ca, cm)
+
+
 partial def packLevel (lvls: Nat) (commit: Bool): CompileM Address :=
   match Ixon.natPackAsAddress lvls with
   | some lvlsAddr => do
     if commit then
       let secret <- freshSecret
       let comm := .comm (Ixon.Comm.mk secret lvlsAddr)
-      let commAddr <- writeToStore comm
+      let commAddr <- storeConst comm
       modify fun stt => { stt with
         comms := stt.comms.insert commAddr.toUniqueName (commAddr, commAddr)
       }
@@ -730,16 +715,6 @@ partial def evalClaim
   where
     comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
 
-def compileConstIO (env : Lean.Environment ) (const: Lean.ConstantInfo)
-  : IO $ (Address × Address) × CompileState := do
-  let (a, s) <- (compileConst const).runIO 200000 (.init env)
-  let a <- IO.ofExcept a
-  return (a, s)
-
-def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
-  : CompileM Unit := do
-  delta.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
-
 /--
 Content-addresses the "delta" of an environment, that is, the content that is
 added on top of the imports.
@@ -748,14 +723,37 @@ Important: constants with open references in their expressions are filtered out.
 Open references are variables that point to names which aren't present in the
 `Lean.ConstMap`.
 -/
-def compileDeltaIO
-  (env: Lean.Environment)
-  (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
-  : IO CompileState := do
-  let (res, stt) <- (compileDelta delta).runIO 200000 (.init env)
-  IO.ofExcept res
-  return stt
+def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
+  : CompileM Unit := do
+  delta.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
+
+
+def CompileError.pretty : CompileError -> IO String
+| .unknownConstant n => pure s!"Unknown constant '{n}'"
+| .unfilledLevelMetavariable l => pure s!"Unfilled level metavariable on universe '{l}'"
+| .unfilledExprMetavariable e => pure s!"Unfilled level metavariable on expression '{e}'"
+| .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
+| .freeVariableExpr e => pure s!"Free variable in expression '{e}'"
+| .metaVariableExpr e => pure s!"Metavariable in expression '{e}'"
+| .metaDataExpr e => pure s!"Meta data in expression '{e}'"
+| .levelNotFound n ns => pure s!"'Level {n}' not found in '{ns}'"
+| .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
+| .constantNotContentAddressed n => pure s!"Constant '{n}' wasn't content-addressed"
+| .nonRecursorExtractedFromChildren n => pure
+  s!"Non-recursor '{n}' extracted from children"
+| .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
+| .transportError n => pure s!"Transport error '{repr n}'"
+| .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
+| _ => pure s!"todo"
+
+def CompileM.runIO (env: Lean.Environment) (c : CompileM α) (maxHeartBeats: USize := 200000)
+  : IO (α × CompileState) := do
+  match c.run (.init maxHeartBeats) (.init env (<- IO.monoNanosNow)) with
+  | .ok a stt => do
+    stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
+    return (a, stt)
+  | .error e _ => throw (IO.userError (<- e.pretty))
 
 def compileEnvIO (env: Lean.Environment) : IO CompileState := do
-  compileDeltaIO env env.getDelta
+  Prod.snd <$> CompileM.runIO env (compileDelta env.getDelta)
 
diff --git a/Ix/IR/Const.lean b/Ix/IR/Const.lean
index ec31fa20..51df0521 100644
--- a/Ix/IR/Const.lean
+++ b/Ix/IR/Const.lean
@@ -10,31 +10,31 @@ structure Quotient where
   lvls : Nat
   type : Expr
   kind : Lean.QuotKind
-  deriving Ord, BEq, Hashable, Repr
+  deriving Ord, BEq, Hashable, Repr, Nonempty
 
 structure Axiom where
   lvls  : Nat
   type  : Expr
-  deriving Ord, BEq, Hashable, Repr
+  deriving Ord, BEq, Hashable, Repr, Nonempty
 
 structure Theorem where
   lvls  : Nat
   type  : Expr
   value : Expr
-  deriving Ord, BEq, Hashable, Repr
+  deriving Ord, BEq, Hashable, Repr, Nonempty
 
 structure Opaque where
   lvls  : Nat
   type  : Expr
   value : Expr
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure Definition where
   lvls  : Nat
   type  : Expr
   value : Expr
   part  : Bool
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure Constructor where
   lvls   : Nat
@@ -42,12 +42,12 @@ structure Constructor where
   idx    : Nat
   params : Nat
   fields : Nat
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure RecursorRule where
   fields : Nat
   rhs    : Expr
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure Recursor where
   lvls     : Nat
@@ -59,7 +59,7 @@ structure Recursor where
   rules    : List RecursorRule
   isK      : Bool
   internal : Bool
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure Inductive where
   lvls    : Nat
@@ -72,33 +72,33 @@ structure Inductive where
   refl    : Bool
   struct  : Bool
   unit    : Bool
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure InductiveProj where
   blockCont : Address
   blockMeta : Address
   idx   : Nat
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure ConstructorProj where
   blockCont : Address
   blockMeta : Address
   idx   : Nat
   cidx  : Nat
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure RecursorProj where
   blockCont : Address
   blockMeta : Address
   idx   : Nat
   ridx  : Nat
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure DefinitionProj where
   blockCont : Address
   blockMeta : Address
   idx   : Nat
-  deriving BEq, Ord, Hashable, Repr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
 
 inductive Const where
   | «axiom»     : Axiom      → Const
@@ -114,7 +114,7 @@ inductive Const where
   -- constants to represent mutual blocks
   | mutDefBlock : List Definition → Const
   | mutIndBlock : List Inductive  → Const
-  deriving Ord, BEq, Inhabited, Repr
+  deriving Ord, BEq, Inhabited, Repr, Nonempty
 
 def Const.isMutType : Const → Bool
   | .mutDefBlock _ | .mutIndBlock _ => true
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index d439e56f..0c563393 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -38,9 +38,9 @@ elab "this_file!" : term => do
 macro "get_env!" : term =>
   `(getFileEnv this_file!)
 
-def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO Address := do
-  let ((a, _), _) <- Ix.Compile.compileConstIO env const
-  return a
+--def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO Address := do
+--  let ((a, _), _) <- Ix.Compile.compileConstIO env const
+--  return a
 
 def runCore (f : CoreM α) (env : Environment) : IO α :=
   Prod.fst <$> f.toIO { fileName := default, fileMap := default } { env }
diff --git a/Ix/Store.lean b/Ix/Store.lean
index 9f5da80c..75da1dc4 100644
--- a/Ix/Store.lean
+++ b/Ix/Store.lean
@@ -48,6 +48,14 @@ def writeConst (x: Ixon.Const) : StoreIO Address := do
   let _ <- IO.toEIO .ioError (IO.FS.writeBinFile path bytes)
   return addr
 
+-- unsafe, can corrupt store if called with bad address
+def forceWriteConst (addr: Address) (x: Ixon.Const) : StoreIO Address := do
+  let bytes := Ixon.Serialize.put x
+  let store ← storeDir
+  let path := store / hexOfBytes addr.hash
+  let _ <- IO.toEIO .ioError (IO.FS.writeBinFile path bytes)
+  return addr
+
 def readConst (a: Address) : StoreIO Ixon.Const := do
   let store ← storeDir
   let path := store / hexOfBytes a.hash

From 37c57798d21bd4734661e034ce6d4573b3a12f99 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 25 Apr 2025 11:27:50 -0400
Subject: [PATCH 16/74] add level params to Ix IR to support decompilation

---
 Ix/CompileM.lean   | 103 +++++++++++++++++++----------------------
 Ix/DecompileM.lean |  91 +++++++++++++++++++++++++++++++++++++
 Ix/IR/Const.lean   |  16 +++----
 Ix/IR/Expr.lean    |   2 +-
 Ix/TransportM.lean | 111 +++++++++++++++++++++++++++++++++++++--------
 Tests/Ix/Lean.lean |   0
 6 files changed, 237 insertions(+), 86 deletions(-)
 create mode 100644 Ix/DecompileM.lean
 create mode 100644 Tests/Ix/Lean.lean

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 2efdb5e8..80fb9c66 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -12,7 +12,6 @@ open Ix.TransportM
 
 namespace Ix.Compile
 
-
 inductive CompileError
 | unknownConstant : Lean.Name → CompileError
 | unfilledLevelMetavariable : Lean.Level → CompileError
@@ -28,27 +27,25 @@ inductive CompileError
 | cantFindMutDefIndex : Lean.Name → CompileError
 | transportError : TransportError → CompileError
 | kernelException : Lean.Kernel.Exception → CompileError
---| storeError : StoreError → CompileError
-| todo
-
---instance : ToString CompileError where toString
---| .unknownConstant n => s!"Unknown constant '{n}'"
---| .unfilledLevelMetavariable l => s!"Unfilled level metavariable on universe '{l}'"
---| .unfilledExprMetavariable e => s!"Unfilled level metavariable on expression '{e}'"
---| .invalidBVarIndex idx => s!"Invalid index {idx} for bound variable context"
---| .freeVariableExpr e => s!"Free variable in expression '{e}'"
---| .metaVariableExpr e => s!"Metavariable in expression '{e}'"
---| .metaDataExpr e => s!"Meta data in expression '{e}'"
---| .levelNotFound n ns => s!"'Level {n}' not found in '{ns}'"
---| .invalidConstantKind n ex gt =>
---  s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
---| .constantNotContentAddressed n => s!"Constant '{n}' wasn't content-addressed"
---| .nonRecursorExtractedFromChildren n =>
---  s!"Non-recursor '{n}' extracted from children"
---| .cantFindMutDefIndex n => s!"Can't find index for mutual definition '{n}'"
---| .transportError n => s!"Transport error '{repr n}'"
---| .kernelException e => e
---| _ => s!"todo"
+| cantPackLevel : Nat → CompileError
+
+def CompileError.pretty : CompileError -> IO String
+| .unknownConstant n => pure s!"Unknown constant '{n}'"
+| .unfilledLevelMetavariable l => pure s!"Unfilled level metavariable on universe '{l}'"
+| .unfilledExprMetavariable e => pure s!"Unfilled level metavariable on expression '{e}'"
+| .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
+| .freeVariableExpr e => pure s!"Free variable in expression '{e}'"
+| .metaVariableExpr e => pure s!"Metavariable in expression '{e}'"
+| .metaDataExpr e => pure s!"Meta data in expression '{e}'"
+| .levelNotFound n ns => pure s!"'Level {n}' not found in '{ns}'"
+| .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
+| .constantNotContentAddressed n => pure s!"Constant '{n}' wasn't content-addressed"
+| .nonRecursorExtractedFromChildren n => pure
+  s!"Non-recursor '{n}' extracted from children"
+| .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
+| .transportError n => pure s!"Transport error '{repr n}'"
+| .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
+| .cantPackLevel n => pure s!"Can't pack level {n} greater than 2^256'"
 
 structure CompileEnv where
   univCtx : List Lean.Name
@@ -78,7 +75,6 @@ def CompileM.run (env: CompileEnv) (stt: CompileState) (c : CompileM α)
   : EStateM.Result CompileError CompileState α
   := EStateM.run (ReaderT.run c env) stt
 
-
 def storeConst (const: Ixon.Const): CompileM Address := do
   let addr := Address.blake3 (Ixon.Serialize.put const)
   modifyGet fun stt => (addr, { stt with
@@ -98,15 +94,27 @@ def freshSecret : CompileM Address := do
   return ⟨secret⟩
 
 -- add binding name to local context
-def withBinder (name: Lean.Name) : CompileM α -> CompileM α :=
+def withBinder
+  {m : Type -> Type} {α : Type}
+  [Monad m] [MonadWithReader CompileEnv m]
+  (name: Lean.Name) 
+  : m α -> m α :=
   withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
 
 -- add levels to local context
-def withLevels (lvls : List Lean.Name) : CompileM α -> CompileM α :=
+def withLevels
+  {m : Type -> Type} {α : Type}
+  [Monad m] [MonadWithReader CompileEnv m]
+  (lvls : List Lean.Name) 
+  : m α -> m α :=
   withReader $ fun c => { c with univCtx := lvls }
 
 -- add mutual recursion info to local context
-def withMutCtx (mutCtx : RBMap Lean.Name Nat compare) : CompileM α -> CompileM α :=
+def withMutCtx
+  {m : Type -> Type} {α : Type}
+  [Monad m] [MonadWithReader CompileEnv m]
+  (mutCtx : RBMap Lean.Name Nat compare) 
+  : m α -> m α :=
   withReader $ fun c => { c with mutCtx := mutCtx }
 
 -- reset local context
@@ -221,7 +229,7 @@ partial def compileConst (const : Lean.ConstantInfo)
       compileConst const
     -- The rest adds the constants to the cache one by one
     | .axiomInfo val => resetCtxWithLevels const.levelParams do
-      let c := .axiom ⟨val.levelParams.length, ← compileExpr val.type⟩
+      let c := .axiom ⟨val.levelParams, ← compileExpr val.type⟩
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
@@ -231,7 +239,7 @@ partial def compileConst (const : Lean.ConstantInfo)
     | .thmInfo val => resetCtxWithLevels const.levelParams do
       let type <- compileExpr val.type
       let value <- compileExpr val.value
-      let c := .theorem ⟨val.levelParams.length, type, value⟩
+      let c := .theorem ⟨val.levelParams, type, value⟩
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         names := stt.names.insert const.name (anonAddr, metaAddr)
@@ -241,7 +249,7 @@ partial def compileConst (const : Lean.ConstantInfo)
       let mutCtx := .single val.name 0
       let type <- compileExpr val.type
       let value <- withMutCtx mutCtx $ compileExpr val.value
-      let c := .opaque ⟨val.levelParams.length, type, value⟩
+      let c := .opaque ⟨val.levelParams, type, value⟩
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         names := stt.names.insert const.name (anonAddr, metaAddr)
@@ -249,7 +257,7 @@ partial def compileConst (const : Lean.ConstantInfo)
       return (anonAddr, metaAddr)
     | .quotInfo val => resetCtxWithLevels const.levelParams do
       let type <- compileExpr val.type
-      let c := .quotient ⟨val.levelParams.length, type, val.kind⟩
+      let c := .quotient ⟨val.levelParams, type, val.kind⟩
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
@@ -310,7 +318,7 @@ partial def definitionToIR (defn: Lean.DefinitionVal)
   : CompileM Ix.Definition := do
   let type <- compileExpr defn.type
   let value <- compileExpr defn.value
-  return ⟨defn.levelParams.length, type, value, defn.safety == .partial⟩
+  return ⟨defn.levelParams, type, value, defn.safety == .partial⟩
 
 /--
 Content-addresses an inductive and all inductives in the mutual block as a
@@ -403,7 +411,7 @@ partial def inductiveToIR (ind : Lean.InductiveVal) : CompileM Ix.Inductive := d
     -- Structures can only have one constructor
     | [ctor] => pure (true, ctor.fields == 0)
     | _ => pure (false, false)
-  return ⟨ind.levelParams.length, ← compileExpr ind.type, ind.numParams, ind.numIndices,
+  return ⟨ind.levelParams, ← compileExpr ind.type, ind.numParams, ind.numIndices,
     -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
     -- match the order used in `recrCtx`
     ctors, recs, ind.isRec, ind.isReflexive, struct, unit⟩
@@ -418,7 +426,7 @@ partial def internalRecToIR (ctors : List Lean.Name)
           let (ctor, rule) ← recRuleToIR r
           pure $ (ctor :: retCtors, rule :: retRules)
         else pure (retCtors, retRules) -- this is an external recursor rule
-    let recr := ⟨rec.levelParams.length, typ, rec.numParams, rec.numIndices,
+    let recr := ⟨rec.levelParams, typ, rec.numParams, rec.numIndices,
       rec.numMotives, rec.numMinors, retRules, rec.k, true⟩
     return (recr, retCtors)
   | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
@@ -430,7 +438,7 @@ partial def recRuleToIR (rule : Lean.RecursorRule)
   | .ctorInfo ctor => withLevels ctor.levelParams do
     let typ ← compileExpr ctor.type
     let ctor :=
-      ⟨ctor.levelParams.length, typ, ctor.cidx, ctor.numParams, ctor.numFields⟩
+      ⟨ctor.levelParams, typ, ctor.cidx, ctor.numParams, ctor.numFields⟩
     pure (ctor, ⟨rule.nfields, rhs⟩)
   | const =>
     throw $ .invalidConstantKind const.name "constructor" const.ctorName
@@ -439,7 +447,7 @@ partial def externalRecToIR : Lean.ConstantInfo → CompileM Recursor
   | .recInfo rec => withLevels rec.levelParams do
     let typ ← compileExpr rec.type
     let rules ← rec.rules.mapM externalRecRuleToIR
-    return ⟨rec.levelParams.length, typ, rec.numParams, rec.numIndices,
+    return ⟨rec.levelParams, typ, rec.numParams, rec.numIndices,
       rec.numMotives, rec.numMinors, rules, rec.k, false⟩
   | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
 
@@ -468,7 +476,7 @@ partial def compileExpr : Lean.Expr → CompileM Expr
     let univs ← lvls.mapM compileLevel
     match (← read).mutCtx.find? name with
     -- recursing!
-    | some i => return .rec_ i univs
+    | some i => return .rec_ name i univs
     | none => match (<- get).comms.find? name with
       | some (commAddr, metaAddr) => do
         return .const name commAddr metaAddr univs
@@ -645,7 +653,7 @@ partial def addDef (lvls: List Lean.Name) (typ val: Lean.Expr)
   : CompileM (Address × Address) := do
   let typ' <- compileExpr typ
   let val' <- compileExpr val
-  let (a, m) <- hashConst $ Ix.Const.definition ⟨lvls.length, typ', val', true⟩
+  let (a, m) <- hashConst $ Ix.Const.definition ⟨lvls, typ', val', true⟩
   tryAddLeanDecl (makeLeanDef a.toUniqueName lvls typ val)
   return (a, m)
 
@@ -682,7 +690,7 @@ partial def packLevel (lvls: Nat) (commit: Bool): CompileM Address :=
       }
       return commAddr
     else return lvlsAddr
-  | .none => throw .todo
+  | .none => throw $ .cantPackLevel lvls
 
 partial def checkClaim
   (const: Lean.Name)
@@ -727,25 +735,6 @@ def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
   : CompileM Unit := do
   delta.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
 
-
-def CompileError.pretty : CompileError -> IO String
-| .unknownConstant n => pure s!"Unknown constant '{n}'"
-| .unfilledLevelMetavariable l => pure s!"Unfilled level metavariable on universe '{l}'"
-| .unfilledExprMetavariable e => pure s!"Unfilled level metavariable on expression '{e}'"
-| .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
-| .freeVariableExpr e => pure s!"Free variable in expression '{e}'"
-| .metaVariableExpr e => pure s!"Metavariable in expression '{e}'"
-| .metaDataExpr e => pure s!"Meta data in expression '{e}'"
-| .levelNotFound n ns => pure s!"'Level {n}' not found in '{ns}'"
-| .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
-| .constantNotContentAddressed n => pure s!"Constant '{n}' wasn't content-addressed"
-| .nonRecursorExtractedFromChildren n => pure
-  s!"Non-recursor '{n}' extracted from children"
-| .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
-| .transportError n => pure s!"Transport error '{repr n}'"
-| .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
-| _ => pure s!"todo"
-
 def CompileM.runIO (env: Lean.Environment) (c : CompileM α) (maxHeartBeats: USize := 200000)
   : IO (α × CompileState) := do
   match c.run (.init maxHeartBeats) (.init env (<- IO.monoNanosNow)) with
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
new file mode 100644
index 00000000..79ec108c
--- /dev/null
+++ b/Ix/DecompileM.lean
@@ -0,0 +1,91 @@
+import Batteries.Data.RBMap
+import Ix.TransportM
+import Ix.Ixon.Metadata
+import Ix.Ixon.Const
+import Ix.Ixon.Serialize
+import Ix.Common
+import Ix.Store
+import Ix.CompileM
+
+open Batteries (RBMap)
+open Batteries (RBSet)
+open Ix.TransportM
+open Ix.Compile
+
+inductive DecompileError
+| freeLevel : List Lean.Name -> Lean.Name -> Nat -> DecompileError
+| mismatchedLevelName : List Lean.Name -> Lean.Name -> Lean.Name -> Nat -> DecompileError
+| invalidBVarIndex : List Lean.Name -> Nat -> DecompileError
+| mismatchedMutIdx : RBMap Lean.Name Nat compare -> Lean.Name -> Nat -> Nat -> DecompileError
+| unknownMutual : RBMap Lean.Name Nat compare -> Lean.Name -> Nat -> DecompileError
+| todo
+
+abbrev DecompileM := ReaderT CompileEnv <| EStateM DecompileError CompileState
+
+def DecompileM.run (env: CompileEnv) (stt: CompileState) (c : DecompileM α)
+  : EStateM.Result DecompileError CompileState α
+  := EStateM.run (ReaderT.run c env) stt
+
+def decompileLevel : Ix.Univ → DecompileM Lean.Level
+| .zero => pure .zero
+| .succ u => .succ <$> decompileLevel u
+| .max a b => Lean.Level.max  <$> decompileLevel a <*> decompileLevel b
+| .imax a b => Lean.Level.imax <$> decompileLevel a <*> decompileLevel b
+| .var n i => do
+  match (<- read).univCtx[i]? with
+  | some n' => 
+    if n == n' then pure (Lean.Level.param n)
+    else throw (.mismatchedLevelName (<- read).univCtx n' n i)
+  | none => throw <| .freeLevel (<- read).univCtx n i
+
+mutual
+
+partial def decompileExpr : Ix.Expr → DecompileM Lean.Expr
+| .var i      => do match (← read).bindCtx[i]? with
+  | some _ => return .bvar i
+  | none => throw $ .invalidBVarIndex (<-read).bindCtx i
+| .sort u     => Lean.Expr.sort <$> decompileLevel u
+| .lit l      => pure (.lit l)
+| .app f a    => Lean.mkApp <$> decompileExpr f <*> decompileExpr a
+| .lam n bi t b =>
+    Lean.mkLambda n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
+| .pi n bi t b =>
+    Lean.mkForall n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
+| .letE n t v b nd =>
+    (@Lean.mkLet n) 
+      <$> decompileExpr t
+      <*> decompileExpr v 
+      <*> withBinder n (decompileExpr b)
+      <*> pure nd
+| .proj n cont meta i e => do
+    ensureConst n cont meta
+    Lean.mkProj n i <$> decompileExpr e
+| .const n cont meta us => do
+    ensureConst n cont meta
+    return Lean.mkConst n (<- us.mapM decompileLevel)
+| .rec_ n i us => do match (<- read).mutCtx.find? n with
+  | some i' =>
+    if i == i' then do
+      return Lean.mkConst n (<- us.mapM decompileLevel)
+    else throw <| .mismatchedMutIdx (<- read).mutCtx n i i'
+  | none => throw <| .unknownMutual (<- read).mutCtx n i
+
+partial def ensureConst (name: Lean.Name) (cont meta: Address) : DecompileM Unit := do
+  --match (<- get).names.find? n 
+  sorry
+
+partial def decompileConst (name: Lean.Name): Ix.Const -> DecompileM Lean.ConstantInfo
+| .axiom x => sorry
+  --return .axiomInfo ⟨name, levels, type⟩
+| .theorem x => sorry
+| .opaque x => sorry
+| .definition x => sorry
+| .quotient x => sorry
+| .inductiveProj x => sorry
+| .constructorProj x => sorry
+| .recursorProj x => sorry
+| .definitionProj x => sorry
+| .mutDefBlock x => sorry
+| .mutIndBlock x => sorry
+
+end
diff --git a/Ix/IR/Const.lean b/Ix/IR/Const.lean
index 51df0521..339d273e 100644
--- a/Ix/IR/Const.lean
+++ b/Ix/IR/Const.lean
@@ -7,37 +7,37 @@ deriving instance BEq, Repr, Hashable, Ord for Lean.QuotKind
 namespace Ix
 
 structure Quotient where
-  lvls : Nat
+  lvls : List Lean.Name
   type : Expr
   kind : Lean.QuotKind
   deriving Ord, BEq, Hashable, Repr, Nonempty
 
 structure Axiom where
-  lvls  : Nat
+  lvls  : List Lean.Name
   type  : Expr
   deriving Ord, BEq, Hashable, Repr, Nonempty
 
 structure Theorem where
-  lvls  : Nat
+  lvls  : List Lean.Name
   type  : Expr
   value : Expr
   deriving Ord, BEq, Hashable, Repr, Nonempty
 
 structure Opaque where
-  lvls  : Nat
+  lvls  : List Lean.Name
   type  : Expr
   value : Expr
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure Definition where
-  lvls  : Nat
+  lvls  : List Lean.Name
   type  : Expr
   value : Expr
   part  : Bool
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure Constructor where
-  lvls   : Nat
+  lvls   : List Lean.Name
   type   : Expr
   idx    : Nat
   params : Nat
@@ -50,7 +50,7 @@ structure RecursorRule where
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure Recursor where
-  lvls     : Nat
+  lvls     : List Lean.Name
   type     : Expr
   params   : Nat
   indices  : Nat
@@ -62,7 +62,7 @@ structure Recursor where
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure Inductive where
-  lvls    : Nat
+  lvls    : List Lean.Name
   type    : Expr
   params  : Nat
   indices : Nat
diff --git a/Ix/IR/Expr.lean b/Ix/IR/Expr.lean
index 8eb82ff6..b416503d 100644
--- a/Ix/IR/Expr.lean
+++ b/Ix/IR/Expr.lean
@@ -9,7 +9,7 @@ inductive Expr
   | var   (idx: Nat)
   | sort  (univ: Univ)
   | const (name: Lean.Name) (ref: Address) (meta: Address) (univs: List Univ)
-  | rec_  (idx: Nat) (univs: List Univ)
+  | rec_  (name: Lean.Name) (idx: Nat) (univs: List Univ)
   | app   (func: Expr) (argm: Expr)
   | lam   (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
   | pi    (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index aebcf6c1..de235d80 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -88,6 +88,16 @@ partial def dematUniv : Ix.Univ -> DematM Ixon.Univ
   dematMeta { name := .some n, info := .none, link := .none }
   .var <$> dematNat i
 
+partial def dematLevels (lvls: List Lean.Name): DematM Nat :=
+  go 0 lvls
+  where
+    go (acc: Nat) : List Lean.Name -> DematM Nat
+    | n::ns => do
+      let _ <- dematIncr
+      dematMeta { name := .some n, info := .none, link := .none}
+      go (acc+1) ns
+    | [] => pure acc
+
 def rematIncrN (x: Nat) : RematM Nat := do
   let n <- (·.idx) <$> get
   modify fun stt => { stt with idx := n + x }
@@ -107,6 +117,18 @@ def rematThrowUnexpectedNode : RematM α := do
   let m <- (·.meta) <$> read
   throw (.unexpectedNode n m)
 
+partial def rematLevels (lvls: Nat): RematM (List Lean.Name) := do
+  go [] lvls
+  where
+    go (acc: List Lean.Name): Nat -> RematM (List Lean.Name)
+    | 0 => pure acc.reverse
+    | i => do
+      let _ <- rematIncr
+      let node <- rematMeta
+      match node.name, node.info, node.link with
+      | .some n, .none, .none => go (n::acc) (i - 1)
+      | _, _, _ => rematThrowUnexpectedNode
+
 def rematBindMeta : RematM (Lean.Name × Lean.BinderInfo) := do
   let n <- rematMeta
   match n.name, n.info with
@@ -136,7 +158,10 @@ partial def dematExpr : Ix.Expr -> DematM Ixon.Expr
   let _ <- dematIncr
   dematMeta { name := .some n, info := .none, link := .some m }
   .cnst r <$> (us.mapM dematUniv)
-| .rec_ i us => dematIncr *> .rec_ <$> dematNat i <*> (us.mapM dematUniv)
+| .rec_ n i us => do
+  let _ <- dematIncr
+  dematMeta { name := .some n, info := .none, link := .none}
+  .rec_ <$> dematNat i <*> (us.mapM dematUniv)
 | .app f a => apps f a []
 | .lam n i t b => lams (.lam n i t b) []
 | .pi n i t b => alls (.pi n i t b) []
@@ -182,7 +207,13 @@ partial def rematExpr : Ixon.Expr -> RematM Ix.Expr
   match node.name, node.link with
   | .some name, .some link => return (.const name adr link us')
   | _, _ => rematThrowUnexpectedNode
-| .rec_ i us => rematIncr *> .rec_ i.toNat <$> us.mapM rematUniv
+| .rec_ i us => do 
+  let _ <- rematIncr
+  let node <- rematMeta
+  let us' <- us.mapM rematUniv
+  match node.name with
+  | .some name => return (.rec_ name i.toNat us')
+  | _ => rematThrowUnexpectedNode
 | .apps f a as => do
   let as' <- as.reverse.mapM (fun e => rematIncr *> rematExpr e)
   let f' <- rematExpr f
@@ -216,13 +247,25 @@ partial def rematExpr : Ixon.Expr -> RematM Ix.Expr
 | .natl n => rematIncr *> return .lit (.natVal n)
 
 partial def dematConst : Ix.Const -> DematM Ixon.Const
-| .«axiom» x => .axio <$> (.mk x.lvls <$> dematExpr x.type)
-| .«theorem» x => .theo <$> (.mk x.lvls <$> dematExpr x.type <*> dematExpr x.value)
-| .«opaque» x => 
-  .opaq <$> (.mk x.lvls <$> dematExpr x.type <*> dematExpr x.value)
+| .«axiom» x => do
+  let lvls <- dematLevels x.lvls
+  let type <- dematExpr x.type
+  return .axio (.mk lvls type)
+| .«theorem» x => do
+  let lvls <- dematLevels x.lvls
+  let type <- dematExpr x.type
+  let value <- dematExpr x.value
+  return .theo (.mk lvls type value)
+| .«opaque» x => do
+  let lvls <- dematLevels x.lvls
+  let type <- dematExpr x.type
+  let value <- dematExpr x.value
+  return .opaq (.mk lvls type value)
 | .«definition» x => .defn <$> dematDefn x
-| .quotient x => .quot <$> 
-  (.mk x.lvls <$> dematExpr x.type <*> pure x.kind)
+| .quotient x => do
+  let lvls <- dematLevels x.lvls
+  let type <- dematExpr x.type
+  return .quot (.mk lvls type x.kind)
 | .inductiveProj x => do
   dematMeta { name := .none, info := .none, link := .some x.blockMeta}
   return .indcProj (.mk x.blockCont x.idx)
@@ -239,22 +282,29 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
 | .mutIndBlock xs => .mutInd <$> (xs.mapM dematInd)
   where
     dematDefn : Ix.Definition -> DematM Ixon.Definition
-    | x => .mk x.lvls <$> dematExpr x.type <*> dematExpr x.value <*> pure x.part
+    | x => do
+      let lvls <- dematLevels x.lvls 
+      let type <- dematExpr x.type
+      let value <- dematExpr x.value
+      return .mk lvls type value x.part
     dematCtor : Ix.Constructor -> DematM Ixon.Constructor
     | x => do
+      let lvls <- dematLevels x.lvls
       let t <- dematExpr x.type
-      return .mk x.lvls t x.idx x.params x.fields
+      return .mk lvls t x.idx x.params x.fields
     dematRecr : Ix.Recursor -> DematM Ixon.Recursor
     | x => do
+      let lvls <- dematLevels x.lvls
       let t <- dematExpr x.type
       let rrs <- x.rules.mapM (fun rr => .mk rr.fields <$> dematExpr rr.rhs)
-      return .mk x.lvls t x.params x.indices x.motives x.minors rrs x.isK x.internal
+      return .mk lvls t x.params x.indices x.motives x.minors rrs x.isK x.internal
     dematInd : Ix.Inductive -> DematM Ixon.Inductive
     | x => do
+      let lvls <- dematLevels x.lvls
       let t <- dematExpr x.type
       let cs <- x.ctors.mapM dematCtor
       let rs <- x.recrs.mapM dematRecr
-      return .mk x.lvls t x.params x.indices cs rs x.recr x.refl x.struct x.unit
+      return .mk lvls t x.params x.indices cs rs x.recr x.refl x.struct x.unit
 
 def constToIxon (x: Ix.Const) : Except TransportError (Ixon.Const × Ixon.Const) := 
   match EStateM.run (dematConst x) emptyDematState with
@@ -270,11 +320,25 @@ def constAddress (x: Ix.Const) : Except TransportError Address := do
   return Address.blake3 bs
 
 partial def rematConst : Ixon.Const -> RematM Ix.Const
-| .axio x => .«axiom» <$> (.mk x.lvls <$> rematExpr x.type)
-| .theo x => .«theorem» <$> (.mk x.lvls <$> rematExpr x.type <*> rematExpr x.value)
-| .opaq x => .«opaque» <$> (.mk x.lvls <$> rematExpr x.type <*> rematExpr x.value)
+| .axio x => do
+  let lvls <- rematLevels x.lvls
+  let type <- rematExpr x.type
+  return .«axiom» (.mk lvls type)
+| .theo x => do
+  let lvls <- rematLevels x.lvls
+  let type <- rematExpr x.type
+  let value <- rematExpr x.value
+  return .«theorem» (.mk lvls type value)
+| .opaq x => do
+  let lvls <- rematLevels x.lvls
+  let type <- rematExpr x.type
+  let value <- rematExpr x.value
+  return .«opaque» (.mk lvls type value)
 | .defn x => .«definition» <$> rematDefn x
-| .quot x => .quotient <$> (.mk x.lvls <$> rematExpr x.type <*> pure x.kind)
+| .quot x => do
+  let lvls <- rematLevels x.lvls
+  let type <- rematExpr x.type
+  return .quotient (.mk lvls type x.kind)
 | .indcProj x => do
   let link <- rematMeta >>= fun m => m.link.elim rematThrowUnexpectedNode pure
   return .inductiveProj (.mk x.block link x.idx)
@@ -295,21 +359,28 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
 | .comm p => throw (.rawComm p)
   where
     rematDefn : Ixon.Definition -> RematM Ix.Definition
-    | x => .mk x.lvls <$> rematExpr x.type <*> rematExpr x.value <*> pure x.part
+    | x => do
+      let lvls <- rematLevels x.lvls
+      let type <- rematExpr x.type
+      let value <- rematExpr x.value
+      return .mk lvls type value x.part
     rematCtor : Ixon.Constructor -> RematM Ix.Constructor
     | x => do
+      let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
-      return .mk x.lvls t x.idx x.params x.fields
+      return .mk lvls t x.idx x.params x.fields
     rematRecr : Ixon.Recursor -> RematM Ix.Recursor
     | x => do
+      let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
       let rrs <- x.rules.mapM (fun rr => .mk rr.fields <$> rematExpr rr.rhs)
-      return .mk x.lvls t x.params x.indices x.motives x.minors rrs x.isK x.internal
+      return .mk lvls t x.params x.indices x.motives x.minors rrs x.isK x.internal
     rematInd : Ixon.Inductive -> RematM Ix.Inductive
     | x => do
+      let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
       let cs <- x.ctors.mapM rematCtor
       let rs <- x.recrs.mapM rematRecr
-      return .mk x.lvls t x.params x.indices cs rs x.recr x.refl x.struct x.unit
+      return .mk lvls t x.params x.indices cs rs x.recr x.refl x.struct x.unit
 
 end Ix.TransportM
diff --git a/Tests/Ix/Lean.lean b/Tests/Ix/Lean.lean
new file mode 100644
index 00000000..e69de29b

From 802650e9ab0e2ce9048da032f4a2348b63361499 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 2 May 2025 01:38:42 -0400
Subject: [PATCH 17/74] refactor Ix IR to support decompilation

---
 Ix/Common.lean         |  10 +-
 Ix/CompileM.lean       |  69 ++++---
 Ix/DecompileM.lean     |  24 ++-
 Ix/IR.lean             | 456 ++++++++++++++++++++++++++++++++++++++++-
 Ix/IR/Const.lean       | 123 -----------
 Ix/IR/Env.lean         |  19 --
 Ix/IR/Expr.lean        |  21 --
 Ix/IR/Univ.lean        | 179 ----------------
 Ix/Ixon/Const.lean     | 295 +++++++++++++-------------
 Ix/Ixon/Expr.lean      |   4 +-
 Ix/Ixon/Metadata.lean  |  55 ++---
 Ix/Ixon/Serialize.lean |  40 +++-
 Ix/TransportM.lean     | 233 +++++++++++----------
 STYLE.md               |  38 ++++
 Tests/Ix.lean          |   9 +-
 Tests/Ix/Common.lean   |  13 ++
 Tests/Ix/IR.lean       |  58 ++++--
 Tests/Ix/Ixon.lean     |  43 ++--
 18 files changed, 990 insertions(+), 699 deletions(-)
 delete mode 100644 Ix/IR/Const.lean
 delete mode 100644 Ix/IR/Env.lean
 delete mode 100644 Ix/IR/Expr.lean
 delete mode 100644 Ix/IR/Univ.lean
 create mode 100644 STYLE.md

diff --git a/Ix/Common.lean b/Ix/Common.lean
index 266fe2f7..45121c06 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -23,13 +23,21 @@ instance : Ord Lean.Name where
 
 deriving instance Ord for Lean.Literal
 deriving instance Ord for Lean.BinderInfo
-deriving instance Ord for Lean.QuotKind
+deriving instance BEq, Repr, Hashable, Ord for Lean.QuotKind
+deriving instance Hashable, Repr for Lean.ReducibilityHints
 
 def UInt8.MAX : UInt64 := 0xFF
 def UInt16.MAX : UInt64 := 0xFFFF
 def UInt32.MAX : UInt64 := 0xFFFFFFFF
 def UInt64.MAX : UInt64 := 0xFFFFFFFFFFFFFFFF
 
+/-- Distinguish different kinds of Ix definitions --/
+inductive Ix.DefMode where
+| «definition»
+| «opaque»
+| «theorem»
+deriving BEq, Ord, Hashable, Repr, Nonempty, Inhabited
+
 namespace List
 
 partial def mergeM [Monad μ] (cmp : α → α → μ Ordering) : List α → List α → μ (List α)
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 80fb9c66..f289dc67 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -173,7 +173,7 @@ def compareLevel (x : Lean.Level) (y : Lean.Level) : CompileM Ordering :=
     | _,       none    => throw $ .levelNotFound y lvls
 
 /-- Canonicalizes a Lean universe level and adds it to the store -/
-def compileLevel : Lean.Level → CompileM Ix.Univ
+def compileLevel : Lean.Level → CompileM Ix.Level
 | .zero => pure .zero
 | .succ u => return .succ (← compileLevel u)
 | .max a b  => return .max (← compileLevel a) (← compileLevel b)
@@ -181,7 +181,7 @@ def compileLevel : Lean.Level → CompileM Ix.Univ
 | .param name => do
   let lvls := (← read).univCtx
   match lvls.idxOf? name with
-  | some n => pure $ .var name n
+  | some n => pure $ .param name n
   | none   => throw $ .levelNotFound name lvls
 | l@(.mvar ..) => throw $ .unfilledLevelMetavariable l
 
@@ -239,7 +239,7 @@ partial def compileConst (const : Lean.ConstantInfo)
     | .thmInfo val => resetCtxWithLevels const.levelParams do
       let type <- compileExpr val.type
       let value <- compileExpr val.value
-      let c := .theorem ⟨val.levelParams, type, value⟩
+      let c := .definition <| mkTheorem val.levelParams type value val.all
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         names := stt.names.insert const.name (anonAddr, metaAddr)
@@ -249,7 +249,7 @@ partial def compileConst (const : Lean.ConstantInfo)
       let mutCtx := .single val.name 0
       let type <- compileExpr val.type
       let value <- withMutCtx mutCtx $ compileExpr val.value
-      let c := .opaque ⟨val.levelParams, type, value⟩
+      let c := .definition <| mkOpaque val.levelParams type value val.all
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         names := stt.names.insert const.name (anonAddr, metaAddr)
@@ -277,6 +277,7 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
     }
     return (anonAddr, metaAddr)
   -- Collecting and sorting all definitions in the mutual block
+  -- TODO: This needs to support mutual blocks that include theorems and opaques
   let mutualDefs <- struct.all.mapM fun name => do
     match <- findLeanConst name with
       | .defnInfo defn => pure defn
@@ -313,12 +314,13 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
   | some ret => return ret
   | none => throw $ .constantNotContentAddressed struct.name
 
-
 partial def definitionToIR (defn: Lean.DefinitionVal)
   : CompileM Ix.Definition := do
   let type <- compileExpr defn.type
   let value <- compileExpr defn.value
-  return ⟨defn.levelParams, type, value, defn.safety == .partial⟩
+  let isPartial := defn.safety == .partial
+  let mode := .definition
+  return ⟨defn.levelParams, type, mode, value, defn.hints, isPartial, defn.all⟩
 
 /--
 Content-addresses an inductive and all inductives in the mutual block as a
@@ -394,27 +396,25 @@ partial def compileInductive (initInd: Lean.InductiveVal)
 partial def inductiveToIR (ind : Lean.InductiveVal) : CompileM Ix.Inductive := do
   let leanRecs := (← get).env.constants.childrenOfWith ind.name
     fun c => match c with | .recInfo _ => true | _ => false
-  let (recs, ctors) ← leanRecs.foldrM (init := ([], []))
-    fun r (recs, ctors) => match r with
-      | .recInfo rv =>
+  let (recs, ctors) := <- leanRecs.foldrM (init := ([], [])) collectRecsCtors
+  let type <- compileExpr ind.type
+    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
+    -- match the order used in `recrCtx`
+  return ⟨ind.levelParams, type, ind.numParams, ind.numIndices,
+    ind.all, ctors, recs, ind.isRec, ind.isReflexive⟩
+  where
+    collectRecsCtors
+      : Lean.ConstantInfo
+      -> List Recursor × List Constructor 
+      -> CompileM (List Recursor × List Constructor)
+      | r@(.recInfo rv), (recs, ctors) =>
         if isInternalRec rv.type ind.name then do
-          let (thisRec, thisCtors) := ← internalRecToIR ind.ctors r
+          let (thisRec, thisCtors) <- internalRecToIR ind.ctors r
           pure (thisRec :: recs, thisCtors)
         else do
           let thisRec ← externalRecToIR r
           pure (thisRec :: recs, ctors)
-      | _ => throw $ .nonRecursorExtractedFromChildren r.name
-  let (struct, unit) ← if ind.isRec || ind.numIndices != 0 
-  then pure (false, false)
-  else
-    match ctors with
-    -- Structures can only have one constructor
-    | [ctor] => pure (true, ctor.fields == 0)
-    | _ => pure (false, false)
-  return ⟨ind.levelParams, ← compileExpr ind.type, ind.numParams, ind.numIndices,
-    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
-    -- match the order used in `recrCtx`
-    ctors, recs, ind.isRec, ind.isReflexive, struct, unit⟩
+      | r, _ => throw $ .nonRecursorExtractedFromChildren r.name
 
 partial def internalRecToIR (ctors : List Lean.Name)
   : Lean.ConstantInfo → CompileM (Ix.Recursor × List Ix.Constructor)
@@ -426,8 +426,8 @@ partial def internalRecToIR (ctors : List Lean.Name)
           let (ctor, rule) ← recRuleToIR r
           pure $ (ctor :: retCtors, rule :: retRules)
         else pure (retCtors, retRules) -- this is an external recursor rule
-    let recr := ⟨rec.levelParams, typ, rec.numParams, rec.numIndices,
-      rec.numMotives, rec.numMinors, retRules, rec.k, true⟩
+    let recr := ⟨rec.name, rec.levelParams, typ, rec.numParams, rec.numIndices,
+      rec.numMotives, rec.numMinors, retRules, rec.k⟩
     return (recr, retCtors)
   | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
 
@@ -438,8 +438,8 @@ partial def recRuleToIR (rule : Lean.RecursorRule)
   | .ctorInfo ctor => withLevels ctor.levelParams do
     let typ ← compileExpr ctor.type
     let ctor :=
-      ⟨ctor.levelParams, typ, ctor.cidx, ctor.numParams, ctor.numFields⟩
-    pure (ctor, ⟨rule.nfields, rhs⟩)
+      ⟨ctor.name, ctor.levelParams, typ, ctor.cidx, ctor.numParams, ctor.numFields⟩
+    pure (ctor, ⟨rule.ctor, rule.nfields, rhs⟩)
   | const =>
     throw $ .invalidConstantKind const.name "constructor" const.ctorName
 
@@ -447,13 +447,13 @@ partial def externalRecToIR : Lean.ConstantInfo → CompileM Recursor
   | .recInfo rec => withLevels rec.levelParams do
     let typ ← compileExpr rec.type
     let rules ← rec.rules.mapM externalRecRuleToIR
-    return ⟨rec.levelParams, typ, rec.numParams, rec.numIndices,
-      rec.numMotives, rec.numMinors, rules, rec.k, false⟩
+    return ⟨rec.name, rec.levelParams, typ, rec.numParams, rec.numIndices,
+      rec.numMotives, rec.numMinors, rules, rec.k⟩
   | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
 
 partial def externalRecRuleToIR (rule : Lean.RecursorRule) 
   : CompileM RecursorRule :=
-  return ⟨rule.nfields, ← compileExpr rule.rhs⟩
+  return ⟨rule.ctor, rule.nfields, ← compileExpr rule.rhs⟩
 
 /--
 Content-addresses a Lean expression and adds it to the store.
@@ -649,11 +649,14 @@ partial def tryAddLeanDecl (defn: Lean.DefinitionVal) : CompileM Unit := do
       return ()
     | .error e => throw $ .kernelException e
 
-partial def addDef (lvls: List Lean.Name) (typ val: Lean.Expr)
+partial def addDef 
+  (lvls: List Lean.Name)
+  (typ val: Lean.Expr)
   : CompileM (Address × Address) := do
   let typ' <- compileExpr typ
   let val' <- compileExpr val
-  let (a, m) <- hashConst $ Ix.Const.definition ⟨lvls, typ', val', true⟩
+  let (a, m) <- hashConst $ 
+    Ix.Const.definition ⟨lvls, typ', .definition, val', .opaque, false, []⟩
   tryAddLeanDecl (makeLeanDef a.toUniqueName lvls typ val)
   return (a, m)
 
@@ -669,7 +672,9 @@ partial def commitConst (anon meta: Address)
   }
   return (commAddr, commMetaAddr)
 
-partial def commitDef (lvls: List Lean.Name) (typ val: Lean.Expr)
+partial def commitDef 
+  (lvls: List Lean.Name) 
+  (typ val: Lean.Expr)
   : CompileM (Address × Address) := do
   let (a, m) <- addDef lvls typ val
   let (ca, cm) <- commitConst a m
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index 79ec108c..6fce9b55 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -74,12 +74,26 @@ partial def ensureConst (name: Lean.Name) (cont meta: Address) : DecompileM Unit
   --match (<- get).names.find? n 
   sorry
 
+-- TODO: mutual block all needs better logic
 partial def decompileConst (name: Lean.Name): Ix.Const -> DecompileM Lean.ConstantInfo
-| .axiom x => sorry
-  --return .axiomInfo ⟨name, levels, type⟩
-| .theorem x => sorry
-| .opaque x => sorry
-| .definition x => sorry
+| .axiom x => do
+  let type <- decompileExpr x.type
+  return .axiomInfo (Lean.mkAxiomValEx name x.lvls type false)
+| .theorem x => do
+  let all := (<- read).mutCtx.keysList
+  let type <- decompileExpr x.type
+  let value <- decompileExpr x.type
+  return .thmInfo (Lean.mkTheoremValEx name x.lvls type value all)
+| .opaque x => do
+  let all := (<- read).mutCtx.keysList
+  let type <- decompileExpr x.type
+  let value <- decompileExpr x.type
+  return .opaqueInfo (Lean.mkOpaqueValEx name x.lvls type value false all)
+| .definition x => do
+  let all := (<- read).mutCtx.keysList
+  let type <- decompileExpr x.type
+  let value <- decompileExpr x.type
+  return .defnInfo (Lean.mkDefinitionValEx name x.lvls type value false all)
 | .quotient x => sorry
 | .inductiveProj x => sorry
 | .constructorProj x => sorry
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 9e6010f9..8e78d559 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -1,4 +1,452 @@
-import Ix.IR.Univ
-import Ix.IR.Expr
-import Ix.IR.Const
-import Ix.IR.Env
+import Ix.Common
+import Ix.Address
+
+namespace Ix
+
+/-
+Ix.IR is an internal representation of the Lean kernel values defined in
+[Lean.Declaration](https://leanprover-community.github.io/mathlib4_docs/Lean/Declaration.html)
+The purpose of Ix.IR is to separate-in-place alpha-invariant or nameless
+computational information from non-computational symbolic or ergonomic metadata.
+
+Ix.IR is generated as an intermediate output from the Ix compiler in Ix.CompileM,
+in the course of generating the anonymously content-addressed Ixon bytecode.
+Ix.IR is consumed by the Ix transporter in Ix.TransportM, which completes
+separation or "dematerialization" of the Lean kernel into Ixon bytecode and Ixon
+metadata. The transporter can also reconstitute, or "rematerialize" Ix IR from
+the Ixon wire-format.
+
+Finally, Ix.IR can be converted back into Lean kernel values via Ix.DecompileM
+
+The Ix IR differs from the Lean kernel in the following ways:
+
+1. It excludes all `unsafe` constants, as these are not guaranteed to be
+   well-defined in the pure setting of a zero-knowledge prover
+2. It excludes free variables and metavariables in expressions, all Ix IR terms
+are closed.
+3. It guarantees disambiguation of all names with de-bruijn index (int the case
+   of universe variables) and hash Addresses in the case of global constant
+   references. These Addresses are generated by hashing the anonymous Ixon
+   bytecode of the referenced constant, following dematerialization. The
+   separated metadata is also hashed and stored in-place in the Expr.const
+   reference.
+4. Since inductive datatypes are content-addressed namelessly, only the type of
+   an inductive and the type and order of its constructors are relevant for
+   defining an Ix inductive. Consequently, the datatypes
+
+   ```lean
+   inductive Boolean where
+   | false : Bool
+   | true : Bool
+
+   inductive Loobean where
+   | true : Bool
+   | false : Bool
+   ```
+
+   compile to identical Ixon inductives, with the same Ix address (differing
+   only in their metadata)
+
+   As a consequence, Ix will accept as valid the following Lean code:
+
+   ```lean
+   def Boolean.and (x y: Boolean) : Boolean
+   | .true, .true => true
+   | _, _ => false
+
+   def coerceLoobeanAsBoolean : Bool := Boolean.and Loobean.false Loobean.false
+   ```
+
+   We conjecture that this does not cause soundness issues in the Ix
+   typechecker, as one can treat this case as the Ix compiler inferring an
+   implicit coercion between isomorphic datatypes like so:
+
+   ```
+   def Loobean.toBoolean : Loobean -> Boolean
+   | .true => Boolean.false
+   | .false => Boolean.true
+
+   def coerceLoobeanAsBoolean : Bool :=
+    Boolean.and Loobean.false.toBoolean Loobean.false.toBoolean
+   ```
+
+   However, we have not rigourously demonstrated this yet, and therefore best
+   practice is to only pass environments to Ix which have passed Lean
+   typechecking to sanitize this case.
+-/
+
+/--
+Ix.Level universe levels are almost identical to Lean.Level, except that they
+exclude metavariables and de-bruijn index variable parameters.
+--/
+inductive Level
+  | zero
+  | succ : Level → Level
+  | max  : Level → Level → Level
+  | imax : Level → Level → Level
+  | param: Lean.Name → Nat → Level
+  deriving Inhabited, Ord, BEq, Hashable, Repr
+
+/--
+Ix.Expr expressions are similar to Lean.Expr, except they exclude free variables
+and metavariables, and annotate global constant references with Ix.Address
+content-addresses
+--/
+inductive Expr
+  | var   (idx: Nat)
+  | sort  (univ: Level)
+  | const (name: Lean.Name) (ref: Address) (meta: Address) (univs: List Level)
+  | rec_  (name: Lean.Name) (idx: Nat) (univs: List Level)
+  | app   (func: Expr) (argm: Expr)
+  | lam   (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
+  | pi    (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
+  | letE  (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
+  | lit   (lit: Lean.Literal)
+  | proj  (typeName: Lean.Name) (typeCont: Address) (typeMeta: Address) (idx: Nat) (struct: Expr)
+  deriving Inhabited, Ord, BEq, Repr, Hashable
+
+
+/--
+Ix.Quotient quotients are analogous to Lean.QuotVal
+--/
+structure Quotient where
+  levelParams : List Lean.Name
+  type : Expr
+  kind : Lean.QuotKind
+  deriving Ord, BEq, Hashable, Repr, Nonempty
+
+/--
+Ix.Axiom axioms are analogous to Lean.AxiomVal, differing only in not including
+the `isUnsafe` parameter, as Ix constants are never unsafe
+--/
+structure Axiom where
+  levelParams : List Lean.Name
+  type : Expr
+  deriving Ord, BEq, Hashable, Repr, Nonempty
+
+
+/--
+Ix.Definition definitions combine Lean.DefinitionVal, Lean.OpaqueVal and
+Lean.TheoremVal into a single structure in order to enable content-addressing of
+mutually recursive blocks. These cases are disambiguated via the Ix.DefMode
+inductive. ReducibilityHints are preserved only as metadata, and are set to
+`ReducibilityHints.opaque` and ignored if the DefMode is either .opaque or
+.theorem. The `safety : Lean.DefinitionSafety` parameter from DefinitionVal is
+replaced with a boolean for partial definitions, as Ix definitions are
+restricted to exclude unsafe constants.
+--/
+structure Definition where
+  levelParams : List Lean.Name
+  type : Expr
+  mode: DefMode
+  value : Expr
+  hints : Lean.ReducibilityHints
+  isPartial : Bool
+  all : List Lean.Name
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+def mkTheorem
+  (levelParams: List Lean.Name)
+  (type: Expr)
+  (value: Expr)
+  (all: List Lean.Name)
+  : Definition
+  := ⟨levelParams, type, .theorem, value, .opaque, false, all⟩
+
+def mkOpaque
+  (levelParams: List Lean.Name)
+  (type: Expr)
+  (value: Expr)
+  (all: List Lean.Name)
+  : Definition
+  := ⟨levelParams, type, .opaque, value, .opaque, false, all⟩
+
+/--
+Ix.Constructor inductive datatype constructors are analogous to
+Lean.ConstructorVal. The primary difference is that Ix.Constructor only appears
+within an Ix.Inductive, and is not directly present in the top level
+environment. This is done to enable content-addressing of inductive datatypes.
+Instead, Ix.ConstructorProj is used to project or access an inductive
+constructor at the top level. Unlike other Ix constants, the `name` parameter is
+represented here, but only as metadata to aid in decompilation.
+--/
+structure Constructor where
+  name : Lean.Name
+  levelParams : List Lean.Name
+  type : Expr
+  cidx : Nat
+  numParams : Nat
+  numFields : Nat
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+/--
+Ix.RecursorRule is analogous to Lean.RecursorRule 
+--/
+structure RecursorRule where
+  ctor : Lean.Name
+  nfields : Nat
+  rhs : Expr
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+/--
+Ix.Recursor represents inductive recursors and is analogous to Lean.RecursorVal.
+However, like Ix.Constructor, recursors do not appear directly in the top-level
+environment but are instead held directly within their corresponding Inductive.
+Recursors are accessed in an environment using the `Ix.RecursorProj` projection
+constant
+--/
+structure Recursor where
+  name: Lean.Name
+  levelParams : List Lean.Name
+  type : Expr
+  numParams : Nat
+  numIndices : Nat
+  numMotives : Nat
+  numMinors  : Nat
+  rules : List RecursorRule
+  k : Bool
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+/--
+Ix.Inductive represents inductive datatypes and is analogous to
+Lean.InductiveVal. However, unlike in Lean, Ix.Inductive directly contains its
+corresponding Constructors and Recursors in order to enable content-addressing.
+--/
+structure Inductive where
+  lvls : List Lean.Name
+  type : Expr
+  numParams : Nat
+  numIndices : Nat
+  all : List Lean.Name
+  ctors : List Constructor
+  recrs : List Recursor
+  isRec : Bool
+  isReflexive : Bool
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+structure InductiveProj where
+  /-- content-address of a mutual inductive block --/
+  blockCont : Address
+  /-- metadata content-address a mutual inductive block --/
+  blockMeta : Address
+  /-- index of the specific inductive datatype within the block --/
+  idx   : Nat
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+structure ConstructorProj where
+  /-- content-address of a mutual inductive block --/
+  blockCont : Address
+  /-- metadata content-address a mutual inductive block --/
+  blockMeta : Address
+  /-- index of a specific inductive datatype within the block --/
+  idx   : Nat
+  /-- index of a specific constructor within the inductive --/
+  cidx  : Nat
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+structure RecursorProj where
+  /-- content-address of a mutual inductive block --/
+  blockCont : Address
+  /-- metadata content-address of a mutual inductive block --/
+  blockMeta : Address
+  /-- index of a specific inductive datatype within the block --/
+  idx : Nat
+  /-- index of a specific recursor within the inductive --/
+  ridx : Nat
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+structure DefinitionProj where
+  /-- content-address of a mutual definition block --/
+  blockCont : Address
+  /-- metadata content-address of a mutual definition block --/
+  blockMeta : Address
+  /-- index of a specific definition within the block --/
+  idx : Nat
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
+inductive Const where
+  | «axiom» : Axiom → Const
+  | quotient : Quotient → Const
+  | «definition»: Definition → Const
+  | «inductive» : Inductive → Const
+  -- projections of mutual blocks
+  | inductiveProj : InductiveProj → Const
+  | constructorProj : ConstructorProj → Const
+  | recursorProj : RecursorProj → Const
+  | definitionProj : DefinitionProj → Const
+  -- constants to represent mutual blocks
+  | mutDefBlock : List Definition → Const
+  | mutIndBlock : List Inductive → Const
+  deriving Ord, BEq, Inhabited, Repr, Nonempty
+
+def Const.isMutBlock : Const → Bool
+  | .mutDefBlock _ | .mutIndBlock _ => true
+  | _ => false
+
+namespace Level
+
+/--
+Reduces as a `max` applied to two values: `max a 0 = max 0 a = a` and
+`max (succ a) (succ b) = succ (max a b)`.
+It is assumed that `a` and `b` are already reduced
+-/
+def reduceMax (a b : Level) : Level :=
+  match a, b with
+  | .zero, _ => b
+  | _, .zero => a
+  | .succ a, .succ b => .succ (reduceMax a b)
+  | .param _ idx, .param _ idx' => if idx == idx' then a else .max a b
+  | _, _ => .max a b
+
+/--
+Reduces as an `imax` applied to two values.
+It is assumed that `a` and `b` are already reduced
+-/
+def reduceIMax (a b : Level) : Level :=
+  match b with
+  -- IMax(a, b) will reduce to 0 if b == 0
+  | .zero => .zero
+  -- IMax(a, b) will reduce as Max(a, b) if b == Succ(..) (impossible case)
+  | .succ _ => reduceMax a b
+  | .param _ idx => match a with
+    | .param _ idx' => if idx == idx' then a else .imax a b
+    | _ => .imax a b
+  -- Otherwise, IMax(a, b) is stuck, with a and b reduced
+  | _ => .imax a b
+
+/--
+Reduce, or simplify, the universe levels to a normal form. Notice that universe
+levels with no free paramiables always reduce to a number, i.e., a sequence of
+`succ`s followed by a `zero`
+-/
+def reduce : Level → Level
+  | .succ u' => .succ (reduce u')
+  | .max a b => reduceMax (reduce a) (reduce b)
+  | .imax a b =>
+    let b' := reduce b
+    match b' with
+    | .zero => .zero
+    | .succ _ => reduceMax (reduce a) b'
+    | _ => .imax (reduce a) b'
+  | u => u
+
+/--
+Instantiate a paramiable and reduce at the same time. Assumes an already reduced
+`subst`. This function is only used in the comparison algorithm, and it doesn't
+shift paramiables, because we want to instantiate a paramiable `param idx` with
+`succ (param idx)`, so by shifting the paramiables we would transform `param (idx+1)`
+into `param idx` which is not what we want
+-/
+def instReduce (u : Level) (idx : Nat) (subst : Level) : Level :=
+  match u with
+  | .succ u => .succ (instReduce u idx subst)
+  | .max a b => reduceMax (instReduce a idx subst) (instReduce b idx subst)
+  | .imax a b =>
+    let a' := instReduce a idx subst
+    let b' := instReduce b idx subst
+    match b' with
+    | .zero => .zero
+    | .succ _ => reduceMax a' b'
+    | _ => .imax a' b'
+  | .param _ idx' => if idx' == idx then subst else u
+  | .zero => u
+
+/--
+Instantiate multiple paramiables at the same time and reduce. Assumes already
+reduced `substs`
+-/
+def instBulkReduce (substs : List Level) : Level → Level
+  | z@(.zero ..) => z
+  | .succ u => .succ (instBulkReduce substs u)
+  | .max a b => reduceMax (instBulkReduce substs a) (instBulkReduce substs b)
+  | .imax a b =>
+    let b' := instBulkReduce substs b
+    match b' with
+    | .zero => .zero
+    | .succ _ => reduceMax (instBulkReduce substs a) b'
+    | _ => .imax (instBulkReduce substs a) b'
+  | .param n idx => match substs[idx]? with
+    | some u => u
+    -- This case should never happen if we're correctly enclosing every
+    -- expression with a big enough universe environment
+    | none => .param n (idx - substs.length)
+
+/--
+We say that two universe levels `a` and `b` are (semantically) equal, if they
+are equal as numbers for all possible substitution of free paramiables to numbers.
+Although writing an algorithm that follows this exact scheme is impossible, it
+is possible to write one that is equivalent to such semantical equality.
+Comparison algorithm `a <= b + diff`. Assumes `a` and `b` are already reduced
+-/
+partial def leq (a b : Level) (diff : Int) : Bool :=
+  if diff >= 0 && a == .zero then true
+  else match a, b with
+  | .zero, .zero => diff >= 0
+  --! Succ cases
+  | .succ a, _ => leq a b (diff - 1)
+  | _, .succ b => leq a b (diff + 1)
+  | .param .., .zero => false
+  | .zero, .param .. => diff >= 0
+  | .param _ x, .param _ y => x == y && diff >= 0
+  --! IMax cases
+  -- The case `a = imax c d` has only three possibilities:
+  -- 1) d = param ..
+  -- 2) d = max ..
+  -- 3) d = imax ..
+  -- It can't be any otherway since we are assuming `a` is reduced, and thus `d` is reduced as well
+  | .imax _ (.param n idx), _ =>
+    -- In the case for `param idx`, we need to compare two substitutions:
+    -- 1) idx <- zero
+    -- 2) idx <- succ (param idx)
+    -- In the first substitution, we know `a` becomes `zero`
+    leq .zero (instReduce b idx .zero) diff &&
+    let succ := .succ (.param n idx)
+    leq (instReduce a idx succ) (instReduce b idx succ) diff
+
+  | .imax c (.max e f), _ =>
+    -- Here we use the relationship
+    -- imax c (max e f) = max (imax c e) (imax c f)
+    let new_max := reduceMax (reduceIMax c e) (reduceIMax c f)
+    leq new_max b diff
+  | .imax c (.imax e f), _ =>
+    -- Here we use the relationship
+    -- imax c (imax e f) = max (imax c e) (imax e f)
+    let new_max := reduceMax (reduceIMax c e) (.imax e f)
+    leq new_max b diff
+  -- Analogous to previous case
+  | _, .imax _ (.param n idx) =>
+    leq (instReduce a idx .zero) .zero diff &&
+    let succ := .succ (.param n idx)
+    leq (instReduce a idx succ) (instReduce b idx succ) diff
+  | _, .imax c (.max e f) =>
+    let new_max := reduceMax (reduceIMax c e) (reduceIMax c f)
+    leq a new_max diff
+  | _, .imax c (.imax e f) =>
+    let new_max := reduceMax (reduceIMax c e) (.imax e f)
+    leq a new_max diff
+  --! Max cases
+  | .max c d, _ => leq c b diff && leq d b diff
+  | _, .max c d => leq a c diff || leq a d diff
+  | _, _ => false -- Impossible cases
+
+/-- The equality algorithm. Assumes `a` and `b` are already reduced -/
+def equalLevel (a b : Level) : Bool :=
+  leq a b 0 && leq b a 0
+
+/--
+Two lists of universes are considered equal iff they have the same length and
+`Ix.equalLevel` returns `true` for all of their zip pairs
+-/
+def equalLevels : List Level → List Level → Bool
+  | [], [] => true
+  | u::us, u'::us' => equalLevel u u' && equalLevels us us'
+  | _, _ => false
+
+/-- Faster equality for zero, assumes that the input is already reduced -/
+def isZero : Level → Bool
+  | .zero => true
+  -- all other cases are false since they are either `succ` or a reduced
+  -- expression with free paramiables, which are never semantically equal to zero
+  | _ => false
+
+end Ix.Level
diff --git a/Ix/IR/Const.lean b/Ix/IR/Const.lean
deleted file mode 100644
index 339d273e..00000000
--- a/Ix/IR/Const.lean
+++ /dev/null
@@ -1,123 +0,0 @@
-import Ix.IR.Univ
-import Ix.IR.Expr
-import Ix.Address
-
-deriving instance BEq, Repr, Hashable, Ord for Lean.QuotKind
-
-namespace Ix
-
-structure Quotient where
-  lvls : List Lean.Name
-  type : Expr
-  kind : Lean.QuotKind
-  deriving Ord, BEq, Hashable, Repr, Nonempty
-
-structure Axiom where
-  lvls  : List Lean.Name
-  type  : Expr
-  deriving Ord, BEq, Hashable, Repr, Nonempty
-
-structure Theorem where
-  lvls  : List Lean.Name
-  type  : Expr
-  value : Expr
-  deriving Ord, BEq, Hashable, Repr, Nonempty
-
-structure Opaque where
-  lvls  : List Lean.Name
-  type  : Expr
-  value : Expr
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure Definition where
-  lvls  : List Lean.Name
-  type  : Expr
-  value : Expr
-  part  : Bool
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure Constructor where
-  lvls   : List Lean.Name
-  type   : Expr
-  idx    : Nat
-  params : Nat
-  fields : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure RecursorRule where
-  fields : Nat
-  rhs    : Expr
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure Recursor where
-  lvls     : List Lean.Name
-  type     : Expr
-  params   : Nat
-  indices  : Nat
-  motives  : Nat
-  minors   : Nat
-  rules    : List RecursorRule
-  isK      : Bool
-  internal : Bool
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure Inductive where
-  lvls    : List Lean.Name
-  type    : Expr
-  params  : Nat
-  indices : Nat
-  ctors   : List Constructor
-  recrs   : List Recursor
-  recr    : Bool
-  refl    : Bool
-  struct  : Bool
-  unit    : Bool
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure InductiveProj where
-  blockCont : Address
-  blockMeta : Address
-  idx   : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure ConstructorProj where
-  blockCont : Address
-  blockMeta : Address
-  idx   : Nat
-  cidx  : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure RecursorProj where
-  blockCont : Address
-  blockMeta : Address
-  idx   : Nat
-  ridx  : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-structure DefinitionProj where
-  blockCont : Address
-  blockMeta : Address
-  idx   : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
-
-inductive Const where
-  | «axiom»     : Axiom      → Const
-  | «theorem»   : Theorem    → Const
-  | «opaque»    : Opaque     → Const
-  | «definition»: Definition → Const
-  | quotient    : Quotient   → Const
-  -- projections of mutual blocks
-  | inductiveProj   : InductiveProj   → Const
-  | constructorProj : ConstructorProj → Const
-  | recursorProj    : RecursorProj    → Const
-  | definitionProj  : DefinitionProj  → Const
-  -- constants to represent mutual blocks
-  | mutDefBlock : List Definition → Const
-  | mutIndBlock : List Inductive  → Const
-  deriving Ord, BEq, Inhabited, Repr, Nonempty
-
-def Const.isMutType : Const → Bool
-  | .mutDefBlock _ | .mutIndBlock _ => true
-  | _ => false
-
-end Ix
diff --git a/Ix/IR/Env.lean b/Ix/IR/Env.lean
deleted file mode 100644
index 254bb317..00000000
--- a/Ix/IR/Env.lean
+++ /dev/null
@@ -1,19 +0,0 @@
-import Batteries.Data.RBMap
-import Ix.IR.Univ
-import Ix.IR.Expr
-import Ix.IR.Const
-import Ix.Ixon.Const
-import Ix.Ixon.Metadata
-import Ix.Common
-
-namespace Ix
-
-open Batteries (RBMap)
-open Batteries (RBSet)
-
---structure Env where
---  names  : RBMap Lean.Name Address compare
---  store  : RBMap Address Ixon.Const compare
---  consts : RBMap Address (Batteries.RBMap Address Ix.Const compare) compare
---  blocks : RBSet Address compare
-
diff --git a/Ix/IR/Expr.lean b/Ix/IR/Expr.lean
deleted file mode 100644
index b416503d..00000000
--- a/Ix/IR/Expr.lean
+++ /dev/null
@@ -1,21 +0,0 @@
-import Ix.IR.Univ
-import Ix.Address
-import Ix.Common
-import Lean.Expr
-
-namespace Ix
-
-inductive Expr
-  | var   (idx: Nat)
-  | sort  (univ: Univ)
-  | const (name: Lean.Name) (ref: Address) (meta: Address) (univs: List Univ)
-  | rec_  (name: Lean.Name) (idx: Nat) (univs: List Univ)
-  | app   (func: Expr) (argm: Expr)
-  | lam   (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
-  | pi    (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
-  | letE  (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
-  | lit   (lit: Lean.Literal)
-  | proj  (typeName: Lean.Name) (typeCont: Address) (typeMeta: Address) (idx: Nat) (struct: Expr)
-  deriving Inhabited, Ord, BEq, Repr, Hashable
-
-end Ix
diff --git a/Ix/IR/Univ.lean b/Ix/IR/Univ.lean
deleted file mode 100644
index d92bb2d2..00000000
--- a/Ix/IR/Univ.lean
+++ /dev/null
@@ -1,179 +0,0 @@
-import Ix.Common
-
-namespace Ix
-
-inductive Univ
-  | zero
-  | succ : Univ → Univ
-  | max  : Univ → Univ → Univ
-  | imax : Univ → Univ → Univ
-  | var  : Lean.Name → Nat → Univ
-  deriving Inhabited, Ord, BEq, Hashable, Repr
-
-namespace Univ
-
-/--
-Reduces as a `max` applied to two values: `max a 0 = max 0 a = a` and
-`max (succ a) (succ b) = succ (max a b)`.
-It is assumed that `a` and `b` are already reduced
--/
-def reduceMax (a b : Univ) : Univ :=
-  match a, b with
-  | .zero, _ => b
-  | _, .zero => a
-  | .succ a, .succ b => .succ (reduceMax a b)
-  | .var _ idx, .var _ idx' => if idx == idx' then a else .max a b
-  | _, _ => .max a b
-
-/--
-Reduces as an `imax` applied to two values.
-It is assumed that `a` and `b` are already reduced
--/
-def reduceIMax (a b : Univ) : Univ :=
-  match b with
-  -- IMax(a, b) will reduce to 0 if b == 0
-  | .zero => .zero
-  -- IMax(a, b) will reduce as Max(a, b) if b == Succ(..) (impossible case)
-  | .succ _ => reduceMax a b
-  | .var _ idx => match a with
-    | .var _ idx' => if idx == idx' then a else .imax a b
-    | _ => .imax a b
-  -- Otherwise, IMax(a, b) is stuck, with a and b reduced
-  | _ => .imax a b
-
-/--
-Reduce, or simplify, the universe levels to a normal form. Notice that universe
-levels with no free variables always reduce to a number, i.e., a sequence of
-`succ`s followed by a `zero`
--/
-def reduce : Univ → Univ
-  | .succ u' => .succ (reduce u')
-  | .max a b => reduceMax (reduce a) (reduce b)
-  | .imax a b =>
-    let b' := reduce b
-    match b' with
-    | .zero => .zero
-    | .succ _ => reduceMax (reduce a) b'
-    | _ => .imax (reduce a) b'
-  | u => u
-
-/--
-Instantiate a variable and reduce at the same time. Assumes an already reduced
-`subst`. This function is only used in the comparison algorithm, and it doesn't
-shift variables, because we want to instantiate a variable `var idx` with
-`succ (var idx)`, so by shifting the variables we would transform `var (idx+1)`
-into `var idx` which is not what we want
--/
-def instReduce (u : Univ) (idx : Nat) (subst : Univ) : Univ :=
-  match u with
-  | .succ u => .succ (instReduce u idx subst)
-  | .max a b => reduceMax (instReduce a idx subst) (instReduce b idx subst)
-  | .imax a b =>
-    let a' := instReduce a idx subst
-    let b' := instReduce b idx subst
-    match b' with
-    | .zero => .zero
-    | .succ _ => reduceMax a' b'
-    | _ => .imax a' b'
-  | .var _ idx' => if idx' == idx then subst else u
-  | .zero => u
-
-/--
-Instantiate multiple variables at the same time and reduce. Assumes already
-reduced `substs`
--/
-def instBulkReduce (substs : List Univ) : Univ → Univ
-  | z@(.zero ..) => z
-  | .succ u => .succ (instBulkReduce substs u)
-  | .max a b => reduceMax (instBulkReduce substs a) (instBulkReduce substs b)
-  | .imax a b =>
-    let b' := instBulkReduce substs b
-    match b' with
-    | .zero => .zero
-    | .succ _ => reduceMax (instBulkReduce substs a) b'
-    | _ => .imax (instBulkReduce substs a) b'
-  | .var n idx => match substs[idx]? with
-    | some u => u
-    -- This case should never happen if we're correctly enclosing every
-    -- expression with a big enough universe environment
-    | none => .var n (idx - substs.length)
-
-/--
-We say that two universe levels `a` and `b` are (semantically) equal, if they
-are equal as numbers for all possible substitution of free variables to numbers.
-Although writing an algorithm that follows this exact scheme is impossible, it
-is possible to write one that is equivalent to such semantical equality.
-Comparison algorithm `a <= b + diff`. Assumes `a` and `b` are already reduced
--/
-partial def leq (a b : Univ) (diff : Int) : Bool :=
-  if diff >= 0 && a == .zero then true
-  else match a, b with
-  | .zero, .zero => diff >= 0
-  --! Succ cases
-  | .succ a, _ => leq a b (diff - 1)
-  | _, .succ b => leq a b (diff + 1)
-  | .var .., .zero => false
-  | .zero, .var .. => diff >= 0
-  | .var _ x, .var _ y => x == y && diff >= 0
-  --! IMax cases
-  -- The case `a = imax c d` has only three possibilities:
-  -- 1) d = var ..
-  -- 2) d = max ..
-  -- 3) d = imax ..
-  -- It can't be any otherway since we are assuming `a` is reduced, and thus `d` is reduced as well
-  | .imax _ (.var n idx), _ =>
-    -- In the case for `var idx`, we need to compare two substitutions:
-    -- 1) idx <- zero
-    -- 2) idx <- succ (var idx)
-    -- In the first substitution, we know `a` becomes `zero`
-    leq .zero (instReduce b idx .zero) diff &&
-    let succ := .succ (.var n idx)
-    leq (instReduce a idx succ) (instReduce b idx succ) diff
-
-  | .imax c (.max e f), _ =>
-    -- Here we use the relationship
-    -- imax c (max e f) = max (imax c e) (imax c f)
-    let new_max := reduceMax (reduceIMax c e) (reduceIMax c f)
-    leq new_max b diff
-  | .imax c (.imax e f), _ =>
-    -- Here we use the relationship
-    -- imax c (imax e f) = max (imax c e) (imax e f)
-    let new_max := reduceMax (reduceIMax c e) (.imax e f)
-    leq new_max b diff
-  -- Analogous to previous case
-  | _, .imax _ (.var n idx) =>
-    leq (instReduce a idx .zero) .zero diff &&
-    let succ := .succ (.var n idx)
-    leq (instReduce a idx succ) (instReduce b idx succ) diff
-  | _, .imax c (.max e f) =>
-    let new_max := reduceMax (reduceIMax c e) (reduceIMax c f)
-    leq a new_max diff
-  | _, .imax c (.imax e f) =>
-    let new_max := reduceMax (reduceIMax c e) (.imax e f)
-    leq a new_max diff
-  --! Max cases
-  | .max c d, _ => leq c b diff && leq d b diff
-  | _, .max c d => leq a c diff || leq a d diff
-  | _, _ => false -- Impossible cases
-
-/-- The equality algorithm. Assumes `a` and `b` are already reduced -/
-def equalUniv (a b : Univ) : Bool :=
-  leq a b 0 && leq b a 0
-
-/--
-Two lists of universes are considered equal iff they have the same length and
-`Yatima.Univ.equalUniv` returns `true` for all of their zip pairs
--/
-def equalUnivs : List Univ → List Univ → Bool
-  | [], [] => true
-  | u::us, u'::us' => equalUniv u u' && equalUnivs us us'
-  | _, _ => false
-
-/-- Faster equality for zero, assumes that the input is already reduced -/
-def isZero : Univ → Bool
-  | .zero => true
-  -- all other cases are false since they are either `succ` or a reduced
-  -- expression with free variables, which are never semantically equal to zero
-  | _ => false
-
-end Ix.Univ
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index 962f7ef3..2fd08f11 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -1,3 +1,4 @@
+import Ix.Common
 import Ix.Address
 import Ix.Prove
 import Lean.Declaration
@@ -7,10 +8,6 @@ import Ix.Ixon.Expr
 
 namespace Ixon
 
-deriving instance BEq for Lean.QuotKind
-
-deriving instance Repr for Lean.QuotKind
-
 structure Quotient where
   lvls : Nat
   type : Expr
@@ -18,217 +15,237 @@ structure Quotient where
   deriving BEq, Repr
 
 structure Axiom where
-  lvls  : Nat
-  type  : Expr
-  deriving BEq, Repr
-
-structure Theorem where
-  lvls  : Nat
-  type  : Expr
-  value : Expr
-  deriving BEq, Repr
-
-structure Opaque where
-  lvls  : Nat
-  type  : Expr
-  value : Expr
+  lvls : Nat
+  type : Expr
   deriving BEq, Repr
 
 structure Definition where
-  lvls  : Nat
-  type  : Expr
+  lvls : Nat
+  type : Expr
+  mode : Ix.DefMode
   value : Expr
-  part  : Bool
+  part : Bool
   deriving BEq, Repr
 
 structure Constructor where
-  lvls   : Nat
-  type   : Expr
-  idx    : Nat
+  lvls : Nat
+  type : Expr
+  cidx : Nat
   params : Nat
   fields : Nat
   deriving BEq, Repr
 
 structure RecursorRule where
   fields : Nat
-  rhs    : Expr
+  rhs : Expr
   deriving BEq, Repr
 
 structure Recursor where
-  lvls     : Nat
-  type     : Expr
-  params   : Nat
-  indices  : Nat
-  motives  : Nat
-  minors   : Nat
-  rules    : List RecursorRule
-  isK      : Bool
-  internal : Bool
+  lvls : Nat
+  type : Expr
+  params : Nat
+  indices : Nat
+  motives : Nat
+  minors : Nat
+  rules : List RecursorRule
+  k : Bool
   deriving BEq, Repr
 
 structure Inductive where
-  lvls    : Nat
-  type    : Expr
-  params  : Nat
+  lvls : Nat
+  type : Expr
+  params : Nat
   indices : Nat
-  ctors   : List Constructor
-  recrs   : List Recursor
-  recr    : Bool
-  refl    : Bool
-  struct  : Bool
-  unit    : Bool
+  ctors : List Constructor
+  recrs : List Recursor
+  recr : Bool
+  refl : Bool
   deriving BEq, Repr
 
 structure InductiveProj where
   block : Address
-  idx   : Nat
+  idx : Nat
   deriving BEq, Repr
 
 structure ConstructorProj where
   block : Address
-  idx   : Nat
-  cidx  : Nat
+  idx : Nat
+  cidx : Nat
   deriving BEq, Repr
 
 structure RecursorProj where
   block : Address
-  idx   : Nat
-  ridx  : Nat
+  idx : Nat
+  ridx : Nat
   deriving BEq, Repr
 
 structure DefinitionProj where
   block : Address
-  idx   : Nat
+  idx : Nat
   deriving BEq, Repr
 
 structure Comm where
-  secret: Address
-  payload: Address
+  secret : Address
+  payload : Address
   deriving BEq, Repr
 
 inductive Const where
   -- 0xC0
-  | axio : Axiom -> Const
+  | defn : Definition -> Const
   -- 0xC1
-  | theo : Theorem -> Const
+  | indc : Inductive -> Const
   -- 0xC2
-  | opaq : Opaque -> Const
+  | axio : Axiom -> Const
   -- 0xC3
-  | defn : Definition -> Const
-  -- 0xC4
   | quot : Quotient -> Const
-  -- 0xC5
+  -- 0xC4
   | ctorProj : ConstructorProj -> Const
-  -- 0xC6
+  -- 0xC5
   | recrProj : RecursorProj -> Const
-  -- 0xC7
+  -- 0xC6
   | indcProj : InductiveProj -> Const
-  -- 0xC8
+  -- 0xC7
   | defnProj : DefinitionProj -> Const
-  -- 0xC9
+  -- 0xC8
   | mutDef : List Definition -> Const
-  -- 0xCA
+  -- 0xC9
   | mutInd : List Inductive -> Const
-  -- 0xCB
+  -- 0xCA
   | meta   : Metadata -> Const
-  -- 0xCC
+  -- 0xCB
   | proof : Proof -> Const
-  -- 0xCD
+  -- 0xCC
   | comm: Comm -> Const
   deriving BEq, Repr, Inhabited
 
 def putConst : Const → PutM
-| .axio x => putUInt8 0xC0 *> putNatl x.lvls *> putExpr x.type
-| .theo x => putUInt8 0xC1 *> putNatl x.lvls *> putExpr x.type *> putExpr x.value
-| .opaq x => putUInt8 0xC2 *> putNatl x.lvls *> putExpr x.type *> putExpr x.value
-| .defn x => putUInt8 0xC3 *> putDefn x
-| .quot x => putUInt8 0xC4 *> putNatl x.lvls *> putExpr x.type *> putQuotKind x.kind
-| .ctorProj x => putUInt8 0xC5 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.cidx
-| .recrProj x => putUInt8 0xC6 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
-| .indcProj x => putUInt8 0xC7 *> putBytes x.block.hash *> putNatl x.idx
-| .defnProj x => putUInt8 0xC8 *> putBytes x.block.hash *> putNatl x.idx
-| .mutDef xs => putUInt8 0xC9 *> putArray (putDefn <$> xs)
-| .mutInd xs => putUInt8 0xCA *> putArray (putIndc <$> xs)
-| .meta m => putUInt8 0xCB *> putMetadata m
-| .proof p => putUInt8 0xCC *> putProof p
-| .comm c => putUInt8 0xCD *> putComm c
+| .defn x => putUInt8 0xC0 *> putDefn x
+| .indc x => putUInt8 0xC1 *> putIndc x
+| .axio x => putUInt8 0xC2 *> putNatl x.lvls *> putExpr x.type
+| .quot x => putUInt8 0xC3 *> putNatl x.lvls *> putExpr x.type *> putQuotKind x.kind
+| .ctorProj x => putUInt8 0xC4 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.cidx
+| .recrProj x => putUInt8 0xC5 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
+| .indcProj x => putUInt8 0xC6 *> putBytes x.block.hash *> putNatl x.idx
+| .defnProj x => putUInt8 0xC7 *> putBytes x.block.hash *> putNatl x.idx
+| .mutDef xs => putUInt8 0xC8 *> putArray (putDefn <$> xs)
+| .mutInd xs => putUInt8 0xC9 *> putArray (putIndc <$> xs)
+| .meta m => putUInt8 0xCA *> putMetadata m
+| .proof p => putUInt8 0xCB *> putProof p
+| .comm c => putUInt8 0xCC *> putComm c
   where
-    putDefn (x: Definition) :=
-      putNatl x.lvls *> putExpr x.type *> putExpr x.value *> putBool x.part
+    putDefn (x: Definition) := do
+      putNatl x.lvls
+      putExpr x.type
+      putDefMode x.mode
+      putExpr x.value
+      putBool x.part
     putRecrRule (x: RecursorRule) : PutM := putNatl x.fields *> putExpr x.rhs
-    putCtor (x: Constructor) : PutM :=
-      putNatl x.lvls *> putExpr x.type
-        *> putNatl x.idx *> putNatl x.params *> putNatl x.fields
-    putRecr (x: Recursor) : PutM :=
-      putNatl x.lvls *> putExpr x.type
-        *> putNatl x.params *> putNatl x.indices *> putNatl x.motives
-        *> putNatl x.minors *> putArray (putRecrRule <$> x.rules)
-        *> putBools [x.isK, x.internal]
-    putIndc (x: Inductive) : PutM :=
-      putNatl x.lvls *> putExpr x.type
-        *> putNatl x.params *> putNatl x.indices
-        *> putArray (putCtor <$> x.ctors) *> putArray (putRecr <$> x.recrs)
-        *> putBools [x.recr, x.refl, x.struct, x.unit]
+    putCtor (x: Constructor) : PutM := do
+      putNatl x.lvls
+      putExpr x.type
+      putNatl x.cidx
+      putNatl x.params
+      putNatl x.fields
+    putRecr (x: Recursor) : PutM := do
+      putNatl x.lvls
+      putExpr x.type
+      putNatl x.params
+      putNatl x.indices
+      putNatl x.motives
+      putNatl x.minors
+      putArray (putRecrRule <$> x.rules)
+      putBool x.k
+    putIndc (x: Inductive) : PutM := do
+      putNatl x.lvls
+      putExpr x.type
+      putNatl x.params
+      putNatl x.indices
+      putArray (putCtor <$> x.ctors)
+      putArray (putRecr <$> x.recrs)
+      putBools [x.recr, x.refl]
     putProof (p: Proof) : PutM :=
       match p.claim with
-      | .checks lvls type value => 
-          putUInt8 0
-          *> putBytes lvls.hash
-          *> putBytes type.hash 
-          *> putBytes value.hash
-          *> putByteArray p.bin
-      | .evals lvls inp out type =>
-          putUInt8 1
-          *> putBytes lvls.hash
-          *> putBytes inp.hash
-          *> putBytes out.hash
-          *> putBytes type.hash 
-          *> putByteArray p.bin
+      | .checks lvls type value => do
+        putUInt8 0
+        putBytes lvls.hash
+        putBytes type.hash
+        putBytes value.hash
+        putByteArray p.bin
+      | .evals lvls inp out type => do
+        putUInt8 1
+        putBytes lvls.hash
+        putBytes inp.hash
+        putBytes out.hash
+        putBytes type.hash
+        putByteArray p.bin
     putComm (c: Comm) : PutM :=
       putBytes c.secret.hash *> putBytes c.payload.hash
 
 def getConst : GetM Const := do
   let tag ← getUInt8
   match tag with
-  | 0xC0 => .axio <$> (.mk <$> getNatl <*> getExpr)
-  | 0xC1 => .theo <$> (.mk <$> getNatl <*> getExpr <*> getExpr)
-  | 0xC2 => .opaq <$> (.mk <$> getNatl <*> getExpr <*> getExpr)
-  | 0xC3 => .defn <$> getDefn
-  | 0xC4 => .quot <$> (.mk <$> getNatl <*> getExpr <*> getQuotKind)
-  | 0xC5 => .ctorProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
-  | 0xC6 => .recrProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
-  | 0xC7 => .indcProj <$> (.mk <$> getAddr <*> getNatl)
-  | 0xC8 => .defnProj <$> (.mk <$> getAddr <*> getNatl)
-  | 0xC9 => .mutDef <$> getArray getDefn
-  | 0xCA => .mutInd <$> getArray getIndc
-  | 0xCB => .meta <$> getMetadata
-  | 0xCC => .proof <$> getProof
-  | 0xCD => .comm <$> getComm
+  | 0xC0 => .defn <$> getDefn
+  | 0xC1 => .indc <$> getIndc
+  | 0xC2 => .axio <$> (.mk <$> getNatl <*> getExpr)
+  | 0xC3 => .quot <$> (.mk <$> getNatl <*> getExpr <*> getQuotKind)
+  | 0xC4 => .ctorProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
+  | 0xC5 => .recrProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
+  | 0xC6 => .indcProj <$> (.mk <$> getAddr <*> getNatl)
+  | 0xC7 => .defnProj <$> (.mk <$> getAddr <*> getNatl)
+  | 0xC8 => .mutDef <$> getArray getDefn
+  | 0xC9 => .mutInd <$> getArray getIndc
+  | 0xCA => .meta <$> getMetadata
+  | 0xCB => .proof <$> getProof
+  | 0xCC => .comm <$> getComm
   | e => throw s!"expected Const tag, got {e}"
   where
-    getDefn : GetM Definition :=
-      .mk <$> getNatl <*> getExpr <*> getExpr <*> getBool
-    getCtor : GetM Constructor :=
-      .mk <$> getNatl <*> getExpr <*> getNatl <*> getNatl <*> getNatl
-    getRecrRule : GetM RecursorRule := 
-      RecursorRule.mk <$> getNatl <*> getExpr
+    getDefn : GetM Definition := do
+      let lvls <- getNatl
+      let type <- getExpr
+      let mode <- getDefMode
+      let value <- getExpr
+      let part <- getBool
+      return ⟨lvls, type, mode, value, part⟩
+    getCtor : GetM Constructor := do
+      let lvls <- getNatl
+      let type <- getExpr
+      let cidx <- getNatl
+      let params <- getNatl
+      let fields <- getNatl
+      return ⟨lvls, type, cidx, params, fields⟩
+    getRecrRule : GetM RecursorRule := RecursorRule.mk <$> getNatl <*> getExpr
     getRecr : GetM Recursor := do
-      let f ← Recursor.mk <$> getNatl <*> getExpr <*> getNatl
-        <*> getNatl <*> getNatl <*> getNatl <*> getArray getRecrRule
-      match ← getBools 2 with
-      | [x, y] => return f x y
-      | _ => throw s!"unreachable"
+      let lvls <- getNatl
+      let type <- getExpr
+      let params <- getNatl
+      let indices <- getNatl
+      let motives <- getNatl
+      let minors <- getNatl
+      let rules <- getArray getRecrRule
+      let k <- getBool
+      return ⟨lvls, type, params, indices, motives, minors, rules, k⟩
     getIndc : GetM Inductive := do
-      let f ← Inductive.mk <$> getNatl <*> getExpr <*> getNatl <*> getNatl
-        <*> getArray getCtor <*> getArray getRecr
-      match ← getBools 4 with
-      | [w, x, y, z] => return f w x y z
-      | _ => throw s!"unreachable"
+      let lvls <- getNatl
+      let type <- getExpr
+      let params <- getNatl
+      let indices <- getNatl
+      let ctors <- getArray getCtor
+      let recrs <- getArray getRecr
+      let (recr, refl) <- match ← getBools 2 with
+        | [x, y] => pure (x, y)
+        | _ => throw s!"unreachable"
+      return ⟨lvls, type, params, indices, ctors, recrs, recr, refl⟩
     getAddr : GetM Address := .mk <$> getBytes 32
     getProof : GetM Proof := do
       match (<- getUInt8) with
-      | 0 => .mk <$> (.checks <$> getAddr <*> getAddr <*> getAddr) <*> getByteArray
-      | 1 => .mk <$> (.evals <$> getAddr <*> getAddr <*> getAddr <*> getAddr) <*> getByteArray
+      | 0 => do
+        let claim <- .checks <$> getAddr <*> getAddr <*> getAddr
+        let proof <- getByteArray
+        return ⟨claim, proof⟩
+      | 1 => do
+        let claim <- .evals <$> getAddr <*> getAddr <*> getAddr <*> getAddr
+        let proof <- getByteArray
+        return ⟨claim, proof⟩
       | e => throw s!"expect proof variant tag, got {e}"
     getComm : GetM Comm :=
       .mk <$> getAddr <*> getAddr
diff --git a/Ix/Ixon/Expr.lean b/Ix/Ixon/Expr.lean
index 8db1c7e8..618e85d3 100644
--- a/Ix/Ixon/Expr.lean
+++ b/Ix/Ixon/Expr.lean
@@ -133,11 +133,11 @@ instance : Serialize Expr where
   put := runPut ∘ putExpr
   get := runGet getExpr
 
-def putArray (xs : List PutM) := do
+def putArray (xs : List PutM) : PutM := do
   putExprTag 0xB (UInt64.ofNat xs.length)
   List.forM xs id
 
-def putByteArray (x: ByteArray) := do
+def putByteArray (x: ByteArray) : PutM := do
   putExprTag 0xB (UInt64.ofNat x.size)
   x.toList.forM putUInt8
 
diff --git a/Ix/Ixon/Metadata.lean b/Ix/Ixon/Metadata.lean
index 822b98cb..0fe6bd6e 100644
--- a/Ix/Ixon/Metadata.lean
+++ b/Ix/Ixon/Metadata.lean
@@ -6,14 +6,16 @@ import Batteries.Data.RBMap
 
 namespace Ixon
 
-structure MetaNode where
-  name : Option Lean.Name
-  info : Option Lean.BinderInfo
-  link : Option Address
-  deriving BEq, Repr, Ord
+inductive Metadatum where
+| name : Lean.Name -> Metadatum
+| info : Lean.BinderInfo -> Metadatum
+| link : Address -> Metadatum
+| hints : Lean.ReducibilityHints -> Metadatum
+| all : List Lean.Name -> Metadatum
+deriving BEq, Repr, Ord, Inhabited
 
 structure Metadata where
-  map: Batteries.RBMap Nat MetaNode compare
+  map: Batteries.RBMap Nat (List Metadatum) compare
   deriving BEq, Repr
 
 inductive NamePart where
@@ -44,33 +46,32 @@ def getNamePart : GetM NamePart := do
 def putName (n: Lean.Name): PutM := putArray (putNamePart <$> (nameToParts n))
 def getName: GetM Lean.Name := nameFromParts <$> getArray getNamePart
 
-def putMetaNode: MetaNode → PutM
-| ⟨n, b, l⟩ => putArray 
-  [ putOption putName n,
-    putOption putBinderInfo b,
-    putOption (putBytes ·.hash) l
-  ]
+def putMetadatum : Metadatum → PutM
+| .name n => putUInt8 0 *> putName n
+| .info i => putUInt8 1 *> putBinderInfo i
+| .link l => putUInt8 2 *> putBytes l.hash
+| .hints h => putUInt8 3 *> putReducibilityHints h
+| .all ns => putUInt8 4 *> putArray (putName <$> ns)
 
-def getMetaNode: GetM MetaNode := do
-  let tagByte ← getUInt8
-  let tag := UInt8.shiftRight tagByte 4
-  let small := UInt8.land tagByte 0b111
-  let isLarge := (UInt8.land tagByte 0b1000 != 0)
-  match tag with
-  | 0xB => do
-    let _ ← UInt64.toNat <$> getExprTag isLarge small
-    let n ← getOption getName
-    let b ← getOption getBinderInfo
-    let l ← getOption (Address.mk <$> getBytes 32)
-    return MetaNode.mk n b l
-  | e => throw s!"expected metanode Array with tag 0xB, got {e}"
+def getMetadatum : GetM Metadatum := do
+  match (<- getUInt8) with
+  | 0 => .name <$> getName
+  | 1 => .info <$> getBinderInfo
+  | 2 => .link <$> (.mk <$> getBytes 32)
+  | 3 => .hints <$> getReducibilityHints
+  | 4 => .all <$> getArray getName
+  | e => throw s!"expected Metadatum encoding between 0 and 4, got {e}"
 
 def putMetadata (m: Metadata) : PutM := putArray (putEntry <$> m.map.toList)
   where
-    putEntry e := putNatl e.fst *> putMetaNode e.snd
+    putEntry e := putNatl e.fst *> putArray (putMetadatum <$> e.snd)
 
 def getMetadata : GetM Metadata := do
-  let xs <- getArray (Prod.mk <$> getNatl <*> getMetaNode)
+  let xs <- getArray (Prod.mk <$> getNatl <*> getArray getMetadatum)
   return Metadata.mk (Batteries.RBMap.ofList xs compare)
 
+instance : Serialize Metadatum where
+  put := runPut ∘ putMetadatum
+  get := runGet getMetadatum
+
 end Ixon
diff --git a/Ix/Ixon/Serialize.lean b/Ix/Ixon/Serialize.lean
index 13acf07e..b2fafe8c 100644
--- a/Ix/Ixon/Serialize.lean
+++ b/Ix/Ixon/Serialize.lean
@@ -1,3 +1,4 @@
+import Ix.Common
 import Lean.Declaration
 import Ix.Address
 
@@ -26,6 +27,12 @@ def runPut (putm: PutM) : ByteArray :=
 
 def putUInt8 (x: UInt8) : PutM := StateT.modifyGet (fun s => ((), s.push x))
 
+def putUInt32LE (x: UInt32) : PutM := do
+  List.forM (List.range 4) fun i =>
+    let b := UInt32.toUInt8 (x >>> (i.toUInt32 * 8))
+    putUInt8 b
+  pure ()
+
 def putUInt64LE (x: UInt64) : PutM := do
   List.forM (List.range 8) fun i =>
     let b := UInt64.toUInt8 (x >>> (i.toUInt64 * 8))
@@ -44,6 +51,13 @@ def getUInt8 : GetM UInt8 := do
   else
     throw "EOF"
 
+def getUInt32LE : GetM UInt32 := do
+  let mut x : UInt32 := 0
+  for i in List.range 4 do
+    let b ← getUInt8
+    x := x + (UInt8.toUInt32 b) <<< ((UInt32.ofNat i) * 8)
+  pure x
+
 def getUInt64LE : GetM UInt64 := do
   let mut x : UInt64 := 0
   for i in List.range 8 do
@@ -144,6 +158,18 @@ def getQuotKind : GetM Lean.QuotKind := do
   | 3 => return .ind
   | e => throw s!"expected QuotKind encoding between 0 and 3, got {e}"
 
+def putDefMode : Ix.DefMode → PutM
+| .«definition» => putUInt8 0
+| .«opaque» => putUInt8 1
+| .«theorem» => putUInt8 2
+
+def getDefMode : GetM Ix.DefMode := do
+  match (← getUInt8) with
+  | 0 => return .definition
+  | 1 => return .opaque
+  | 2 => return .theorem
+  | e => throw s!"expected DefMode encoding between 0 and 3, got {e}"
+
 def putBinderInfo : Lean.BinderInfo → PutM
 | .default => putUInt8 0
 | .implicit => putUInt8 1
@@ -156,6 +182,18 @@ def getBinderInfo : GetM Lean.BinderInfo := do
   | 1 => return .implicit
   | 2 => return .strictImplicit
   | 3 => return .instImplicit
-  | e => throw s!"expected QuotKind encoding between 0 and 3, got {e}"
+  | e => throw s!"expected BinderInfo encoding between 0 and 3, got {e}"
+
+def putReducibilityHints : Lean.ReducibilityHints → PutM
+| .«opaque» => putUInt8 0
+| .«abbrev» => putUInt8 1
+| .regular x => putUInt8 2 *> putUInt32LE x
+
+def getReducibilityHints : GetM Lean.ReducibilityHints := do
+  match (← getUInt8) with
+  | 0 => return .«opaque»
+  | 1 => return .«abbrev» 
+  | 2 => .regular <$> getUInt32LE
+  | e => throw s!"expected ReducibilityHints encoding between 0 and 2, got {e}"
 
 end Ixon
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index de235d80..253c74ce 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -1,8 +1,6 @@
-import Ix.IR.Univ
+import Ix.IR
 import Ix.Ixon.Univ
-import Ix.IR.Expr
 import Ix.Ixon.Expr
-import Ix.IR.Const
 import Ix.Ixon.Const
 import Ix.Common
 import Ix.Address
@@ -50,11 +48,11 @@ structure RematCtx where
 
 abbrev RematM := ReaderT RematCtx (EStateM TransportError RematState)
 
-def countSucc : Ix.Univ -> Nat -> (Nat × Ix.Univ)
+def countSucc : Ix.Level -> Nat -> (Nat × Ix.Level)
 | .succ x, i => countSucc x (.succ i)
 | n, i => (i, n)
 
-def unrollSucc : Nat -> Ix.Univ -> Ix.Univ
+def unrollSucc : Nat -> Ix.Level -> Ix.Level
 | 0, x => x
 | .succ i, x => unrollSucc i (.succ x)
 
@@ -70,22 +68,22 @@ def dematIncrN (x: Nat) : DematM Nat := do
 
 def dematIncr : DematM Nat := dematIncrN 1
 
-def dematMeta (node: Ixon.MetaNode): DematM Unit := do
+def dematMeta (node: List Ixon.Metadatum): DematM Unit := do
   let n <- (·.idx) <$> get
   modify fun stt =>
     { stt with meta :=
       { stt.meta with map := stt.meta.map.insert n node } }
 
-partial def dematUniv : Ix.Univ -> DematM Ixon.Univ
+partial def dematUniv : Ix.Level -> DematM Ixon.Univ
 | .zero => dematIncr *> return .const 0
 | .succ x => match countSucc x 1 with
   | (i, .zero) => dematIncrN (i + 1) *> .const <$> dematNat i
   | (i, x) => dematIncrN (i + 1) *> .add <$> dematNat i <*> dematUniv x
 | .max x y => dematIncr *> .max <$> dematUniv x <*> dematUniv y
 | .imax x y => dematIncr *> .imax <$> dematUniv x <*> dematUniv y
-| .var n i => do
+| .param n i => do
   let _ <- dematIncr
-  dematMeta { name := .some n, info := .none, link := .none }
+  dematMeta [.name n]
   .var <$> dematNat i
 
 partial def dematLevels (lvls: List Lean.Name): DematM Nat :=
@@ -94,7 +92,7 @@ partial def dematLevels (lvls: List Lean.Name): DematM Nat :=
     go (acc: Nat) : List Lean.Name -> DematM Nat
     | n::ns => do
       let _ <- dematIncr
-      dematMeta { name := .some n, info := .none, link := .none}
+      dematMeta [.name n]
       go (acc+1) ns
     | [] => pure acc
 
@@ -105,14 +103,14 @@ def rematIncrN (x: Nat) : RematM Nat := do
 
 def rematIncr : RematM Nat := rematIncrN 1
 
-def rematMeta : RematM Ixon.MetaNode := do
+def rematMeta : RematM (List Ixon.Metadatum) := do
   let n <- (·.idx) <$> get
   let m <- (·.meta) <$> read
   match m.map.find? n with
   | .some n => return n
   | .none => throw (.unknownIndex n m)
 
-def rematThrowUnexpectedNode : RematM α := do
+def rematThrowUnexpected : RematM α := do
   let n <- (·.idx) <$> get
   let m <- (·.meta) <$> read
   throw (.unexpectedNode n m)
@@ -124,18 +122,16 @@ partial def rematLevels (lvls: Nat): RematM (List Lean.Name) := do
     | 0 => pure acc.reverse
     | i => do
       let _ <- rematIncr
-      let node <- rematMeta
-      match node.name, node.info, node.link with
-      | .some n, .none, .none => go (n::acc) (i - 1)
-      | _, _, _ => rematThrowUnexpectedNode
+      match (<- rematMeta) with
+      | [.name n] => go (n::acc) (i - 1)
+      | _ => rematThrowUnexpected
 
 def rematBindMeta : RematM (Lean.Name × Lean.BinderInfo) := do
-  let n <- rematMeta
-  match n.name, n.info with
-  | .some n, some i => return (n, i)
-  | _, _ => rematThrowUnexpectedNode
+  match (<- rematMeta) with
+  | [.name n, .info i] => return (n, i)
+  | _ => rematThrowUnexpected
 
-def rematUniv : Ixon.Univ -> RematM Ix.Univ
+def rematUniv : Ixon.Univ -> RematM Ix.Level
 | .const i => do
   let i' := UInt64.toNat i
   rematIncrN (i' + 1) *> return (unrollSucc i') .zero
@@ -145,36 +141,35 @@ def rematUniv : Ixon.Univ -> RematM Ix.Univ
 | .max x y => rematIncr *> .max <$> rematUniv x <*> rematUniv y
 | .imax x y => rematIncr *> .imax <$> rematUniv x <*> rematUniv y
 | .var x => do
-  let k <- rematIncr
-  let mn <- rematMeta
-  match mn.name with
-  | .some name => return .var name (UInt64.toNat x)
-  | .none => read >>= fun ctx => throw (.unexpectedNode k ctx.meta)
+  let _ <- rematIncr
+  match (<- rematMeta) with
+  | [.name name] => return .param name (UInt64.toNat x)
+  | _ => rematThrowUnexpected
 
 partial def dematExpr : Ix.Expr -> DematM Ixon.Expr
 | .var i => dematIncr *> .vari <$> dematNat i
 | .sort u => dematIncr *> .sort <$> dematUniv u
 | .const n r m us => do
   let _ <- dematIncr
-  dematMeta { name := .some n, info := .none, link := .some m }
+  dematMeta [.name n, .link m ]
   .cnst r <$> (us.mapM dematUniv)
 | .rec_ n i us => do
   let _ <- dematIncr
-  dematMeta { name := .some n, info := .none, link := .none}
+  dematMeta [.name n]
   .rec_ <$> dematNat i <*> (us.mapM dematUniv)
 | .app f a => apps f a []
 | .lam n i t b => lams (.lam n i t b) []
 | .pi n i t b => alls (.pi n i t b) []
 | .letE n t v b nD => do
   let _ <- dematIncr
-  dematMeta { name := .some n, info := .none, link := none }
+  dematMeta [.name n]
   .let_ nD <$> dematExpr t <*> dematExpr v <*> dematExpr b
 | .lit l => dematIncr *> match l with
   | .strVal s => return .strl s
   | .natVal n => return .natl n
 | .proj n t tM i s => do
   let _ <- dematIncr
-  dematMeta { name := .some n, info := .none, link := .some tM }
+  dematMeta [.name n, .link tM ]
   .proj t <$> dematNat i <*> dematExpr s
   where
     apps : Ix.Expr -> Ix.Expr -> List Ix.Expr -> DematM Ixon.Expr
@@ -185,14 +180,14 @@ partial def dematExpr : Ix.Expr -> DematM Ixon.Expr
     lams : Ix.Expr -> List Ixon.Expr -> DematM Ixon.Expr
     | .lam n i t b, ts => do
       let _ <- dematIncr
-      dematMeta { name := .some n, info := .some i, link := .none}
+      dematMeta [.name n, .info i]
       let t' <- dematExpr t
       lams b (t'::ts)
     | x, ts => .lams ts.reverse <$> dematExpr x
     alls : Ix.Expr -> List Ixon.Expr -> DematM Ixon.Expr
     | .pi n i t b, ts => do
       let _ <- dematIncr
-      dematMeta { name := .some n, info := .some i, link := .none}
+      dematMeta [.name n, .info i]
       let t' <- dematExpr t
       alls b (t'::ts)
     | x, ts => .alls ts.reverse <$> dematExpr x
@@ -204,16 +199,16 @@ partial def rematExpr : Ixon.Expr -> RematM Ix.Expr
   let _ <- rematIncr
   let node <- rematMeta
   let us' <- us.mapM rematUniv
-  match node.name, node.link with
-  | .some name, .some link => return (.const name adr link us')
-  | _, _ => rematThrowUnexpectedNode
+  match node with
+  | [.name name, .link link] => return (.const name adr link us')
+  | _ => rematThrowUnexpected
 | .rec_ i us => do 
   let _ <- rematIncr
   let node <- rematMeta
   let us' <- us.mapM rematUniv
-  match node.name with
-  | .some name => return (.rec_ name i.toNat us')
-  | _ => rematThrowUnexpectedNode
+  match node with
+  | [.name name] => return (.rec_ name i.toNat us')
+  | _ => rematThrowUnexpected
 | .apps f a as => do
   let as' <- as.reverse.mapM (fun e => rematIncr *> rematExpr e)
   let f' <- rematExpr f
@@ -231,80 +226,80 @@ partial def rematExpr : Ixon.Expr -> RematM Ix.Expr
   return ts'.foldr (fun (m, t) b => Expr.pi m.fst m.snd t b) b'
 | .let_ nD t d b => do
   let _ <- rematIncr
-  let m <- (·.name) <$> rematMeta
-  let name <- match m with
-    | .some m => pure m
-    | _ => rematThrowUnexpectedNode
+  let node <- rematMeta
+  let name <- match node with
+    | [.name n] => pure n
+    | _ => rematThrowUnexpected
   .letE name <$> rematExpr t <*> rematExpr d <*> rematExpr b <*> pure nD
 | .proj t i s => do
   let _ <- rematIncr
-  let m <- rematMeta
-  let (name, link) <- match m.name, m.link with
-    | .some n, .some l => pure (n, l)
-    | _, _ => rematThrowUnexpectedNode
+  let node <- rematMeta
+  let (name, link) <- match node with
+    | [.name n, .link l] => pure (n, l)
+    | _ => rematThrowUnexpected
   .proj name t link i.toNat <$> rematExpr s
 | .strl s => rematIncr *> return .lit (.strVal s)
 | .natl n => rematIncr *> return .lit (.natVal n)
 
 partial def dematConst : Ix.Const -> DematM Ixon.Const
 | .«axiom» x => do
-  let lvls <- dematLevels x.lvls
+  let lvls <- dematLevels x.levelParams
   let type <- dematExpr x.type
   return .axio (.mk lvls type)
-| .«theorem» x => do
-  let lvls <- dematLevels x.lvls
-  let type <- dematExpr x.type
-  let value <- dematExpr x.value
-  return .theo (.mk lvls type value)
-| .«opaque» x => do
-  let lvls <- dematLevels x.lvls
-  let type <- dematExpr x.type
-  let value <- dematExpr x.value
-  return .opaq (.mk lvls type value)
 | .«definition» x => .defn <$> dematDefn x
+| .«inductive» x => .indc <$> dematIndc x
 | .quotient x => do
-  let lvls <- dematLevels x.lvls
+  let lvls <- dematLevels x.levelParams
   let type <- dematExpr x.type
   return .quot (.mk lvls type x.kind)
 | .inductiveProj x => do
-  dematMeta { name := .none, info := .none, link := .some x.blockMeta}
+  dematMeta [.link x.blockMeta]
   return .indcProj (.mk x.blockCont x.idx)
 | .constructorProj x => do
-  dematMeta { name := .none, info := .none, link := .some x.blockMeta}
+  dematMeta [.link x.blockMeta]
   return .ctorProj (.mk x.blockCont x.idx x.cidx)
 | .recursorProj x => do
-  dematMeta { name := .none, info := .none, link := .some x.blockMeta}
+  dematMeta [.link x.blockMeta]
   return .recrProj (.mk x.blockCont x.idx x.ridx)
 | .definitionProj x => do
-  dematMeta { name := .none, info := .none, link := .some x.blockMeta}
+  dematMeta [.link x.blockMeta]
   return .defnProj (.mk x.blockCont x.idx)
 | .mutDefBlock xs => .mutDef <$> (xs.mapM dematDefn)
-| .mutIndBlock xs => .mutInd <$> (xs.mapM dematInd)
+| .mutIndBlock xs => .mutInd <$> (xs.mapM dematIndc)
   where
-    dematDefn : Ix.Definition -> DematM Ixon.Definition
-    | x => do
-      let lvls <- dematLevels x.lvls 
+    dematDefn (x: Ix.Definition): DematM Ixon.Definition := do
+      let _ <- dematIncr
+      dematMeta [.hints x.hints, .all x.all]
+      let lvls <- dematLevels x.levelParams
       let type <- dematExpr x.type
       let value <- dematExpr x.value
-      return .mk lvls type value x.part
-    dematCtor : Ix.Constructor -> DematM Ixon.Constructor
-    | x => do
-      let lvls <- dematLevels x.lvls
+      return .mk lvls type x.mode value x.isPartial
+    dematCtor (x: Ix.Constructor): DematM Ixon.Constructor := do
+      let _ <- dematIncr
+      dematMeta [.name x.name]
+      let lvls <- dematLevels x.levelParams
       let t <- dematExpr x.type
-      return .mk lvls t x.idx x.params x.fields
-    dematRecr : Ix.Recursor -> DematM Ixon.Recursor
-    | x => do
-      let lvls <- dematLevels x.lvls
+      return .mk lvls t x.cidx x.numParams x.numFields
+    dematRecrRule (x: Ix.RecursorRule): DematM Ixon.RecursorRule := do
+      let _ <- dematIncr
+      dematMeta [.name x.ctor]
+      let rhs <- dematExpr x.rhs
+      return ⟨x.nfields, rhs⟩
+    dematRecr (x: Ix.Recursor): DematM Ixon.Recursor := do
+      let _ <- dematIncr
+      dematMeta [.name x.name]
+      let lvls <- dematLevels x.levelParams
       let t <- dematExpr x.type
-      let rrs <- x.rules.mapM (fun rr => .mk rr.fields <$> dematExpr rr.rhs)
-      return .mk lvls t x.params x.indices x.motives x.minors rrs x.isK x.internal
-    dematInd : Ix.Inductive -> DematM Ixon.Inductive
-    | x => do
+      let rrs <- x.rules.mapM dematRecrRule
+      return .mk lvls t x.numParams x.numIndices x.numMotives x.numMinors rrs x.k
+    dematIndc (x: Ix.Inductive): DematM Ixon.Inductive := do
+      let _ <- dematIncr
+      dematMeta [.all x.all]
       let lvls <- dematLevels x.lvls
       let t <- dematExpr x.type
       let cs <- x.ctors.mapM dematCtor
       let rs <- x.recrs.mapM dematRecr
-      return .mk lvls t x.params x.indices cs rs x.recr x.refl x.struct x.unit
+      return .mk lvls t x.numParams x.numIndices cs rs x.isRec x.isReflexive
 
 def constToIxon (x: Ix.Const) : Except TransportError (Ixon.Const × Ixon.Const) := 
   match EStateM.run (dematConst x) emptyDematState with
@@ -320,67 +315,85 @@ def constAddress (x: Ix.Const) : Except TransportError Address := do
   return Address.blake3 bs
 
 partial def rematConst : Ixon.Const -> RematM Ix.Const
+| .defn x => .«definition» <$> rematDefn x
+| .indc x => .«inductive» <$> rematIndc x
 | .axio x => do
   let lvls <- rematLevels x.lvls
   let type <- rematExpr x.type
-  return .«axiom» (.mk lvls type)
-| .theo x => do
-  let lvls <- rematLevels x.lvls
-  let type <- rematExpr x.type
-  let value <- rematExpr x.value
-  return .«theorem» (.mk lvls type value)
-| .opaq x => do
-  let lvls <- rematLevels x.lvls
-  let type <- rematExpr x.type
-  let value <- rematExpr x.value
-  return .«opaque» (.mk lvls type value)
-| .defn x => .«definition» <$> rematDefn x
+  return .«axiom» ⟨lvls, type⟩
 | .quot x => do
   let lvls <- rematLevels x.lvls
   let type <- rematExpr x.type
-  return .quotient (.mk lvls type x.kind)
+  return .quotient ⟨lvls, type, x.kind⟩
 | .indcProj x => do
-  let link <- rematMeta >>= fun m => m.link.elim rematThrowUnexpectedNode pure
+  let link <- match (<- rematMeta) with
+    | [.link x] => pure x
+    | _ => rematThrowUnexpected
   return .inductiveProj (.mk x.block link x.idx)
 | .ctorProj x => do
-  let link <- rematMeta >>= fun m => m.link.elim rematThrowUnexpectedNode pure
+  let link <- match (<- rematMeta) with
+    | [.link x] => pure x
+    | _ => rematThrowUnexpected
   return .constructorProj (.mk x.block link x.idx x.cidx)
 | .recrProj x => do
-  let link <- rematMeta >>= fun m => m.link.elim rematThrowUnexpectedNode pure
+  let link <- match (<- rematMeta) with
+    | [.link x] => pure x
+    | _ => rematThrowUnexpected
   return .recursorProj (.mk x.block link x.idx x.ridx)
 | .defnProj x => do
-  let link <- rematMeta >>= fun m => m.link.elim rematThrowUnexpectedNode pure
+  let link <- match (<- rematMeta) with
+    | [.link x] => pure x
+    | _ => rematThrowUnexpected
   return .definitionProj (.mk x.block link x.idx)
 | .mutDef xs => .mutDefBlock <$> (xs.mapM rematDefn)
-| .mutInd xs => .mutIndBlock <$> (xs.mapM rematInd)
+| .mutInd xs => .mutIndBlock <$> (xs.mapM rematIndc)
 | .meta m => throw (.rawMetadata m)
 -- TODO: This could return a Proof inductive, since proofs have no metadata
 | .proof p => throw (.rawProof p)
 | .comm p => throw (.rawComm p)
   where
-    rematDefn : Ixon.Definition -> RematM Ix.Definition
-    | x => do
+    rematDefn (x: Ixon.Definition) : RematM Ix.Definition := do
+      let _ <- rematIncr
+      let (hints, all) <- match (<- rematMeta) with
+        | [.hints h, .all as] => pure (h, as)
+        | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
       let type <- rematExpr x.type
       let value <- rematExpr x.value
-      return .mk lvls type value x.part
-    rematCtor : Ixon.Constructor -> RematM Ix.Constructor
-    | x => do
+      return .mk lvls type x.mode value hints x.part all
+    rematCtor (x: Ixon.Constructor) : RematM Ix.Constructor := do
+      let _ <- rematIncr
+      let name <- match (<- rematMeta) with
+        | [.name n] => pure n
+        | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
-      return .mk lvls t x.idx x.params x.fields
-    rematRecr : Ixon.Recursor -> RematM Ix.Recursor
-    | x => do
+      return .mk name lvls t x.cidx x.params x.fields
+    rematRecrRule (x: Ixon.RecursorRule) : RematM Ix.RecursorRule := do
+      let _ <- rematIncr
+      let ctor <- match (<- rematMeta) with
+        | [.name n] => pure n
+        | _ => rematThrowUnexpected
+      let rhs <- rematExpr x.rhs
+      return ⟨ctor, x.fields, rhs⟩
+    rematRecr (x: Ixon.Recursor) : RematM Ix.Recursor := do
+      let _ <- rematIncr
+      let name <- match (<- rematMeta) with
+        | [.name n] => pure n
+        | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
-      let rrs <- x.rules.mapM (fun rr => .mk rr.fields <$> rematExpr rr.rhs)
-      return .mk lvls t x.params x.indices x.motives x.minors rrs x.isK x.internal
-    rematInd : Ixon.Inductive -> RematM Ix.Inductive
-    | x => do
+      let rs <- x.rules.mapM rematRecrRule
+      return ⟨name, lvls, t, x.params, x.indices, x.motives, x.minors, rs, x.k⟩
+    rematIndc (x: Ixon.Inductive) : RematM Ix.Inductive := do
+      let _ <- rematIncr
+      let all <- match (<- rematMeta) with
+        | [.all as] => pure as
+        | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
       let cs <- x.ctors.mapM rematCtor
       let rs <- x.recrs.mapM rematRecr
-      return .mk lvls t x.params x.indices cs rs x.recr x.refl x.struct x.unit
+      return ⟨lvls, t, x.params, x.indices, all, cs, rs, x.recr, x.refl⟩
 
 end Ix.TransportM
diff --git a/STYLE.md b/STYLE.md
new file mode 100644
index 00000000..513356bb
--- /dev/null
+++ b/STYLE.md
@@ -0,0 +1,38 @@
+# Ix Style Guide
+
+Keep all lines under 80 columns. This is restrictive, but is the only way to
+ensure readability in every environment.
+
+Indent using two-spaces, never put tabs in a source file.
+
+Structure declarations should not align the type-signatures of their parameters.
+Prefer
+
+```lean
+structure Foo where
+  parameterAcme : A
+  condition1 : B
+```
+
+over
+
+```lean4
+structure Foo where
+  parameterAcme : A
+  condition1    : B
+```
+
+Minimize usage of unicode where ascii equivalents exist. Prefer
+
+```lean4
+def foo (A: Type) (x: A) : Foo -> Bar
+| foo => bar
+```
+
+over
+
+```
+def foo (α: Type) (x: α) : Foo → Bar
+| foo => bar
+```
+
diff --git a/Tests/Ix.lean b/Tests/Ix.lean
index dd8f83cd..c8369dba 100644
--- a/Tests/Ix.lean
+++ b/Tests/Ix.lean
@@ -1,5 +1,6 @@
 import LSpec
 import Ix.Ixon
+import Ix.Ixon.Metadata
 import Ix.Address
 import Ix.Ixon.Serialize
 import Ix.Ixon.Univ
@@ -8,6 +9,8 @@ import LSpec.SlimCheck.Gen
 import LSpec
 import Blake3
 
+import Tests.Common
+import Tests.Ix.Common
 import Tests.Ix.Ixon
 import Tests.Ix.IR
 
@@ -22,7 +25,7 @@ def serde [Ixon.Serialize A] [BEq A] (x: A) : Bool :=
 
 open Ix.TransportM
 
-def transportUniv (univ: Ix.Univ): Bool :=
+def transportUniv (univ: Ix.Level): Bool :=
   match EStateM.run (dematUniv univ) emptyDematState with
   | .ok ixon stt =>
     let remat := (ReaderT.run (rematUniv ixon) { meta := stt.meta})
@@ -75,10 +78,12 @@ def transportConst (x: Ix.Const): Bool :=
 --  testExprs.foldl (init := .done) fun tSeq x =>
 --    tSeq ++ (test s!"transport {repr x}" $ Except.isOk (transportExpr' x))
 
+
 def Tests.Ix.suite : List LSpec.TestSeq :=
   [
+    check "metadatum serde" (∀ x : Ixon.Metadatum, serde x),
     check "universe serde" (∀ x : Ixon.Univ, serde x),
-    check "universe transport" (∀ x : Ix.Univ, transportUniv x),
+    check "universe transport" (∀ x : Ix.Level, transportUniv x),
     check "expr serde" (∀ x : Ixon.Expr, serde x),
     check "expr transport" (∀ x : Ix.Expr, transportExpr x),
     check "const serde" (∀ x : Ixon.Const, serde x),
diff --git a/Tests/Ix/Common.lean b/Tests/Ix/Common.lean
index 438a725a..332c2363 100644
--- a/Tests/Ix/Common.lean
+++ b/Tests/Ix/Common.lean
@@ -1,4 +1,5 @@
 import LSpec
+import Ix.Common
 import Ix.Ixon
 import Ix.Address
 import Ix.Ixon.Serialize
@@ -65,6 +66,18 @@ def genBinderInfo : Gen Lean.BinderInfo := oneOf'
    , pure .instImplicit
    ]
 
+def genDefMode : Gen Ix.DefMode := oneOf'
+   [ pure .opaque
+   , pure .theorem
+   , pure .definition
+   ]
+
+def genReducibilityHints : Gen Lean.ReducibilityHints := oneOf'
+   [ pure .opaque
+   , pure .abbrev
+   , (.regular ·.toUInt32) <$> genUSize
+   ]
+
 def genQuotKind : Gen Lean.QuotKind := oneOf'
    [ pure .type
    , pure .ctor
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index 66f0e477..aa0d5ade 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -1,3 +1,4 @@
+import Ix.Common
 import Ix.IR
 
 import LSpec.SlimCheck.Gen
@@ -12,23 +13,23 @@ open SlimCheck.Gen
 
 namespace Ix
 
-def genUniv : Gen Ix.Univ := getSize >>= go
+def genLevel : Gen Ix.Level := getSize >>= go
   where
-    go : Nat -> Gen Ix.Univ
+    go : Nat -> Gen Ix.Level
     | 0 => return .zero
     | Nat.succ f =>
       frequency [
         (100, return .zero),
-        (100, .var <$> genName <*> genNatUSize),
+        (100, .param <$> genName <*> genNatUSize),
         (50, .succ <$> go f),
         (25, .max <$> go f <*> go f),
         (25, .imax <$> go f <*> go f)
       ]
 
-instance : Shrinkable Ix.Univ where
+instance : Shrinkable Ix.Level where
   shrink _ := []
 
-instance : SampleableExt Ix.Univ := SampleableExt.mkSelfContained genUniv
+instance : SampleableExt Ix.Level := SampleableExt.mkSelfContained genLevel
 
 def genExpr : Gen Ix.Expr := getSize >>= go
   where
@@ -37,9 +38,9 @@ def genExpr : Gen Ix.Expr := getSize >>= go
     | Nat.succ f =>
       frequency [
         (100, .var <$> genNatUSize),
-        (100, .sort <$> genUniv),
-        (50, .const <$> genName <*> genAddress <*> genAddress <*> resizeListOf genUniv),
-        (50, .rec_ <$> genNat' <*> resizeListOf genUniv),
+        (100, .sort <$> genLevel),
+        (50, .const <$> genName <*> genAddress <*> genAddress <*> resizeListOf genLevel),
+        (50, .rec_ <$> genName <*> genNat' <*> resizeListOf genLevel),
         (50, .app <$> go f <*> go f),
         (50, .lam <$> genName <*> genBinderInfo <*> go f <*> go f),
         (50, .pi <$> genName <*> genBinderInfo <*> go f <*> go f),
@@ -57,26 +58,39 @@ instance : SampleableExt Ix.Expr := SampleableExt.mkSelfContained genExpr
 
 def genConst : Gen Ix.Const := getSize >>= go
   where
-    genDef : Gen Ix.Definition := .mk <$> genNat' <*> genExpr <*> genExpr <*> genBool
+    genNames : Gen (List Lean.Name) := resizeListOf genName
+    genDef : Gen Ix.Definition := do
+      let lvls <- genNames
+      let type <- genExpr
+      let mode <- genDefMode
+      let value <- genExpr
+      let hints <- genReducibilityHints
+      let isPartial <- genBool
+      let all <- genNames
+      return ⟨lvls, type, mode, value, hints, isPartial, all⟩
     genCtor : Gen Ix.Constructor := 
-      .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat'
+      .mk <$> genName <*> genNames <*> genExpr <*> genNat' <*> genNat' <*> genNat'
     genRecr : Gen Ix.Recursor := 
-      .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat' <*> genNat'
-        <*> resizeListOf (.mk <$> genNat' <*> genExpr)
-        <*> genBool <*> genBool
-    genInd : Gen Ix.Inductive := 
-      .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat'
-        <*> resizeListOf genCtor <*> resizeListOf genRecr
-        <*> genBool <*> genBool <*> genBool <*> genBool
+      .mk <$> genName <*> genNames <*> genExpr <*> genNat' <*> genNat' <*> genNat' <*> genNat'
+        <*> resizeListOf (.mk <$> genName <*> genNat' <*> genExpr)
+        <*> genBool
+    genInd : Gen Ix.Inductive := do
+      let lvls <- genNames
+      let type <- genExpr
+      let params <- genNat'
+      let indices <- genNat'
+      let all <- genNames
+      let ctors <- resizeListOf genCtor
+      let recrs <- resizeListOf genRecr
+      let (isRec, isRefl) <- Prod.mk <$> genBool <*> genBool
+      return ⟨lvls, type, params, indices, all, ctors, recrs, isRec, isRefl⟩
     go : Nat -> Gen Ix.Const
-    | 0 => return .«axiom» (.mk 0 (Ix.Expr.sort (Ix.Univ.zero)))
+    | 0 => return .«axiom» (.mk [] (Ix.Expr.sort (Ix.Level.zero)))
     | Nat.succ _ =>
       frequency [
-        (100, .«axiom» <$> (.mk <$> genNat' <*> genExpr)),
-        (100, .«theorem» <$> (.mk <$> genNat' <*> genExpr <*> genExpr)),
-        (100, .«opaque» <$> (.mk <$> genNat' <*> genExpr <*> genExpr)),
+        (100, .«axiom» <$> (.mk <$> genNames <*> genExpr)),
         (100, .«definition» <$> genDef),
-        (100, .quotient <$> (.mk <$> genNat' <*> genExpr <*> genQuotKind)),
+        (100, .quotient <$> (.mk <$> genNames <*> genExpr <*> genQuotKind)),
         (100, .inductiveProj <$> (.mk <$> genAddress <*> genAddress <*> genNat')),
         (100, .constructorProj <$> (.mk <$> genAddress <*> genAddress <*> genNat' <*> genNat')),
         (100, .recursorProj <$> (.mk <$> genAddress <*> genAddress <*> genNat' <*> genNat')),
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index e64cafb3..f17b1d33 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -16,9 +16,9 @@ open Ixon
 
 namespace Ixon
 
-def genUniv : SlimCheck.Gen Ixon.Univ := getSize >>= go
+def genUniv : Gen Ixon.Univ := getSize >>= go
   where
-    go : Nat -> SlimCheck.Gen Ixon.Univ
+    go : Nat -> Gen Ixon.Univ
     | 0 => return .const 0
     | Nat.succ f =>
       frequency [
@@ -64,20 +64,41 @@ instance : SampleableExt Expr := SampleableExt.mkSelfContained genExpr
 
 -- Metadata
 
-def genMetaNode : Gen MetaNode := 
-  .mk <$> genOption genName <*> genOption genBinderInfo <*> genOption genAddress
+
+def genMetadatum : Gen Ixon.Metadatum := 
+  frequency [
+    (100, .name <$> genName),
+    (100, .info <$> genBinderInfo),
+    (100, .link <$> genAddress),
+    (100, .hints <$> genReducibilityHints),
+    (25, .all <$> genList' genName),
+  ]
+
+instance : Shrinkable Metadatum where
+  shrink _ := []
+
+instance : SampleableExt Metadatum :=
+  SampleableExt.mkSelfContained genMetadatum
+
+def genMetaNode : Gen (List Metadatum) := 
+  genList' genMetadatum
 
 def genMetadata : Gen Metadata := do
   let xs ← genList' genMetaNode
   return .mk (Batteries.RBMap.ofList ((List.range xs.length).zip xs) compare)
 
+
 -- Const
 
 def genAxiom : Gen Axiom := .mk <$> genNat' <*> genExpr
-def genTheorem : Gen Theorem := .mk <$> genNat' <*> genExpr <*> genExpr
-def genOpaque : Gen Opaque := .mk <$> genNat' <*> genExpr <*> genExpr
-def genDefinition : Gen Definition := 
-  .mk <$> genNat' <*> genExpr <*> genExpr <*> genBool
+
+def genDefinition : Gen Definition := do
+  let lvls <- genNat'
+  let type <- genExpr
+  let mode <- genDefMode
+  let value <- genExpr
+  let isPartial <- genBool
+  return .mk lvls type mode value isPartial
 
 def genConstructor : Gen Constructor :=
   .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat'
@@ -86,12 +107,12 @@ def genRecursorRule : Gen RecursorRule := .mk <$> genNat' <*> genExpr
 
 def genRecursor : Gen Recursor :=
   .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat'
-    <*> genNat' <*> genList' genRecursorRule <*> genBool <*> genBool
+    <*> genNat' <*> genList' genRecursorRule <*> genBool
 
 def genInductive : Gen Inductive :=
   .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat'
     <*> genList' genConstructor <*> genList' genRecursor
-    <*> genBool <*> genBool <*> genBool <*> genBool 
+    <*> genBool <*> genBool
 
 def genConstructorProj : Gen ConstructorProj :=
   .mk <$> genAddress <*> genNat' <*> genNat'
@@ -113,8 +134,6 @@ def genConst : Gen Ixon.Const := getSize >>= go
     | Nat.succ _ =>
       frequency [
         (100, .axio <$> genAxiom),
-        (100, .theo <$> genTheorem),
-        (100, .opaq <$> genOpaque),
         (100, .defn <$> genDefinition),
         --(100, .ctor <$> genConstructor),
         --(100, .recr <$> genRecursor),

From 3de279ec66f9dc4b6c52ac9a9ced57476f29fde5 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sat, 3 May 2025 02:38:38 -0400
Subject: [PATCH 18/74] implement decompilation mutdefs, compilation of mixed
 mutdefs, and tests for new mutdef format

---
 Ix/CompileM.lean      | 139 ++++++++++++++++++++++++++++++++++++++----
 Ix/DecompileM.lean    |  86 +++++++++++++++++++-------
 Ix/IR.lean            |  10 ++-
 Ix/Ixon/Const.lean    |  15 +++--
 Ix/Ixon/Expr.lean     |  13 +++-
 Ix/Ixon/Metadata.lean |  11 ++--
 Ix/TransportM.lean    |  40 +++++++++---
 Tests/Ix/Common.lean  |   4 ++
 Tests/Ix/IR.lean      |  11 +++-
 Tests/Ix/Ixon.lean    |   2 +-
 10 files changed, 269 insertions(+), 62 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index f289dc67..8ad73350 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -278,23 +278,51 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
     return (anonAddr, metaAddr)
   -- Collecting and sorting all definitions in the mutual block
   -- TODO: This needs to support mutual blocks that include theorems and opaques
-  let mutualDefs <- struct.all.mapM fun name => do
-    match <- findLeanConst name with
-      | .defnInfo defn => pure defn
-      | const => 
-        throw $ .invalidConstantKind const.name "definition" const.ctorName
-  let mutualDefs <- sortDefs [mutualDefs]
+  let mut mutDefs : Array Lean.DefinitionVal := #[]
+  let mut mutOpaqs : Array Lean.OpaqueVal := #[]
+  let mut mutTheos : Array Lean.TheoremVal := #[]
+  for n in struct.all do
+    match <- findLeanConst n with
+      | .defnInfo x => mutDefs := mutDefs.push x
+      | .opaqueInfo x => mutOpaqs := mutOpaqs.push x
+      | .thmInfo x => mutTheos := mutTheos.push x
+      | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
+  let mutualDefs <- sortDefs [mutDefs.toList]
+  let mutualOpaqs <- sortOpaqs [mutOpaqs.toList]
+  let mutualTheos <- sortTheos [mutTheos.toList]
   -- Building the `mutCtx`
   let mut mutCtx := default
-  for (ds, i) in List.zipIdx mutualDefs do
+  let mut names := #[]
+  let mut i := 0
+  for ds in mutualDefs do
+    let mut x := #[]
     for d in ds do
+      x := x.push d.name
       mutCtx := mutCtx.insert d.name i
-  let definitions ← withMutCtx mutCtx $ mutualDefs.mapM (·.mapM definitionToIR)
+    names := names.push x.toList
+    i := i + 1
+  for ds in mutualOpaqs do
+    let mut x := #[]
+    for d in ds do
+      x := x.push d.name
+      mutCtx := mutCtx.insert d.name i
+    names := names.push x.toList
+    i := i + 1
+  for ds in mutualTheos do
+    let mut x := #[]
+    for d in ds do
+      x := x.push d.name
+      mutCtx := mutCtx.insert d.name i
+    names := names.push x.toList
+    i := i + 1
+  let defnDefs ← withMutCtx mutCtx $ mutualDefs.mapM (·.mapM definitionToIR)
+  let opaqDefs ← withMutCtx mutCtx $ mutualOpaqs.mapM (·.mapM opaqueToIR)
+  let theoDefs ← withMutCtx mutCtx $ mutualTheos.mapM (·.mapM theoremToIR)
   -- Building and storing the block
   -- TODO: check if this flatten call actually makes sense
-  let definitionsIR := (definitions.map (match ·.head? with
-    | some d => [d] | none => [])).flatten
-  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .mutDefBlock definitionsIR
+  let definitions := defnDefs ++ opaqDefs ++ theoDefs
+  let (blockAnonAddr, blockMetaAddr) ← 
+    hashConst $ .mutDefBlock ⟨definitions, names.toList⟩
   modify fun stt =>
     { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
   -- While iterating on the definitions from the mutual block, we need to track
@@ -322,6 +350,18 @@ partial def definitionToIR (defn: Lean.DefinitionVal)
   let mode := .definition
   return ⟨defn.levelParams, type, mode, value, defn.hints, isPartial, defn.all⟩
 
+partial def opaqueToIR (opaq: Lean.OpaqueVal)
+  : CompileM Ix.Definition := do
+  let type <- compileExpr opaq.type
+  let value <- compileExpr opaq.value
+  return mkOpaque opaq.levelParams type value opaq.all
+
+partial def theoremToIR (theo: Lean.TheoremVal)
+  : CompileM Ix.Definition := do
+  let type <- compileExpr theo.type
+  let value <- compileExpr theo.value
+  return mkOpaque theo.levelParams type value theo.all
+
 /--
 Content-addresses an inductive and all inductives in the mutual block as a
 mutual block, even if the inductive itself is not in a mutual block.
@@ -401,7 +441,7 @@ partial def inductiveToIR (ind : Lean.InductiveVal) : CompileM Ix.Inductive := d
     -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
     -- match the order used in `recrCtx`
   return ⟨ind.levelParams, type, ind.numParams, ind.numIndices,
-    ind.all, ctors, recs, ind.isRec, ind.isReflexive⟩
+    ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive⟩
   where
     collectRecsCtors
       : Lean.ConstantInfo
@@ -622,13 +662,86 @@ partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
     | [d] => pure [[d]]
     | ds  => do pure $ (← List.groupByM (eqDef weakOrd) $
       ← ds.sortByM (compareDef weakOrd))).joinM
-
   -- must normalize, see comments
   let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
   let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
   if normDss == normNewDss then return newDss
   else sortDefs newDss
 
+-- boilerplate repetition for opaque and theorem
+
+/-- AST comparison of two Lean opaque definitions.
+  `weakOrd` contains the best known current mutual ordering -/
+partial def compareOpaq
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (x : Lean.OpaqueVal) 
+  (y : Lean.OpaqueVal) 
+  : CompileM Ordering := do
+  let ls := compare x.levelParams.length y.levelParams.length
+  let ts ← compareExpr weakOrd x.type y.type
+  let vs ← compareExpr weakOrd x.value y.value
+  return concatOrds [ls, ts, vs]
+
+/-- AST equality between two Lean opaque definitions.
+  `weakOrd` contains the best known current mutual ordering -/
+@[inline] partial def eqOpaq
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (x y : Lean.OpaqueVal) 
+  : CompileM Bool :=
+  return (← compareOpaq weakOrd x y) == .eq
+
+partial def sortOpaqs (dss : List (List Lean.OpaqueVal)) :
+    CompileM (List (List Lean.OpaqueVal)) := do
+  let enum (ll : List (List Lean.OpaqueVal)) :=
+    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
+  let weakOrd := enum dss _
+  let newDss ← (← dss.mapM fun ds =>
+    match ds with
+    | []  => unreachable!
+    | [d] => pure [[d]]
+    | ds  => do pure $ (← List.groupByM (eqOpaq weakOrd) $
+      ← ds.sortByM (compareOpaq weakOrd))).joinM
+  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
+  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
+  if normDss == normNewDss then return newDss
+  else sortOpaqs newDss
+
+/-- AST comparison of two Lean opaque definitions.
+  `weakOrd` contains the best known current mutual ordering -/
+partial def compareTheo
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (x : Lean.TheoremVal) 
+  (y : Lean.TheoremVal) 
+  : CompileM Ordering := do
+  let ls := compare x.levelParams.length y.levelParams.length
+  let ts ← compareExpr weakOrd x.type y.type
+  let vs ← compareExpr weakOrd x.value y.value
+  return concatOrds [ls, ts, vs]
+
+/-- AST equality between two Lean opaque definitions.
+  `weakOrd` contains the best known current mutual ordering -/
+@[inline] partial def eqTheo
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (x y : Lean.TheoremVal) 
+  : CompileM Bool :=
+  return (← compareTheo weakOrd x y) == .eq
+
+partial def sortTheos (dss : List (List Lean.TheoremVal)) :
+    CompileM (List (List Lean.TheoremVal)) := do
+  let enum (ll : List (List Lean.TheoremVal)) :=
+    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
+  let weakOrd := enum dss _
+  let newDss ← (← dss.mapM fun ds =>
+    match ds with
+    | []  => unreachable!
+    | [d] => pure [[d]]
+    | ds  => do pure $ (← List.groupByM (eqTheo weakOrd) $
+      ← ds.sortByM (compareTheo weakOrd))).joinM
+  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
+  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
+  if normDss == normNewDss then return newDss
+  else sortTheos newDss
+
 end
 
 partial def makeLeanDef
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index 6fce9b55..b0ce55fc 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -26,12 +26,12 @@ def DecompileM.run (env: CompileEnv) (stt: CompileState) (c : DecompileM α)
   : EStateM.Result DecompileError CompileState α
   := EStateM.run (ReaderT.run c env) stt
 
-def decompileLevel : Ix.Univ → DecompileM Lean.Level
+def decompileLevel : Ix.Level → DecompileM Lean.Level
 | .zero => pure .zero
 | .succ u => .succ <$> decompileLevel u
 | .max a b => Lean.Level.max  <$> decompileLevel a <*> decompileLevel b
 | .imax a b => Lean.Level.imax <$> decompileLevel a <*> decompileLevel b
-| .var n i => do
+| .param n i => do
   match (<- read).univCtx[i]? with
   | some n' => 
     if n == n' then pure (Lean.Level.param n)
@@ -74,32 +74,74 @@ partial def ensureConst (name: Lean.Name) (cont meta: Address) : DecompileM Unit
   --match (<- get).names.find? n 
   sorry
 
--- TODO: mutual block all needs better logic
-partial def decompileConst (name: Lean.Name): Ix.Const -> DecompileM Lean.ConstantInfo
-| .axiom x => do
-  let type <- decompileExpr x.type
-  return .axiomInfo (Lean.mkAxiomValEx name x.lvls type false)
-| .theorem x => do
-  let all := (<- read).mutCtx.keysList
-  let type <- decompileExpr x.type
-  let value <- decompileExpr x.type
-  return .thmInfo (Lean.mkTheoremValEx name x.lvls type value all)
-| .opaque x => do
-  let all := (<- read).mutCtx.keysList
+partial def decompileMutCtx (ctx: List (List Lean.Name)) 
+  : DecompileM (RBMap Lean.Name Nat compare) := do
+  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
+  for (ns, i) in List.zipIdx ctx do
+    for n in ns do
+      mutCtx := mutCtx.insert n i
+  return mutCtx
+
+partial def decompileConst (name: Lean.Name): Ix.Const -> DecompileM (List Lean.ConstantInfo)
+| .axiom x => withLevels x.levelParams do
   let type <- decompileExpr x.type
-  let value <- decompileExpr x.type
-  return .opaqueInfo (Lean.mkOpaqueValEx name x.lvls type value false all)
-| .definition x => do
-  let all := (<- read).mutCtx.keysList
+  return [.axiomInfo (Lean.mkAxiomValEx name x.levelParams type false)]
+| .definition x => List.singleton <$> decompileDefn name x
+| .inductive x => decompileIndc x
+| .quotient x => withLevels x.levelParams do
   let type <- decompileExpr x.type
-  let value <- decompileExpr x.type
-  return .defnInfo (Lean.mkDefinitionValEx name x.lvls type value false all)
-| .quotient x => sorry
+  return [.quotInfo <| Lean.mkQuotValEx name x.levelParams type x.kind]
 | .inductiveProj x => sorry
 | .constructorProj x => sorry
 | .recursorProj x => sorry
 | .definitionProj x => sorry
-| .mutDefBlock x => sorry
+| .mutDefBlock x => do
+  let mutCtx <- decompileMutCtx x.ctx
+  withMutCtx mutCtx do
+    let mut vals := #[]
+    for (defns, names) in List.zip x.defs x.ctx do
+      for (defn, name) in List.zip defns names do
+        let d <- decompileDefn name defn
+        vals := vals.push d
+    return vals.toList
 | .mutIndBlock x => sorry
+where
+  decompileDefn (name: Lean.Name) (x: Ix.Definition) : DecompileM Lean.ConstantInfo := 
+    withLevels x.levelParams do
+      let type <- decompileExpr x.type
+      let val <- decompileExpr x.type
+      let safety := if x.isPartial then .«partial» else .safe
+      match x.mode with
+      | .definition => return .defnInfo <|
+        Lean.mkDefinitionValEx name x.levelParams type val x.hints safety x.all
+      | .opaque => return .opaqueInfo <|
+        Lean.mkOpaqueValEx name x.levelParams type val true x.all
+      | .theorem => return .thmInfo <|
+        Lean.mkTheoremValEx name x.levelParams type val x.all
+  decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
+    : DecompileM Lean.ConstantInfo := do
+    let type <- decompileExpr x.type
+    return .ctorInfo <|
+      Lean.mkConstructorValEx x.name x.levelParams type indcName 
+        x.cidx x.numParams x.numFields false
+  decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
+    let rhs <- decompileExpr x.rhs
+    return ⟨x.ctor, x.nfields, rhs⟩
+  decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
+    : DecompileM Lean.ConstantInfo := do
+    let type <- decompileExpr x.type
+    let rules <- x.rules.mapM decompileRecrRule
+    return .recInfo <|
+      Lean.mkRecursorValEx x.name x.levelParams type indcAll
+        x.numParams x.numIndices x.numMotives x.numMinors rules x.k false
+  decompileIndc (x: Ix.Inductive) : DecompileM (List Lean.ConstantInfo) := 
+    withLevels x.levelParams do
+      let type <- decompileExpr x.type
+      let indc :=
+        Lean.mkInductiveValEx name x.levelParams type x.numParams x.numIndices
+          x.all (x.ctors.map (·.name)) x.numNested x.isRec false x.isReflexive
+      let ctors <- x.ctors.mapM (decompileCtor name)
+      let recrs <- x.recrs.mapM (decompileRecr x.all)
+      return .inductInfo indc :: ctors ++ recrs
 
 end
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 8e78d559..a5c87d94 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -213,13 +213,14 @@ Lean.InductiveVal. However, unlike in Lean, Ix.Inductive directly contains its
 corresponding Constructors and Recursors in order to enable content-addressing.
 --/
 structure Inductive where
-  lvls : List Lean.Name
+  levelParams : List Lean.Name
   type : Expr
   numParams : Nat
   numIndices : Nat
   all : List Lean.Name
   ctors : List Constructor
   recrs : List Recursor
+  numNested: Nat
   isRec : Bool
   isReflexive : Bool
   deriving BEq, Ord, Hashable, Repr, Nonempty
@@ -264,6 +265,11 @@ structure DefinitionProj where
   idx : Nat
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
+structure MutualDefinitionBlock where
+  defs : List (List Definition)
+  ctx  : List (List Lean.Name)
+  deriving BEq, Ord, Hashable, Repr, Nonempty
+
 inductive Const where
   | «axiom» : Axiom → Const
   | quotient : Quotient → Const
@@ -275,7 +281,7 @@ inductive Const where
   | recursorProj : RecursorProj → Const
   | definitionProj : DefinitionProj → Const
   -- constants to represent mutual blocks
-  | mutDefBlock : List Definition → Const
+  | mutDefBlock : MutualDefinitionBlock → Const
   | mutIndBlock : List Inductive → Const
   deriving Ord, BEq, Inhabited, Repr, Nonempty
 
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index 2fd08f11..fc674607 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -58,6 +58,7 @@ structure Inductive where
   indices : Nat
   ctors : List Constructor
   recrs : List Recursor
+  nested : Nat
   recr : Bool
   refl : Bool
   deriving BEq, Repr
@@ -127,8 +128,8 @@ def putConst : Const → PutM
 | .recrProj x => putUInt8 0xC5 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
 | .indcProj x => putUInt8 0xC6 *> putBytes x.block.hash *> putNatl x.idx
 | .defnProj x => putUInt8 0xC7 *> putBytes x.block.hash *> putNatl x.idx
-| .mutDef xs => putUInt8 0xC8 *> putArray (putDefn <$> xs)
-| .mutInd xs => putUInt8 0xC9 *> putArray (putIndc <$> xs)
+| .mutDef xs => putUInt8 0xC8 *> putArray putDefn xs
+| .mutInd xs => putUInt8 0xC9 *> putArray putIndc xs
 | .meta m => putUInt8 0xCA *> putMetadata m
 | .proof p => putUInt8 0xCB *> putProof p
 | .comm c => putUInt8 0xCC *> putComm c
@@ -153,15 +154,16 @@ def putConst : Const → PutM
       putNatl x.indices
       putNatl x.motives
       putNatl x.minors
-      putArray (putRecrRule <$> x.rules)
+      putArray putRecrRule x.rules
       putBool x.k
     putIndc (x: Inductive) : PutM := do
       putNatl x.lvls
       putExpr x.type
       putNatl x.params
       putNatl x.indices
-      putArray (putCtor <$> x.ctors)
-      putArray (putRecr <$> x.recrs)
+      putArray putCtor x.ctors
+      putArray putRecr x.recrs
+      putNatl x.nested
       putBools [x.recr, x.refl]
     putProof (p: Proof) : PutM :=
       match p.claim with
@@ -231,10 +233,11 @@ def getConst : GetM Const := do
       let indices <- getNatl
       let ctors <- getArray getCtor
       let recrs <- getArray getRecr
+      let nested <- getNatl
       let (recr, refl) <- match ← getBools 2 with
         | [x, y] => pure (x, y)
         | _ => throw s!"unreachable"
-      return ⟨lvls, type, params, indices, ctors, recrs, recr, refl⟩
+      return ⟨lvls, type, params, indices, ctors, recrs, nested, recr, refl⟩
     getAddr : GetM Address := .mk <$> getBytes 32
     getProof : GetM Proof := do
       match (<- getUInt8) with
diff --git a/Ix/Ixon/Expr.lean b/Ix/Ixon/Expr.lean
index 618e85d3..9843f19d 100644
--- a/Ix/Ixon/Expr.lean
+++ b/Ix/Ixon/Expr.lean
@@ -133,7 +133,14 @@ instance : Serialize Expr where
   put := runPut ∘ putExpr
   get := runGet getExpr
 
-def putArray (xs : List PutM) : PutM := do
+
+def putArray {A: Type} (putM : A -> PutM) (xs : List A) : PutM := do
+  putExprTag 0xB (UInt64.ofNat xs.length)
+  List.forM xs putM
+
+-- useful for arrays of non-uniform type, such as encoding tuples, although that
+-- requires a custom getArray equivalent
+def putArray' (xs : List PutM) : PutM := do
   putExprTag 0xB (UInt64.ofNat xs.length)
   List.forM xs id
 
@@ -158,8 +165,8 @@ def getByteArray : GetM ByteArray := do
 
 
 def putOption (putM: A -> PutM): Option A → PutM
-| .none => putArray []
-| .some x => putArray [putM x]
+| .none => putArray putM []
+| .some x => putArray putM [x]
 
 def getOption [Repr A] (getM: GetM A): GetM (Option A) := do
   match ← getArray getM with
diff --git a/Ix/Ixon/Metadata.lean b/Ix/Ixon/Metadata.lean
index 0fe6bd6e..b917cb1e 100644
--- a/Ix/Ixon/Metadata.lean
+++ b/Ix/Ixon/Metadata.lean
@@ -12,6 +12,7 @@ inductive Metadatum where
 | link : Address -> Metadatum
 | hints : Lean.ReducibilityHints -> Metadatum
 | all : List Lean.Name -> Metadatum
+| mutCtx : List (List Lean.Name) -> Metadatum
 deriving BEq, Repr, Ord, Inhabited
 
 structure Metadata where
@@ -43,7 +44,7 @@ def getNamePart : GetM NamePart := do
   | .natl s => return (.num s)
   | e => throw s!"expected NamePart from .strl or .natl, got {repr e}"
 
-def putName (n: Lean.Name): PutM := putArray (putNamePart <$> (nameToParts n))
+def putName (n: Lean.Name): PutM := putArray putNamePart (nameToParts n)
 def getName: GetM Lean.Name := nameFromParts <$> getArray getNamePart
 
 def putMetadatum : Metadatum → PutM
@@ -51,7 +52,8 @@ def putMetadatum : Metadatum → PutM
 | .info i => putUInt8 1 *> putBinderInfo i
 | .link l => putUInt8 2 *> putBytes l.hash
 | .hints h => putUInt8 3 *> putReducibilityHints h
-| .all ns => putUInt8 4 *> putArray (putName <$> ns)
+| .all ns => putUInt8 4 *> putArray putName ns
+| .mutCtx ctx => putUInt8 5 *> (putArray (putArray putName) ctx)
 
 def getMetadatum : GetM Metadatum := do
   match (<- getUInt8) with
@@ -60,11 +62,12 @@ def getMetadatum : GetM Metadatum := do
   | 2 => .link <$> (.mk <$> getBytes 32)
   | 3 => .hints <$> getReducibilityHints
   | 4 => .all <$> getArray getName
+  | 5 => .mutCtx <$> getArray (getArray getName)
   | e => throw s!"expected Metadatum encoding between 0 and 4, got {e}"
 
-def putMetadata (m: Metadata) : PutM := putArray (putEntry <$> m.map.toList)
+def putMetadata (m: Metadata) : PutM := putArray putEntry m.map.toList
   where
-    putEntry e := putNatl e.fst *> putArray (putMetadatum <$> e.snd)
+    putEntry e := putNatl e.fst *> putArray putMetadatum e.snd
 
 def getMetadata : GetM Metadata := do
   let xs <- getArray (Prod.mk <$> getNatl <*> getArray getMetadatum)
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index 253c74ce..ea1567a5 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -26,6 +26,7 @@ inductive TransportError
   | rawMetadata (m: Ixon.Metadata)
   | rawProof (m: Proof)
   | rawComm (m: Ixon.Comm)
+  | emptyEquivalenceClass
   deriving BEq, Repr
 
 instance : ToString TransportError where toString
@@ -35,6 +36,7 @@ instance : ToString TransportError where toString
 | .rawMetadata x => s!"Can't rematerialize raw metadata {repr x}"
 | .rawProof x => s!"Can't rematerialize raw proof {repr x}"
 | .rawComm x => s!"Can't rematerialize raw commitment {repr x}"
+| .emptyEquivalenceClass => s!"empty equivalence class, should be unreachable"
 
 abbrev DematM := EStateM TransportError DematState
 
@@ -264,7 +266,13 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
 | .definitionProj x => do
   dematMeta [.link x.blockMeta]
   return .defnProj (.mk x.blockCont x.idx)
-| .mutDefBlock xs => .mutDef <$> (xs.mapM dematDefn)
+| .mutDefBlock x => do
+  dematMeta [.mutCtx x.ctx]
+  let defs <- x.defs.mapM fun ds => ds.mapM dematDefn
+  let ds <- defs.mapM fun d => match d.head? with
+    | .some a => pure a
+    | .none => throw .emptyEquivalenceClass
+  return .mutDef ds
 | .mutIndBlock xs => .mutInd <$> (xs.mapM dematIndc)
   where
     dematDefn (x: Ix.Definition): DematM Ixon.Definition := do
@@ -291,15 +299,17 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
       let lvls <- dematLevels x.levelParams
       let t <- dematExpr x.type
       let rrs <- x.rules.mapM dematRecrRule
-      return .mk lvls t x.numParams x.numIndices x.numMotives x.numMinors rrs x.k
+      return ⟨lvls, t, x.numParams, x.numIndices, x.numMotives, x.numMinors, 
+        rrs, x.k⟩
     dematIndc (x: Ix.Inductive): DematM Ixon.Inductive := do
       let _ <- dematIncr
       dematMeta [.all x.all]
-      let lvls <- dematLevels x.lvls
-      let t <- dematExpr x.type
-      let cs <- x.ctors.mapM dematCtor
-      let rs <- x.recrs.mapM dematRecr
-      return .mk lvls t x.numParams x.numIndices cs rs x.isRec x.isReflexive
+      let lvls <- dematLevels x.levelParams
+      let type <- dematExpr x.type
+      let ctors <- x.ctors.mapM dematCtor
+      let recrs <- x.recrs.mapM dematRecr
+      return ⟨lvls, type, x.numParams, x.numIndices, ctors, recrs, x.numNested,
+        x.isRec, x.isReflexive⟩
 
 def constToIxon (x: Ix.Const) : Except TransportError (Ixon.Const × Ixon.Const) := 
   match EStateM.run (dematConst x) emptyDematState with
@@ -345,7 +355,18 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
     | [.link x] => pure x
     | _ => rematThrowUnexpected
   return .definitionProj (.mk x.block link x.idx)
-| .mutDef xs => .mutDefBlock <$> (xs.mapM rematDefn)
+| .mutDef xs => do
+  let ctx <- match (<- rematMeta) with
+    | [.mutCtx x] => pure x
+    | _ => rematThrowUnexpected
+  let mut defs := #[]
+  for (x, ns) in List.zip xs ctx do
+    let mut ds := #[]
+    for _ in ns do
+      let d <- rematDefn x
+      ds := ds.push d
+    defs := defs.push ds.toList
+  return .mutDefBlock ⟨defs.toList, ctx⟩
 | .mutInd xs => .mutIndBlock <$> (xs.mapM rematIndc)
 | .meta m => throw (.rawMetadata m)
 -- TODO: This could return a Proof inductive, since proofs have no metadata
@@ -394,6 +415,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       let t <- rematExpr x.type
       let cs <- x.ctors.mapM rematCtor
       let rs <- x.recrs.mapM rematRecr
-      return ⟨lvls, t, x.params, x.indices, all, cs, rs, x.recr, x.refl⟩
+      return ⟨lvls, t, x.params, x.indices, all, cs, rs, x.nested, x.recr,
+        x.refl⟩
 
 end Ix.TransportM
diff --git a/Tests/Ix/Common.lean b/Tests/Ix/Common.lean
index 332c2363..1b37f51c 100644
--- a/Tests/Ix/Common.lean
+++ b/Tests/Ix/Common.lean
@@ -38,6 +38,10 @@ def genList' (gen: Gen α) : Gen (List α) := do
   let n ← genNat'
   List.mapM (fun _ => gen) (List.range n)
 
+def genListSize (gen: Gen α) (lo hi: Nat): Gen (List α) := do
+  let n ← choose Nat lo hi
+  List.mapM (fun _ => gen) (List.range n)
+
 def genOption (gen: Gen α) : Gen (Option α) :=
   oneOf' [ pure .none, .some <$> gen]
 
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index aa0d5ade..23042eb0 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -82,8 +82,15 @@ def genConst : Gen Ix.Const := getSize >>= go
       let all <- genNames
       let ctors <- resizeListOf genCtor
       let recrs <- resizeListOf genRecr
+      let nested <- genNat'
       let (isRec, isRefl) <- Prod.mk <$> genBool <*> genBool
-      return ⟨lvls, type, params, indices, all, ctors, recrs, isRec, isRefl⟩
+      return ⟨lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl⟩
+    genMutDef : Gen Ix.MutualDefinitionBlock := do
+      let nns <- resizeListOf (genListSize genName 1 5)
+      let ds <- nns.mapM fun ns => do
+        let x <- genDef
+        ns.mapM (fun _ => pure x)
+      return .mk ds nns
     go : Nat -> Gen Ix.Const
     | 0 => return .«axiom» (.mk [] (Ix.Expr.sort (Ix.Level.zero)))
     | Nat.succ _ =>
@@ -95,7 +102,7 @@ def genConst : Gen Ix.Const := getSize >>= go
         (100, .constructorProj <$> (.mk <$> genAddress <*> genAddress <*> genNat' <*> genNat')),
         (100, .recursorProj <$> (.mk <$> genAddress <*> genAddress <*> genNat' <*> genNat')),
         (100, .definitionProj <$> (.mk <$> genAddress <*> genAddress <*> genNat')),
-        (100, .mutDefBlock <$> resizeListOf genDef),
+        (100, .mutDefBlock <$> genMutDef),
         (100, .mutIndBlock <$> resizeListOf genInd),
       ]
 
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index f17b1d33..4dbee645 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -111,7 +111,7 @@ def genRecursor : Gen Recursor :=
 
 def genInductive : Gen Inductive :=
   .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat'
-    <*> genList' genConstructor <*> genList' genRecursor
+    <*> genList' genConstructor <*> genList' genRecursor <*> genNat'
     <*> genBool <*> genBool
 
 def genConstructorProj : Gen ConstructorProj :=

From e0973fe9f9448a57bf19f6eb04e61aefdaf708f0 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 16 May 2025 07:44:47 -0400
Subject: [PATCH 19/74] wip

---
 Ix.lean               |   1 +
 Ix/Common.lean        |  27 ++
 Ix/CompileM.lean      | 312 ++++++++++-----
 Ix/DecompileM.lean    | 894 ++++++++++++++++++++++++++++++++++++------
 Ix/IR.lean            |  50 ++-
 Ix/TransportM.lean    |  88 +++--
 Tests/Ix.lean         |  21 +-
 Tests/Ix/Compile.lean |  43 +-
 Tests/Ix/IR.lean      |  28 +-
 9 files changed, 1196 insertions(+), 268 deletions(-)

diff --git a/Ix.lean b/Ix.lean
index 3da4f8da..e2d4bc7e 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -5,5 +5,6 @@ import Ix.TransportM
 import Ix.IR
 import Ix.Meta
 import Ix.CompileM
+import Ix.DecompileM
 import Ix.Claim
 import Ix.Prove
diff --git a/Ix/Common.lean b/Ix/Common.lean
index 45121c06..bfd3a425 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -10,6 +10,16 @@ def compareList [Ord α] : List α -> List α -> Ordering
 | [], _::_ => .lt
 | [], [] => .eq
 
+def compareListM 
+  [Monad μ] (cmp: α -> α -> μ Ordering) : List α -> List α -> μ Ordering
+| a::as, b::bs => do
+  match (<- cmp a b) with
+  | .eq => compareListM cmp as bs
+  | x => pure x
+| _::_, [] => pure .gt
+| [], _::_ => pure .lt
+| [], [] => pure .eq
+
 instance [Ord α] : Ord (List α) where 
   compare := compareList
 
@@ -25,6 +35,17 @@ deriving instance Ord for Lean.Literal
 deriving instance Ord for Lean.BinderInfo
 deriving instance BEq, Repr, Hashable, Ord for Lean.QuotKind
 deriving instance Hashable, Repr for Lean.ReducibilityHints
+deriving instance BEq, Repr for Lean.ConstantVal
+deriving instance BEq, Repr for Lean.QuotVal
+deriving instance BEq, Repr for Lean.AxiomVal
+deriving instance BEq, Repr for Lean.TheoremVal
+deriving instance BEq, Repr for Lean.DefinitionVal
+deriving instance BEq, Repr for Lean.OpaqueVal
+deriving instance BEq, Repr for Lean.RecursorRule
+deriving instance BEq, Repr for Lean.RecursorVal
+deriving instance BEq, Repr for Lean.ConstructorVal
+deriving instance BEq, Repr for Lean.InductiveVal
+deriving instance BEq, Repr for Lean.ConstantInfo
 
 def UInt8.MAX : UInt64 := 0xFF
 def UInt16.MAX : UInt64 := 0xFFFF
@@ -142,6 +163,12 @@ def ConstMap.childrenOfWith (map : ConstMap) (name : Name)
   | .num n .. => if n == name && p c then c :: acc else acc
   | _ => acc
 
+def Name.parent : Name -> Name
+| .str n ..
+| .num n .. => n
+| .anonymous => .anonymous
+
+
 --def ConstMap.patchUnsafeRec (cs : ConstMap) : ConstMap :=
 --  let unsafes : Batteries.RBSet Name compare := cs.fold (init := .empty)
 --    fun acc n _ => match n with
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 8ad73350..e824f7f6 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -28,6 +28,8 @@ inductive CompileError
 | transportError : TransportError → CompileError
 | kernelException : Lean.Kernel.Exception → CompileError
 | cantPackLevel : Nat → CompileError
+| nonCongruentInductives : PreInductive -> PreInductive -> CompileError
+| alphaInvarianceFailure : Ix.Const -> Address -> Ix.Const -> Address -> CompileError
 
 def CompileError.pretty : CompileError -> IO String
 | .unknownConstant n => pure s!"Unknown constant '{n}'"
@@ -43,9 +45,12 @@ def CompileError.pretty : CompileError -> IO String
 | .nonRecursorExtractedFromChildren n => pure
   s!"Non-recursor '{n}' extracted from children"
 | .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
-| .transportError n => pure s!"Transport error '{repr n}'"
+| .transportError n => pure s!"compiler transport error '{repr n}'"
 | .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
 | .cantPackLevel n => pure s!"Can't pack level {n} greater than 2^256'"
+| .nonCongruentInductives a b => pure s!"noncongruent inductives {a.name} {b.name}'"
+| .alphaInvarianceFailure x xa y ya => 
+  pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
 
 structure CompileEnv where
   univCtx : List Lean.Name
@@ -94,27 +99,16 @@ def freshSecret : CompileM Address := do
   return ⟨secret⟩
 
 -- add binding name to local context
-def withBinder
-  {m : Type -> Type} {α : Type}
-  [Monad m] [MonadWithReader CompileEnv m]
-  (name: Lean.Name) 
-  : m α -> m α :=
+def withBinder (name: Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
 
 -- add levels to local context
-def withLevels
-  {m : Type -> Type} {α : Type}
-  [Monad m] [MonadWithReader CompileEnv m]
-  (lvls : List Lean.Name) 
-  : m α -> m α :=
+def withLevels (lvls : List Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with univCtx := lvls }
 
 -- add mutual recursion info to local context
-def withMutCtx
-  {m : Type -> Type} {α : Type}
-  [Monad m] [MonadWithReader CompileEnv m]
-  (mutCtx : RBMap Lean.Name Nat compare) 
-  : m α -> m α :=
+def withMutCtx (mutCtx : RBMap Lean.Name Nat compare) 
+  : CompileM α -> CompileM α :=
   withReader $ fun c => { c with mutCtx := mutCtx }
 
 -- reset local context
@@ -229,7 +223,7 @@ partial def compileConst (const : Lean.ConstantInfo)
       compileConst const
     -- The rest adds the constants to the cache one by one
     | .axiomInfo val => resetCtxWithLevels const.levelParams do
-      let c := .axiom ⟨val.levelParams, ← compileExpr val.type⟩
+      let c := .axiom ⟨val.name, val.levelParams, ← compileExpr val.type⟩
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
@@ -239,7 +233,8 @@ partial def compileConst (const : Lean.ConstantInfo)
     | .thmInfo val => resetCtxWithLevels const.levelParams do
       let type <- compileExpr val.type
       let value <- compileExpr val.value
-      let c := .definition <| mkTheorem val.levelParams type value val.all
+      let c := .definition <|
+        mkTheorem val.name val.levelParams type value val.all
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         names := stt.names.insert const.name (anonAddr, metaAddr)
@@ -249,7 +244,8 @@ partial def compileConst (const : Lean.ConstantInfo)
       let mutCtx := .single val.name 0
       let type <- compileExpr val.type
       let value <- withMutCtx mutCtx $ compileExpr val.value
-      let c := .definition <| mkOpaque val.levelParams type value val.all
+      let c := .definition <|
+        mkOpaque val.name val.levelParams type value val.all
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         names := stt.names.insert const.name (anonAddr, metaAddr)
@@ -257,7 +253,7 @@ partial def compileConst (const : Lean.ConstantInfo)
       return (anonAddr, metaAddr)
     | .quotInfo val => resetCtxWithLevels const.levelParams do
       let type <- compileExpr val.type
-      let c := .quotient ⟨val.levelParams, type, val.kind⟩
+      let c := .quotient ⟨val.name, val.levelParams, type, val.kind⟩
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
@@ -277,7 +273,6 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
     }
     return (anonAddr, metaAddr)
   -- Collecting and sorting all definitions in the mutual block
-  -- TODO: This needs to support mutual blocks that include theorems and opaques
   let mut mutDefs : Array Lean.DefinitionVal := #[]
   let mut mutOpaqs : Array Lean.OpaqueVal := #[]
   let mut mutTheos : Array Lean.TheoremVal := #[]
@@ -319,9 +314,8 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
   let opaqDefs ← withMutCtx mutCtx $ mutualOpaqs.mapM (·.mapM opaqueToIR)
   let theoDefs ← withMutCtx mutCtx $ mutualTheos.mapM (·.mapM theoremToIR)
   -- Building and storing the block
-  -- TODO: check if this flatten call actually makes sense
   let definitions := defnDefs ++ opaqDefs ++ theoDefs
-  let (blockAnonAddr, blockMetaAddr) ← 
+  let (blockAnonAddr, blockMetaAddr) ←
     hashConst $ .mutDefBlock ⟨definitions, names.toList⟩
   modify fun stt =>
     { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
@@ -333,7 +327,7 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
     -- Also adds the constant to the array of constants
     let some idx := mutCtx.find? name | throw $ .cantFindMutDefIndex name
     let (anonAddr, metaAddr) ←
-      hashConst $ .definitionProj ⟨blockAnonAddr, blockMetaAddr, idx⟩
+      hashConst $ .definitionProj ⟨name, blockAnonAddr, blockMetaAddr, idx⟩
     modify fun stt => { stt with
       names := stt.names.insert name (anonAddr, metaAddr)
     }
@@ -342,25 +336,62 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
   | some ret => return ret
   | none => throw $ .constantNotContentAddressed struct.name
 
-partial def definitionToIR (defn: Lean.DefinitionVal)
+partial def definitionToIR (d: Lean.DefinitionVal)
   : CompileM Ix.Definition := do
-  let type <- compileExpr defn.type
-  let value <- compileExpr defn.value
-  let isPartial := defn.safety == .partial
-  let mode := .definition
-  return ⟨defn.levelParams, type, mode, value, defn.hints, isPartial, defn.all⟩
+  let typ <- compileExpr d.type
+  let val <- compileExpr d.value
+  let isPartial := d.safety == .partial
+  let mod := .definition
+  return ⟨d.name, d.levelParams, typ, mod, val, d.hints, isPartial, d.all⟩
 
 partial def opaqueToIR (opaq: Lean.OpaqueVal)
   : CompileM Ix.Definition := do
   let type <- compileExpr opaq.type
   let value <- compileExpr opaq.value
-  return mkOpaque opaq.levelParams type value opaq.all
+  return mkOpaque opaq.name opaq.levelParams type value opaq.all
 
 partial def theoremToIR (theo: Lean.TheoremVal)
   : CompileM Ix.Definition := do
   let type <- compileExpr theo.type
   let value <- compileExpr theo.value
-  return mkOpaque theo.levelParams type value theo.all
+  return mkOpaque theo.name theo.levelParams type value theo.all
+
+partial def getRecursors (ind : Lean.InductiveVal) 
+  : CompileM (List Lean.RecursorVal) := do
+    return (<- get).env.constants.fold accRecr []
+    where
+      accRecr (acc: List Lean.RecursorVal) (n: Lean.Name) (c: Lean.ConstantInfo)
+        : List Lean.RecursorVal :=
+        match n with
+        | .str n ..
+        | .num n .. =>
+          if n == ind.name then match c with
+            | .recInfo r => r :: acc
+            | _ => acc
+          else acc
+        | _ => acc
+
+partial def makePreInductive (ind: Lean.InductiveVal) 
+  : CompileM Ix.PreInductive := do
+    let ctors <- ind.ctors.mapM getCtor
+    let recrs <- getRecursors ind
+    return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices, 
+      ind.all, ctors, recrs, ind.numNested, ind.isRec, ind.isReflexive⟩
+    where
+      getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
+        match (<- findLeanConst name) with
+        | .ctorInfo c => pure c
+        | _ => throw <| .invalidConstantKind name "constructor" ""
+
+partial def checkCtorRecrLengths : List PreInductive -> CompileM (Nat × Nat)
+| [] => return (0, 0)
+| x::xs => go x xs
+  where
+    go : PreInductive -> List PreInductive -> CompileM (Nat × Nat)
+    | x, [] => return (x.ctors.length, x.recrs.length)
+    | x, a::as =>
+      if x.ctors.length == a.ctors.length && x.recrs.length == a.recrs.length
+      then go x as else throw <| .nonCongruentInductives x a
 
 /--
 Content-addresses an inductive and all inductives in the mutual block as a
@@ -371,32 +402,55 @@ constructors and recursors, hence the complexity of this function.
 -/
 partial def compileInductive (initInd: Lean.InductiveVal) 
   : CompileM (Address × Address) := do
-  let mut inds := []
-  let mut indCtors := []
-  let mut indRecs := []
+  let mut preInds := #[]
   let mut nameData : RBMap Lean.Name (List Lean.Name × List Lean.Name) compare
     := .empty
+  if initInd.all matches [_] then
+    let ind <- makePreInductive initInd
+    let numCtors := ind.ctors.length
+    let mut mutCtx := (.single ind.name 0)
+    for (c, cidx) in List.zipIdx ind.ctors do
+      mutCtx := mutCtx.insert c.name cidx
+    for (r, ridx) in List.zipIdx ind.recrs do
+      mutCtx := mutCtx.insert r.name (numCtors + ridx)
+    let indc <- withMutCtx mutCtx $ preInductiveToIR ind
+    let (anonAddr, metaAddr) <- hashConst $ .inductive indc
+    modify fun stt => { stt with
+      names := stt.names.insert ind.name (anonAddr, metaAddr)
+    }
+    return (anonAddr, metaAddr)
+  -- collect all mutual inductives as Ix.PreInductives
   for indName in initInd.all do
     match ← findLeanConst indName with
     | .inductInfo ind =>
-      let indRecrs := ((← get).env.constants.childrenOfWith ind.name
-        fun c => match c with | .recInfo _ => true | _ => false).map (·.name)
-      inds := inds ++ [indName]
-      indCtors := indCtors ++ ind.ctors
-      indRecs := indRecs ++ indRecrs
-      nameData := nameData.insert indName (ind.ctors, indRecrs)
-    | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
-  -- `mutualConsts` is the list of the names of all constants associated with an
-  -- inductive block: the inductives themselves, the constructors and the recursors
-  let mutualConsts := inds ++ indCtors ++ indRecs
-  let mutCtx := mutualConsts.zipIdx.foldl (init := default)
-    fun acc (n, i) => acc.insert n i
-  -- This part builds the inductive block
-  -- and adds all inductives, constructors and recursors to `consts`
-  let irInds ← initInd.all.mapM fun name => do match ← findLeanConst name with
-    | .inductInfo ind => withMutCtx mutCtx do pure $ (← inductiveToIR ind)
+      let preInd <- makePreInductive ind
+      preInds := preInds.push preInd
+      nameData := nameData.insert indName (ind.ctors, preInd.recrs.map (·.name))
     | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
-  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .mutIndBlock irInds
+  -- sort PreInductives into equivalence classes
+  let mutualInds <- sortPreInds [preInds.toList]
+  let mut mutCtx : RBMap Lean.Name Nat compare := default
+  let mut names := #[]
+  let mut i := 0
+  -- build the mutual context
+  for inds in mutualInds do
+    let mut x := #[]
+    -- double-check that all inductives in the class have the same number
+    -- of constructors and recursors
+    let (numCtors, numRecrs) <- checkCtorRecrLengths inds
+    for ind in inds do
+      x := x.push ind.name
+      mutCtx := mutCtx.insert ind.name i
+      for (c, cidx) in List.zipIdx ind.ctors do
+        mutCtx := mutCtx.insert c.name (i + cidx)
+      for (r, ridx) in List.zipIdx ind.recrs do
+        mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
+    names := names.push x.toList
+    i := i + 1 + numCtors + numRecrs
+  -- compile each preinductive with the mutCtx
+  let irInds ← withMutCtx mutCtx $ mutualInds.mapM (·.mapM preInductiveToIR)
+  let (blockAnonAddr, blockMetaAddr) ←
+    hashConst $ .mutIndBlock ⟨irInds, names.toList⟩
   modify fun stt =>
     { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
   -- While iterating on the inductives from the mutual block, we need to track
@@ -406,7 +460,7 @@ partial def compileInductive (initInd: Lean.InductiveVal)
     -- Store and cache inductive projections
     let name := indName
     let (anonAddr, metaAddr) ←
-      hashConst $ .inductiveProj ⟨blockAnonAddr, blockMetaAddr, indIdx⟩
+      hashConst $ .inductiveProj ⟨name, blockAnonAddr, blockMetaAddr, indIdx⟩
     modify fun stt => { stt with
       names := stt.names.insert name (anonAddr, metaAddr)
     }
@@ -417,7 +471,7 @@ partial def compileInductive (initInd: Lean.InductiveVal)
       -- Store and cache constructor projections
       let (anonAddr, metaAddr) ←
         hashConst $ .constructorProj
-          ⟨blockAnonAddr, blockMetaAddr, indIdx, ctorIdx⟩
+          ⟨ctorName, blockAnonAddr, blockMetaAddr, indIdx, indName, ctorIdx⟩
       modify fun stt => { stt with
         names := stt.names.insert ctorName (anonAddr, metaAddr)
       }
@@ -425,7 +479,7 @@ partial def compileInductive (initInd: Lean.InductiveVal)
       -- Store and cache recursor projections
       let (anonAddr, metaAddr) ←
         hashConst $ .recursorProj
-          ⟨blockAnonAddr, blockMetaAddr, indIdx, recrIdx⟩
+          ⟨recrName, blockAnonAddr, blockMetaAddr, indIdx, indName, recrIdx⟩
       modify fun stt => { stt with
         names := stt.names.insert recrName (anonAddr, metaAddr)
       }
@@ -433,43 +487,46 @@ partial def compileInductive (initInd: Lean.InductiveVal)
   | some ret => return ret
   | none => throw $ .constantNotContentAddressed initInd.name
 
-partial def inductiveToIR (ind : Lean.InductiveVal) : CompileM Ix.Inductive := do
-  let leanRecs := (← get).env.constants.childrenOfWith ind.name
-    fun c => match c with | .recInfo _ => true | _ => false
-  let (recs, ctors) := <- leanRecs.foldrM (init := ([], [])) collectRecsCtors
+partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive := do
+  let (recs, ctors) := <- ind.recrs.foldrM (init := ([], [])) collectRecsCtors
   let type <- compileExpr ind.type
     -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
-    -- match the order used in `recrCtx`
-  return ⟨ind.levelParams, type, ind.numParams, ind.numIndices,
+    -- match the order used in `mutCtx`
+  return ⟨ind.name, ind.levelParams, type, ind.numParams, ind.numIndices,
     ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive⟩
   where
     collectRecsCtors
-      : Lean.ConstantInfo
+      : Lean.RecursorVal
       -> List Recursor × List Constructor 
       -> CompileM (List Recursor × List Constructor)
-      | r@(.recInfo rv), (recs, ctors) =>
-        if isInternalRec rv.type ind.name then do
-          let (thisRec, thisCtors) <- internalRecToIR ind.ctors r
+      | r, (recs, ctors) =>
+        if isInternalRec r.type ind.name then do
+          let (thisRec, thisCtors) <- internalRecToIR (ind.ctors.map (·.name)) r
           pure (thisRec :: recs, thisCtors)
         else do
           let thisRec ← externalRecToIR r
           pure (thisRec :: recs, ctors)
-      | r, _ => throw $ .nonRecursorExtractedFromChildren r.name
 
-partial def internalRecToIR (ctors : List Lean.Name)
-  : Lean.ConstantInfo → CompileM (Ix.Recursor × List Ix.Constructor)
-  | .recInfo rec => withLevels rec.levelParams do
-    let typ ← compileExpr rec.type
-    let (retCtors, retRules) ← rec.rules.foldrM (init := ([], []))
+partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
+  : CompileM (Ix.Recursor × List Ix.Constructor) := do
+  withLevels recr.levelParams do
+    let typ ← compileExpr recr.type
+    let (retCtors, retRules) ← recr.rules.foldrM (init := ([], []))
       fun r (retCtors, retRules) => do
         if ctors.contains r.ctor then
           let (ctor, rule) ← recRuleToIR r
           pure $ (ctor :: retCtors, rule :: retRules)
         else pure (retCtors, retRules) -- this is an external recursor rule
-    let recr := ⟨rec.name, rec.levelParams, typ, rec.numParams, rec.numIndices,
-      rec.numMotives, rec.numMinors, retRules, rec.k⟩
+    let recr := ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
+      recr.numMotives, recr.numMinors, retRules, recr.k⟩
     return (recr, retCtors)
-  | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
+
+partial def externalRecToIR (recr: Lean.RecursorVal): CompileM Recursor := do
+  withLevels recr.levelParams do
+    let typ ← compileExpr recr.type
+    let rules ← recr.rules.mapM externalRecRuleToIR
+    return ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
+      recr.numMotives, recr.numMinors, rules, recr.k⟩
 
 partial def recRuleToIR (rule : Lean.RecursorRule)
   : CompileM (Ix.Constructor × Ix.RecursorRule) := do
@@ -483,14 +540,6 @@ partial def recRuleToIR (rule : Lean.RecursorRule)
   | const =>
     throw $ .invalidConstantKind const.name "constructor" const.ctorName
 
-partial def externalRecToIR : Lean.ConstantInfo → CompileM Recursor
-  | .recInfo rec => withLevels rec.levelParams do
-    let typ ← compileExpr rec.type
-    let rules ← rec.rules.mapM externalRecRuleToIR
-    return ⟨rec.name, rec.levelParams, typ, rec.numParams, rec.numIndices,
-      rec.numMotives, rec.numMinors, rules, rec.k⟩
-  | const => throw $ .invalidConstantKind const.name "recursor" const.ctorName
-
 partial def externalRecRuleToIR (rule : Lean.RecursorRule) 
   : CompileM RecursorRule :=
   return ⟨rule.ctor, rule.nfields, ← compileExpr rule.rhs⟩
@@ -742,6 +791,68 @@ partial def sortTheos (dss : List (List Lean.TheoremVal)) :
   if normDss == normNewDss then return newDss
   else sortTheos newDss
 
+/-- AST comparison of two Lean opaque definitions.
+  `weakOrd` contains the best known current mutual ordering -/
+partial def comparePreInds
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (x : PreInductive)
+  (y : PreInductive)
+  : CompileM Ordering := do
+  let ls := compare x.levelParams.length y.levelParams.length
+  let ts ← compareExpr weakOrd x.type y.type
+  let nps := compare x.numParams y.numParams
+  let nis := compare x.numIndices y.numIndices
+  let ctors <- compareListM compareCtors x.ctors y.ctors
+  let recrs <- compareListM compareRecrs x.recrs y.recrs
+  return concatOrds [ls, ts,nps, nis, ctors, recrs]
+  where
+    compareCtors (x y: Lean.ConstructorVal) : CompileM Ordering := do
+      let ls := compare x.levelParams.length y.levelParams.length
+      let ts <- compareExpr weakOrd x.type y.type
+      let cis := compare x.cidx y.cidx
+      let nps := compare x.numParams y.numParams
+      let nfs := compare x.numFields y.numFields
+      return concatOrds [ls, ts, cis, nps, nfs]
+    compareRecrs (x y: Lean.RecursorVal) : CompileM Ordering := do
+      let ls := compare x.levelParams.length y.levelParams.length
+      let ts <- compareExpr weakOrd x.type y.type
+      let nps := compare x.numParams y.numParams
+      let nis := compare x.numIndices y.numIndices
+      let nmos := compare x.numMotives y.numMotives
+      let nmis := compare x.numMinors y.numMinors
+      let rrs <- compareListM compareRules x.rules y.rules
+      let ks := compare x.k y.k
+      return concatOrds [ls, ts, nps, nis, nmos, nmis, rrs, ks]
+    compareRules (x y: Lean.RecursorRule) : CompileM Ordering := do
+      let nfs := compare x.nfields y.nfields
+      let rs <- compareExpr weakOrd x.rhs y.rhs
+      return concatOrds [nfs, rs]
+
+/-- AST equality between two Lean opaque definitions.
+  `weakOrd` contains the best known current mutual ordering -/
+@[inline] partial def eqPreInds
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (x y : PreInductive) 
+  : CompileM Bool :=
+  return (← comparePreInds weakOrd x y) == .eq
+
+partial def sortPreInds (dss : List (List PreInductive)) :
+    CompileM (List (List PreInductive)) := do
+  let enum (ll : List (List PreInductive)) :=
+    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
+  let weakOrd := enum dss _
+  let newDss ← (← dss.mapM fun ds =>
+    match ds with
+    | []  => unreachable!
+    | [d] => pure [[d]]
+    | ds  => do pure $ (← List.groupByM (eqPreInds weakOrd) $
+      ← ds.sortByM (comparePreInds weakOrd))).joinM
+  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
+  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
+  if normDss == normNewDss then return newDss
+  else sortPreInds newDss
+
+
 end
 
 partial def makeLeanDef
@@ -749,7 +860,7 @@ partial def makeLeanDef
   : Lean.DefinitionVal :=
   { name, levelParams, type, value, hints := .opaque, safety := .safe }
 
-partial def tryAddLeanDecl (defn: Lean.DefinitionVal) : CompileM Unit := do
+partial def tryAddLeanDef (defn: Lean.DefinitionVal) : CompileM Unit := do
   match (<- get).env.constants.find? defn.name with
   | some _ => pure ()
   | none => do
@@ -762,16 +873,27 @@ partial def tryAddLeanDecl (defn: Lean.DefinitionVal) : CompileM Unit := do
       return ()
     | .error e => throw $ .kernelException e
 
-partial def addDef 
+partial def addDef
   (lvls: List Lean.Name)
   (typ val: Lean.Expr)
   : CompileM (Address × Address) := do
   let typ' <- compileExpr typ
   let val' <- compileExpr val
-  let (a, m) <- hashConst $ 
-    Ix.Const.definition ⟨lvls, typ', .definition, val', .opaque, false, []⟩
-  tryAddLeanDecl (makeLeanDef a.toUniqueName lvls typ val)
-  return (a, m)
+  let anonConst := Ix.Const.definition 
+    ⟨.anonymous, lvls, typ', .definition, val', .opaque, false, []⟩
+  let anonIxon <- match constToIxon anonConst with
+    | .ok (a, _) => pure a
+    | .error e => throw (.transportError e)
+  let anonAddr <- storeConst anonIxon
+  let name := anonAddr.toUniqueName
+  let const := 
+    Ix.Const.definition ⟨name, lvls, typ', .definition, val', .opaque, false, []⟩
+  let (a, m) <- hashConst const
+  if a != anonAddr then
+    throw <| .alphaInvarianceFailure anonConst anonAddr const a
+  else
+    tryAddLeanDef (makeLeanDef a.toUniqueName lvls typ val)
+    return (a, m)
 
 partial def commitConst (anon meta: Address)
   : CompileM (Address × Address) := do
@@ -791,7 +913,7 @@ partial def commitDef
   : CompileM (Address × Address) := do
   let (a, m) <- addDef lvls typ val
   let (ca, cm) <- commitConst a m
-  tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ val)
+  tryAddLeanDef (makeLeanDef ca.toUniqueName lvls typ val)
   --tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ (mkConst a.toUniqueName []))
   return (ca, cm)
 
@@ -853,14 +975,20 @@ def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
   : CompileM Unit := do
   delta.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
 
-def CompileM.runIO (env: Lean.Environment) (c : CompileM α) (maxHeartBeats: USize := 200000)
+def CompileM.runIO (c : CompileM α) 
+  (env: Lean.Environment)
+  (maxHeartBeats: USize := 200000)
+  (seed : Option Nat := .none)
   : IO (α × CompileState) := do
-  match c.run (.init maxHeartBeats) (.init env (<- IO.monoNanosNow)) with
+  let seed <- match seed with
+    | .none => IO.monoNanosNow
+    | .some s => pure s
+  match c.run (.init maxHeartBeats) (.init env seed) with
   | .ok a stt => do
     stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
     return (a, stt)
   | .error e _ => throw (IO.userError (<- e.pretty))
 
 def compileEnvIO (env: Lean.Environment) : IO CompileState := do
-  Prod.snd <$> CompileM.runIO env (compileDelta env.getDelta)
+  Prod.snd <$> (compileDelta env.getDelta).runIO env
 
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index b0ce55fc..18bd8add 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -12,136 +12,788 @@ open Batteries (RBSet)
 open Ix.TransportM
 open Ix.Compile
 
+namespace Ix.Decompile
+
+/- the current Ix constant being decompiled -/
+structure Named where
+  name: Lean.Name
+  cont: Address
+  meta: Address
+deriving Inhabited, Repr
+
+instance : ToString Named where
+  toString n := s!"{n.cont}:{n.meta}-{n.name}"
+
+/- The local environment for the Ix -> Lean4 decompiler -/
+structure DecompileEnv where
+  names : RBMap Lean.Name (Address × Address) compare
+  store : RBMap Address Ixon.Const compare
+  univCtx : List Lean.Name
+  bindCtx : List Lean.Name
+  mutCtx  : RBMap Lean.Name Nat compare
+  current: Named
+
+/- initialize from an Ixon store and a name-index to the store -/
+def DecompileEnv.init
+  (names : RBMap Lean.Name (Address × Address) compare)
+  (store : RBMap Address Ixon.Const compare)
+  : DecompileEnv
+  := ⟨names, store, default, default, default, default⟩
+
+/- a collection of an inductive datatype with its constructors and recursors -/
+structure InductiveBlock where
+  val: Lean.ConstantInfo
+  ctors: List Lean.ConstantInfo
+  recrs: List Lean.ConstantInfo
+deriving Repr
+
+def InductiveBlock.contains (i: InductiveBlock) (name: Lean.Name) : Bool := 
+  i.val.name == name ||
+  i.ctors.any (fun c => c.name == name) ||
+  i.recrs.any (fun r => r.name == name)
+
+/- A Block is one of the possible sets of Lean constants we could generate
+ from a pair of content and metadata Ix addresses -/
+inductive Block where
+| single : Lean.ConstantInfo -> Block
+| mutual : List Lean.ConstantInfo -> Block
+| inductive : InductiveBlock -> Block
+| mutualInductive : List InductiveBlock -> Block
+deriving Repr
+
+def Block.contains (name: Lean.Name) : Block -> Bool
+| .single const => const.name == name
+| .mutual consts => consts.any (fun c => c.name == name)
+| .inductive i => i.contains name
+| .mutualInductive is => is.any (fun i => i.contains name)
+
+/- The name of an inductive datatype with the names of its constructors and
+recursors. Used to create a BlockNames struct.
+-/
+structure InductiveBlockNames where
+  val: Lean.Name
+  ctors: List Lean.Name
+  recrs: List Lean.Name
+deriving Repr
+
+def InductiveBlockNames.contains (i: InductiveBlockNames) (name: Lean.Name) : Bool := 
+  i.val == name ||
+  i.ctors.any (fun c => c == name) ||
+  i.recrs.any (fun r => r == name)
+
+/- A BlockNames struct is the names of a Block. Naively, the decompiler
+operates by mapping content-address pairs to blocks, but since each block might
+be mapped onto by many address pairs, we only record address pair to BlockNames
+mapping, and separately keep a single level map of Lean.Name to
+Lean.ConstantInfo
+-/
+inductive BlockNames where
+| single : Lean.Name -> BlockNames
+| mutual : List Lean.Name -> BlockNames
+| inductive : InductiveBlockNames -> BlockNames
+| mutualInductive : List InductiveBlockNames -> BlockNames
+deriving Repr
+
+def BlockNames.contains (name: Lean.Name) : BlockNames -> Bool
+| .single const => const == name
+| .mutual consts => consts.any (fun c => c == name)
+| .inductive i => i.contains name
+| .mutualInductive is => is.any (fun i => i.contains name)
+
+structure DecompileState where
+  constants: RBMap Lean.Name Lean.ConstantInfo compare
+  blocks : RBMap (Address × Address) BlockNames compare
+  deriving Inhabited
+
 inductive DecompileError
-| freeLevel : List Lean.Name -> Lean.Name -> Nat -> DecompileError
-| mismatchedLevelName : List Lean.Name -> Lean.Name -> Lean.Name -> Nat -> DecompileError
-| invalidBVarIndex : List Lean.Name -> Nat -> DecompileError
-| mismatchedMutIdx : RBMap Lean.Name Nat compare -> Lean.Name -> Nat -> Nat -> DecompileError
-| unknownMutual : RBMap Lean.Name Nat compare -> Lean.Name -> Nat -> DecompileError
+| freeLevel (curr: Named) (ctx: List Lean.Name) (lvl: Lean.Name) (idx: Nat)
+| mismatchedLevelName
+  (curr: Named) (ctx: List Lean.Name) (got: Lean.Name)
+  (exp: Lean.Name) (idx: Nat)
+| invalidBVarIndex (curr: Named) (ctx: List Lean.Name) (idx: Nat)
+| mismatchedMutIdx
+  (curr: Named) (ctx: RBMap Lean.Name Nat compare) (exp: Lean.Name) 
+  (idx: Nat) (got: Nat)
+| unknownMutual 
+  (curr: Named) (ctx: RBMap Lean.Name Nat compare) (exp: Lean.Name) (idx: Nat)
+| transport (curr: Named) (err: TransportError) (cont meta: Address)
+| unknownName (curr: Named) (name: Lean.Name)
+| unknownStoreAddress (curr: Named) (exp: Address)
+| expectedIxonMetadata (curr: Named) (exp: Address) (got: Ixon.Const)
+| badProjection
+  (curr: Named) (name: Lean.Name) (cont meta: Address) (msg: String)
+| nonCongruentInductives (curr: Named) (x y: Ix.Inductive)
+| nameNotInBlockNames
+  (curr: Named) (block: BlockNames) (name: Lean.Name) (cont meta: Address)
+| nameNotInBlock
+  (curr: Named) (block: Block) (name: Lean.Name) (cont meta: Address)
+| mismatchedName
+  (curr: Named) (exp: Lean.Name) (got: Lean.Name) (cont meta: Address)
+| expectedNameInBlock
+  (curr: Named) (exp: Lean.Name) (got: BlockNames) (cont meta: Address)
+| expectedDefnBlock (curr: Named) (exp: Lean.Name) (got: Block) (cont meta: Address)
+| expectedMutDefBlock (curr: Named) (got: BlockNames) (cont meta: Address)
+| expectedMutIndBlock (curr: Named) (got: BlockNames) (cont meta: Address)
+| expectedMutIndConst (curr: Named) (got: Ix.Const) (cont meta: Address)
+| expectedMutDefConst (curr: Named) (got: Ix.Const) (cont meta: Address)
+| overloadedConstants (curr: Named) (x y: Lean.ConstantInfo)
 | todo
+deriving Repr
+
+
+def DecompileError.pretty : DecompileError -> String
+| .freeLevel c lvls n i => s!"Free level {n} at {i} with ctx {repr lvls} @ {c}"
+| .mismatchedLevelName c ctx n' n i => 
+  s!"Expected level name {n} at index {i} but got {n'} with context {repr ctx} @ {c}"
+| .invalidBVarIndex c ctx i => 
+  s!"Bound variable {i} escapes context {ctx} @ {c}"
+| .mismatchedMutIdx c ctx n i i' => 
+  s!"expected mutual recusion index {i} at name {n} but got {i'} with context {repr ctx} @ {c}"
+| .unknownMutual c ctx n i => 
+  s!"unknown mutual name {n} with expected index {i} with context {repr ctx} @ {c}"
+| .transport curr e c m => s!"decompiler transport error {e} at {c} {m} @ {curr}"
+| .unknownName c n => s!"unknown name {n} @ {c}"
+| .unknownStoreAddress c x => s!"unknown store address {x} @ {c}"
+| .expectedIxonMetadata c x ixon => s!"expected metadata at address {x}, got {repr ixon} @ {c}"
+| .badProjection curr n c m s => s!"bad projection {n} at address {c}:{m}, {s} @ {curr}"
+| .nonCongruentInductives c x y  => s!"noncongruent inductives {repr x} {repr y} @ {c}"
+| .nameNotInBlockNames curr b n c m  => s!"expected block names {repr b} at {c}:{m} to contain {n} @ {curr}"
+| .nameNotInBlock curr b n c m  => s!"expected block {repr b} at {c}:{m} to contain {n} @ {curr}"
+| .mismatchedName curr e g c m => 
+  s!"expected name {e}, got {g} at address {c} {m} @ {curr}"
+| .expectedNameInBlock curr e b c m => 
+  s!"expected name {e} in block {repr b} at address {c} {m} @ {curr}"
+| .expectedDefnBlock curr e g c m =>
+  s!"expected definition named {e}, got {repr g} at address {c} {m} @ {curr}"
+| .expectedMutDefBlock curr g c m =>
+  s!"expected mutual definition block, got {repr g} at address {c} {m} @ {curr}"
+| .expectedMutIndBlock curr g c m =>
+  s!"expected mutual inductive block, got {repr g} at address {c} {m} @ {curr}"
+| .expectedMutIndConst curr g c m =>
+  s!"expected mutual inductive constant, got {repr g} at address {c} {m} @ {curr}"
+| .expectedMutDefConst curr g c m =>
+  s!"expected mutual definition constant, got {repr g} at address {c} {m} @ {curr}"
+| .overloadedConstants curr x y => 
+  s!"overloaded constants, tried to overwrite {repr y} with {repr x} @ {curr}"
+| .todo => s!"todo"
 
-abbrev DecompileM := ReaderT CompileEnv <| EStateM DecompileError CompileState
+abbrev DecompileM := ReaderT DecompileEnv <| EStateM DecompileError DecompileState
 
-def DecompileM.run (env: CompileEnv) (stt: CompileState) (c : DecompileM α)
-  : EStateM.Result DecompileError CompileState α
+def DecompileM.run (env: DecompileEnv) (stt: DecompileState) (c : DecompileM α)
+  : EStateM.Result DecompileError DecompileState α
   := EStateM.run (ReaderT.run c env) stt
 
-def decompileLevel : Ix.Level → DecompileM Lean.Level
+-- add binding name to local context
+def withBinder (name: Lean.Name) : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
+
+-- add levels to local context
+def withLevels (lvls : List Lean.Name) : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with univCtx := lvls }
+
+-- add mutual recursion info to local context
+def withMutCtx (mutCtx : RBMap Lean.Name Nat compare) 
+  : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with mutCtx := mutCtx }
+
+def withNamed (name: Lean.Name) (cont meta: Address)
+  : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with current := ⟨name, cont, meta⟩ }
+
+-- reset local context
+def resetCtx : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := .empty }
+
+def resetCtxWithLevels (lvls: List Lean.Name) : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := .empty }
+
+def decompileLevel: Ix.Level → DecompileM Lean.Level
 | .zero => pure .zero
 | .succ u => .succ <$> decompileLevel u
 | .max a b => Lean.Level.max  <$> decompileLevel a <*> decompileLevel b
 | .imax a b => Lean.Level.imax <$> decompileLevel a <*> decompileLevel b
 | .param n i => do
-  match (<- read).univCtx[i]? with
-  | some n' => 
+  let env <- read
+  match env.univCtx[i]? with
+  | some n' =>
     if n == n' then pure (Lean.Level.param n)
-    else throw (.mismatchedLevelName (<- read).univCtx n' n i)
-  | none => throw <| .freeLevel (<- read).univCtx n i
-
-mutual
-
-partial def decompileExpr : Ix.Expr → DecompileM Lean.Expr
-| .var i      => do match (← read).bindCtx[i]? with
-  | some _ => return .bvar i
-  | none => throw $ .invalidBVarIndex (<-read).bindCtx i
-| .sort u     => Lean.Expr.sort <$> decompileLevel u
-| .lit l      => pure (.lit l)
-| .app f a    => Lean.mkApp <$> decompileExpr f <*> decompileExpr a
-| .lam n bi t b =>
-    Lean.mkLambda n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
-| .pi n bi t b =>
-    Lean.mkForall n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
-| .letE n t v b nd =>
-    (@Lean.mkLet n) 
-      <$> decompileExpr t
-      <*> decompileExpr v 
-      <*> withBinder n (decompileExpr b)
-      <*> pure nd
-| .proj n cont meta i e => do
-    ensureConst n cont meta
-    Lean.mkProj n i <$> decompileExpr e
-| .const n cont meta us => do
-    ensureConst n cont meta
-    return Lean.mkConst n (<- us.mapM decompileLevel)
-| .rec_ n i us => do match (<- read).mutCtx.find? n with
-  | some i' =>
-    if i == i' then do
-      return Lean.mkConst n (<- us.mapM decompileLevel)
-    else throw <| .mismatchedMutIdx (<- read).mutCtx n i i'
-  | none => throw <| .unknownMutual (<- read).mutCtx n i
-
-partial def ensureConst (name: Lean.Name) (cont meta: Address) : DecompileM Unit := do
-  --match (<- get).names.find? n 
-  sorry
-
-partial def decompileMutCtx (ctx: List (List Lean.Name)) 
-  : DecompileM (RBMap Lean.Name Nat compare) := do
-  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
-  for (ns, i) in List.zipIdx ctx do
-    for n in ns do
-      mutCtx := mutCtx.insert n i
-  return mutCtx
-
-partial def decompileConst (name: Lean.Name): Ix.Const -> DecompileM (List Lean.ConstantInfo)
-| .axiom x => withLevels x.levelParams do
-  let type <- decompileExpr x.type
-  return [.axiomInfo (Lean.mkAxiomValEx name x.levelParams type false)]
-| .definition x => List.singleton <$> decompileDefn name x
-| .inductive x => decompileIndc x
-| .quotient x => withLevels x.levelParams do
-  let type <- decompileExpr x.type
-  return [.quotInfo <| Lean.mkQuotValEx name x.levelParams type x.kind]
-| .inductiveProj x => sorry
-| .constructorProj x => sorry
-| .recursorProj x => sorry
-| .definitionProj x => sorry
-| .mutDefBlock x => do
-  let mutCtx <- decompileMutCtx x.ctx
-  withMutCtx mutCtx do
-    let mut vals := #[]
-    for (defns, names) in List.zip x.defs x.ctx do
-      for (defn, name) in List.zip defns names do
-        let d <- decompileDefn name defn
-        vals := vals.push d
-    return vals.toList
-| .mutIndBlock x => sorry
-where
-  decompileDefn (name: Lean.Name) (x: Ix.Definition) : DecompileM Lean.ConstantInfo := 
-    withLevels x.levelParams do
-      let type <- decompileExpr x.type
-      let val <- decompileExpr x.type
-      let safety := if x.isPartial then .«partial» else .safe
-      match x.mode with
-      | .definition => return .defnInfo <|
-        Lean.mkDefinitionValEx name x.levelParams type val x.hints safety x.all
-      | .opaque => return .opaqueInfo <|
-        Lean.mkOpaqueValEx name x.levelParams type val true x.all
-      | .theorem => return .thmInfo <|
-        Lean.mkTheoremValEx name x.levelParams type val x.all
-  decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
-    : DecompileM Lean.ConstantInfo := do
-    let type <- decompileExpr x.type
-    return .ctorInfo <|
-      Lean.mkConstructorValEx x.name x.levelParams type indcName 
-        x.cidx x.numParams x.numFields false
-  decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
-    let rhs <- decompileExpr x.rhs
-    return ⟨x.ctor, x.nfields, rhs⟩
-  decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
-    : DecompileM Lean.ConstantInfo := do
-    let type <- decompileExpr x.type
-    let rules <- x.rules.mapM decompileRecrRule
-    return .recInfo <|
-      Lean.mkRecursorValEx x.name x.levelParams type indcAll
-        x.numParams x.numIndices x.numMotives x.numMinors rules x.k false
-  decompileIndc (x: Ix.Inductive) : DecompileM (List Lean.ConstantInfo) := 
-    withLevels x.levelParams do
-      let type <- decompileExpr x.type
-      let indc :=
-        Lean.mkInductiveValEx name x.levelParams type x.numParams x.numIndices
-          x.all (x.ctors.map (·.name)) x.numNested x.isRec false x.isReflexive
-      let ctors <- x.ctors.mapM (decompileCtor name)
-      let recrs <- x.recrs.mapM (decompileRecr x.all)
-      return .inductInfo indc :: ctors ++ recrs
-
-end
+    else throw (.mismatchedLevelName env.current env.univCtx n' n i)
+  | none => throw <| .freeLevel env.current env.univCtx n i
+
+partial def insertConst
+  (const: Lean.ConstantInfo)
+  : DecompileM Lean.Name := do
+  match (<- get).constants.find? const.name with
+  | .some const' =>
+      if const == const' then return const.name
+      else throw <| .overloadedConstants (<- read).current const const'
+  | .none => modify fun stt => 
+    { stt with constants := stt.constants.insert const.name const }
+    return const.name
+
+partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
+  let bn <- match b with
+    | .single const => .single <$> insertConst const
+    | .mutual cs => .mutual <$> cs.mapM insertConst
+    | .inductive i => .inductive <$> insertInductive i
+    | .mutualInductive is => .mutualInductive <$> is.mapM insertInductive
+  modifyGet fun stt =>
+    (bn, { stt with blocks := stt.blocks.insert (c, m) bn })
+  where
+    insertInductive (i: InductiveBlock) : DecompileM InductiveBlockNames := do
+      let val <- insertConst i.val
+      let ctors <- i.ctors.mapM insertConst
+      let recrs <- i.recrs.mapM insertConst
+      return ⟨val, ctors, recrs⟩
+
+--mutual
+--
+--partial def decompileExpr: Ix.Expr → DecompileM Lean.Expr
+--| .var i      => do match (← read).bindCtx[i]? with
+--  | some _ => return .bvar i
+--  | none => throw <| .invalidBVarIndex (<-read).current (<-read).bindCtx i
+--| .sort u     => Lean.Expr.sort <$> decompileLevel u
+--| .lit l      => pure (.lit l)
+--| .app f a    => Lean.mkApp <$> decompileExpr f <*> decompileExpr a
+--| .lam n bi t b =>
+--    Lean.mkLambda n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
+--| .pi n bi t b =>
+--    Lean.mkForall n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
+--| .letE n t v b nd =>
+--    (@Lean.mkLet n)
+--      <$> decompileExpr t
+--      <*> decompileExpr v
+--      <*> withBinder n (decompileExpr b)
+--      <*> pure nd
+--| .proj n cont meta i e => do
+--    let _ <- ensureBlock n cont meta
+--    Lean.mkProj n i <$> decompileExpr e
+--| .const n cont meta us => do
+--    let _ <- ensureBlock n cont meta
+--    return Lean.mkConst n (<- us.mapM decompileLevel)
+--| .rec_ n i us => do match (<- read).mutCtx.find? n with
+--  | some i' =>
+--    if i == i' then return Lean.mkConst n (<- us.mapM decompileLevel)
+--    else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx n i i'
+--  | none => throw <| .unknownMutual (<- read).current (<- read).mutCtx n i
+--
+--partial def ensureBlock (name: Lean.Name) (c m: Address) : DecompileM BlockNames := do
+--  match (<- get).blocks.find? (c, m) with
+--  | .some b =>
+--    if b.contains name then pure b
+--    else throw <| .nameNotInBlockNames (<- read).current b name c m
+--  | .none =>
+--    let cont : Ixon.Const <- match (<- read).store.find? c with
+--      | .some ixon => pure ixon
+--      | .none => throw <| .unknownStoreAddress (<- read).current c
+--    let meta : Ixon.Metadata <- match (<- read).store.find? m with
+--      | .some (.meta meta) => pure meta
+--      | .some x => throw <| .expectedIxonMetadata (<- read).current m x
+--      | .none => throw <| .unknownStoreAddress (<- read).current m
+--    match rematerialize cont meta with
+--    | .ok const  => do
+--      let blockNames <- withNamed name c m <| decompileConst const
+--      if !blockNames.contains name then
+--         throw <| .nameNotInBlockNames (<- read).current blockNames name c m
+--      return blockNames
+--    | .error e => throw (.transport (<- read).current e c m)
+--
+--partial def decompileDefn (x: Ix.Definition)
+--  : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+--    let type <- decompileExpr x.type
+--    let val <- decompileExpr x.value
+--    let safety := if x.isPartial then .«partial» else .safe
+--    match x.mode with
+--    | .definition => return .defnInfo <|
+--      Lean.mkDefinitionValEx x.name x.levelParams type val x.hints safety x.all
+--    | .opaque => return .opaqueInfo <|
+--      Lean.mkOpaqueValEx x.name x.levelParams type val true x.all
+--    | .theorem => return .thmInfo <|
+--      Lean.mkTheoremValEx x.name x.levelParams type val x.all
+--
+--partial def decompileIndc (x: Ix.Inductive)
+--  : DecompileM
+--    (Lean.ConstantInfo × List Lean.ConstantInfo × List Lean.ConstantInfo)
+--    := withLevels x.levelParams do
+--      let type <- decompileExpr x.type
+--      let indc :=
+--        Lean.mkInductiveValEx x.name x.levelParams type x.numParams x.numIndices
+--          x.all (x.ctors.map (·.name)) x.numNested x.isRec false x.isReflexive
+--      let ctors <- x.ctors.mapM (decompileCtor x.name)
+--      let recrs <- x.recrs.mapM (decompileRecr x.all)
+--      return (.inductInfo indc, ctors, recrs)
+--  where
+--    decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
+--      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+--      let type <- decompileExpr x.type
+--      return .ctorInfo <|
+--        Lean.mkConstructorValEx x.name x.levelParams type indcName
+--          x.cidx x.numParams x.numFields false
+--    decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
+--      let rhs <- decompileExpr x.rhs
+--      return ⟨x.ctor, x.nfields, rhs⟩
+--    decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
+--      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+--      let type <- decompileExpr x.type
+--      let rules <- x.rules.mapM decompileRecrRule
+--      return .recInfo <|
+--        Lean.mkRecursorValEx x.name x.levelParams type indcAll
+--          x.numParams x.numIndices x.numMotives x.numMinors rules x.k false
+--
+--partial def decompileConst : Ix.Const -> DecompileM BlockNames
+--| .axiom x => withLevels x.levelParams do
+--  let ⟨name, c, m⟩ := (<- read).current
+--  let type <- decompileExpr x.type
+--  let const := (.axiomInfo <| Lean.mkAxiomValEx name x.levelParams type false)
+--  insertBlock c m (.single const)
+--| .definition x => do
+--  let ⟨name, c, m⟩ := (<- read).current
+--  let const <- decompileDefn x
+--  insertBlock c m (.single const)
+--| .inductive x => do
+--  let ⟨name, c, m⟩ := (<- read).current
+--  let (i, cs, rs) <- decompileIndc x
+--  insertBlock c m (.inductive ⟨i, cs, rs⟩)
+--| .quotient x => withLevels x.levelParams do
+--  let ⟨name, c, m⟩ := (<- read).current
+--  let type <- decompileExpr x.type
+--  let const := (.quotInfo <| Lean.mkQuotValEx name x.levelParams type x.kind)
+--  insertBlock c m (.single const)
+--| .inductiveProj x => do
+--  let curr@⟨name, c, m⟩ := (<- read).current
+--  let bs <- ensureBlock name x.blockCont x.blockMeta
+--  match bs with
+--  | .inductive ⟨i, _, _⟩ => 
+--    if x.idx == 0 && i == name then return bs
+--    else throw (.badProjection curr i x.blockCont x.blockMeta "inductive")
+--  | .mutualInductive is => match is[x.idx]? with
+--    | .some ⟨i, _, _⟩ =>
+--       if i == name then return bs
+--       else throw (.badProjection curr i x.blockCont x.blockMeta "mutual")
+--    | .none => throw (.badProjection curr name x.blockCont x.blockMeta "mutual no idx")
+--  | _ => throw (.badProjection curr name x.blockCont x.blockMeta "not inductive")
+--| .constructorProj x => do
+--  let curr@⟨name, c, m⟩ := (<- read).current
+--  let bs <- ensureBlock name.parent x.blockCont x.blockMeta
+--  let cs <- match bs with
+--    | .inductive ⟨i, cs, _⟩ => 
+--      if x.idx == 0 && i == name.parent then pure cs
+--      else throw (.badProjection curr i x.blockCont x.blockMeta "inductive")
+--    | .mutualInductive is => match is[x.idx]? with
+--      | .some ⟨i, cs, _⟩ =>
+--         if i == name then pure cs
+--         else throw (.badProjection curr i x.blockCont x.blockMeta "mutual")
+--      | .none => throw (.badProjection curr name x.blockCont x.blockMeta "mutual no idx")
+--    | _ => throw (.badProjection curr name x.blockCont x.blockMeta "not inductive")
+--  --match cs[x.cidx]
+--  return bs
+--| _ => sorry
+--
+----partial def decompileConst
+----  (n: Lean.Name) (c m: Address): Ix.Const -> DecompileM Unit
+----| .constructorProj x => do
+----  ensureIndBlock n x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.indcs ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let (_, cs, _) <- match ns[x.idx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
+----  let n <- match cs[x.cidx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta s!"bad ctor idx {x.cidx} {cs}"
+----    if n == n then return () else 
+----      throw <| .badProjection n x.blockCont x.blockMeta "ctor name mismatch"
+----| .recursorProj x => do
+----  ensureIndBlock n x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.indcs ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let (_, _, rs) <- match ns[x.idx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
+----  let n <- match rs[x.ridx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad recr idx"
+----    if n == n then return () else
+----      throw <| .badProjection n x.blockCont x.blockMeta "recr name mismatch"
+----| .definitionProj x => do
+----  ensureMutDefBlock x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.defns ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not defns block"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let n <- match ns[x.idx]? with
+----    | .some n => pure n 
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad defn idx"
+----    if n == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "defn name mismatch"
+------ these should be unreachable here
+----| .mutDefBlock x => throw <| .namedMutDefBlock n x
+----| .mutIndBlock x => throw <| .namedMutIndBlock n x
+----
+--
+--end
+--
+----partial def ensureConst'
+----  (c m: Address) (n: Option Lean.Name) : DecompileM Unit := do
+----  match n, (<- get).blocks.find? (c, m) with
+----  | .some name, .some b =>
+----    if b.contains name then return ()
+----    else throw <| .expectedNameInBlock name b c m
+----  | .none, .some b => return ()
+----  | n, .none => do
+----    let cont : Ixon.Const <- match (<- get).store.find? c with
+----      | .some ixon => pure ixon
+----      | .none => throw <| .unknownStoreAddress c
+----    let meta : Ixon.Metadata <- match (<- get).store.find? m with
+----      | .some (.meta meta) => pure meta
+----      | .some x => throw <| .expectedIxonMetadata m x
+----      | .none => throw <| .unknownStoreAddress m
+----    match rematerialize cont meta with
+----    | .ok const  => do
+----      let consts <- decompileConst' c m n const
+----
+----    | .error e => throw (.transport e c m)
+--
+----partial def ensureConst (name: Lean.Name) (cont meta: Address) : DecompileM Unit := do
+----  match (<- get).blocks.find? (cont, meta) with
+----  | .some (.defn n) => 
+----    if n == name then return () else throw <| .mismatchedName name n cont meta
+----  | .some x => throw <| .expectedDefnBlock name x cont meta
+----  | .none => do
+----    let c : Ixon.Const <- match (<- get).store.find? cont with
+----      | .some ixon => pure ixon
+----      | .none => throw <| .unknownStoreAddress cont
+----    let m : Ixon.Metadata <- match (<- get).store.find? meta with
+----      | .some (.meta meta) => pure meta
+----      | .some x => throw <| .expectedIxonMetadata meta x
+----      | .none => throw <| .unknownStoreAddress meta
+----    match rematerialize c m with
+----    | .ok a  => decompileConst name cont meta a
+----    | .error e => throw (.transport e cont meta)
+----
+----partial def ensureIndBlock (n: Lean.Name) (cont meta: Address) : DecompileM Unit := do
+----  match (<- get).blocks.find? (cont, meta) with
+----  | .some (.indcs _) => return ()
+----  | .some x => throw <| .expectedMutIndBlock x cont meta
+----  | .none => do
+----    let c : Ixon.Const <- match (<- get).store.find? cont with
+----      | .some ixon => pure ixon
+----      | .none => throw <| .unknownStoreAddress cont
+----    let m : Ixon.Metadata <- match (<- get).store.find? meta with
+----      | .some (.meta meta) => pure meta
+----      | .some x => throw <| .expectedIxonMetadata meta x
+----      | .none => throw <| .unknownStoreAddress meta
+----    match rematerialize c m with
+----    | .ok (.mutIndBlock x)  => decompileMutIndBlock x cont meta
+----    | .ok c@(.«inductive» x) => decompileConst n cont meta c
+----    | .ok x => throw <| .expectedMutIndConst x cont meta
+----    | .error e => throw (.transport e cont meta)
+----
+----partial def ensureMutDefBlock (cont meta: Address) : DecompileM Unit := do
+----  match (<- get).blocks.find? (cont, meta) with
+----  | .some (.defns _) => return ()
+----  | .some x => throw <| .expectedMutDefBlock x cont meta
+----  | .none => do
+----    let c : Ixon.Const <- match (<- get).store.find? cont with
+----      | .some ixon => pure ixon
+----      | .none => throw <| .unknownStoreAddress cont
+----    let m : Ixon.Metadata <- match (<- get).store.find? meta with
+----      | .some (.meta meta) => pure meta
+----      | .some x => throw <| .expectedIxonMetadata meta x
+----      | .none => throw <| .unknownStoreAddress meta
+----    match rematerialize c m with
+----    | .ok (.mutDefBlock x)  => decompileMutDefBlock x cont meta
+----    | .ok x  => throw <| .expectedMutDefConst x cont meta
+----    | .error e => throw (.transport e cont meta)
+----
+----partial def decompileMutDefCtx (ctx: List (List Lean.Name)) 
+----  : DecompileM (RBMap Lean.Name Nat compare) := do
+----  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
+----  for (ns, i) in List.zipIdx ctx do
+----    for n in ns do
+----      mutCtx := mutCtx.insert n i
+----  return mutCtx
+----
+----partial def checkCtorRecrLengths : List Ix.Inductive -> DecompileM (Nat × Nat)
+----| [] => return (0, 0)
+----| x::xs => go x xs
+----  where
+----    go : Ix.Inductive -> List Ix.Inductive -> DecompileM (Nat × Nat)
+----    | x, [] => return (x.ctors.length, x.recrs.length)
+----    | x, a::as =>
+----      if x.ctors.length == a.ctors.length && x.recrs.length == a.recrs.length
+----      then go x as else throw <| .nonCongruentInductives x a
+----
+----partial def decompileMutIndCtx (block: Ix.MutualInductiveBlock)
+----  : DecompileM (RBMap Lean.Name Nat compare) := do
+----  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
+----  let mut i := 0
+----  for (inds, names) in List.zip block.inds block.ctx do
+----    let (numCtors, numRecrs) <- checkCtorRecrLengths inds
+----    for (ind, name) in List.zip inds names do
+----      mutCtx := mutCtx.insert name i
+----      for (c, cidx) in List.zipIdx ind.ctors do
+----        mutCtx := mutCtx.insert c.name (i + cidx)
+----      for (r, ridx) in List.zipIdx ind.recrs do
+----        mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
+----    i := i + 1 + numCtors + numRecrs
+----  return mutCtx
+----
+----partial def tryInsertConst
+----  (const: Lean.ConstantInfo)
+----  : DecompileM Unit := do
+----  match (<- get).env.find? const.name with
+----  | .some const' =>
+----      if const == const'
+----      then return ()
+----      else throw <| .inconsistentConsts const const'
+----  | .none => modify fun stt => { stt with env := stt.env.insert const.name const }
+----
+----partial def decompileDefn (name: Lean.Name) (c m : Address) (x: Ix.Definition)
+----  : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+----    let type <- decompileExpr c m x.type
+----    let val <- decompileExpr c m x.value
+----    let safety := if x.isPartial then .«partial» else .safe
+----    match x.mode with
+----    | .definition => return .defnInfo <|
+----      Lean.mkDefinitionValEx name x.levelParams type val x.hints safety x.all
+----    | .opaque => return .opaqueInfo <|
+----      Lean.mkOpaqueValEx name x.levelParams type val true x.all
+----    | .theorem => return .thmInfo <|
+----      Lean.mkTheoremValEx name x.levelParams type val x.all
+----
+----partial def decompileIndc 
+----  (name: Lean.Name)
+----  (c m : Address)
+----  (x: Ix.Inductive) :
+----  DecompileM 
+----    (Lean.ConstantInfo × List Lean.ConstantInfo × List Lean.ConstantInfo)
+----    := withLevels x.levelParams do
+----      let type <- decompileExpr c m x.type
+----      let indc :=
+----        Lean.mkInductiveValEx name x.levelParams type x.numParams x.numIndices
+----          x.all (x.ctors.map (·.name)) x.numNested x.isRec false x.isReflexive
+----      let ctors <- x.ctors.mapM (decompileCtor name)
+----      let recrs <- x.recrs.mapM (decompileRecr x.all)
+----      return (.inductInfo indc, ctors, recrs)
+----  where
+----    decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
+----      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+----      let type <- decompileExpr c m x.type
+----      return .ctorInfo <|
+----        Lean.mkConstructorValEx x.name x.levelParams type indcName 
+----          x.cidx x.numParams x.numFields false
+----    decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
+----      let rhs <- decompileExpr c m x.rhs
+----      return ⟨x.ctor, x.nfields, rhs⟩
+----    decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
+----      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+----      let type <- decompileExpr c m x.type
+----      let rules <- x.rules.mapM decompileRecrRule
+----      return .recInfo <|
+----        Lean.mkRecursorValEx x.name x.levelParams type indcAll
+----          x.numParams x.numIndices x.numMotives x.numMinors rules x.k false
+----
+----partial def ensureConst'
+----  (c m: Address) (n: Option Lean.Name) : DecompileM Unit := do
+----  match n, (<- get).blocks.find? (c, m) with
+----  | .some name, .some b =>
+----    if b.contains name then return ()
+----    else throw <| .expectedNameInBlock name b c m
+----  | .none, .some b => return ()
+----  | n, .none => do
+----    let cont : Ixon.Const <- match (<- get).store.find? c with
+----      | .some ixon => pure ixon
+----      | .none => throw <| .unknownStoreAddress c
+----    let meta : Ixon.Metadata <- match (<- get).store.find? m with
+----      | .some (.meta meta) => pure meta
+----      | .some x => throw <| .expectedIxonMetadata m x
+----      | .none => throw <| .unknownStoreAddress m
+----    match rematerialize cont meta with
+----    | .ok const  => do
+----      let consts <- decompileConst' c m n const
+----
+----    | .error e => throw (.transport e c m)
+----
+----
+----partial def decompileConst' (c m: Address)
+----  : Option Lean.Name -> Ix.Const -> DecompileM (List Lean.ConstantInfo)
+----| .some n, .«axiom» x => withLevels x.levelParams do
+----  let type <- decompileExpr c m x.type
+----  return [.axiomInfo <| Lean.mkAxiomValEx n x.levelParams type false]
+----| .some n, .«definition» x => do
+----  let d <- decompileDefn n c m x
+----  return [d]
+----| .some n, .«inductive» x => do
+----  let (i, _, _) <- decompileIndc n c m x
+----  return [i]
+----| .some n, .quotient x => withLevels x.levelParams do
+----  let type <- decompileExpr c m x.type
+----  return [.quotInfo <| Lean.mkQuotValEx n x.levelParams type x.kind]
+----| .some n, .inductiveProj x => do
+----  ensureConst (.some n) x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.indcs ns) => pure ns
+----    | .some (.indc n) => pure [n]
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indcs or indc block"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let (i, _, _) <- match ns[x.idx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
+----    if i == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "indc name mismatch"
+----| .constructorProj x => do
+----  ensureIndBlock n x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.indcs ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let (_, cs, _) <- match ns[x.idx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
+----  let n <- match cs[x.cidx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta s!"bad ctor idx {x.cidx} {cs}"
+----    if n == n then return () else 
+----      throw <| .badProjection n x.blockCont x.blockMeta "ctor name mismatch"
+----| .recursorProj x => do
+----  ensureIndBlock n x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.indcs ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let (_, _, rs) <- match ns[x.idx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
+----  let n <- match rs[x.ridx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad recr idx"
+----    if n == n then return () else
+----      throw <| .badProjection n x.blockCont x.blockMeta "recr name mismatch"
+----| .definitionProj x => do
+----  ensureMutDefBlock x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.defns ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not defns block"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let n <- match ns[x.idx]? with
+----    | .some n => pure n 
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad defn idx"
+----    if n == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "defn name mismatch"
+----| .none, .mutDefBlock x => sorry
+----| .none, .mutIndBlock x => sorry
+----
+----
+----partial def decompileConst
+----  (n: Lean.Name) (c m: Address): Ix.Const -> DecompileM Unit
+----| .axiom x => withLevels x.levelParams do
+----  let type <- decompileExpr c m x.type
+----  let val := Lean.mkAxiomValEx n x.levelParams type false
+----  tryInsertConst (.axiomInfo val)
+----| .definition x => do
+----  decompileDefn n c m x >>= tryInsertConst
+----  modify fun stt => 
+----    { stt with blocks := stt.blocks.insert (c, m) (.defn i) }
+----| .inductive x => do
+----  let (i, cs, rs) <- decompileIndc n c m x
+----  tryInsertConst i
+----  let cns <- cs.mapM <| fun c => tryInsertConst c *> pure c.name
+----  let rns <- rs.mapM <| fun r => tryInsertConst r *> pure r.name
+----  modify fun stt => 
+----    { stt with blocks := stt.blocks.insert (c, m) (.indcs [(i.name, cns, rns)]) }
+----| .quotient x => withLevels x.levelParams do
+----  let type <- decompileExpr c m x.type
+----  let val :=  Lean.mkQuotValEx n x.levelParams type x.kind
+----  tryInsertConst (.quotInfo val)
+----| .inductiveProj x => do
+----  ensureIndBlock n x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.indcs ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indcs block"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let (i, _, _) <- match ns[x.idx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
+----    if i == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "indc name mismatch"
+----| .constructorProj x => do
+----  ensureIndBlock n x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.indcs ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let (_, cs, _) <- match ns[x.idx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
+----  let n <- match cs[x.cidx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta s!"bad ctor idx {x.cidx} {cs}"
+----    if n == n then return () else 
+----      throw <| .badProjection n x.blockCont x.blockMeta "ctor name mismatch"
+----| .recursorProj x => do
+----  ensureIndBlock n x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.indcs ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let (_, _, rs) <- match ns[x.idx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
+----  let n <- match rs[x.ridx]? with
+----    | .some ns => pure ns
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad recr idx"
+----    if n == n then return () else
+----      throw <| .badProjection n x.blockCont x.blockMeta "recr name mismatch"
+----| .definitionProj x => do
+----  ensureMutDefBlock x.blockCont x.blockMeta
+----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
+----    | .some (.defns ns) => pure ns
+----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not defns block"
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
+----  let n <- match ns[x.idx]? with
+----    | .some n => pure n 
+----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad defn idx"
+----    if n == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "defn name mismatch"
+------ these should be unreachable here
+----| .mutDefBlock x => throw <| .namedMutDefBlock n x
+----| .mutIndBlock x => throw <| .namedMutIndBlock n x
+----
+----partial def decompileMutDefBlock
+----  (x: Ix.MutualDefinitionBlock)
+----  (c m: Address)
+----  : DecompileM Unit := do
+----  let mutCtx <- decompileMutDefCtx x.ctx
+----  withMutCtx mutCtx do
+----    let mut block := #[]
+----    for (defns, names) in List.zip x.defs x.ctx do
+----      for (defn, name) in List.zip defns names do
+----        decompileDefn name c m defn >>= tryInsertConst
+----        block := block.push name
+----    modify fun stt => 
+----      { stt with blocks := stt.blocks.insert (c, m) (.defns block.toList) }
+----
+----partial def decompileMutIndBlock
+----  (x: Ix.MutualInductiveBlock)
+----  (c m: Address)
+----  : DecompileM Unit := do
+----  let mutCtx <- decompileMutIndCtx x
+----  withMutCtx mutCtx do
+----    let mut block := #[]
+----    for (inds, names) in List.zip x.inds x.ctx do
+----      for (ind, name) in List.zip inds names do
+----        let (i, cs, rs) <- decompileIndc name c m ind
+----        tryInsertConst i
+----        let cs <- cs.mapM <| fun c => tryInsertConst c *> pure c.name
+----        let rs <- rs.mapM <| fun r => tryInsertConst r *> pure r.name
+----        block := block.push (i.name, cs, rs)
+----    modify fun stt =>
+----      { stt with blocks := stt.blocks.insert (c, m) (.indcs block.toList)}
+----
+----end
+----
+----def decompileEnv : DecompileM Unit := do
+----  for (n, (anon, meta)) in (<- get).names do
+----    ensureConst n anon meta
+--
+--end Decompile
diff --git a/Ix/IR.lean b/Ix/IR.lean
index a5c87d94..6874542d 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -70,7 +70,7 @@ are closed.
     Boolean.and Loobean.false.toBoolean Loobean.false.toBoolean
    ```
 
-   However, we have not rigourously demonstrated this yet, and therefore best
+   However, we have not rigorously demonstrated this yet, and therefore best
    practice is to only pass environments to Ix which have passed Lean
    typechecking to sanitize this case.
 -/
@@ -110,6 +110,7 @@ inductive Expr
 Ix.Quotient quotients are analogous to Lean.QuotVal
 --/
 structure Quotient where
+  name: Lean.Name
   levelParams : List Lean.Name
   type : Expr
   kind : Lean.QuotKind
@@ -120,11 +121,11 @@ Ix.Axiom axioms are analogous to Lean.AxiomVal, differing only in not including
 the `isUnsafe` parameter, as Ix constants are never unsafe
 --/
 structure Axiom where
+  name: Lean.Name
   levelParams : List Lean.Name
   type : Expr
   deriving Ord, BEq, Hashable, Repr, Nonempty
 
-
 /--
 Ix.Definition definitions combine Lean.DefinitionVal, Lean.OpaqueVal and
 Lean.TheoremVal into a single structure in order to enable content-addressing of
@@ -136,6 +137,7 @@ replaced with a boolean for partial definitions, as Ix definitions are
 restricted to exclude unsafe constants.
 --/
 structure Definition where
+  name: Lean.Name
   levelParams : List Lean.Name
   type : Expr
   mode: DefMode
@@ -146,20 +148,22 @@ structure Definition where
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 def mkTheorem
+  (name: Lean.Name)
   (levelParams: List Lean.Name)
   (type: Expr)
   (value: Expr)
   (all: List Lean.Name)
   : Definition
-  := ⟨levelParams, type, .theorem, value, .opaque, false, all⟩
+  := ⟨name, levelParams, type, .theorem, value, .opaque, false, all⟩
 
 def mkOpaque
+  (name: Lean.Name)
   (levelParams: List Lean.Name)
   (type: Expr)
   (value: Expr)
   (all: List Lean.Name)
   : Definition
-  := ⟨levelParams, type, .opaque, value, .opaque, false, all⟩
+  := ⟨name, levelParams, type, .opaque, value, .opaque, false, all⟩
 
 /--
 Ix.Constructor inductive datatype constructors are analogous to
@@ -207,12 +211,31 @@ structure Recursor where
   k : Bool
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
+/--
+Ix.PreInductive is used to capture a Lean.InductiveVal along with their
+constructors and recursors, in order to perform structural sorting
+--/
+structure PreInductive where
+  name: Lean.Name
+  levelParams : List Lean.Name
+  type : Lean.Expr
+  numParams : Nat
+  numIndices : Nat
+  all : List Lean.Name
+  ctors : List Lean.ConstructorVal
+  recrs : List Lean.RecursorVal
+  numNested: Nat
+  isRec : Bool
+  isReflexive : Bool
+  deriving BEq, Repr, Nonempty
+
 /--
 Ix.Inductive represents inductive datatypes and is analogous to
 Lean.InductiveVal. However, unlike in Lean, Ix.Inductive directly contains its
 corresponding Constructors and Recursors in order to enable content-addressing.
 --/
 structure Inductive where
+  name: Lean.Name
   levelParams : List Lean.Name
   type : Expr
   numParams : Nat
@@ -225,7 +248,10 @@ structure Inductive where
   isReflexive : Bool
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
+
 structure InductiveProj where
+  /-- name of an inductive within a mutual inductive block --/
+  name: Lean.Name
   /-- content-address of a mutual inductive block --/
   blockCont : Address
   /-- metadata content-address a mutual inductive block --/
@@ -235,28 +261,37 @@ structure InductiveProj where
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure ConstructorProj where
+  /-- name of a specific constructor within an inductive --/
+  name: Lean.Name
   /-- content-address of a mutual inductive block --/
   blockCont : Address
   /-- metadata content-address a mutual inductive block --/
   blockMeta : Address
   /-- index of a specific inductive datatype within the block --/
   idx   : Nat
+  /-- name of a specific inductive datatype within the block --/
+  induct: Lean.Name
   /-- index of a specific constructor within the inductive --/
   cidx  : Nat
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure RecursorProj where
+  /-- name of a specific recursor within the inductive --/
+  name: Lean.Name
   /-- content-address of a mutual inductive block --/
   blockCont : Address
   /-- metadata content-address of a mutual inductive block --/
   blockMeta : Address
   /-- index of a specific inductive datatype within the block --/
   idx : Nat
+  /-- name of a specific inductive datatype within the block --/
+  induct: Lean.Name
   /-- index of a specific recursor within the inductive --/
   ridx : Nat
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 structure DefinitionProj where
+  name: Lean.Name
   /-- content-address of a mutual definition block --/
   blockCont : Address
   /-- metadata content-address of a mutual definition block --/
@@ -270,6 +305,11 @@ structure MutualDefinitionBlock where
   ctx  : List (List Lean.Name)
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
+structure MutualInductiveBlock where
+  inds : List (List Inductive)
+  ctx  : List (List Lean.Name)
+  deriving BEq, Ord, Hashable, Repr, Nonempty, Inhabited
+
 inductive Const where
   | «axiom» : Axiom → Const
   | quotient : Quotient → Const
@@ -282,7 +322,7 @@ inductive Const where
   | definitionProj : DefinitionProj → Const
   -- constants to represent mutual blocks
   | mutDefBlock : MutualDefinitionBlock → Const
-  | mutIndBlock : List Inductive → Const
+  | mutIndBlock : MutualInductiveBlock → Const
   deriving Ord, BEq, Inhabited, Repr, Nonempty
 
 def Const.isMutBlock : Const → Bool
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index ea1567a5..b0bc373c 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -50,6 +50,7 @@ structure RematCtx where
 
 abbrev RematM := ReaderT RematCtx (EStateM TransportError RematState)
 
+
 def countSucc : Ix.Level -> Nat -> (Nat × Ix.Level)
 | .succ x, i => countSucc x (.succ i)
 | n, i => (i, n)
@@ -245,26 +246,28 @@ partial def rematExpr : Ixon.Expr -> RematM Ix.Expr
 
 partial def dematConst : Ix.Const -> DematM Ixon.Const
 | .«axiom» x => do
+  dematMeta [.name x.name]
   let lvls <- dematLevels x.levelParams
   let type <- dematExpr x.type
   return .axio (.mk lvls type)
 | .«definition» x => .defn <$> dematDefn x
 | .«inductive» x => .indc <$> dematIndc x
 | .quotient x => do
+  dematMeta [.name x.name]
   let lvls <- dematLevels x.levelParams
   let type <- dematExpr x.type
   return .quot (.mk lvls type x.kind)
 | .inductiveProj x => do
-  dematMeta [.link x.blockMeta]
+  dematMeta [.name x.name, .link x.blockMeta]
   return .indcProj (.mk x.blockCont x.idx)
 | .constructorProj x => do
-  dematMeta [.link x.blockMeta]
+  dematMeta [.name x.name, .link x.blockMeta, .name x.induct]
   return .ctorProj (.mk x.blockCont x.idx x.cidx)
 | .recursorProj x => do
-  dematMeta [.link x.blockMeta]
+  dematMeta [.name x.name, .link x.blockMeta, .name x.induct]
   return .recrProj (.mk x.blockCont x.idx x.ridx)
 | .definitionProj x => do
-  dematMeta [.link x.blockMeta]
+  dematMeta [.name x.name, .link x.blockMeta]
   return .defnProj (.mk x.blockCont x.idx)
 | .mutDefBlock x => do
   dematMeta [.mutCtx x.ctx]
@@ -273,11 +276,17 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
     | .some a => pure a
     | .none => throw .emptyEquivalenceClass
   return .mutDef ds
-| .mutIndBlock xs => .mutInd <$> (xs.mapM dematIndc)
+| .mutIndBlock x => do
+  dematMeta [.mutCtx x.ctx]
+  let inds <- x.inds.mapM fun is => is.mapM dematIndc
+  let is <- inds.mapM fun i => match i.head? with
+    | .some a => pure a
+    | .none => throw .emptyEquivalenceClass
+  return .mutInd is
   where
     dematDefn (x: Ix.Definition): DematM Ixon.Definition := do
       let _ <- dematIncr
-      dematMeta [.hints x.hints, .all x.all]
+      dematMeta [.name x.name, .hints x.hints, .all x.all]
       let lvls <- dematLevels x.levelParams
       let type <- dematExpr x.type
       let value <- dematExpr x.value
@@ -303,7 +312,7 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
         rrs, x.k⟩
     dematIndc (x: Ix.Inductive): DematM Ixon.Inductive := do
       let _ <- dematIncr
-      dematMeta [.all x.all]
+      dematMeta [.name x.name, .all x.all]
       let lvls <- dematLevels x.levelParams
       let type <- dematExpr x.type
       let ctors <- x.ctors.mapM dematCtor
@@ -328,33 +337,39 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
 | .defn x => .«definition» <$> rematDefn x
 | .indc x => .«inductive» <$> rematIndc x
 | .axio x => do
+  let name <- match (<- rematMeta) with
+    | [.name x] => pure x
+    | _ => rematThrowUnexpected
   let lvls <- rematLevels x.lvls
   let type <- rematExpr x.type
-  return .«axiom» ⟨lvls, type⟩
+  return .«axiom» ⟨name, lvls, type⟩
 | .quot x => do
+  let name <- match (<- rematMeta) with
+    | [.name x] => pure x
+    | _ => rematThrowUnexpected
   let lvls <- rematLevels x.lvls
   let type <- rematExpr x.type
-  return .quotient ⟨lvls, type, x.kind⟩
+  return .quotient ⟨name, lvls, type, x.kind⟩
 | .indcProj x => do
-  let link <- match (<- rematMeta) with
-    | [.link x] => pure x
+  let (name, link) <- match (<- rematMeta) with
+    | [.name n, .link x] => pure (n, x)
     | _ => rematThrowUnexpected
-  return .inductiveProj (.mk x.block link x.idx)
+  return .inductiveProj ⟨name, x.block, link, x.idx⟩
 | .ctorProj x => do
-  let link <- match (<- rematMeta) with
-    | [.link x] => pure x
+  let (name, link, induct) <- match (<- rematMeta) with
+    | [.name n, .link x, .name i] => pure (n, x, i)
     | _ => rematThrowUnexpected
-  return .constructorProj (.mk x.block link x.idx x.cidx)
+  return .constructorProj ⟨name, x.block, link, x.idx, induct, x.cidx⟩
 | .recrProj x => do
-  let link <- match (<- rematMeta) with
-    | [.link x] => pure x
+  let (name, link, induct) <- match (<- rematMeta) with
+    | [.name n, .link x, .name i] => pure (n, x, i)
     | _ => rematThrowUnexpected
-  return .recursorProj (.mk x.block link x.idx x.ridx)
+  return .recursorProj ⟨name, x.block, link, x.idx, induct, x.ridx⟩
 | .defnProj x => do
-  let link <- match (<- rematMeta) with
-    | [.link x] => pure x
+  let (name, link) <- match (<- rematMeta) with
+    | [.name n, .link x] => pure (n, x)
     | _ => rematThrowUnexpected
-  return .definitionProj (.mk x.block link x.idx)
+  return .definitionProj ⟨name, x.block, link, x.idx⟩
 | .mutDef xs => do
   let ctx <- match (<- rematMeta) with
     | [.mutCtx x] => pure x
@@ -367,7 +382,18 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       ds := ds.push d
     defs := defs.push ds.toList
   return .mutDefBlock ⟨defs.toList, ctx⟩
-| .mutInd xs => .mutIndBlock <$> (xs.mapM rematIndc)
+| .mutInd xs => do
+  let ctx <- match (<- rematMeta) with
+    | [.mutCtx x] => pure x
+    | _ => rematThrowUnexpected
+  let mut inds := #[]
+  for (x, ns) in List.zip xs ctx do
+    let mut is := #[]
+    for _ in ns do
+      let i <- rematIndc x
+      is := is.push i
+    inds := inds.push is.toList
+  return .mutIndBlock ⟨inds.toList, ctx⟩
 | .meta m => throw (.rawMetadata m)
 -- TODO: This could return a Proof inductive, since proofs have no metadata
 | .proof p => throw (.rawProof p)
@@ -375,13 +401,13 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
   where
     rematDefn (x: Ixon.Definition) : RematM Ix.Definition := do
       let _ <- rematIncr
-      let (hints, all) <- match (<- rematMeta) with
-        | [.hints h, .all as] => pure (h, as)
+      let (name, hints, all) <- match (<- rematMeta) with
+        | [.name n, .hints h, .all as] => pure (n, h, as)
         | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
       let type <- rematExpr x.type
       let value <- rematExpr x.value
-      return .mk lvls type x.mode value hints x.part all
+      return .mk name lvls type x.mode value hints x.part all
     rematCtor (x: Ixon.Constructor) : RematM Ix.Constructor := do
       let _ <- rematIncr
       let name <- match (<- rematMeta) with
@@ -408,14 +434,20 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       return ⟨name, lvls, t, x.params, x.indices, x.motives, x.minors, rs, x.k⟩
     rematIndc (x: Ixon.Inductive) : RematM Ix.Inductive := do
       let _ <- rematIncr
-      let all <- match (<- rematMeta) with
-        | [.all as] => pure as
+      let (name, all) <- match (<- rematMeta) with
+        | [.name n, .all as] => pure (n, as)
         | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
       let cs <- x.ctors.mapM rematCtor
       let rs <- x.recrs.mapM rematRecr
-      return ⟨lvls, t, x.params, x.indices, all, cs, rs, x.nested, x.recr,
+      return ⟨name, lvls, t, x.params, x.indices, all, cs, rs, x.nested, x.recr,
         x.refl⟩
 
+def rematerialize (c : Ixon.Const) (m: Ixon.Metadata) 
+  : Except TransportError Ix.Const
+  := match ((rematConst c).run { meta := m }).run emptyRematState with
+    | .ok a _ => return a
+    | .error e _ => throw e
+
 end Ix.TransportM
diff --git a/Tests/Ix.lean b/Tests/Ix.lean
index c8369dba..774abf88 100644
--- a/Tests/Ix.lean
+++ b/Tests/Ix.lean
@@ -61,18 +61,17 @@ def transportConst (x: Ix.Const): Bool :=
 --    | .error e _ => .error e
 --  | .error e _ => .error e
 --
---def myConfig : SlimCheck.Configuration where
---  numInst := 100000
---  maxSize := 100
---  traceDiscarded := true
---  traceSuccesses := true
---  traceShrink := true
---  traceShrinkCandidates := true
+def myConfig : SlimCheck.Configuration where
+  numInst := 10000
+  maxSize := 100
+  traceDiscarded := true
+  traceSuccesses := true
+  traceShrink := true
+  traceShrinkCandidates := true
 
---def dbg : IO UInt32 := do
---   --SlimCheck.Checkable.check (∀ x: Ix.Univ, transportUniv x) myConfig
---   SlimCheck.Checkable.check (∀ x: Ix.Expr, transportExpr x) myConfig
---   return 0
+def dbg : IO UInt32 := do
+   SlimCheck.Checkable.check (∀ x: Ix.Const, transportConst x) myConfig
+   return 0
 
 --def Test.Ix.unitTransport : TestSeq :=
 --  testExprs.foldl (init := .done) fun tSeq x =>
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 39f2f995..8b2bedfd 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -4,6 +4,7 @@ import Ix.Ixon
 import Ix.Address
 import Ix.Common
 import Ix.CompileM
+import Ix.DecompileM
 import Ix.Meta
 import Lean
 import Tests.Ix.Fixtures
@@ -12,6 +13,21 @@ import Lean
 open LSpec
 open Ix.Compile
 
+--def testCompileEnv (env: Lean.Environment) : Except DecompileError Bool := do
+--  let delta := env.getDelta
+--  let stt <- match (compileDelta delta).run (.init 200000) (.init env 0) with
+--  | .ok _ s => pure s
+--  | .error e s => throw <| .compileError e s
+--  let stt2 <- match decompileEnv.run (.init 200000) (.init stt.names stt.store) with
+--    | .ok _ s => pure s
+--    | .error e _ => throw e
+--  let mut res := true
+--  for (n, c) in delta do
+--    match stt2.env.find? n with
+--    | .some c2 => res := res && c == c2
+--    | .none => throw <| .unknownName n
+--  return res
+
 --def testCompileExpr (env: Lean.Environment)
 --  (msg: String) (commit: Bool) (input: Lean.Expr) (expected: Ix.Expr)
 --  : IO TestSeq := do
@@ -41,6 +57,31 @@ def test1 : IO TestSeq := do
   let expected := Lean.Expr.lit (Lean.Literal.natVal 3)
   return test "expected 3" (input == expected)
 
+--def testRoundtripGetEnv : IO TestSeq := do
+--  let env <- get_env!
+--  let delta := env.getDelta
+--  let (_, cstt) <- (compileDelta delta).runIO env (seed := .some 0)
+--  IO.println s!"compiled env"
+--  let mut dstt := DecompileState.init cstt.names cstt.store
+--  for (n, (anon, meta)) in dstt.names do
+--    IO.println s!"decompiling {n} {anon}:{meta}"
+--    match (ensureConst n anon meta).run (.init 200000) dstt with
+--    | .ok _ s => do
+--      IO.println s!"✓ {n} @ {anon}:{meta}"
+--      dstt := s
+--    | .error e _ => do
+--      IO.println s!"{repr <| cstt.env.constants.find! n}"
+--      e.pretty >>= fun e => throw (IO.userError e)
+--  let mut res := true
+--  for (n, c) in delta do
+--    match dstt.env.find? n with
+--    | .some c2 => res := (res && c == c2)
+--    | .none => do
+--      let e' <- (DecompileError.unknownName n).pretty
+--      throw (IO.userError e')
+--  return test "env compile roundtrip" (res == true)
+
 def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
-  test1
+  test1,
+--  testRoundtripGetEnv
 ]
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index 23042eb0..96c71076 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -60,6 +60,7 @@ def genConst : Gen Ix.Const := getSize >>= go
   where
     genNames : Gen (List Lean.Name) := resizeListOf genName
     genDef : Gen Ix.Definition := do
+      let n <- genName
       let lvls <- genNames
       let type <- genExpr
       let mode <- genDefMode
@@ -67,7 +68,7 @@ def genConst : Gen Ix.Const := getSize >>= go
       let hints <- genReducibilityHints
       let isPartial <- genBool
       let all <- genNames
-      return ⟨lvls, type, mode, value, hints, isPartial, all⟩
+      return ⟨n, lvls, type, mode, value, hints, isPartial, all⟩
     genCtor : Gen Ix.Constructor := 
       .mk <$> genName <*> genNames <*> genExpr <*> genNat' <*> genNat' <*> genNat'
     genRecr : Gen Ix.Recursor := 
@@ -75,6 +76,7 @@ def genConst : Gen Ix.Const := getSize >>= go
         <*> resizeListOf (.mk <$> genName <*> genNat' <*> genExpr)
         <*> genBool
     genInd : Gen Ix.Inductive := do
+      let n <- genName
       let lvls <- genNames
       let type <- genExpr
       let params <- genNat'
@@ -84,26 +86,32 @@ def genConst : Gen Ix.Const := getSize >>= go
       let recrs <- resizeListOf genRecr
       let nested <- genNat'
       let (isRec, isRefl) <- Prod.mk <$> genBool <*> genBool
-      return ⟨lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl⟩
+      return ⟨n, lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl⟩
     genMutDef : Gen Ix.MutualDefinitionBlock := do
       let nns <- resizeListOf (genListSize genName 1 5)
       let ds <- nns.mapM fun ns => do
         let x <- genDef
         ns.mapM (fun _ => pure x)
       return .mk ds nns
+    genMutInd : Gen Ix.MutualInductiveBlock := do
+      let nns <- resizeListOf (genListSize genName 1 5)
+      let ds <- nns.mapM fun ns => do
+        let x <- genInd
+        ns.mapM (fun _ => pure x)
+      return .mk ds nns
     go : Nat -> Gen Ix.Const
-    | 0 => return .«axiom» (.mk [] (Ix.Expr.sort (Ix.Level.zero)))
+    | 0 => return .«axiom» (.mk .anonymous [] (Ix.Expr.sort (Ix.Level.zero)))
     | Nat.succ _ =>
       frequency [
-        (100, .«axiom» <$> (.mk <$> genNames <*> genExpr)),
+        (100, .«axiom» <$> (.mk <$> genName <*> genNames <*> genExpr)),
         (100, .«definition» <$> genDef),
-        (100, .quotient <$> (.mk <$> genNames <*> genExpr <*> genQuotKind)),
-        (100, .inductiveProj <$> (.mk <$> genAddress <*> genAddress <*> genNat')),
-        (100, .constructorProj <$> (.mk <$> genAddress <*> genAddress <*> genNat' <*> genNat')),
-        (100, .recursorProj <$> (.mk <$> genAddress <*> genAddress <*> genNat' <*> genNat')),
-        (100, .definitionProj <$> (.mk <$> genAddress <*> genAddress <*> genNat')),
+        (100, .quotient <$> (.mk <$> genName <*> genNames <*> genExpr <*> genQuotKind)),
+        (100, .inductiveProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat')),
+        (100, .constructorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat' <*> genName <*> genNat')),
+        (100, .recursorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat' <*> genName <*> genNat')),
+        (100, .definitionProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat')),
         (100, .mutDefBlock <$> genMutDef),
-        (100, .mutIndBlock <$> resizeListOf genInd),
+        (100, .mutIndBlock <$> genMutInd),
       ]
 
 instance : Shrinkable Ix.Const where

From 6bb012930345fe2959ac819c890a5cf306013088 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 16 May 2025 08:51:26 -0400
Subject: [PATCH 20/74] decompilation roundtrip of Ix get_env working

---
 Ix/CompileM.lean      |  28 +--
 Ix/DecompileM.lean    | 487 ++++++++++++++++++++----------------------
 Ix/IR.lean            |  11 +-
 Ix/Ixon/Const.lean    |  62 +++---
 Ix/TransportM.lean    |  10 +-
 Tests/Ix/Compile.lean |  50 ++---
 Tests/Ix/IR.lean      |   8 +-
 7 files changed, 303 insertions(+), 353 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index e824f7f6..8f9d87d5 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -282,9 +282,12 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
       | .opaqueInfo x => mutOpaqs := mutOpaqs.push x
       | .thmInfo x => mutTheos := mutTheos.push x
       | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
-  let mutualDefs <- sortDefs [mutDefs.toList]
-  let mutualOpaqs <- sortOpaqs [mutOpaqs.toList]
-  let mutualTheos <- sortTheos [mutTheos.toList]
+  let mutualDefs <- if mutDefs.isEmpty then pure []
+    else sortDefs [mutDefs.toList]
+  let mutualOpaqs <- if mutOpaqs.isEmpty then pure []
+    else sortOpaqs [mutOpaqs.toList]
+  let mutualTheos <- if mutTheos.isEmpty then pure []
+    else sortTheos [mutTheos.toList]
   -- Building the `mutCtx`
   let mut mutCtx := default
   let mut names := #[]
@@ -316,7 +319,7 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
   -- Building and storing the block
   let definitions := defnDefs ++ opaqDefs ++ theoDefs
   let (blockAnonAddr, blockMetaAddr) ←
-    hashConst $ .mutDefBlock ⟨definitions, names.toList⟩
+    hashConst $ .mutual ⟨definitions, names.toList⟩
   modify fun stt =>
     { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
   -- While iterating on the definitions from the mutual block, we need to track
@@ -405,20 +408,6 @@ partial def compileInductive (initInd: Lean.InductiveVal)
   let mut preInds := #[]
   let mut nameData : RBMap Lean.Name (List Lean.Name × List Lean.Name) compare
     := .empty
-  if initInd.all matches [_] then
-    let ind <- makePreInductive initInd
-    let numCtors := ind.ctors.length
-    let mut mutCtx := (.single ind.name 0)
-    for (c, cidx) in List.zipIdx ind.ctors do
-      mutCtx := mutCtx.insert c.name cidx
-    for (r, ridx) in List.zipIdx ind.recrs do
-      mutCtx := mutCtx.insert r.name (numCtors + ridx)
-    let indc <- withMutCtx mutCtx $ preInductiveToIR ind
-    let (anonAddr, metaAddr) <- hashConst $ .inductive indc
-    modify fun stt => { stt with
-      names := stt.names.insert ind.name (anonAddr, metaAddr)
-    }
-    return (anonAddr, metaAddr)
   -- collect all mutual inductives as Ix.PreInductives
   for indName in initInd.all do
     match ← findLeanConst indName with
@@ -449,8 +438,7 @@ partial def compileInductive (initInd: Lean.InductiveVal)
     i := i + 1 + numCtors + numRecrs
   -- compile each preinductive with the mutCtx
   let irInds ← withMutCtx mutCtx $ mutualInds.mapM (·.mapM preInductiveToIR)
-  let (blockAnonAddr, blockMetaAddr) ←
-    hashConst $ .mutIndBlock ⟨irInds, names.toList⟩
+  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .inductive ⟨irInds, names.toList⟩
   modify fun stt =>
     { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
   -- While iterating on the inductives from the mutual block, we need to track
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index 18bd8add..a10caa76 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -32,6 +32,7 @@ structure DecompileEnv where
   bindCtx : List Lean.Name
   mutCtx  : RBMap Lean.Name Nat compare
   current: Named
+  deriving Repr, Inhabited
 
 /- initialize from an Ixon store and a name-index to the store -/
 def DecompileEnv.init
@@ -57,15 +58,13 @@ def InductiveBlock.contains (i: InductiveBlock) (name: Lean.Name) : Bool :=
 inductive Block where
 | single : Lean.ConstantInfo -> Block
 | mutual : List Lean.ConstantInfo -> Block
-| inductive : InductiveBlock -> Block
-| mutualInductive : List InductiveBlock -> Block
+| inductive: List InductiveBlock -> Block
 deriving Repr
 
 def Block.contains (name: Lean.Name) : Block -> Bool
 | .single const => const.name == name
 | .mutual consts => consts.any (fun c => c.name == name)
-| .inductive i => i.contains name
-| .mutualInductive is => is.any (fun i => i.contains name)
+| .inductive is => is.any (fun i => i.contains name)
 
 /- The name of an inductive datatype with the names of its constructors and
 recursors. Used to create a BlockNames struct.
@@ -90,15 +89,13 @@ Lean.ConstantInfo
 inductive BlockNames where
 | single : Lean.Name -> BlockNames
 | mutual : List Lean.Name -> BlockNames
-| inductive : InductiveBlockNames -> BlockNames
-| mutualInductive : List InductiveBlockNames -> BlockNames
-deriving Repr
+| inductive : List InductiveBlockNames -> BlockNames
+deriving Repr, Inhabited, Nonempty
 
 def BlockNames.contains (name: Lean.Name) : BlockNames -> Bool
 | .single const => const == name
 | .mutual consts => consts.any (fun c => c == name)
-| .inductive i => i.contains name
-| .mutualInductive is => is.any (fun i => i.contains name)
+| .inductive is => is.any (fun i => i.contains name)
 
 structure DecompileState where
   constants: RBMap Lean.Name Lean.ConstantInfo compare
@@ -235,8 +232,7 @@ partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
   let bn <- match b with
     | .single const => .single <$> insertConst const
     | .mutual cs => .mutual <$> cs.mapM insertConst
-    | .inductive i => .inductive <$> insertInductive i
-    | .mutualInductive is => .mutualInductive <$> is.mapM insertInductive
+    | .inductive is => .inductive <$> is.mapM insertInductive
   modifyGet fun stt =>
     (bn, { stt with blocks := stt.blocks.insert (c, m) bn })
   where
@@ -246,195 +242,226 @@ partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
       let recrs <- i.recrs.mapM insertConst
       return ⟨val, ctors, recrs⟩
 
---mutual
---
---partial def decompileExpr: Ix.Expr → DecompileM Lean.Expr
---| .var i      => do match (← read).bindCtx[i]? with
---  | some _ => return .bvar i
---  | none => throw <| .invalidBVarIndex (<-read).current (<-read).bindCtx i
---| .sort u     => Lean.Expr.sort <$> decompileLevel u
---| .lit l      => pure (.lit l)
---| .app f a    => Lean.mkApp <$> decompileExpr f <*> decompileExpr a
---| .lam n bi t b =>
---    Lean.mkLambda n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
---| .pi n bi t b =>
---    Lean.mkForall n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
---| .letE n t v b nd =>
---    (@Lean.mkLet n)
---      <$> decompileExpr t
---      <*> decompileExpr v
---      <*> withBinder n (decompileExpr b)
---      <*> pure nd
---| .proj n cont meta i e => do
---    let _ <- ensureBlock n cont meta
---    Lean.mkProj n i <$> decompileExpr e
---| .const n cont meta us => do
---    let _ <- ensureBlock n cont meta
---    return Lean.mkConst n (<- us.mapM decompileLevel)
---| .rec_ n i us => do match (<- read).mutCtx.find? n with
---  | some i' =>
---    if i == i' then return Lean.mkConst n (<- us.mapM decompileLevel)
---    else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx n i i'
---  | none => throw <| .unknownMutual (<- read).current (<- read).mutCtx n i
---
---partial def ensureBlock (name: Lean.Name) (c m: Address) : DecompileM BlockNames := do
---  match (<- get).blocks.find? (c, m) with
---  | .some b =>
---    if b.contains name then pure b
---    else throw <| .nameNotInBlockNames (<- read).current b name c m
---  | .none =>
---    let cont : Ixon.Const <- match (<- read).store.find? c with
---      | .some ixon => pure ixon
---      | .none => throw <| .unknownStoreAddress (<- read).current c
---    let meta : Ixon.Metadata <- match (<- read).store.find? m with
---      | .some (.meta meta) => pure meta
---      | .some x => throw <| .expectedIxonMetadata (<- read).current m x
---      | .none => throw <| .unknownStoreAddress (<- read).current m
---    match rematerialize cont meta with
---    | .ok const  => do
---      let blockNames <- withNamed name c m <| decompileConst const
---      if !blockNames.contains name then
---         throw <| .nameNotInBlockNames (<- read).current blockNames name c m
---      return blockNames
---    | .error e => throw (.transport (<- read).current e c m)
---
---partial def decompileDefn (x: Ix.Definition)
---  : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
---    let type <- decompileExpr x.type
---    let val <- decompileExpr x.value
---    let safety := if x.isPartial then .«partial» else .safe
---    match x.mode with
---    | .definition => return .defnInfo <|
---      Lean.mkDefinitionValEx x.name x.levelParams type val x.hints safety x.all
---    | .opaque => return .opaqueInfo <|
---      Lean.mkOpaqueValEx x.name x.levelParams type val true x.all
---    | .theorem => return .thmInfo <|
---      Lean.mkTheoremValEx x.name x.levelParams type val x.all
---
---partial def decompileIndc (x: Ix.Inductive)
---  : DecompileM
---    (Lean.ConstantInfo × List Lean.ConstantInfo × List Lean.ConstantInfo)
---    := withLevels x.levelParams do
---      let type <- decompileExpr x.type
---      let indc :=
---        Lean.mkInductiveValEx x.name x.levelParams type x.numParams x.numIndices
---          x.all (x.ctors.map (·.name)) x.numNested x.isRec false x.isReflexive
---      let ctors <- x.ctors.mapM (decompileCtor x.name)
---      let recrs <- x.recrs.mapM (decompileRecr x.all)
---      return (.inductInfo indc, ctors, recrs)
---  where
---    decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
---      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
---      let type <- decompileExpr x.type
---      return .ctorInfo <|
---        Lean.mkConstructorValEx x.name x.levelParams type indcName
---          x.cidx x.numParams x.numFields false
---    decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
---      let rhs <- decompileExpr x.rhs
---      return ⟨x.ctor, x.nfields, rhs⟩
---    decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
---      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
---      let type <- decompileExpr x.type
---      let rules <- x.rules.mapM decompileRecrRule
---      return .recInfo <|
---        Lean.mkRecursorValEx x.name x.levelParams type indcAll
---          x.numParams x.numIndices x.numMotives x.numMinors rules x.k false
---
---partial def decompileConst : Ix.Const -> DecompileM BlockNames
---| .axiom x => withLevels x.levelParams do
---  let ⟨name, c, m⟩ := (<- read).current
---  let type <- decompileExpr x.type
---  let const := (.axiomInfo <| Lean.mkAxiomValEx name x.levelParams type false)
---  insertBlock c m (.single const)
---| .definition x => do
---  let ⟨name, c, m⟩ := (<- read).current
---  let const <- decompileDefn x
---  insertBlock c m (.single const)
---| .inductive x => do
---  let ⟨name, c, m⟩ := (<- read).current
---  let (i, cs, rs) <- decompileIndc x
---  insertBlock c m (.inductive ⟨i, cs, rs⟩)
---| .quotient x => withLevels x.levelParams do
---  let ⟨name, c, m⟩ := (<- read).current
---  let type <- decompileExpr x.type
---  let const := (.quotInfo <| Lean.mkQuotValEx name x.levelParams type x.kind)
---  insertBlock c m (.single const)
---| .inductiveProj x => do
---  let curr@⟨name, c, m⟩ := (<- read).current
---  let bs <- ensureBlock name x.blockCont x.blockMeta
---  match bs with
---  | .inductive ⟨i, _, _⟩ => 
---    if x.idx == 0 && i == name then return bs
---    else throw (.badProjection curr i x.blockCont x.blockMeta "inductive")
---  | .mutualInductive is => match is[x.idx]? with
---    | .some ⟨i, _, _⟩ =>
---       if i == name then return bs
---       else throw (.badProjection curr i x.blockCont x.blockMeta "mutual")
---    | .none => throw (.badProjection curr name x.blockCont x.blockMeta "mutual no idx")
---  | _ => throw (.badProjection curr name x.blockCont x.blockMeta "not inductive")
---| .constructorProj x => do
---  let curr@⟨name, c, m⟩ := (<- read).current
---  let bs <- ensureBlock name.parent x.blockCont x.blockMeta
---  let cs <- match bs with
---    | .inductive ⟨i, cs, _⟩ => 
---      if x.idx == 0 && i == name.parent then pure cs
---      else throw (.badProjection curr i x.blockCont x.blockMeta "inductive")
---    | .mutualInductive is => match is[x.idx]? with
---      | .some ⟨i, cs, _⟩ =>
---         if i == name then pure cs
---         else throw (.badProjection curr i x.blockCont x.blockMeta "mutual")
---      | .none => throw (.badProjection curr name x.blockCont x.blockMeta "mutual no idx")
---    | _ => throw (.badProjection curr name x.blockCont x.blockMeta "not inductive")
---  --match cs[x.cidx]
---  return bs
---| _ => sorry
---
-----partial def decompileConst
-----  (n: Lean.Name) (c m: Address): Ix.Const -> DecompileM Unit
-----| .constructorProj x => do
-----  ensureIndBlock n x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.indcs ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let (_, cs, _) <- match ns[x.idx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
-----  let n <- match cs[x.cidx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta s!"bad ctor idx {x.cidx} {cs}"
-----    if n == n then return () else 
-----      throw <| .badProjection n x.blockCont x.blockMeta "ctor name mismatch"
-----| .recursorProj x => do
-----  ensureIndBlock n x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.indcs ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let (_, _, rs) <- match ns[x.idx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
-----  let n <- match rs[x.ridx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad recr idx"
-----    if n == n then return () else
-----      throw <| .badProjection n x.blockCont x.blockMeta "recr name mismatch"
-----| .definitionProj x => do
-----  ensureMutDefBlock x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.defns ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not defns block"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let n <- match ns[x.idx]? with
-----    | .some n => pure n 
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad defn idx"
-----    if n == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "defn name mismatch"
------- these should be unreachable here
-----| .mutDefBlock x => throw <| .namedMutDefBlock n x
-----| .mutIndBlock x => throw <| .namedMutIndBlock n x
-----
---
---end
+partial def decompileMutualCtx (ctx: List (List Lean.Name))
+  : DecompileM (RBMap Lean.Name Nat compare) := do
+  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
+  for (ns, i) in List.zipIdx ctx do
+    for n in ns do
+      mutCtx := mutCtx.insert n i
+  return mutCtx
+
+partial def checkCtorRecrLengths : List Ix.Inductive -> DecompileM (Nat × Nat)
+| [] => return (0, 0)
+| x::xs => go x xs
+  where
+    go : Ix.Inductive -> List Ix.Inductive -> DecompileM (Nat × Nat)
+    | x, [] => return (x.ctors.length, x.recrs.length)
+    | x, a::as => do
+      if x.ctors.length == a.ctors.length && x.recrs.length == a.recrs.length
+      then go x as else throw <| .nonCongruentInductives (<- read).current x a
+
+partial def decompileMutIndCtx (block: Ix.InductiveBlock)
+  : DecompileM (RBMap Lean.Name Nat compare) := do
+  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
+  let mut i := 0
+  for (inds, names) in List.zip block.inds block.ctx do
+    let (numCtors, numRecrs) <- checkCtorRecrLengths inds
+    for (ind, name) in List.zip inds names do
+      mutCtx := mutCtx.insert name i
+      for (c, cidx) in List.zipIdx ind.ctors do
+        mutCtx := mutCtx.insert c.name (i + cidx)
+      for (r, ridx) in List.zipIdx ind.recrs do
+        mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
+    i := i + 1 + numCtors + numRecrs
+  return mutCtx
+
+mutual
+
+partial def decompileExpr: Ix.Expr → DecompileM Lean.Expr
+| .var i      => do match (← read).bindCtx[i]? with
+  | some _ => return .bvar i
+  | none => throw <| .invalidBVarIndex (<-read).current (<-read).bindCtx i
+| .sort u     => Lean.Expr.sort <$> decompileLevel u
+| .lit l      => pure (.lit l)
+| .app f a    => Lean.mkApp <$> decompileExpr f <*> decompileExpr a
+| .lam n bi t b =>
+    Lean.mkLambda n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
+| .pi n bi t b =>
+    Lean.mkForall n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
+| .letE n t v b nd =>
+    (@Lean.mkLet n)
+      <$> decompileExpr t
+      <*> decompileExpr v
+      <*> withBinder n (decompileExpr b)
+      <*> pure nd
+| .proj n cont meta i e => do
+    let _ <- ensureBlock n cont meta
+    Lean.mkProj n i <$> decompileExpr e
+| .const n cont meta us => do
+    let _ <- ensureBlock n cont meta
+    return Lean.mkConst n (<- us.mapM decompileLevel)
+| .rec_ n i us => do match (<- read).mutCtx.find? n with
+  | some i' =>
+    if i == i' then return Lean.mkConst n (<- us.mapM decompileLevel)
+    else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx n i i'
+  | none => throw <| .unknownMutual (<- read).current (<- read).mutCtx n i
+
+partial def ensureBlock (name: Lean.Name) (c m: Address) : DecompileM BlockNames := do
+  match (<- get).blocks.find? (c, m) with
+  | .some b =>
+    if b.contains name then pure b
+    else throw <| .nameNotInBlockNames (<- read).current b name c m
+  | .none =>
+    let cont : Ixon.Const <- match (<- read).store.find? c with
+      | .some ixon => pure ixon
+      | .none => throw <| .unknownStoreAddress (<- read).current c
+    let meta : Ixon.Metadata <- match (<- read).store.find? m with
+      | .some (.meta meta) => pure meta
+      | .some x => throw <| .expectedIxonMetadata (<- read).current m x
+      | .none => throw <| .unknownStoreAddress (<- read).current m
+    match rematerialize cont meta with
+    | .ok const  => do
+      let blockNames <- withNamed name c m <| decompileConst const
+      if !blockNames.contains name then
+         throw <| .nameNotInBlockNames (<- read).current blockNames name c m
+      return blockNames
+    | .error e => throw (.transport (<- read).current e c m)
+
+partial def decompileDefn (x: Ix.Definition)
+  : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+    let type <- decompileExpr x.type
+    let val <- decompileExpr x.value
+    let safety := if x.isPartial then .«partial» else .safe
+    match x.mode with
+    | .definition => return .defnInfo <|
+      Lean.mkDefinitionValEx x.name x.levelParams type val x.hints safety x.all
+    | .opaque => return .opaqueInfo <|
+      Lean.mkOpaqueValEx x.name x.levelParams type val true x.all
+    | .theorem => return .thmInfo <|
+      Lean.mkTheoremValEx x.name x.levelParams type val x.all
+
+partial def decompileIndc (x: Ix.Inductive)
+  : DecompileM
+    (Lean.ConstantInfo × List Lean.ConstantInfo × List Lean.ConstantInfo)
+    := withLevels x.levelParams do
+      let type <- decompileExpr x.type
+      let indc :=
+        Lean.mkInductiveValEx x.name x.levelParams type x.numParams x.numIndices
+          x.all (x.ctors.map (·.name)) x.numNested x.isRec false x.isReflexive
+      let ctors <- x.ctors.mapM (decompileCtor x.name)
+      let recrs <- x.recrs.mapM (decompileRecr x.all)
+      return (.inductInfo indc, ctors, recrs)
+  where
+    decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
+      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+      let type <- decompileExpr x.type
+      return .ctorInfo <|
+        Lean.mkConstructorValEx x.name x.levelParams type indcName
+          x.cidx x.numParams x.numFields false
+    decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
+      let rhs <- decompileExpr x.rhs
+      return ⟨x.ctor, x.nfields, rhs⟩
+    decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
+      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+      let type <- decompileExpr x.type
+      let rules <- x.rules.mapM decompileRecrRule
+      return .recInfo <|
+        Lean.mkRecursorValEx x.name x.levelParams type indcAll
+          x.numParams x.numIndices x.numMotives x.numMinors rules x.k false
+
+-- TODO: name integrity
+partial def decompileConst : Ix.Const -> DecompileM BlockNames
+| .axiom x => withLevels x.levelParams do
+  let ⟨name, c, m⟩ := (<- read).current
+  let type <- decompileExpr x.type
+  let const := (.axiomInfo <| Lean.mkAxiomValEx x.name x.levelParams type false)
+  insertBlock c m (.single const)
+| .definition x => do
+  let ⟨name, c, m⟩ := (<- read).current
+  let const <- decompileDefn x
+  insertBlock c m (.single const)
+| .quotient x => withLevels x.levelParams do
+  let ⟨name, c, m⟩ := (<- read).current
+  let type <- decompileExpr x.type
+  let const := (.quotInfo <| Lean.mkQuotValEx x.name x.levelParams type x.kind)
+  insertBlock c m (.single const)
+| .inductiveProj x => do
+  let curr@⟨name, c, m⟩ := (<- read).current
+  let bs <- ensureBlock name x.blockCont x.blockMeta
+  match bs with
+  | .inductive is => match is[x.idx]? with
+    | .some ⟨i, _, _⟩ =>
+       if i == name then return bs
+       else throw (.badProjection curr i x.blockCont x.blockMeta "mutual ind")
+    | .none => throw (.badProjection curr name x.blockCont x.blockMeta "mutual ind no idx")
+  | _ => throw (.badProjection curr name x.blockCont x.blockMeta "not inductive")
+| .constructorProj x => do
+  let curr@⟨name, c, m⟩ := (<- read).current
+  let bs <- ensureBlock x.induct x.blockCont x.blockMeta
+  let cs <- match bs with
+    | .inductive is => match is[x.idx]? with
+      | .some ⟨i, cs, _⟩ =>
+         if i == x.induct then pure cs
+         else throw (.badProjection curr i x.blockCont x.blockMeta "ctor, inductive name {i} != {x.induct}")
+      | .none => throw (.badProjection curr x.induct x.blockCont x.blockMeta "ctor mutual ind no idx {x.idx}")
+    | _ => throw (.badProjection curr x.induct x.blockCont x.blockMeta "ctor not inductive")
+  let n <- match cs[x.cidx]? with
+  | .some n => pure n
+  | .none => throw (.badProjection curr name x.blockCont x.blockMeta s!"bad ctor idx {x.cidx} {cs}")
+  if name == n then return bs
+  else
+    throw (.badProjection curr name x.blockCont x.blockMeta "ctor name mismatch")
+| .recursorProj x => do
+  let curr@⟨name, c, m⟩ := (<- read).current
+  let bs <- ensureBlock x.induct x.blockCont x.blockMeta
+  let rs <- match bs with
+    | .inductive is => match is[x.idx]? with
+      | .some ⟨i, _, rs⟩ =>
+         if i == x.induct then pure rs
+         else throw (.badProjection curr i x.blockCont x.blockMeta "recursor, inductive name {i} != {x.induct}")
+      | .none => throw (.badProjection curr name x.blockCont x.blockMeta "recursor, no idx {x.idx}")
+    | _ => throw (.badProjection curr name x.blockCont x.blockMeta "recr not inductive")
+  let n <- match rs[x.ridx]? with
+  | .some n => pure n
+  | .none => throw (.badProjection curr name x.blockCont x.blockMeta s!"bad recr idx {x.ridx} {rs}")
+  if name == n then return bs
+  else
+    throw (.badProjection curr name x.blockCont x.blockMeta "recr name mismatch")
+| .definitionProj x => do
+  let curr@⟨name, c, m⟩ := (<- read).current
+  let bs <- ensureBlock name x.blockCont x.blockMeta
+  match bs with
+  | .mutual is => match is[x.idx]? with
+    | .some d =>
+       if d == x.name then return bs
+       else throw (.badProjection curr d x.blockCont x.blockMeta "def mutual")
+    | .none => throw (.badProjection curr name x.blockCont x.blockMeta "def mutual no idx")
+  | .single d =>
+    if x.idx == 0 && d == x.name then pure bs
+    else throw (.badProjection curr d x.blockCont x.blockMeta "def single")
+  | _ => throw (.badProjection curr name x.blockCont x.blockMeta "def not mutual")
+| .mutual x => do
+  let curr@⟨name, c, m⟩ := (<- read).current
+  let mutCtx <- decompileMutualCtx x.ctx
+  withMutCtx mutCtx do
+    let mut block := #[]
+    for (defns, names) in List.zip x.defs x.ctx do
+      for (defn, name) in List.zip defns names do
+        let const <- decompileDefn defn
+        block := block.push const
+    insertBlock c m (.mutual block.toList)
+| .inductive x => do
+  let curr@⟨name, c, m⟩ := (<- read).current
+  let mutCtx <- decompileMutIndCtx x
+  withMutCtx mutCtx do
+    let mut block := #[]
+    for (inds, names) in List.zip x.inds x.ctx do
+      for (ind, name) in List.zip inds names do
+        let (i, cs, rs) <- decompileIndc ind
+        block := block.push ⟨i, cs, rs⟩
+    insertBlock c m (Block.inductive block.toList)
+
+end
 --
 ----partial def ensureConst'
 ----  (c m: Address) (n: Option Lean.Name) : DecompileM Unit := do
@@ -509,38 +536,8 @@ partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
 ----    | .ok x  => throw <| .expectedMutDefConst x cont meta
 ----    | .error e => throw (.transport e cont meta)
 ----
-----partial def decompileMutDefCtx (ctx: List (List Lean.Name)) 
-----  : DecompileM (RBMap Lean.Name Nat compare) := do
-----  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
-----  for (ns, i) in List.zipIdx ctx do
-----    for n in ns do
-----      mutCtx := mutCtx.insert n i
-----  return mutCtx
 ----
-----partial def checkCtorRecrLengths : List Ix.Inductive -> DecompileM (Nat × Nat)
-----| [] => return (0, 0)
-----| x::xs => go x xs
-----  where
-----    go : Ix.Inductive -> List Ix.Inductive -> DecompileM (Nat × Nat)
-----    | x, [] => return (x.ctors.length, x.recrs.length)
-----    | x, a::as =>
-----      if x.ctors.length == a.ctors.length && x.recrs.length == a.recrs.length
-----      then go x as else throw <| .nonCongruentInductives x a
 ----
-----partial def decompileMutIndCtx (block: Ix.MutualInductiveBlock)
-----  : DecompileM (RBMap Lean.Name Nat compare) := do
-----  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
-----  let mut i := 0
-----  for (inds, names) in List.zip block.inds block.ctx do
-----    let (numCtors, numRecrs) <- checkCtorRecrLengths inds
-----    for (ind, name) in List.zip inds names do
-----      mutCtx := mutCtx.insert name i
-----      for (c, cidx) in List.zipIdx ind.ctors do
-----        mutCtx := mutCtx.insert c.name (i + cidx)
-----      for (r, ridx) in List.zipIdx ind.recrs do
-----        mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
-----    i := i + 1 + numCtors + numRecrs
-----  return mutCtx
 ----
 ----partial def tryInsertConst
 ----  (const: Lean.ConstantInfo)
@@ -759,36 +756,6 @@ partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
 ----| .mutDefBlock x => throw <| .namedMutDefBlock n x
 ----| .mutIndBlock x => throw <| .namedMutIndBlock n x
 ----
-----partial def decompileMutDefBlock
-----  (x: Ix.MutualDefinitionBlock)
-----  (c m: Address)
-----  : DecompileM Unit := do
-----  let mutCtx <- decompileMutDefCtx x.ctx
-----  withMutCtx mutCtx do
-----    let mut block := #[]
-----    for (defns, names) in List.zip x.defs x.ctx do
-----      for (defn, name) in List.zip defns names do
-----        decompileDefn name c m defn >>= tryInsertConst
-----        block := block.push name
-----    modify fun stt => 
-----      { stt with blocks := stt.blocks.insert (c, m) (.defns block.toList) }
-----
-----partial def decompileMutIndBlock
-----  (x: Ix.MutualInductiveBlock)
-----  (c m: Address)
-----  : DecompileM Unit := do
-----  let mutCtx <- decompileMutIndCtx x
-----  withMutCtx mutCtx do
-----    let mut block := #[]
-----    for (inds, names) in List.zip x.inds x.ctx do
-----      for (ind, name) in List.zip inds names do
-----        let (i, cs, rs) <- decompileIndc name c m ind
-----        tryInsertConst i
-----        let cs <- cs.mapM <| fun c => tryInsertConst c *> pure c.name
-----        let rs <- rs.mapM <| fun r => tryInsertConst r *> pure r.name
-----        block := block.push (i.name, cs, rs)
-----    modify fun stt =>
-----      { stt with blocks := stt.blocks.insert (c, m) (.indcs block.toList)}
 ----
 ----end
 ----
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 6874542d..5ffb0e04 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -300,12 +300,12 @@ structure DefinitionProj where
   idx : Nat
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
-structure MutualDefinitionBlock where
+structure MutualBlock where
   defs : List (List Definition)
   ctx  : List (List Lean.Name)
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
-structure MutualInductiveBlock where
+structure InductiveBlock where
   inds : List (List Inductive)
   ctx  : List (List Lean.Name)
   deriving BEq, Ord, Hashable, Repr, Nonempty, Inhabited
@@ -314,19 +314,18 @@ inductive Const where
   | «axiom» : Axiom → Const
   | quotient : Quotient → Const
   | «definition»: Definition → Const
-  | «inductive» : Inductive → Const
   -- projections of mutual blocks
   | inductiveProj : InductiveProj → Const
   | constructorProj : ConstructorProj → Const
   | recursorProj : RecursorProj → Const
   | definitionProj : DefinitionProj → Const
   -- constants to represent mutual blocks
-  | mutDefBlock : MutualDefinitionBlock → Const
-  | mutIndBlock : MutualInductiveBlock → Const
+  | «mutual» : MutualBlock → Const
+  | «inductive» : InductiveBlock → Const
   deriving Ord, BEq, Inhabited, Repr, Nonempty
 
 def Const.isMutBlock : Const → Bool
-  | .mutDefBlock _ | .mutIndBlock _ => true
+  | .mutual _ | .inductive _ => true
   | _ => false
 
 namespace Level
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index fc674607..7c21501e 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -94,26 +94,24 @@ inductive Const where
   -- 0xC0
   | defn : Definition -> Const
   -- 0xC1
-  | indc : Inductive -> Const
-  -- 0xC2
   | axio : Axiom -> Const
-  -- 0xC3
+  -- 0xC2
   | quot : Quotient -> Const
-  -- 0xC4
+  -- 0xC3
   | ctorProj : ConstructorProj -> Const
-  -- 0xC5
+  -- 0xC4
   | recrProj : RecursorProj -> Const
-  -- 0xC6
+  -- 0xC5
   | indcProj : InductiveProj -> Const
-  -- 0xC7
+  -- 0xC6
   | defnProj : DefinitionProj -> Const
-  -- 0xC8
+  -- 0xC7
   | mutDef : List Definition -> Const
-  -- 0xC9
+  -- 0xC8
   | mutInd : List Inductive -> Const
-  -- 0xCA
+  -- 0xC9
   | meta   : Metadata -> Const
-  -- 0xCB
+  -- 0xCA
   | proof : Proof -> Const
   -- 0xCC
   | comm: Comm -> Const
@@ -121,17 +119,16 @@ inductive Const where
 
 def putConst : Const → PutM
 | .defn x => putUInt8 0xC0 *> putDefn x
-| .indc x => putUInt8 0xC1 *> putIndc x
-| .axio x => putUInt8 0xC2 *> putNatl x.lvls *> putExpr x.type
-| .quot x => putUInt8 0xC3 *> putNatl x.lvls *> putExpr x.type *> putQuotKind x.kind
-| .ctorProj x => putUInt8 0xC4 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.cidx
-| .recrProj x => putUInt8 0xC5 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
-| .indcProj x => putUInt8 0xC6 *> putBytes x.block.hash *> putNatl x.idx
-| .defnProj x => putUInt8 0xC7 *> putBytes x.block.hash *> putNatl x.idx
-| .mutDef xs => putUInt8 0xC8 *> putArray putDefn xs
-| .mutInd xs => putUInt8 0xC9 *> putArray putIndc xs
-| .meta m => putUInt8 0xCA *> putMetadata m
-| .proof p => putUInt8 0xCB *> putProof p
+| .axio x => putUInt8 0xC1 *> putNatl x.lvls *> putExpr x.type
+| .quot x => putUInt8 0xC2 *> putNatl x.lvls *> putExpr x.type *> putQuotKind x.kind
+| .ctorProj x => putUInt8 0xC3 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.cidx
+| .recrProj x => putUInt8 0xC4 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
+| .indcProj x => putUInt8 0xC5 *> putBytes x.block.hash *> putNatl x.idx
+| .defnProj x => putUInt8 0xC6 *> putBytes x.block.hash *> putNatl x.idx
+| .mutDef xs => putUInt8 0xC7 *> putArray putDefn xs
+| .mutInd xs => putUInt8 0xC8 *> putArray putIndc xs
+| .meta m => putUInt8 0xC9 *> putMetadata m
+| .proof p => putUInt8 0xCA *> putProof p
 | .comm c => putUInt8 0xCC *> putComm c
   where
     putDefn (x: Definition) := do
@@ -187,17 +184,16 @@ def getConst : GetM Const := do
   let tag ← getUInt8
   match tag with
   | 0xC0 => .defn <$> getDefn
-  | 0xC1 => .indc <$> getIndc
-  | 0xC2 => .axio <$> (.mk <$> getNatl <*> getExpr)
-  | 0xC3 => .quot <$> (.mk <$> getNatl <*> getExpr <*> getQuotKind)
-  | 0xC4 => .ctorProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
-  | 0xC5 => .recrProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
-  | 0xC6 => .indcProj <$> (.mk <$> getAddr <*> getNatl)
-  | 0xC7 => .defnProj <$> (.mk <$> getAddr <*> getNatl)
-  | 0xC8 => .mutDef <$> getArray getDefn
-  | 0xC9 => .mutInd <$> getArray getIndc
-  | 0xCA => .meta <$> getMetadata
-  | 0xCB => .proof <$> getProof
+  | 0xC1 => .axio <$> (.mk <$> getNatl <*> getExpr)
+  | 0xC2 => .quot <$> (.mk <$> getNatl <*> getExpr <*> getQuotKind)
+  | 0xC3 => .ctorProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
+  | 0xC4 => .recrProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
+  | 0xC5 => .indcProj <$> (.mk <$> getAddr <*> getNatl)
+  | 0xC6 => .defnProj <$> (.mk <$> getAddr <*> getNatl)
+  | 0xC7 => .mutDef <$> getArray getDefn
+  | 0xC8 => .mutInd <$> getArray getIndc
+  | 0xC9 => .meta <$> getMetadata
+  | 0xCA => .proof <$> getProof
   | 0xCC => .comm <$> getComm
   | e => throw s!"expected Const tag, got {e}"
   where
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index b0bc373c..36b74729 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -251,7 +251,6 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
   let type <- dematExpr x.type
   return .axio (.mk lvls type)
 | .«definition» x => .defn <$> dematDefn x
-| .«inductive» x => .indc <$> dematIndc x
 | .quotient x => do
   dematMeta [.name x.name]
   let lvls <- dematLevels x.levelParams
@@ -269,14 +268,14 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
 | .definitionProj x => do
   dematMeta [.name x.name, .link x.blockMeta]
   return .defnProj (.mk x.blockCont x.idx)
-| .mutDefBlock x => do
+| .mutual x => do
   dematMeta [.mutCtx x.ctx]
   let defs <- x.defs.mapM fun ds => ds.mapM dematDefn
   let ds <- defs.mapM fun d => match d.head? with
     | .some a => pure a
     | .none => throw .emptyEquivalenceClass
   return .mutDef ds
-| .mutIndBlock x => do
+| .inductive x => do
   dematMeta [.mutCtx x.ctx]
   let inds <- x.inds.mapM fun is => is.mapM dematIndc
   let is <- inds.mapM fun i => match i.head? with
@@ -335,7 +334,6 @@ def constAddress (x: Ix.Const) : Except TransportError Address := do
 
 partial def rematConst : Ixon.Const -> RematM Ix.Const
 | .defn x => .«definition» <$> rematDefn x
-| .indc x => .«inductive» <$> rematIndc x
 | .axio x => do
   let name <- match (<- rematMeta) with
     | [.name x] => pure x
@@ -381,7 +379,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       let d <- rematDefn x
       ds := ds.push d
     defs := defs.push ds.toList
-  return .mutDefBlock ⟨defs.toList, ctx⟩
+  return .mutual ⟨defs.toList, ctx⟩
 | .mutInd xs => do
   let ctx <- match (<- rematMeta) with
     | [.mutCtx x] => pure x
@@ -393,7 +391,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       let i <- rematIndc x
       is := is.push i
     inds := inds.push is.toList
-  return .mutIndBlock ⟨inds.toList, ctx⟩
+  return .inductive ⟨inds.toList, ctx⟩
 | .meta m => throw (.rawMetadata m)
 -- TODO: This could return a Proof inductive, since proofs have no metadata
 | .proof p => throw (.rawProof p)
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 8b2bedfd..cd02f977 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -12,6 +12,7 @@ import Lean
 
 open LSpec
 open Ix.Compile
+open Ix.Decompile
 
 --def testCompileEnv (env: Lean.Environment) : Except DecompileError Bool := do
 --  let delta := env.getDelta
@@ -57,31 +58,32 @@ def test1 : IO TestSeq := do
   let expected := Lean.Expr.lit (Lean.Literal.natVal 3)
   return test "expected 3" (input == expected)
 
---def testRoundtripGetEnv : IO TestSeq := do
---  let env <- get_env!
---  let delta := env.getDelta
---  let (_, cstt) <- (compileDelta delta).runIO env (seed := .some 0)
---  IO.println s!"compiled env"
---  let mut dstt := DecompileState.init cstt.names cstt.store
---  for (n, (anon, meta)) in dstt.names do
---    IO.println s!"decompiling {n} {anon}:{meta}"
---    match (ensureConst n anon meta).run (.init 200000) dstt with
---    | .ok _ s => do
---      IO.println s!"✓ {n} @ {anon}:{meta}"
---      dstt := s
---    | .error e _ => do
---      IO.println s!"{repr <| cstt.env.constants.find! n}"
---      e.pretty >>= fun e => throw (IO.userError e)
---  let mut res := true
---  for (n, c) in delta do
---    match dstt.env.find? n with
---    | .some c2 => res := (res && c == c2)
---    | .none => do
---      let e' <- (DecompileError.unknownName n).pretty
---      throw (IO.userError e')
---  return test "env compile roundtrip" (res == true)
+def testRoundtripGetEnv : IO TestSeq := do
+  let env <- get_env!
+  let delta := env.getDelta
+  let (_, cstt) <- (compileDelta delta).runIO env (seed := .some 0)
+  IO.println s!"compiled env"
+  let denv := DecompileEnv.init cstt.names cstt.store
+  let mut dstt := default
+  for (n, (anon, meta)) in denv.names do
+    IO.println s!"decompiling {n} {anon}:{meta}"
+    match (ensureBlock n anon meta).run denv dstt with
+    | .ok _ s => do
+      IO.println s!"✓ {n} @ {anon}:{meta}"
+      dstt := s
+    | .error e _ => do
+      IO.println s!"{repr <| cstt.env.constants.find! n}"
+      throw (IO.userError e.pretty)
+  let mut res := true
+  for (n, c) in delta do
+    match dstt.constants.find? n with
+    | .some c2 => res := (res && c == c2)
+    | .none => do
+      let e' := (DecompileError.unknownName default n).pretty
+      throw (IO.userError e')
+  return test "env compile roundtrip" (res == true)
 
 def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
   test1,
---  testRoundtripGetEnv
+  testRoundtripGetEnv
 ]
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index 96c71076..4575997d 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -87,13 +87,13 @@ def genConst : Gen Ix.Const := getSize >>= go
       let nested <- genNat'
       let (isRec, isRefl) <- Prod.mk <$> genBool <*> genBool
       return ⟨n, lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl⟩
-    genMutDef : Gen Ix.MutualDefinitionBlock := do
+    genMutDef : Gen Ix.MutualBlock := do
       let nns <- resizeListOf (genListSize genName 1 5)
       let ds <- nns.mapM fun ns => do
         let x <- genDef
         ns.mapM (fun _ => pure x)
       return .mk ds nns
-    genMutInd : Gen Ix.MutualInductiveBlock := do
+    genMutInd : Gen Ix.InductiveBlock := do
       let nns <- resizeListOf (genListSize genName 1 5)
       let ds <- nns.mapM fun ns => do
         let x <- genInd
@@ -110,8 +110,8 @@ def genConst : Gen Ix.Const := getSize >>= go
         (100, .constructorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat' <*> genName <*> genNat')),
         (100, .recursorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat' <*> genName <*> genNat')),
         (100, .definitionProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat')),
-        (100, .mutDefBlock <$> genMutDef),
-        (100, .mutIndBlock <$> genMutInd),
+        (100, .mutual <$> genMutDef),
+        (100, .inductive <$> genMutInd),
       ]
 
 instance : Shrinkable Ix.Const where

From 7e9409505d5e6c5ae9852c150a8392c56ffead7b Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 23 May 2025 11:28:02 -0400
Subject: [PATCH 21/74] WIP: new mutual definition changes

---
 Ix/Cli/StoreCmd.lean   |  27 ++-
 Ix/Common.lean         |  25 +--
 Ix/CompileM.lean       | 494 ++++++++++++++++++++---------------------
 Ix/DecompileM.lean     | 407 +++------------------------------
 Ix/IR.lean             |  44 +++-
 Ix/Ixon/Const.lean     |  32 ++-
 Ix/Ixon/Serialize.lean |  12 +
 Ix/TransportM.lean     |  50 +++--
 Tests/Ix/Compile.lean  | 185 +++++++++++++--
 Tests/Ix/Fixtures.lean |   7 +-
 Tests/Ix/IR.lean       |  20 +-
 Tests/Ix/Ixon.lean     |  14 +-
 12 files changed, 594 insertions(+), 723 deletions(-)

diff --git a/Ix/Cli/StoreCmd.lean b/Ix/Cli/StoreCmd.lean
index a7da186a..797d8514 100644
--- a/Ix/Cli/StoreCmd.lean
+++ b/Ix/Cli/StoreCmd.lean
@@ -2,12 +2,14 @@ import Cli
 import Ix.Cronos
 import Ix.Common
 import Ix.CompileM
+import Ix.TransportM
 import Ix.Store
 import Ix.Address
 import Lean
 
 -- ix store <lean file>
 -- ix store get <address>
+-- ix store remat <address> <address>
 def runStore (p : Cli.Parsed) : IO UInt32 := do
   let source : String       := p.positionalArg! "source" |>.as! String
   let mut cronos ← Cronos.new.clock "Lean-frontend"
@@ -48,6 +50,20 @@ def runGet (p : Cli.Parsed) : IO UInt32 := do
   IO.println <| s!"{repr const}"
   return 0
 
+def runRemat (p : Cli.Parsed) : IO UInt32 := do
+  let cont : String       := p.positionalArg! "constantAddress" |>.as! String
+  let meta : String       := p.positionalArg! "metadataAddress" |>.as! String
+  let (c, m) <- IO.ofExcept $
+    match Address.fromString cont, Address.fromString meta with
+    | .some c, .some m => .ok (c, m)
+    | .none, _ => .error "bad address {cont}"
+    | _, .none => .error "bad address {meta}"
+  let cont <- StoreIO.toIO (Store.readConst c)
+  let meta <- StoreIO.toIO (Store.readConst m)
+  let ix := Ix.TransportM.rematerialize cont meta
+  IO.println <| s!"{repr ix}"
+  return 0
+
 def storeGetCmd : Cli.Cmd := `[Cli|
   get VIA runGet;
   "print a store entry"
@@ -55,6 +71,14 @@ def storeGetCmd : Cli.Cmd := `[Cli|
     address  : String; "Ix address"
 ]
 
+def storeRematCmd : Cli.Cmd := `[Cli|
+  remat VIA runRemat;
+  "print a store entry"
+  ARGS:
+    constantAddress  : String; "Ix constant address"
+    metadataAddress  : String; "Ix metadata address"
+]
+
 def storeCmd : Cli.Cmd := `[Cli|
   store VIA runStore;
   "Interact with the Ix store"
@@ -66,6 +90,7 @@ def storeCmd : Cli.Cmd := `[Cli|
     source : String; "Source file input"
 
   SUBCOMMANDS:
-    storeGetCmd
+    storeGetCmd;
+    storeRematCmd
 ]
 
diff --git a/Ix/Common.lean b/Ix/Common.lean
index bfd3a425..d62436f2 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -32,9 +32,11 @@ instance : Ord Lean.Name where
   compare := Lean.Name.quickCmp
 
 deriving instance Ord for Lean.Literal
+--deriving instance Ord for Lean.Expr
 deriving instance Ord for Lean.BinderInfo
 deriving instance BEq, Repr, Hashable, Ord for Lean.QuotKind
 deriving instance Hashable, Repr for Lean.ReducibilityHints
+deriving instance BEq, Ord, Hashable, Repr for Lean.DefinitionSafety
 deriving instance BEq, Repr for Lean.ConstantVal
 deriving instance BEq, Repr for Lean.QuotVal
 deriving instance BEq, Repr for Lean.AxiomVal
@@ -46,6 +48,7 @@ deriving instance BEq, Repr for Lean.RecursorVal
 deriving instance BEq, Repr for Lean.ConstructorVal
 deriving instance BEq, Repr for Lean.InductiveVal
 deriving instance BEq, Repr for Lean.ConstantInfo
+deriving instance BEq, Repr for Ordering
 
 def UInt8.MAX : UInt64 := 0xFF
 def UInt16.MAX : UInt64 := 0xFFFF
@@ -101,26 +104,16 @@ mutual
 
 end
 
-def sortByM [Monad μ] (xs: List α) (cmp: α -> α -> μ Ordering) (rev := false) :
-    μ (List α) := do
-  if rev then
-    let revCmp : _ → _ → μ Ordering := fun x y => do
-      match (← cmp x y) with
-      | .gt => return Ordering.lt
-      | .eq => return Ordering.eq
-      | .lt => return Ordering.gt
-    sequencesM revCmp xs >>= mergeAllM revCmp
-  else
-    sequencesM cmp xs >>= mergeAllM cmp
+def sortByM [Monad μ] (xs: List α) (cmp: α -> α -> μ Ordering) : μ (List α) :=
+  sequencesM cmp xs >>= mergeAllM cmp
 
 /--
-Mergesort from least to greatest. To sort from greatest to
+Mergesort from least to greatest. To sort from greatest to least set `rev`
 -/
-def sortBy (cmp : α -> α -> Ordering) (xs: List α) (rev := false) : List α :=
-  Id.run do xs.sortByM (cmp <$> · <*> ·) rev
+def sortBy (cmp : α -> α -> Ordering) (xs: List α) : List α :=
+  Id.run <| xs.sortByM (fun x y => pure <| cmp x y)
 
-def sort [Ord α] (xs: List α) (rev := false) : List α :=
-  sortBy compare xs rev
+def sort [Ord α] (xs: List α) : List α := sortBy compare xs
 
 def groupByMAux [Monad μ] (eq : α → α → μ Bool) : List α → List (List α) → μ (List (List α))
   | a::as, (ag::g)::gs => do match (← eq a ag) with
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 8f9d87d5..ee21f0a2 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -20,7 +20,7 @@ inductive CompileError
 | freeVariableExpr : Lean.Expr → CompileError
 | metaVariableExpr : Lean.Expr → CompileError
 | metaDataExpr : Lean.Expr → CompileError
-| levelNotFound : Lean.Name → List Lean.Name → CompileError
+| levelNotFound : Lean.Name → List Lean.Name -> String → CompileError
 | invalidConstantKind : Lean.Name → String → String → CompileError
 | constantNotContentAddressed : Lean.Name → CompileError
 | nonRecursorExtractedFromChildren : Lean.Name → CompileError
@@ -30,6 +30,8 @@ inductive CompileError
 | cantPackLevel : Nat → CompileError
 | nonCongruentInductives : PreInductive -> PreInductive -> CompileError
 | alphaInvarianceFailure : Ix.Const -> Address -> Ix.Const -> Address -> CompileError
+| emptyDefsEquivalenceClass: List (List PreDefinition) -> CompileError
+| emptyIndsEquivalenceClass: List (List PreInductive) -> CompileError
 
 def CompileError.pretty : CompileError -> IO String
 | .unknownConstant n => pure s!"Unknown constant '{n}'"
@@ -39,7 +41,7 @@ def CompileError.pretty : CompileError -> IO String
 | .freeVariableExpr e => pure s!"Free variable in expression '{e}'"
 | .metaVariableExpr e => pure s!"Metavariable in expression '{e}'"
 | .metaDataExpr e => pure s!"Meta data in expression '{e}'"
-| .levelNotFound n ns => pure s!"'Level {n}' not found in '{ns}'"
+| .levelNotFound n ns msg => pure s!"'Level {n}' not found in '{ns}', {msg}"
 | .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
 | .constantNotContentAddressed n => pure s!"Constant '{n}' wasn't content-addressed"
 | .nonRecursorExtractedFromChildren n => pure
@@ -51,15 +53,20 @@ def CompileError.pretty : CompileError -> IO String
 | .nonCongruentInductives a b => pure s!"noncongruent inductives {a.name} {b.name}'"
 | .alphaInvarianceFailure x xa y ya => 
   pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
+| .emptyDefsEquivalenceClass dss => 
+  pure s!"empty equivalence class while sorting definitions {dss.map fun ds => ds.map (·.name)}"
+| .emptyIndsEquivalenceClass dss => 
+  pure s!"empty equivalence class while sorting inductives {dss.map fun ds => ds.map (·.name)}"
 
 structure CompileEnv where
   univCtx : List Lean.Name
   bindCtx : List Lean.Name
   mutCtx  : RBMap Lean.Name Nat compare
   maxHeartBeats: USize
+  current : Lean.Name
 
 def CompileEnv.init (maxHeartBeats: USize): CompileEnv :=
-  ⟨default, default, default, maxHeartBeats⟩
+  ⟨default, default, default, maxHeartBeats, default⟩
 
 structure CompileState where
   env: Lean.Environment
@@ -98,6 +105,10 @@ def freshSecret : CompileM Address := do
     secret := secret.push rand.toUInt8
   return ⟨secret⟩
 
+-- add binding name to local context
+def withCurrent (name: Lean.Name) : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with current := name }
+
 -- add binding name to local context
 def withBinder (name: Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
@@ -141,30 +152,35 @@ def concatOrds : List Ordering → Ordering :=
   List.foldl (· * ·) .eq
 
 /-- Defines an ordering for Lean universes -/
-def compareLevel (x : Lean.Level) (y : Lean.Level) : CompileM Ordering :=
-  match x, y with
-  | .mvar .., _ => throw $ .unfilledLevelMetavariable x
-  | _, .mvar .. => throw $ .unfilledLevelMetavariable y
+def compareLevel (xctx yctx: List Lean.Name)
+  : Lean.Level -> Lean.Level -> CompileM Ordering
+  | x@(.mvar ..), _ => throw $ .unfilledLevelMetavariable x
+  | _, y@(.mvar ..) => throw $ .unfilledLevelMetavariable y
   | .zero, .zero => return .eq
   | .zero, _ => return .lt
   | _, .zero => return .gt
-  | .succ x, .succ y => compareLevel x y
+  | .succ x, .succ y => compareLevel xctx yctx x y
   | .succ .., _ => return .lt
   | _, .succ .. => return .gt
-  | .max lx ly, .max rx ry => 
-    (· * ·) <$> compareLevel lx rx <*> compareLevel ly ry
+  | .max xl xr, .max yl yr => do
+    let l' <- compareLevel xctx yctx xl yl
+    let r' <- compareLevel xctx yctx xr yr
+    return l' * r'
   | .max .., _ => return .lt
   | _, .max .. => return .gt
-  | .imax lx ly, .imax rx ry => 
-    (· * ·) <$> compareLevel lx rx <*> compareLevel ly ry
+  | .imax xl xr, .imax yl yr => do
+    let l' <- compareLevel xctx yctx xl yl
+    let r' <- compareLevel xctx yctx xr yr
+    return l' * r'
   | .imax .., _ => return .lt
   | _, .imax .. => return .gt
   | .param x, .param y => do
-    let lvls := (← read).univCtx
-    match (lvls.idxOf? x), (lvls.idxOf? y) with
+    match (xctx.idxOf? x), (yctx.idxOf? y) with
     | some xi, some yi => return (compare xi yi)
-    | none,    _       => throw $ .levelNotFound x lvls
-    | _,       none    => throw $ .levelNotFound y lvls
+    | none,    _       => 
+      throw $ .levelNotFound x xctx s!"compareLevel @ {(<- read).current}"
+    | _,       none    => 
+      throw $ .levelNotFound y yctx s!"compareLevel @ {(<- read).current}"
 
 /-- Canonicalizes a Lean universe level and adds it to the store -/
 def compileLevel : Lean.Level → CompileM Ix.Level
@@ -176,7 +192,7 @@ def compileLevel : Lean.Level → CompileM Ix.Level
   let lvls := (← read).univCtx
   match lvls.idxOf? name with
   | some n => pure $ .param name n
-  | none   => throw $ .levelNotFound name lvls
+  | none   => throw $ .levelNotFound name lvls s!"compileLevel @ {(<- read).current}"
 | l@(.mvar ..) => throw $ .unfilledLevelMetavariable l
 
 /-- Retrieves a Lean constant from the environment by its name -/
@@ -200,57 +216,48 @@ mutual
 /-- compile Lean Constant --/
 partial def compileConst (const : Lean.ConstantInfo)
   : CompileM (Address × Address) := do
+  -- first check if we've already compiled this const
   match (← get).names.find? const.name with
-  | some (anonAddr, metaAddr) => pure (anonAddr, metaAddr)
-  | none => match const with
-    | .defnInfo val =>
-      resetCtxWithLevels val.levelParams $ compileDefinition val
-    | .inductInfo val => 
-      resetCtxWithLevels val.levelParams $ compileInductive val
+  -- if we have, returned the cached address
+  | some (anonAddr, metaAddr) => do
+    pure (anonAddr, metaAddr)
+  -- if not, pattern match on the const
+  | none => resetCtx $ withCurrent const.name $ match const with
+    -- convert possible mutual block elements to PreDefinitions
+    | .defnInfo val => do
+      compileDefinition (mkPreDefinition val)
+    | .thmInfo val => do
+      compileDefinition (mkPreTheorem val)
+    | .opaqueInfo val => do
+      compileDefinition (mkPreOpaque val)
+    -- compile possible mutual inductive block elements
+    | .inductInfo val => do
+      compileInductive val
+    -- compile constructors through their parent inductive
     | .ctorInfo val => do
       match ← findLeanConst val.induct with
-      | .inductInfo ind => discard $ compileConst (.inductInfo ind)
+      | .inductInfo ind => do
+        let _ <- compileInductive ind
+        compileConst (.ctorInfo val)
       | const =>
         throw $ .invalidConstantKind const.name "inductive" const.ctorName
-      -- this should return by finding the ctor in names via the above some case
-      compileConst const
+    -- compile recursors through their parent inductive
     | .recInfo val => do
       match ← findLeanConst val.getMajorInduct with
-      | .inductInfo ind => discard $ compileConst (.inductInfo ind)
+      | .inductInfo ind => do
+        let _ <- compileInductive ind
+        compileConst (.recInfo val)
       | const =>
         throw $ .invalidConstantKind const.name "inductive" const.ctorName
-      -- this should return by finding the recr in names via the above some case
-      compileConst const
     -- The rest adds the constants to the cache one by one
     | .axiomInfo val => resetCtxWithLevels const.levelParams do
-      let c := .axiom ⟨val.name, val.levelParams, ← compileExpr val.type⟩
+      let c := .axiom ⟨val.name, val.levelParams, ← compileExpr val.type, val.isUnsafe⟩
       let (anonAddr, metaAddr) ← hashConst c
       modify fun stt => { stt with
         axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
         names := stt.names.insert const.name (anonAddr, metaAddr)
       }
       return (anonAddr, metaAddr)
-    | .thmInfo val => resetCtxWithLevels const.levelParams do
-      let type <- compileExpr val.type
-      let value <- compileExpr val.value
-      let c := .definition <|
-        mkTheorem val.name val.levelParams type value val.all
-      let (anonAddr, metaAddr) ← hashConst c
-      modify fun stt => { stt with
-        names := stt.names.insert const.name (anonAddr, metaAddr)
-      }
-      return (anonAddr, metaAddr)
-    | .opaqueInfo val => resetCtxWithLevels const.levelParams do
-      let mutCtx := .single val.name 0
-      let type <- compileExpr val.type
-      let value <- withMutCtx mutCtx $ compileExpr val.value
-      let c := .definition <|
-        mkOpaque val.name val.levelParams type value val.all
-      let (anonAddr, metaAddr) ← hashConst c
-      modify fun stt => { stt with
-        names := stt.names.insert const.name (anonAddr, metaAddr)
-      }
-      return (anonAddr, metaAddr)
     | .quotInfo val => resetCtxWithLevels const.levelParams do
       let type <- compileExpr val.type
       let c := .quotient ⟨val.name, val.levelParams, type, val.kind⟩
@@ -262,64 +269,38 @@ partial def compileConst (const : Lean.ConstantInfo)
       return (anonAddr, metaAddr)
 
 /-- compile possibly mutual Lean definition --/
-partial def compileDefinition (struct: Lean.DefinitionVal)
+partial def compileDefinition (struct: PreDefinition)
   : CompileM (Address × Address) := do
   -- If the mutual size is one, simply content address the single definition
   if struct.all matches [_] then
-    let defn <- withMutCtx (.single struct.name 0) $ definitionToIR struct
+    let defn <- withMutCtx (.single struct.name 0) $ preDefinitionToIR struct
     let (anonAddr, metaAddr) <- hashConst $ .definition defn
     modify fun stt => { stt with
       names := stt.names.insert struct.name (anonAddr, metaAddr)
     }
     return (anonAddr, metaAddr)
   -- Collecting and sorting all definitions in the mutual block
-  let mut mutDefs : Array Lean.DefinitionVal := #[]
-  let mut mutOpaqs : Array Lean.OpaqueVal := #[]
-  let mut mutTheos : Array Lean.TheoremVal := #[]
+  let mut mutDefs : Array PreDefinition := #[]
   for n in struct.all do
     match <- findLeanConst n with
-      | .defnInfo x => mutDefs := mutDefs.push x
-      | .opaqueInfo x => mutOpaqs := mutOpaqs.push x
-      | .thmInfo x => mutTheos := mutTheos.push x
+      | .defnInfo x => mutDefs := mutDefs.push (mkPreDefinition x)
+      | .opaqueInfo x => mutDefs := mutDefs.push (mkPreOpaque x)
+      | .thmInfo x => mutDefs := mutDefs.push (mkPreTheorem x)
       | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
-  let mutualDefs <- if mutDefs.isEmpty then pure []
-    else sortDefs [mutDefs.toList]
-  let mutualOpaqs <- if mutOpaqs.isEmpty then pure []
-    else sortOpaqs [mutOpaqs.toList]
-  let mutualTheos <- if mutTheos.isEmpty then pure []
-    else sortTheos [mutTheos.toList]
+  let mutualDefs <- sortDefs mutDefs.toList
   -- Building the `mutCtx`
   let mut mutCtx := default
-  let mut names := #[]
   let mut i := 0
   for ds in mutualDefs do
     let mut x := #[]
     for d in ds do
       x := x.push d.name
       mutCtx := mutCtx.insert d.name i
-    names := names.push x.toList
-    i := i + 1
-  for ds in mutualOpaqs do
-    let mut x := #[]
-    for d in ds do
-      x := x.push d.name
-      mutCtx := mutCtx.insert d.name i
-    names := names.push x.toList
-    i := i + 1
-  for ds in mutualTheos do
-    let mut x := #[]
-    for d in ds do
-      x := x.push d.name
-      mutCtx := mutCtx.insert d.name i
-    names := names.push x.toList
     i := i + 1
-  let defnDefs ← withMutCtx mutCtx $ mutualDefs.mapM (·.mapM definitionToIR)
-  let opaqDefs ← withMutCtx mutCtx $ mutualOpaqs.mapM (·.mapM opaqueToIR)
-  let theoDefs ← withMutCtx mutCtx $ mutualTheos.mapM (·.mapM theoremToIR)
+  let definitions ← withMutCtx mutCtx $ mutualDefs.mapM (·.mapM preDefinitionToIR)
   -- Building and storing the block
-  let definitions := defnDefs ++ opaqDefs ++ theoDefs
   let (blockAnonAddr, blockMetaAddr) ←
-    hashConst $ .mutual ⟨definitions, names.toList⟩
+    hashConst $ .mutual ⟨definitions⟩
   modify fun stt =>
     { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
   -- While iterating on the definitions from the mutual block, we need to track
@@ -339,25 +320,11 @@ partial def compileDefinition (struct: Lean.DefinitionVal)
   | some ret => return ret
   | none => throw $ .constantNotContentAddressed struct.name
 
-partial def definitionToIR (d: Lean.DefinitionVal)
-  : CompileM Ix.Definition := do
+partial def preDefinitionToIR (d: PreDefinition)
+  : CompileM Ix.Definition := withCurrent d.name $ withLevels d.levelParams do
   let typ <- compileExpr d.type
   let val <- compileExpr d.value
-  let isPartial := d.safety == .partial
-  let mod := .definition
-  return ⟨d.name, d.levelParams, typ, mod, val, d.hints, isPartial, d.all⟩
-
-partial def opaqueToIR (opaq: Lean.OpaqueVal)
-  : CompileM Ix.Definition := do
-  let type <- compileExpr opaq.type
-  let value <- compileExpr opaq.value
-  return mkOpaque opaq.name opaq.levelParams type value opaq.all
-
-partial def theoremToIR (theo: Lean.TheoremVal)
-  : CompileM Ix.Definition := do
-  let type <- compileExpr theo.type
-  let value <- compileExpr theo.value
-  return mkOpaque theo.name theo.levelParams type value theo.all
+  return ⟨d.name, d.levelParams, typ, d.mode, val, d.hints, d.safety, d.all⟩
 
 partial def getRecursors (ind : Lean.InductiveVal) 
   : CompileM (List Lean.RecursorVal) := do
@@ -378,8 +345,8 @@ partial def makePreInductive (ind: Lean.InductiveVal)
   : CompileM Ix.PreInductive := do
     let ctors <- ind.ctors.mapM getCtor
     let recrs <- getRecursors ind
-    return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices, 
-      ind.all, ctors, recrs, ind.numNested, ind.isRec, ind.isReflexive⟩
+    return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices,
+      ind.all, ctors, recrs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
     where
       getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
         match (<- findLeanConst name) with
@@ -417,9 +384,8 @@ partial def compileInductive (initInd: Lean.InductiveVal)
       nameData := nameData.insert indName (ind.ctors, preInd.recrs.map (·.name))
     | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
   -- sort PreInductives into equivalence classes
-  let mutualInds <- sortPreInds [preInds.toList]
+  let mutualInds <- sortInds preInds.toList
   let mut mutCtx : RBMap Lean.Name Nat compare := default
-  let mut names := #[]
   let mut i := 0
   -- build the mutual context
   for inds in mutualInds do
@@ -434,11 +400,10 @@ partial def compileInductive (initInd: Lean.InductiveVal)
         mutCtx := mutCtx.insert c.name (i + cidx)
       for (r, ridx) in List.zipIdx ind.recrs do
         mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
-    names := names.push x.toList
     i := i + 1 + numCtors + numRecrs
   -- compile each preinductive with the mutCtx
   let irInds ← withMutCtx mutCtx $ mutualInds.mapM (·.mapM preInductiveToIR)
-  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .inductive ⟨irInds, names.toList⟩
+  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .inductive ⟨irInds⟩
   modify fun stt =>
     { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
   -- While iterating on the inductives from the mutual block, we need to track
@@ -475,13 +440,14 @@ partial def compileInductive (initInd: Lean.InductiveVal)
   | some ret => return ret
   | none => throw $ .constantNotContentAddressed initInd.name
 
-partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive := do
+partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive 
+  := withCurrent ind.name $ withLevels ind.levelParams $ do
   let (recs, ctors) := <- ind.recrs.foldrM (init := ([], [])) collectRecsCtors
   let type <- compileExpr ind.type
     -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
     -- match the order used in `mutCtx`
   return ⟨ind.name, ind.levelParams, type, ind.numParams, ind.numIndices,
-    ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive⟩
+    ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
   where
     collectRecsCtors
       : Lean.RecursorVal
@@ -496,8 +462,8 @@ partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive :=
           pure (thisRec :: recs, ctors)
 
 partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
-  : CompileM (Ix.Recursor × List Ix.Constructor) := do
-  withLevels recr.levelParams do
+  : CompileM (Ix.Recursor × List Ix.Constructor) :=
+  withCurrent recr.name $ withLevels recr.levelParams do
     let typ ← compileExpr recr.type
     let (retCtors, retRules) ← recr.rules.foldrM (init := ([], []))
       fun r (retCtors, retRules) => do
@@ -506,24 +472,24 @@ partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
           pure $ (ctor :: retCtors, rule :: retRules)
         else pure (retCtors, retRules) -- this is an external recursor rule
     let recr := ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
-      recr.numMotives, recr.numMinors, retRules, recr.k⟩
+      recr.numMotives, recr.numMinors, retRules, recr.k, recr.isUnsafe⟩
     return (recr, retCtors)
 
-partial def externalRecToIR (recr: Lean.RecursorVal): CompileM Recursor := do
-  withLevels recr.levelParams do
+partial def externalRecToIR (recr: Lean.RecursorVal): CompileM Recursor :=
+  withCurrent recr.name $ withLevels recr.levelParams do
     let typ ← compileExpr recr.type
     let rules ← recr.rules.mapM externalRecRuleToIR
     return ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
-      recr.numMotives, recr.numMinors, rules, recr.k⟩
+      recr.numMotives, recr.numMinors, rules, recr.k, recr.isUnsafe⟩
 
 partial def recRuleToIR (rule : Lean.RecursorRule)
   : CompileM (Ix.Constructor × Ix.RecursorRule) := do
   let rhs ← compileExpr rule.rhs
   match ← findLeanConst rule.ctor with
-  | .ctorInfo ctor => withLevels ctor.levelParams do
+  | .ctorInfo ctor => withCurrent ctor.name $ withLevels ctor.levelParams do
     let typ ← compileExpr ctor.type
     let ctor :=
-      ⟨ctor.name, ctor.levelParams, typ, ctor.cidx, ctor.numParams, ctor.numFields⟩
+      ⟨ctor.name, ctor.levelParams, typ, ctor.cidx, ctor.numParams, ctor.numFields, ctor.isUnsafe⟩
     pure (ctor, ⟨rule.ctor, rule.nfields, rhs⟩)
   | const =>
     throw $ .invalidConstantKind const.name "constructor" const.ctorName
@@ -580,48 +546,66 @@ partial def compileExpr : Lean.Expr → CompileM Expr
 A name-irrelevant ordering of Lean expressions.
 `weakOrd` contains the best known current mutual ordering
 -/
-partial def compareExpr (weakOrd : RBMap Lean.Name Nat compare)
+partial def compareExpr
+  (weakOrd : RBMap Lean.Name Nat compare)
+  (xlvls ylvls: List Lean.Name)
   : Lean.Expr → Lean.Expr → CompileM Ordering
   | e@(.mvar ..), _ => throw $ .unfilledExprMetavariable e
   | _, e@(.mvar ..) => throw $ .unfilledExprMetavariable e
   | e@(.fvar ..), _ => throw $ .freeVariableExpr e
   | _, e@(.fvar ..) => throw $ .freeVariableExpr e
-  | .mdata _ x, .mdata _ y  => compareExpr weakOrd x y
-  | .mdata _ x, y  => compareExpr weakOrd x y
-  | x, .mdata _ y  => compareExpr weakOrd x y
+  | .mdata _ x, .mdata _ y  => compareExpr weakOrd xlvls ylvls x y
+  | .mdata _ x, y  => compareExpr weakOrd xlvls ylvls x y
+  | x, .mdata _ y  => compareExpr weakOrd xlvls ylvls x y
   | .bvar x, .bvar y => return (compare x y)
   | .bvar .., _ => return .lt
   | _, .bvar .. => return .gt
-  | .sort x, .sort y => compareLevel x y
+  | .sort x, .sort y => compareLevel xlvls ylvls x y
   | .sort .., _ => return .lt
   | _, .sort .. => return .gt
   | .const x xls, .const y yls => do
-    let univs ← concatOrds <$> (xls.zip yls).mapM fun (x,y) => compareLevel x y
-    if univs != .eq then return univs
+    let univs ← concatOrds <$> (xls.zip yls).mapM
+      fun (x,y) => compareLevel xlvls ylvls x y
+    if univs != .eq then
+      return univs
     match weakOrd.find? x, weakOrd.find? y with
     | some nx, some ny => return compare nx ny
-    | none, some _ => return .gt
-    | some _, none => return .lt
+    | none, some _ => do
+      return .gt
+    | some _, none =>
+      return .lt
     | none, none =>
-      return compare
-        (← compileConst $ ← findLeanConst x)
-        (← compileConst $ ← findLeanConst y)
+      if x == y then 
+        return .eq
+      else do
+        let x' <- compileConst $ ← findLeanConst x
+        let y' <- compileConst $ ← findLeanConst y
+        return compare x' y'
   | .const .., _ => return .lt
   | _, .const .. => return .gt
-  | .app xf xa, .app yf ya =>
-    (· * ·) <$> compareExpr weakOrd xf yf <*> compareExpr weakOrd xa ya
+  | .app xf xa, .app yf ya => do
+    let f' <- compareExpr weakOrd xlvls ylvls xf yf
+    let a' <- compareExpr weakOrd xlvls ylvls xa ya
+    return f' * a'
   | .app .., _ => return .lt
   | _, .app .. => return .gt
-  | .lam _ xt xb _, .lam _ yt yb _ =>
-    (· * ·) <$> compareExpr weakOrd xt yt <*> compareExpr weakOrd xb yb
+  | .lam _ xt xb _, .lam _ yt yb _ => do
+    let t' <- compareExpr weakOrd xlvls ylvls xt yt
+    let b' <- compareExpr weakOrd xlvls ylvls xb yb
+    return t' * b'
   | .lam .., _ => return .lt
   | _, .lam .. => return .gt
-  | .forallE _ xt xb _, .forallE _ yt yb _ =>
-    (· * ·) <$> compareExpr weakOrd xt yt <*> compareExpr weakOrd xb yb
+  | .forallE _ xt xb _, .forallE _ yt yb _ => do
+    let t' <- compareExpr weakOrd xlvls ylvls xt yt
+    let b' <- compareExpr weakOrd xlvls ylvls xb yb
+    return t' * b'
   | .forallE .., _ => return .lt
   | _, .forallE .. => return .gt
-  | .letE _ xt xv xb _, .letE _ yt yv yb _ =>
-    (· * · * ·) <$> compareExpr weakOrd xt yt <*> compareExpr weakOrd xv yv <*> compareExpr weakOrd xb yb
+  | .letE _ xt xv xb _, .letE _ yt yv yb _ => do
+    let t' <- compareExpr weakOrd xlvls ylvls xt yt
+    let v' <- compareExpr weakOrd xlvls ylvls xv yv
+    let b' <- compareExpr weakOrd xlvls ylvls xb yb
+    return t' * v' * b'
   | .letE .., _ => return .lt
   | _, .letE .. => return .gt
   | .lit x, .lit y =>
@@ -629,26 +613,26 @@ partial def compareExpr (weakOrd : RBMap Lean.Name Nat compare)
   | .lit .., _ => return .lt
   | _, .lit .. => return .gt
   | .proj _ nx tx, .proj _ ny ty => do
-    let ts ← compareExpr weakOrd tx ty
+    let ts ← compareExpr weakOrd xlvls ylvls tx ty
     return concatOrds [compare nx ny, ts]
 
 /-- AST comparison of two Lean definitions.
   `weakOrd` contains the best known current mutual ordering -/
 partial def compareDef
   (weakOrd : RBMap Lean.Name Nat compare)
-  (x : Lean.DefinitionVal) 
-  (y : Lean.DefinitionVal) 
+  (x y: PreDefinition)
   : CompileM Ordering := do
+  let mode := compare x.mode y.mode
   let ls := compare x.levelParams.length y.levelParams.length
-  let ts ← compareExpr weakOrd x.type y.type
-  let vs ← compareExpr weakOrd x.value y.value
-  return concatOrds [ls, ts, vs]
+  let ts ← compareExpr weakOrd x.levelParams y.levelParams x.type y.type
+  let vs ← compareExpr weakOrd x.levelParams y.levelParams x.value y.value
+  return concatOrds [mode, ls, ts, vs]
 
 /-- AST equality between two Lean definitions.
   `weakOrd` contains the best known current mutual ordering -/
 @[inline] partial def eqDef
   (weakOrd : RBMap Lean.Name Nat compare)
-  (x y : Lean.DefinitionVal) 
+  (x y : PreDefinition) 
   : CompileM Bool :=
   return (← compareDef weakOrd x y) == .eq
 
@@ -688,9 +672,9 @@ Two optimizations:
     them as lists. To fix this, we sort the list by name before comparing. Note we
     could maybe also use `List (RBTree ..)` everywhere, but it seemed like a hassle.
 -/
-partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
-    CompileM (List (List Lean.DefinitionVal)) := do
-  let enum (ll : List (List Lean.DefinitionVal)) :=
+partial def sortPreDefs (dss : List (List PreDefinition)) :
+    CompileM (List (List PreDefinition)) := do
+  let enum (ll : List (List PreDefinition)) :=
     RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
   let weakOrd := enum dss _
   let newDss ← (← dss.mapM fun ds =>
@@ -703,91 +687,47 @@ partial def sortDefs (dss : List (List Lean.DefinitionVal)) :
   let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
   let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
   if normDss == normNewDss then return newDss
-  else sortDefs newDss
-
--- boilerplate repetition for opaque and theorem
-
-/-- AST comparison of two Lean opaque definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-partial def compareOpaq
-  (weakOrd : RBMap Lean.Name Nat compare)
-  (x : Lean.OpaqueVal) 
-  (y : Lean.OpaqueVal) 
-  : CompileM Ordering := do
-  let ls := compare x.levelParams.length y.levelParams.length
-  let ts ← compareExpr weakOrd x.type y.type
-  let vs ← compareExpr weakOrd x.value y.value
-  return concatOrds [ls, ts, vs]
+  else sortPreDefs newDss
 
-/-- AST equality between two Lean opaque definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-@[inline] partial def eqOpaq
-  (weakOrd : RBMap Lean.Name Nat compare)
-  (x y : Lean.OpaqueVal) 
-  : CompileM Bool :=
-  return (← compareOpaq weakOrd x y) == .eq
+partial def sortDefs: List PreDefinition -> CompileM (List (List PreDefinition))
+| [] => return []
+| xs => sortDefs' [xs.sortBy (fun x y => compare x.name y.name)]
 
-partial def sortOpaqs (dss : List (List Lean.OpaqueVal)) :
-    CompileM (List (List Lean.OpaqueVal)) := do
-  let enum (ll : List (List Lean.OpaqueVal)) :=
-    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
-  let weakOrd := enum dss _
-  let newDss ← (← dss.mapM fun ds =>
+partial def weakOrdDefs (dss: List (List PreDefinition)) 
+  : CompileM (RBMap Lean.Name Nat compare) := do
+  let mut weakOrd := default
+  for (ds, n) in dss.zipIdx do
+    for d in ds do
+      weakOrd := weakOrd.insert d.name n
+  return weakOrd
+
+partial def sortDefs' (dss: List (List PreDefinition))
+  : CompileM (List (List PreDefinition)) := do
+  let weakOrd <- weakOrdDefs dss
+  let mut dss' : Array (List PreDefinition) := default
+  for ds in dss do
     match ds with
-    | []  => unreachable!
-    | [d] => pure [[d]]
-    | ds  => do pure $ (← List.groupByM (eqOpaq weakOrd) $
-      ← ds.sortByM (compareOpaq weakOrd))).joinM
-  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
-  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
-  if normDss == normNewDss then return newDss
-  else sortOpaqs newDss
-
-/-- AST comparison of two Lean opaque definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-partial def compareTheo
-  (weakOrd : RBMap Lean.Name Nat compare)
-  (x : Lean.TheoremVal) 
-  (y : Lean.TheoremVal) 
-  : CompileM Ordering := do
-  let ls := compare x.levelParams.length y.levelParams.length
-  let ts ← compareExpr weakOrd x.type y.type
-  let vs ← compareExpr weakOrd x.value y.value
-  return concatOrds [ls, ts, vs]
-
-/-- AST equality between two Lean opaque definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-@[inline] partial def eqTheo
-  (weakOrd : RBMap Lean.Name Nat compare)
-  (x y : Lean.TheoremVal) 
-  : CompileM Bool :=
-  return (← compareTheo weakOrd x y) == .eq
+    | [] => throw <| .emptyDefsEquivalenceClass dss
+    | [d] => dss' := dss'.push [d]
+    | ds => do
+      let ds' <- ds.sortByM (compareDef weakOrd)
+      let ds' <- List.groupByM (eqDef weakOrd) ds'
+      for d in ds' do
+        let d' <- d.sortByM (fun x y => pure $ compare x.name y.name)
+        dss' := dss'.push d'
+  if dss == dss'.toList
+  then return dss
+  else sortDefs' dss'.toList
 
-partial def sortTheos (dss : List (List Lean.TheoremVal)) :
-    CompileM (List (List Lean.TheoremVal)) := do
-  let enum (ll : List (List Lean.TheoremVal)) :=
-    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
-  let weakOrd := enum dss _
-  let newDss ← (← dss.mapM fun ds =>
-    match ds with
-    | []  => unreachable!
-    | [d] => pure [[d]]
-    | ds  => do pure $ (← List.groupByM (eqTheo weakOrd) $
-      ← ds.sortByM (compareTheo weakOrd))).joinM
-  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
-  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
-  if normDss == normNewDss then return newDss
-  else sortTheos newDss
 
 /-- AST comparison of two Lean opaque definitions.
   `weakOrd` contains the best known current mutual ordering -/
-partial def comparePreInds
+partial def compareInd
   (weakOrd : RBMap Lean.Name Nat compare)
-  (x : PreInductive)
-  (y : PreInductive)
+  (x y: PreInductive)
   : CompileM Ordering := do
   let ls := compare x.levelParams.length y.levelParams.length
-  let ts ← compareExpr weakOrd x.type y.type
+  let ts ← compareExpr weakOrd x.levelParams y.levelParams x.type y.type
   let nps := compare x.numParams y.numParams
   let nis := compare x.numIndices y.numIndices
   let ctors <- compareListM compareCtors x.ctors y.ctors
@@ -796,50 +736,86 @@ partial def comparePreInds
   where
     compareCtors (x y: Lean.ConstructorVal) : CompileM Ordering := do
       let ls := compare x.levelParams.length y.levelParams.length
-      let ts <- compareExpr weakOrd x.type y.type
+      let ts <- compareExpr weakOrd x.levelParams y.levelParams x.type y.type
       let cis := compare x.cidx y.cidx
       let nps := compare x.numParams y.numParams
       let nfs := compare x.numFields y.numFields
       return concatOrds [ls, ts, cis, nps, nfs]
     compareRecrs (x y: Lean.RecursorVal) : CompileM Ordering := do
       let ls := compare x.levelParams.length y.levelParams.length
-      let ts <- compareExpr weakOrd x.type y.type
+      let ts <- compareExpr weakOrd x.levelParams y.levelParams x.type y.type
       let nps := compare x.numParams y.numParams
       let nis := compare x.numIndices y.numIndices
       let nmos := compare x.numMotives y.numMotives
       let nmis := compare x.numMinors y.numMinors
-      let rrs <- compareListM compareRules x.rules y.rules
+      let rrs <- compareListM (compareRules x.levelParams y.levelParams) x.rules y.rules
       let ks := compare x.k y.k
       return concatOrds [ls, ts, nps, nis, nmos, nmis, rrs, ks]
-    compareRules (x y: Lean.RecursorRule) : CompileM Ordering := do
+    compareRules (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule) 
+      : CompileM Ordering := do
       let nfs := compare x.nfields y.nfields
-      let rs <- compareExpr weakOrd x.rhs y.rhs
+      let rs <- compareExpr weakOrd xlvls ylvls x.rhs y.rhs
       return concatOrds [nfs, rs]
 
 /-- AST equality between two Lean opaque definitions.
   `weakOrd` contains the best known current mutual ordering -/
-@[inline] partial def eqPreInds
+@[inline] partial def eqInd
   (weakOrd : RBMap Lean.Name Nat compare)
-  (x y : PreInductive) 
+  (x y : PreInductive)
   : CompileM Bool :=
-  return (← comparePreInds weakOrd x y) == .eq
-
-partial def sortPreInds (dss : List (List PreInductive)) :
-    CompileM (List (List PreInductive)) := do
-  let enum (ll : List (List PreInductive)) :=
-    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
-  let weakOrd := enum dss _
-  let newDss ← (← dss.mapM fun ds =>
-    match ds with
-    | []  => unreachable!
-    | [d] => pure [[d]]
-    | ds  => do pure $ (← List.groupByM (eqPreInds weakOrd) $
-      ← ds.sortByM (comparePreInds weakOrd))).joinM
-  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
-  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
-  if normDss == normNewDss then return newDss
-  else sortPreInds newDss
-
+  return (← compareInd weakOrd x y) == .eq
+
+partial def sortInds: List PreInductive -> CompileM (List (List PreInductive))
+| [] => return []
+| xs => sortInds' [xs.sortBy (fun x y => compare x.name y.name)]
+
+--          e_1                    e_2                         e_k
+-- [ [i_1_1, i_1_2, ..., i_1_E1], [i_2_1, i_2_2, ..., i_1_E2], ... [i_k_1, i_k_2, ..., i_k_EK]]
+-- let x be the class index, and y be the inductive index within the class
+--  i_x_y contains c constructors and r recursors, each with a `cidx`
+--  constructor index and a `ridx` recursor index
+-- to construct a weak ordering, we need to create a natural number index `n` for each
+-- inductive, constructor and recursors in the list of equivalence classes, such
+-- that inductives in the same class, constructors with the same cidx, and
+-- recursors with the same ridx all have the same weak index
+
+partial def weakOrdInds (iss: List (List PreInductive))
+  : CompileM (RBMap Lean.Name Nat compare) := do
+  let mut weakOrd := default
+  let mut idx := 0
+  for is in iss do
+    let mut maxCtors := 0
+    let mut maxRecrs := 0
+    for i in is do
+      weakOrd := weakOrd.insert i.name idx
+      let numCtors := i.ctors.length
+      let numRecrs := i.recrs.length
+      if numCtors > maxCtors then maxCtors := numCtors
+      if numRecrs > maxRecrs then maxRecrs := numRecrs
+      for (ctor, cidx) in i.ctors.zipIdx do
+        weakOrd := weakOrd.insert ctor.name (idx + 1 + cidx )
+      for (recr, ridx) in i.recrs.zipIdx do
+        weakOrd := weakOrd.insert recr.name (idx + 1 + numCtors + ridx)
+    idx := idx + 1 + maxCtors + maxRecrs
+  return weakOrd
+
+partial def sortInds' (iss: List (List PreInductive))
+  : CompileM (List (List PreInductive)) := do
+  let weakOrd <- weakOrdInds iss
+  let mut iss' : Array (List PreInductive) := default
+  for is in iss do
+    match is with
+    | [] => throw <| .emptyIndsEquivalenceClass iss
+    | [i] => iss' := iss'.push [i]
+    | is => do
+      let is' <- is.sortByM (compareInd weakOrd)
+      let is' <- List.groupByM (eqInd weakOrd) is'
+      for i in is' do
+        let i' <- i.sortByM (fun x y => pure $ compare x.name y.name)
+        iss' := iss'.push i'
+  if iss == iss'.toList
+  then return iss
+  else sortInds' iss'.toList
 
 end
 
@@ -868,14 +844,14 @@ partial def addDef
   let typ' <- compileExpr typ
   let val' <- compileExpr val
   let anonConst := Ix.Const.definition 
-    ⟨.anonymous, lvls, typ', .definition, val', .opaque, false, []⟩
+    ⟨.anonymous, lvls, typ', .definition, val', .opaque, .safe, []⟩
   let anonIxon <- match constToIxon anonConst with
     | .ok (a, _) => pure a
     | .error e => throw (.transportError e)
   let anonAddr <- storeConst anonIxon
   let name := anonAddr.toUniqueName
   let const := 
-    Ix.Const.definition ⟨name, lvls, typ', .definition, val', .opaque, false, []⟩
+    Ix.Const.definition ⟨name, lvls, typ', .definition, val', .opaque, .safe, []⟩
   let (a, m) <- hashConst const
   if a != anonAddr then
     throw <| .alphaInvarianceFailure anonConst anonAddr const a
@@ -963,6 +939,11 @@ def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
   : CompileM Unit := do
   delta.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
 
+def compileEnv (env: Lean.Environment)
+  : CompileM Unit := do
+  compileDelta env.getDelta
+  env.getConstMap.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
+
 def CompileM.runIO (c : CompileM α) 
   (env: Lean.Environment)
   (maxHeartBeats: USize := 200000)
@@ -977,6 +958,15 @@ def CompileM.runIO (c : CompileM α)
     return (a, stt)
   | .error e _ => throw (IO.userError (<- e.pretty))
 
+def CompileM.runIO' (c : CompileM α) 
+  (stt: CompileState)
+  (maxHeartBeats: USize := 200000)
+  : IO (α × CompileState) := do
+  match c.run (.init maxHeartBeats) stt with
+  | .ok a stt => do
+    stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
+    return (a, stt)
+  | .error e _ => throw (IO.userError (<- e.pretty))
+
 def compileEnvIO (env: Lean.Environment) : IO CompileState := do
   Prod.snd <$> (compileDelta env.getDelta).runIO env
-
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index a10caa76..010d8318 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -264,10 +264,10 @@ partial def decompileMutIndCtx (block: Ix.InductiveBlock)
   : DecompileM (RBMap Lean.Name Nat compare) := do
   let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
   let mut i := 0
-  for (inds, names) in List.zip block.inds block.ctx do
+  for inds in block.inds do
     let (numCtors, numRecrs) <- checkCtorRecrLengths inds
-    for (ind, name) in List.zip inds names do
-      mutCtx := mutCtx.insert name i
+    for ind in inds do
+      mutCtx := mutCtx.insert ind.name i
       for (c, cidx) in List.zipIdx ind.ctors do
         mutCtx := mutCtx.insert c.name (i + cidx)
       for (r, ridx) in List.zipIdx ind.recrs do
@@ -315,9 +315,8 @@ partial def ensureBlock (name: Lean.Name) (c m: Address) : DecompileM BlockNames
     let cont : Ixon.Const <- match (<- read).store.find? c with
       | .some ixon => pure ixon
       | .none => throw <| .unknownStoreAddress (<- read).current c
-    let meta : Ixon.Metadata <- match (<- read).store.find? m with
-      | .some (.meta meta) => pure meta
-      | .some x => throw <| .expectedIxonMetadata (<- read).current m x
+    let meta : Ixon.Const <- match (<- read).store.find? m with
+      | .some ixon => pure ixon
       | .none => throw <| .unknownStoreAddress (<- read).current m
     match rematerialize cont meta with
     | .ok const  => do
@@ -331,10 +330,9 @@ partial def decompileDefn (x: Ix.Definition)
   : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
     let type <- decompileExpr x.type
     let val <- decompileExpr x.value
-    let safety := if x.isPartial then .«partial» else .safe
     match x.mode with
     | .definition => return .defnInfo <|
-      Lean.mkDefinitionValEx x.name x.levelParams type val x.hints safety x.all
+      Lean.mkDefinitionValEx x.name x.levelParams type val x.hints x.safety x.all
     | .opaque => return .opaqueInfo <|
       Lean.mkOpaqueValEx x.name x.levelParams type val true x.all
     | .theorem => return .thmInfo <|
@@ -347,7 +345,7 @@ partial def decompileIndc (x: Ix.Inductive)
       let type <- decompileExpr x.type
       let indc :=
         Lean.mkInductiveValEx x.name x.levelParams type x.numParams x.numIndices
-          x.all (x.ctors.map (·.name)) x.numNested x.isRec false x.isReflexive
+          x.all (x.ctors.map (·.name)) x.numNested x.isRec x.isUnsafe x.isReflexive
       let ctors <- x.ctors.mapM (decompileCtor x.name)
       let recrs <- x.recrs.mapM (decompileRecr x.all)
       return (.inductInfo indc, ctors, recrs)
@@ -357,7 +355,7 @@ partial def decompileIndc (x: Ix.Inductive)
       let type <- decompileExpr x.type
       return .ctorInfo <|
         Lean.mkConstructorValEx x.name x.levelParams type indcName
-          x.cidx x.numParams x.numFields false
+          x.cidx x.numParams x.numFields x.isUnsafe
     decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
       let rhs <- decompileExpr x.rhs
       return ⟨x.ctor, x.nfields, rhs⟩
@@ -367,400 +365,53 @@ partial def decompileIndc (x: Ix.Inductive)
       let rules <- x.rules.mapM decompileRecrRule
       return .recInfo <|
         Lean.mkRecursorValEx x.name x.levelParams type indcAll
-          x.numParams x.numIndices x.numMotives x.numMinors rules x.k false
+          x.numParams x.numIndices x.numMotives x.numMinors rules x.k x.isUnsafe
 
 -- TODO: name integrity
 partial def decompileConst : Ix.Const -> DecompileM BlockNames
 | .axiom x => withLevels x.levelParams do
-  let ⟨name, c, m⟩ := (<- read).current
+  let ⟨_, c, m⟩ := (<- read).current
   let type <- decompileExpr x.type
-  let const := (.axiomInfo <| Lean.mkAxiomValEx x.name x.levelParams type false)
+  let const := (.axiomInfo <| Lean.mkAxiomValEx x.name x.levelParams type x.isUnsafe)
   insertBlock c m (.single const)
 | .definition x => do
-  let ⟨name, c, m⟩ := (<- read).current
+  let ⟨_, c, m⟩ := (<- read).current
   let const <- decompileDefn x
   insertBlock c m (.single const)
 | .quotient x => withLevels x.levelParams do
-  let ⟨name, c, m⟩ := (<- read).current
+  let ⟨_, c, m⟩ := (<- read).current
   let type <- decompileExpr x.type
   let const := (.quotInfo <| Lean.mkQuotValEx x.name x.levelParams type x.kind)
   insertBlock c m (.single const)
-| .inductiveProj x => do
-  let curr@⟨name, c, m⟩ := (<- read).current
-  let bs <- ensureBlock name x.blockCont x.blockMeta
-  match bs with
-  | .inductive is => match is[x.idx]? with
-    | .some ⟨i, _, _⟩ =>
-       if i == name then return bs
-       else throw (.badProjection curr i x.blockCont x.blockMeta "mutual ind")
-    | .none => throw (.badProjection curr name x.blockCont x.blockMeta "mutual ind no idx")
-  | _ => throw (.badProjection curr name x.blockCont x.blockMeta "not inductive")
-| .constructorProj x => do
-  let curr@⟨name, c, m⟩ := (<- read).current
-  let bs <- ensureBlock x.induct x.blockCont x.blockMeta
-  let cs <- match bs with
-    | .inductive is => match is[x.idx]? with
-      | .some ⟨i, cs, _⟩ =>
-         if i == x.induct then pure cs
-         else throw (.badProjection curr i x.blockCont x.blockMeta "ctor, inductive name {i} != {x.induct}")
-      | .none => throw (.badProjection curr x.induct x.blockCont x.blockMeta "ctor mutual ind no idx {x.idx}")
-    | _ => throw (.badProjection curr x.induct x.blockCont x.blockMeta "ctor not inductive")
-  let n <- match cs[x.cidx]? with
-  | .some n => pure n
-  | .none => throw (.badProjection curr name x.blockCont x.blockMeta s!"bad ctor idx {x.cidx} {cs}")
-  if name == n then return bs
-  else
-    throw (.badProjection curr name x.blockCont x.blockMeta "ctor name mismatch")
-| .recursorProj x => do
-  let curr@⟨name, c, m⟩ := (<- read).current
-  let bs <- ensureBlock x.induct x.blockCont x.blockMeta
-  let rs <- match bs with
-    | .inductive is => match is[x.idx]? with
-      | .some ⟨i, _, rs⟩ =>
-         if i == x.induct then pure rs
-         else throw (.badProjection curr i x.blockCont x.blockMeta "recursor, inductive name {i} != {x.induct}")
-      | .none => throw (.badProjection curr name x.blockCont x.blockMeta "recursor, no idx {x.idx}")
-    | _ => throw (.badProjection curr name x.blockCont x.blockMeta "recr not inductive")
-  let n <- match rs[x.ridx]? with
-  | .some n => pure n
-  | .none => throw (.badProjection curr name x.blockCont x.blockMeta s!"bad recr idx {x.ridx} {rs}")
-  if name == n then return bs
-  else
-    throw (.badProjection curr name x.blockCont x.blockMeta "recr name mismatch")
-| .definitionProj x => do
-  let curr@⟨name, c, m⟩ := (<- read).current
-  let bs <- ensureBlock name x.blockCont x.blockMeta
-  match bs with
-  | .mutual is => match is[x.idx]? with
-    | .some d =>
-       if d == x.name then return bs
-       else throw (.badProjection curr d x.blockCont x.blockMeta "def mutual")
-    | .none => throw (.badProjection curr name x.blockCont x.blockMeta "def mutual no idx")
-  | .single d =>
-    if x.idx == 0 && d == x.name then pure bs
-    else throw (.badProjection curr d x.blockCont x.blockMeta "def single")
-  | _ => throw (.badProjection curr name x.blockCont x.blockMeta "def not mutual")
+| .inductiveProj x => ensureBlock x.name x.blockCont x.blockMeta
+| .constructorProj x => ensureBlock x.induct x.blockCont x.blockMeta
+| .recursorProj x => ensureBlock x.induct x.blockCont x.blockMeta
+| .definitionProj x => ensureBlock x.name x.blockCont x.blockMeta
 | .mutual x => do
-  let curr@⟨name, c, m⟩ := (<- read).current
+  let ⟨_, c, m⟩ := (<- read).current
   let mutCtx <- decompileMutualCtx x.ctx
   withMutCtx mutCtx do
     let mut block := #[]
-    for (defns, names) in List.zip x.defs x.ctx do
-      for (defn, name) in List.zip defns names do
+    for defns in x.defs do
+      for defn in defns do
         let const <- decompileDefn defn
         block := block.push const
     insertBlock c m (.mutual block.toList)
 | .inductive x => do
-  let curr@⟨name, c, m⟩ := (<- read).current
+  let ⟨_, c, m⟩ := (<- read).current
   let mutCtx <- decompileMutIndCtx x
   withMutCtx mutCtx do
     let mut block := #[]
-    for (inds, names) in List.zip x.inds x.ctx do
-      for (ind, name) in List.zip inds names do
+    for inds in x.inds do
+      for ind in inds do
         let (i, cs, rs) <- decompileIndc ind
         block := block.push ⟨i, cs, rs⟩
     insertBlock c m (Block.inductive block.toList)
 
 end
---
-----partial def ensureConst'
-----  (c m: Address) (n: Option Lean.Name) : DecompileM Unit := do
-----  match n, (<- get).blocks.find? (c, m) with
-----  | .some name, .some b =>
-----    if b.contains name then return ()
-----    else throw <| .expectedNameInBlock name b c m
-----  | .none, .some b => return ()
-----  | n, .none => do
-----    let cont : Ixon.Const <- match (<- get).store.find? c with
-----      | .some ixon => pure ixon
-----      | .none => throw <| .unknownStoreAddress c
-----    let meta : Ixon.Metadata <- match (<- get).store.find? m with
-----      | .some (.meta meta) => pure meta
-----      | .some x => throw <| .expectedIxonMetadata m x
-----      | .none => throw <| .unknownStoreAddress m
-----    match rematerialize cont meta with
-----    | .ok const  => do
-----      let consts <- decompileConst' c m n const
-----
-----    | .error e => throw (.transport e c m)
---
-----partial def ensureConst (name: Lean.Name) (cont meta: Address) : DecompileM Unit := do
-----  match (<- get).blocks.find? (cont, meta) with
-----  | .some (.defn n) => 
-----    if n == name then return () else throw <| .mismatchedName name n cont meta
-----  | .some x => throw <| .expectedDefnBlock name x cont meta
-----  | .none => do
-----    let c : Ixon.Const <- match (<- get).store.find? cont with
-----      | .some ixon => pure ixon
-----      | .none => throw <| .unknownStoreAddress cont
-----    let m : Ixon.Metadata <- match (<- get).store.find? meta with
-----      | .some (.meta meta) => pure meta
-----      | .some x => throw <| .expectedIxonMetadata meta x
-----      | .none => throw <| .unknownStoreAddress meta
-----    match rematerialize c m with
-----    | .ok a  => decompileConst name cont meta a
-----    | .error e => throw (.transport e cont meta)
-----
-----partial def ensureIndBlock (n: Lean.Name) (cont meta: Address) : DecompileM Unit := do
-----  match (<- get).blocks.find? (cont, meta) with
-----  | .some (.indcs _) => return ()
-----  | .some x => throw <| .expectedMutIndBlock x cont meta
-----  | .none => do
-----    let c : Ixon.Const <- match (<- get).store.find? cont with
-----      | .some ixon => pure ixon
-----      | .none => throw <| .unknownStoreAddress cont
-----    let m : Ixon.Metadata <- match (<- get).store.find? meta with
-----      | .some (.meta meta) => pure meta
-----      | .some x => throw <| .expectedIxonMetadata meta x
-----      | .none => throw <| .unknownStoreAddress meta
-----    match rematerialize c m with
-----    | .ok (.mutIndBlock x)  => decompileMutIndBlock x cont meta
-----    | .ok c@(.«inductive» x) => decompileConst n cont meta c
-----    | .ok x => throw <| .expectedMutIndConst x cont meta
-----    | .error e => throw (.transport e cont meta)
-----
-----partial def ensureMutDefBlock (cont meta: Address) : DecompileM Unit := do
-----  match (<- get).blocks.find? (cont, meta) with
-----  | .some (.defns _) => return ()
-----  | .some x => throw <| .expectedMutDefBlock x cont meta
-----  | .none => do
-----    let c : Ixon.Const <- match (<- get).store.find? cont with
-----      | .some ixon => pure ixon
-----      | .none => throw <| .unknownStoreAddress cont
-----    let m : Ixon.Metadata <- match (<- get).store.find? meta with
-----      | .some (.meta meta) => pure meta
-----      | .some x => throw <| .expectedIxonMetadata meta x
-----      | .none => throw <| .unknownStoreAddress meta
-----    match rematerialize c m with
-----    | .ok (.mutDefBlock x)  => decompileMutDefBlock x cont meta
-----    | .ok x  => throw <| .expectedMutDefConst x cont meta
-----    | .error e => throw (.transport e cont meta)
-----
-----
-----
-----
-----partial def tryInsertConst
-----  (const: Lean.ConstantInfo)
-----  : DecompileM Unit := do
-----  match (<- get).env.find? const.name with
-----  | .some const' =>
-----      if const == const'
-----      then return ()
-----      else throw <| .inconsistentConsts const const'
-----  | .none => modify fun stt => { stt with env := stt.env.insert const.name const }
-----
-----partial def decompileDefn (name: Lean.Name) (c m : Address) (x: Ix.Definition)
-----  : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
-----    let type <- decompileExpr c m x.type
-----    let val <- decompileExpr c m x.value
-----    let safety := if x.isPartial then .«partial» else .safe
-----    match x.mode with
-----    | .definition => return .defnInfo <|
-----      Lean.mkDefinitionValEx name x.levelParams type val x.hints safety x.all
-----    | .opaque => return .opaqueInfo <|
-----      Lean.mkOpaqueValEx name x.levelParams type val true x.all
-----    | .theorem => return .thmInfo <|
-----      Lean.mkTheoremValEx name x.levelParams type val x.all
-----
-----partial def decompileIndc 
-----  (name: Lean.Name)
-----  (c m : Address)
-----  (x: Ix.Inductive) :
-----  DecompileM 
-----    (Lean.ConstantInfo × List Lean.ConstantInfo × List Lean.ConstantInfo)
-----    := withLevels x.levelParams do
-----      let type <- decompileExpr c m x.type
-----      let indc :=
-----        Lean.mkInductiveValEx name x.levelParams type x.numParams x.numIndices
-----          x.all (x.ctors.map (·.name)) x.numNested x.isRec false x.isReflexive
-----      let ctors <- x.ctors.mapM (decompileCtor name)
-----      let recrs <- x.recrs.mapM (decompileRecr x.all)
-----      return (.inductInfo indc, ctors, recrs)
-----  where
-----    decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
-----      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
-----      let type <- decompileExpr c m x.type
-----      return .ctorInfo <|
-----        Lean.mkConstructorValEx x.name x.levelParams type indcName 
-----          x.cidx x.numParams x.numFields false
-----    decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
-----      let rhs <- decompileExpr c m x.rhs
-----      return ⟨x.ctor, x.nfields, rhs⟩
-----    decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
-----      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
-----      let type <- decompileExpr c m x.type
-----      let rules <- x.rules.mapM decompileRecrRule
-----      return .recInfo <|
-----        Lean.mkRecursorValEx x.name x.levelParams type indcAll
-----          x.numParams x.numIndices x.numMotives x.numMinors rules x.k false
-----
-----partial def ensureConst'
-----  (c m: Address) (n: Option Lean.Name) : DecompileM Unit := do
-----  match n, (<- get).blocks.find? (c, m) with
-----  | .some name, .some b =>
-----    if b.contains name then return ()
-----    else throw <| .expectedNameInBlock name b c m
-----  | .none, .some b => return ()
-----  | n, .none => do
-----    let cont : Ixon.Const <- match (<- get).store.find? c with
-----      | .some ixon => pure ixon
-----      | .none => throw <| .unknownStoreAddress c
-----    let meta : Ixon.Metadata <- match (<- get).store.find? m with
-----      | .some (.meta meta) => pure meta
-----      | .some x => throw <| .expectedIxonMetadata m x
-----      | .none => throw <| .unknownStoreAddress m
-----    match rematerialize cont meta with
-----    | .ok const  => do
-----      let consts <- decompileConst' c m n const
-----
-----    | .error e => throw (.transport e c m)
-----
-----
-----partial def decompileConst' (c m: Address)
-----  : Option Lean.Name -> Ix.Const -> DecompileM (List Lean.ConstantInfo)
-----| .some n, .«axiom» x => withLevels x.levelParams do
-----  let type <- decompileExpr c m x.type
-----  return [.axiomInfo <| Lean.mkAxiomValEx n x.levelParams type false]
-----| .some n, .«definition» x => do
-----  let d <- decompileDefn n c m x
-----  return [d]
-----| .some n, .«inductive» x => do
-----  let (i, _, _) <- decompileIndc n c m x
-----  return [i]
-----| .some n, .quotient x => withLevels x.levelParams do
-----  let type <- decompileExpr c m x.type
-----  return [.quotInfo <| Lean.mkQuotValEx n x.levelParams type x.kind]
-----| .some n, .inductiveProj x => do
-----  ensureConst (.some n) x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.indcs ns) => pure ns
-----    | .some (.indc n) => pure [n]
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indcs or indc block"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let (i, _, _) <- match ns[x.idx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
-----    if i == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "indc name mismatch"
-----| .constructorProj x => do
-----  ensureIndBlock n x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.indcs ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let (_, cs, _) <- match ns[x.idx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
-----  let n <- match cs[x.cidx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta s!"bad ctor idx {x.cidx} {cs}"
-----    if n == n then return () else 
-----      throw <| .badProjection n x.blockCont x.blockMeta "ctor name mismatch"
-----| .recursorProj x => do
-----  ensureIndBlock n x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.indcs ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let (_, _, rs) <- match ns[x.idx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
-----  let n <- match rs[x.ridx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad recr idx"
-----    if n == n then return () else
-----      throw <| .badProjection n x.blockCont x.blockMeta "recr name mismatch"
-----| .definitionProj x => do
-----  ensureMutDefBlock x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.defns ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not defns block"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let n <- match ns[x.idx]? with
-----    | .some n => pure n 
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad defn idx"
-----    if n == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "defn name mismatch"
-----| .none, .mutDefBlock x => sorry
-----| .none, .mutIndBlock x => sorry
-----
-----
-----partial def decompileConst
-----  (n: Lean.Name) (c m: Address): Ix.Const -> DecompileM Unit
-----| .axiom x => withLevels x.levelParams do
-----  let type <- decompileExpr c m x.type
-----  let val := Lean.mkAxiomValEx n x.levelParams type false
-----  tryInsertConst (.axiomInfo val)
-----| .definition x => do
-----  decompileDefn n c m x >>= tryInsertConst
-----  modify fun stt => 
-----    { stt with blocks := stt.blocks.insert (c, m) (.defn i) }
-----| .inductive x => do
-----  let (i, cs, rs) <- decompileIndc n c m x
-----  tryInsertConst i
-----  let cns <- cs.mapM <| fun c => tryInsertConst c *> pure c.name
-----  let rns <- rs.mapM <| fun r => tryInsertConst r *> pure r.name
-----  modify fun stt => 
-----    { stt with blocks := stt.blocks.insert (c, m) (.indcs [(i.name, cns, rns)]) }
-----| .quotient x => withLevels x.levelParams do
-----  let type <- decompileExpr c m x.type
-----  let val :=  Lean.mkQuotValEx n x.levelParams type x.kind
-----  tryInsertConst (.quotInfo val)
-----| .inductiveProj x => do
-----  ensureIndBlock n x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.indcs ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indcs block"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let (i, _, _) <- match ns[x.idx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
-----    if i == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "indc name mismatch"
-----| .constructorProj x => do
-----  ensureIndBlock n x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.indcs ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let (_, cs, _) <- match ns[x.idx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
-----  let n <- match cs[x.cidx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta s!"bad ctor idx {x.cidx} {cs}"
-----    if n == n then return () else 
-----      throw <| .badProjection n x.blockCont x.blockMeta "ctor name mismatch"
-----| .recursorProj x => do
-----  ensureIndBlock n x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.indcs ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not indc"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let (_, _, rs) <- match ns[x.idx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad ind idx"
-----  let n <- match rs[x.ridx]? with
-----    | .some ns => pure ns
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad recr idx"
-----    if n == n then return () else
-----      throw <| .badProjection n x.blockCont x.blockMeta "recr name mismatch"
-----| .definitionProj x => do
-----  ensureMutDefBlock x.blockCont x.blockMeta
-----  let ns <- match (<- get).blocks.find? (x.blockCont, x.blockMeta) with
-----    | .some (.defns ns) => pure ns
-----    | .some _ => throw <| .badProjection n x.blockCont x.blockMeta "not defns block"
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "no block"
-----  let n <- match ns[x.idx]? with
-----    | .some n => pure n 
-----    | .none => throw <| .badProjection n x.blockCont x.blockMeta "bad defn idx"
-----    if n == n then return () else throw <| .badProjection n x.blockCont x.blockMeta "defn name mismatch"
------- these should be unreachable here
-----| .mutDefBlock x => throw <| .namedMutDefBlock n x
-----| .mutIndBlock x => throw <| .namedMutIndBlock n x
-----
-----
-----end
-----
-----def decompileEnv : DecompileM Unit := do
-----  for (n, (anon, meta)) in (<- get).names do
-----    ensureConst n anon meta
---
---end Decompile
+
+def decompileEnv : DecompileM Unit := do
+  for (n, (anon, meta)) in (<- read).names do
+    let _ <- ensureBlock n anon meta
+
+end Decompile
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 5ffb0e04..3e7d93fb 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -124,8 +124,31 @@ structure Axiom where
   name: Lean.Name
   levelParams : List Lean.Name
   type : Expr
+  isUnsafe: Bool
   deriving Ord, BEq, Hashable, Repr, Nonempty
 
+structure PreDefinition where
+  name: Lean.Name
+  levelParams : List Lean.Name
+  type : Lean.Expr
+  mode : DefMode
+  value : Lean.Expr
+  hints : Lean.ReducibilityHints
+  safety : Lean.DefinitionSafety
+  all : List Lean.Name
+  deriving BEq, Repr, Nonempty
+
+def mkPreDefinition (x: Lean.DefinitionVal) : PreDefinition := 
+  ⟨x.name, x.levelParams, x.type, .definition, x.value, x.hints, x.safety, x.all⟩
+
+def mkPreTheorem (x: Lean.TheoremVal) : PreDefinition := 
+  ⟨x.name, x.levelParams, x.type, .theorem, x.value, .opaque, .safe, x.all⟩
+
+def mkPreOpaque (x: Lean.OpaqueVal) : PreDefinition := 
+  ⟨x.name, x.levelParams, x.type, .opaque, x.value, .opaque,
+    if x.isUnsafe then .unsafe else .safe, x.all⟩
+
+
 /--
 Ix.Definition definitions combine Lean.DefinitionVal, Lean.OpaqueVal and
 Lean.TheoremVal into a single structure in order to enable content-addressing of
@@ -143,7 +166,7 @@ structure Definition where
   mode: DefMode
   value : Expr
   hints : Lean.ReducibilityHints
-  isPartial : Bool
+  safety: Lean.DefinitionSafety
   all : List Lean.Name
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
@@ -154,7 +177,7 @@ def mkTheorem
   (value: Expr)
   (all: List Lean.Name)
   : Definition
-  := ⟨name, levelParams, type, .theorem, value, .opaque, false, all⟩
+  := ⟨name, levelParams, type, .theorem, value, .opaque, .safe, all⟩
 
 def mkOpaque
   (name: Lean.Name)
@@ -162,8 +185,9 @@ def mkOpaque
   (type: Expr)
   (value: Expr)
   (all: List Lean.Name)
+  (isUnsafe: Bool)
   : Definition
-  := ⟨name, levelParams, type, .opaque, value, .opaque, false, all⟩
+  := ⟨name, levelParams, type, .opaque, value, .opaque, if isUnsafe then .unsafe else .safe, all⟩
 
 /--
 Ix.Constructor inductive datatype constructors are analogous to
@@ -181,6 +205,7 @@ structure Constructor where
   cidx : Nat
   numParams : Nat
   numFields : Nat
+  isUnsafe: Bool
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 /--
@@ -209,6 +234,7 @@ structure Recursor where
   numMinors  : Nat
   rules : List RecursorRule
   k : Bool
+  isUnsafe: Bool
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 /--
@@ -227,6 +253,7 @@ structure PreInductive where
   numNested: Nat
   isRec : Bool
   isReflexive : Bool
+  isUnsafe: Bool
   deriving BEq, Repr, Nonempty
 
 /--
@@ -246,6 +273,7 @@ structure Inductive where
   numNested: Nat
   isRec : Bool
   isReflexive : Bool
+  isUnsafe: Bool
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 
@@ -302,14 +330,20 @@ structure DefinitionProj where
 
 structure MutualBlock where
   defs : List (List Definition)
-  ctx  : List (List Lean.Name)
+  --all: List Lean.Name
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
+def MutualBlock.ctx (x: MutualBlock) : List (List Lean.Name) :=
+  x.defs.map fun xs => xs.map fun x => x.name
+
 structure InductiveBlock where
   inds : List (List Inductive)
-  ctx  : List (List Lean.Name)
+  --all: List Lean.Name
   deriving BEq, Ord, Hashable, Repr, Nonempty, Inhabited
 
+def InductiveBlock.ctx (x: InductiveBlock) : List (List Lean.Name) :=
+  x.inds.map fun xs => xs.map fun x => x.name
+
 inductive Const where
   | «axiom» : Axiom → Const
   | quotient : Quotient → Const
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index 7c21501e..9fb24f48 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -17,6 +17,7 @@ structure Quotient where
 structure Axiom where
   lvls : Nat
   type : Expr
+  isUnsafe: Bool
   deriving BEq, Repr
 
 structure Definition where
@@ -24,7 +25,7 @@ structure Definition where
   type : Expr
   mode : Ix.DefMode
   value : Expr
-  part : Bool
+  safety : Lean.DefinitionSafety
   deriving BEq, Repr
 
 structure Constructor where
@@ -33,6 +34,7 @@ structure Constructor where
   cidx : Nat
   params : Nat
   fields : Nat
+  isUnsafe: Bool
   deriving BEq, Repr
 
 structure RecursorRule where
@@ -49,6 +51,7 @@ structure Recursor where
   minors : Nat
   rules : List RecursorRule
   k : Bool
+  isUnsafe: Bool
   deriving BEq, Repr
 
 structure Inductive where
@@ -61,6 +64,7 @@ structure Inductive where
   nested : Nat
   recr : Bool
   refl : Bool
+  isUnsafe: Bool
   deriving BEq, Repr
 
 structure InductiveProj where
@@ -119,7 +123,7 @@ inductive Const where
 
 def putConst : Const → PutM
 | .defn x => putUInt8 0xC0 *> putDefn x
-| .axio x => putUInt8 0xC1 *> putNatl x.lvls *> putExpr x.type
+| .axio x => putUInt8 0xC1 *> putNatl x.lvls *> putExpr x.type *> putBool x.isUnsafe
 | .quot x => putUInt8 0xC2 *> putNatl x.lvls *> putExpr x.type *> putQuotKind x.kind
 | .ctorProj x => putUInt8 0xC3 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.cidx
 | .recrProj x => putUInt8 0xC4 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
@@ -136,7 +140,7 @@ def putConst : Const → PutM
       putExpr x.type
       putDefMode x.mode
       putExpr x.value
-      putBool x.part
+      putDefinitionSafety x.safety
     putRecrRule (x: RecursorRule) : PutM := putNatl x.fields *> putExpr x.rhs
     putCtor (x: Constructor) : PutM := do
       putNatl x.lvls
@@ -144,6 +148,7 @@ def putConst : Const → PutM
       putNatl x.cidx
       putNatl x.params
       putNatl x.fields
+      putBool x.isUnsafe
     putRecr (x: Recursor) : PutM := do
       putNatl x.lvls
       putExpr x.type
@@ -153,6 +158,7 @@ def putConst : Const → PutM
       putNatl x.minors
       putArray putRecrRule x.rules
       putBool x.k
+      putBool x.isUnsafe
     putIndc (x: Inductive) : PutM := do
       putNatl x.lvls
       putExpr x.type
@@ -161,7 +167,7 @@ def putConst : Const → PutM
       putArray putCtor x.ctors
       putArray putRecr x.recrs
       putNatl x.nested
-      putBools [x.recr, x.refl]
+      putBools [x.recr, x.refl, x.isUnsafe]
     putProof (p: Proof) : PutM :=
       match p.claim with
       | .checks lvls type value => do
@@ -184,7 +190,7 @@ def getConst : GetM Const := do
   let tag ← getUInt8
   match tag with
   | 0xC0 => .defn <$> getDefn
-  | 0xC1 => .axio <$> (.mk <$> getNatl <*> getExpr)
+  | 0xC1 => .axio <$> (.mk <$> getNatl <*> getExpr <*> getBool)
   | 0xC2 => .quot <$> (.mk <$> getNatl <*> getExpr <*> getQuotKind)
   | 0xC3 => .ctorProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
   | 0xC4 => .recrProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
@@ -202,15 +208,16 @@ def getConst : GetM Const := do
       let type <- getExpr
       let mode <- getDefMode
       let value <- getExpr
-      let part <- getBool
-      return ⟨lvls, type, mode, value, part⟩
+      let safety <- getDefinitionSafety
+      return ⟨lvls, type, mode, value, safety⟩
     getCtor : GetM Constructor := do
       let lvls <- getNatl
       let type <- getExpr
       let cidx <- getNatl
       let params <- getNatl
       let fields <- getNatl
-      return ⟨lvls, type, cidx, params, fields⟩
+      let safety <- getBool
+      return ⟨lvls, type, cidx, params, fields, safety⟩
     getRecrRule : GetM RecursorRule := RecursorRule.mk <$> getNatl <*> getExpr
     getRecr : GetM Recursor := do
       let lvls <- getNatl
@@ -221,7 +228,8 @@ def getConst : GetM Const := do
       let minors <- getNatl
       let rules <- getArray getRecrRule
       let k <- getBool
-      return ⟨lvls, type, params, indices, motives, minors, rules, k⟩
+      let safety <- getBool
+      return ⟨lvls, type, params, indices, motives, minors, rules, k, safety⟩
     getIndc : GetM Inductive := do
       let lvls <- getNatl
       let type <- getExpr
@@ -230,10 +238,10 @@ def getConst : GetM Const := do
       let ctors <- getArray getCtor
       let recrs <- getArray getRecr
       let nested <- getNatl
-      let (recr, refl) <- match ← getBools 2 with
-        | [x, y] => pure (x, y)
+      let (recr, refl, safety) <- match ← getBools 3 with
+        | [x, y, z] => pure (x, y, z)
         | _ => throw s!"unreachable"
-      return ⟨lvls, type, params, indices, ctors, recrs, nested, recr, refl⟩
+      return ⟨lvls, type, params, indices, ctors, recrs, nested, recr, refl, safety⟩
     getAddr : GetM Address := .mk <$> getBytes 32
     getProof : GetM Proof := do
       match (<- getUInt8) with
diff --git a/Ix/Ixon/Serialize.lean b/Ix/Ixon/Serialize.lean
index b2fafe8c..598fb83f 100644
--- a/Ix/Ixon/Serialize.lean
+++ b/Ix/Ixon/Serialize.lean
@@ -196,4 +196,16 @@ def getReducibilityHints : GetM Lean.ReducibilityHints := do
   | 2 => .regular <$> getUInt32LE
   | e => throw s!"expected ReducibilityHints encoding between 0 and 2, got {e}"
 
+def putDefinitionSafety : Lean.DefinitionSafety → PutM
+| .«unsafe» => putUInt8 0
+| .«safe» => putUInt8 1
+| .«partial» => putUInt8 2
+
+def getDefinitionSafety : GetM Lean.DefinitionSafety := do
+  match (← getUInt8) with
+  | 0 => return .«unsafe»
+  | 1 => return .«safe»
+  | 2 => return .«partial» 
+  | e => throw s!"expected DefinitionSafety encoding between 0 and 2, got {e}"
+
 end Ixon
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index 36b74729..d9f48336 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -20,20 +20,22 @@ def emptyDematState : DematState :=
   { idx := 0, meta := { map := Batteries.RBMap.empty }}
 
 inductive TransportError
-  | natTooBig (idx: Nat) (x: Nat)
-  | unknownIndex (idx: Nat) (m: Ixon.Metadata)
-  | unexpectedNode (idx: Nat) (m: Ixon.Metadata)
-  | rawMetadata (m: Ixon.Metadata)
-  | rawProof (m: Proof)
-  | rawComm (m: Ixon.Comm)
-  | emptyEquivalenceClass
-  deriving BEq, Repr
+| natTooBig (idx: Nat) (x: Nat)
+| unknownIndex (idx: Nat) (m: Ixon.Metadata)
+| unexpectedNode (idx: Nat) (m: Ixon.Metadata)
+| rawMetadata (m: Ixon.Metadata)
+| expectedMetadata (m: Ixon.Const)
+| rawProof (m: Proof)
+| rawComm (m: Ixon.Comm)
+| emptyEquivalenceClass
+deriving BEq, Repr
 
 instance : ToString TransportError where toString
 | .natTooBig idx x => s!"At index {idx}, natural number {x} too big to fit in UInt64"
 | .unknownIndex idx x => s!"Unknown index {idx} with metadata {repr x}"
 | .unexpectedNode idx x => s!"Unexpected node at {idx} with metadata {repr x}"
 | .rawMetadata x => s!"Can't rematerialize raw metadata {repr x}"
+| .expectedMetadata x => s!"Expected metadata, got {repr x}"
 | .rawProof x => s!"Can't rematerialize raw proof {repr x}"
 | .rawComm x => s!"Can't rematerialize raw commitment {repr x}"
 | .emptyEquivalenceClass => s!"empty equivalence class, should be unreachable"
@@ -249,7 +251,7 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
   dematMeta [.name x.name]
   let lvls <- dematLevels x.levelParams
   let type <- dematExpr x.type
-  return .axio (.mk lvls type)
+  return .axio (.mk lvls type x.isUnsafe)
 | .«definition» x => .defn <$> dematDefn x
 | .quotient x => do
   dematMeta [.name x.name]
@@ -289,13 +291,13 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
       let lvls <- dematLevels x.levelParams
       let type <- dematExpr x.type
       let value <- dematExpr x.value
-      return .mk lvls type x.mode value x.isPartial
+      return .mk lvls type x.mode value x.safety
     dematCtor (x: Ix.Constructor): DematM Ixon.Constructor := do
       let _ <- dematIncr
       dematMeta [.name x.name]
       let lvls <- dematLevels x.levelParams
       let t <- dematExpr x.type
-      return .mk lvls t x.cidx x.numParams x.numFields
+      return .mk lvls t x.cidx x.numParams x.numFields x.isUnsafe
     dematRecrRule (x: Ix.RecursorRule): DematM Ixon.RecursorRule := do
       let _ <- dematIncr
       dematMeta [.name x.ctor]
@@ -308,7 +310,7 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
       let t <- dematExpr x.type
       let rrs <- x.rules.mapM dematRecrRule
       return ⟨lvls, t, x.numParams, x.numIndices, x.numMotives, x.numMinors, 
-        rrs, x.k⟩
+        rrs, x.k, x.isUnsafe⟩
     dematIndc (x: Ix.Inductive): DematM Ixon.Inductive := do
       let _ <- dematIncr
       dematMeta [.name x.name, .all x.all]
@@ -317,7 +319,7 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
       let ctors <- x.ctors.mapM dematCtor
       let recrs <- x.recrs.mapM dematRecr
       return ⟨lvls, type, x.numParams, x.numIndices, ctors, recrs, x.numNested,
-        x.isRec, x.isReflexive⟩
+        x.isRec, x.isReflexive, x.isUnsafe⟩
 
 def constToIxon (x: Ix.Const) : Except TransportError (Ixon.Const × Ixon.Const) := 
   match EStateM.run (dematConst x) emptyDematState with
@@ -340,7 +342,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
     | _ => rematThrowUnexpected
   let lvls <- rematLevels x.lvls
   let type <- rematExpr x.type
-  return .«axiom» ⟨name, lvls, type⟩
+  return .«axiom» ⟨name, lvls, type, x.isUnsafe⟩
 | .quot x => do
   let name <- match (<- rematMeta) with
     | [.name x] => pure x
@@ -379,7 +381,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       let d <- rematDefn x
       ds := ds.push d
     defs := defs.push ds.toList
-  return .mutual ⟨defs.toList, ctx⟩
+  return .mutual ⟨defs.toList⟩
 | .mutInd xs => do
   let ctx <- match (<- rematMeta) with
     | [.mutCtx x] => pure x
@@ -391,7 +393,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       let i <- rematIndc x
       is := is.push i
     inds := inds.push is.toList
-  return .inductive ⟨inds.toList, ctx⟩
+  return .inductive ⟨inds.toList⟩
 | .meta m => throw (.rawMetadata m)
 -- TODO: This could return a Proof inductive, since proofs have no metadata
 | .proof p => throw (.rawProof p)
@@ -405,7 +407,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       let lvls <- rematLevels x.lvls
       let type <- rematExpr x.type
       let value <- rematExpr x.value
-      return .mk name lvls type x.mode value hints x.part all
+      return .mk name lvls type x.mode value hints x.safety all
     rematCtor (x: Ixon.Constructor) : RematM Ix.Constructor := do
       let _ <- rematIncr
       let name <- match (<- rematMeta) with
@@ -413,7 +415,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
         | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
-      return .mk name lvls t x.cidx x.params x.fields
+      return .mk name lvls t x.cidx x.params x.fields x.isUnsafe
     rematRecrRule (x: Ixon.RecursorRule) : RematM Ix.RecursorRule := do
       let _ <- rematIncr
       let ctor <- match (<- rematMeta) with
@@ -429,7 +431,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       let lvls <- rematLevels x.lvls
       let t <- rematExpr x.type
       let rs <- x.rules.mapM rematRecrRule
-      return ⟨name, lvls, t, x.params, x.indices, x.motives, x.minors, rs, x.k⟩
+      return ⟨name, lvls, t, x.params, x.indices, x.motives, x.minors, rs, x.k, x.isUnsafe⟩
     rematIndc (x: Ixon.Inductive) : RematM Ix.Inductive := do
       let _ <- rematIncr
       let (name, all) <- match (<- rematMeta) with
@@ -440,11 +442,13 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       let cs <- x.ctors.mapM rematCtor
       let rs <- x.recrs.mapM rematRecr
       return ⟨name, lvls, t, x.params, x.indices, all, cs, rs, x.nested, x.recr,
-        x.refl⟩
+        x.refl, x.isUnsafe⟩
 
-def rematerialize (c : Ixon.Const) (m: Ixon.Metadata) 
-  : Except TransportError Ix.Const
-  := match ((rematConst c).run { meta := m }).run emptyRematState with
+def rematerialize (c m: Ixon.Const) : Except TransportError Ix.Const := do
+  let m <- match m with
+  | .meta m => pure m
+  | x => throw <| .expectedMetadata x
+  match ((rematConst c).run { meta := m }).run emptyRematState with
     | .ok a _ => return a
     | .error e _ => throw e
 
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index cd02f977..3ac8f126 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -6,6 +6,7 @@ import Ix.Common
 import Ix.CompileM
 import Ix.DecompileM
 import Ix.Meta
+import Ix.IR
 import Lean
 import Tests.Ix.Fixtures
 import Lean
@@ -52,38 +53,188 @@ open Ix.Decompile
 
 --#eval bar
 
-def test1 : IO TestSeq := do
+--def test1 : IO TestSeq := do
+--  let env <- get_env!
+--  let input <- runMeta (Lean.Meta.whnf (Lean.toExpr 3)) env
+--  let expected := Lean.Expr.lit (Lean.Literal.natVal 3)
+--  return test "expected 3" (input == expected)
+
+namespace Test.Ix.Inductives
+
+mutual
+  unsafe inductive A | a : B → C → A
+  unsafe inductive B | b : A → B
+  unsafe inductive C | c : A → C
+end
+
+--#eval show Lean.MetaM _ from do
+--  let env ← Lean.getEnv
+--  return env.find? ``A |>.map (·.value!)
+
+end Test.Ix.Inductives
+
+
+namespace Test.Ix.Mutual
+
+
+mutual
+  unsafe def A : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + C n + 1
+
+  unsafe def B : Nat → Nat
+  | 0 => 0
+  | n + 1 => A n + 1
+
+  unsafe def C : Nat → Nat
+  | 0 => 0
+  | n + 1 => A n + 1
+end
+
+end Test.Ix.Mutual
+
+
+def testMutual : IO TestSeq := do
   let env <- get_env!
-  let input <- runMeta (Lean.Meta.whnf (Lean.toExpr 3)) env
-  let expected := Lean.Expr.lit (Lean.Literal.natVal 3)
-  return test "expected 3" (input == expected)
+  let mut cstt : CompileState := .init env 0
+  let all := (env.getDelta.find! `Test.Ix.Mutual.A).all
+  let predefs <- all.mapM fun n => match env.getDelta.find! n with
+    | .defnInfo d => pure <| Ix.mkPreDefinition d
+    | .opaqueInfo d => pure <| Ix.mkPreOpaque d
+    | .thmInfo d => pure <| Ix.mkPreTheorem d
+    | _ => throw (IO.userError "not a def")
+  let (dss, _) <- match (sortDefs predefs).run (.init 200000) cstt with
+    | .ok a stt => do
+      pure (a, stt)
+    | .error e _ => do
+      throw (IO.userError (<- e.pretty))
+  let res := [[`Test.Ix.Mutual.C, `Test.Ix.Mutual.B],[`Test.Ix.Mutual.A]]
+  let nss := dss.map fun ds => ds.map (·.name)
+  return test "test mutual" (res == nss)
+
+def testInductives : IO TestSeq := do
+  let env <- get_env!
+  let mut cstt : CompileState := .init env 0
+  --let delta := env.getDelta.filter fun n _ => namesp.isPrefixOf n
+  --let consts := env.getConstMap.filter fun n _ => namesp.isPrefixOf n
+  let all := (env.getDelta.find! `Test.Ix.Inductives.A).all
+  let preinds <- all.mapM fun n => match env.getDelta.find! n with
+    | .inductInfo v => match (makePreInductive v).run (.init 200000) cstt with
+      | .ok a _ => pure a
+      | .error e _ => do throw (IO.userError (<- e.pretty))
+    | _ => throw (IO.userError "not an inductive")
+  let (dss, _) <- match (sortInds preinds).run (.init 200000) cstt with
+    | .ok a stt => do
+      pure (a, stt)
+    | .error e _ => do
+      throw (IO.userError (<- e.pretty))
+  let res := [[`Test.Ix.Inductives.C], [`Test.Ix.Inductives.B],[`Test.Ix.Inductives.A]]
+  let nss := dss.map fun ds => ds.map (·.name)
+  return test "test inductives" (res == nss)
+
+
+def testInductivesRoundtrip : IO TestSeq := do
+  let namesp := `Test.Ix.Inductives
+  let env <- get_env!
+  let delta := env.getDelta.filter fun n _ => namesp.isPrefixOf n
+  --IO.println s!"env with delta {delta.toList.map fun (n, _) => n}"
+  let mut cstt : CompileState := .init env 0
+  for (_, c) in delta do
+    let (_, stt) <- match (compileConst c).run (.init 200000) cstt with
+    | .ok a stt => do
+      stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
+      pure (a, stt)
+    | .error e _ => do
+      IO.println s!"failed {c.name}"
+      throw (IO.userError (<- e.pretty))
+    let (anon, meta) <- match stt.names.find? c.name with
+    | .some (a, m) => pure (a, m)
+    | .none => throw (IO.userError "name {n} not in env")
+    IO.println s!"✓ {c.name} -> {anon}:{meta}"
+    cstt := stt
+  let denv := DecompileEnv.init cstt.names cstt.store
+  let mut dstt := default
+  for (n, (a, m)) in denv.names do
+    let (_, stt) <- match (ensureBlock n a m).run denv dstt with
+    | .ok a stt => pure (a, stt)
+    | .error e _ => do
+      IO.println s!"decompilation failed {n}->{a}:{m}"
+      throw (IO.userError e.pretty)
+    IO.println ""
+    dstt := stt
+  let mut res := true
+  for (n, (anon, meta)) in denv.names do
+    let c <- match env.constants.find? n with
+    | .some c => pure c
+    | .none => throw (IO.userError "name {n} not in env")
+    match dstt.constants.find? n with
+    | .some c2 =>
+      if c == c2 then
+        IO.println s!"✓ {n} @ {anon}:{meta}"
+      else
+        IO.println s!"× {n} @ {anon}:{meta}"
+        IO.println s!"× {repr c}"
+        IO.println s!"× {repr c2}"
+        res := false
+        break
+    | .none => do
+      let e' := (DecompileError.unknownName default n).pretty
+      throw (IO.userError e')
+  return test "env compile roundtrip" (res == true)
 
 def testRoundtripGetEnv : IO TestSeq := do
   let env <- get_env!
   let delta := env.getDelta
-  let (_, cstt) <- (compileDelta delta).runIO env (seed := .some 0)
+  let consts := env.getConstMap
+  IO.println s!"env with delta {delta.toList.length}, constMap {consts.toList.length}"
+  let mut cstt : CompileState := .init env 0
+  IO.println s!"compiling env"
+  for (_, c) in env.getDelta do
+    let (_, stt) <- match (compileConst c).run (.init 200000) cstt with
+    | .ok a stt => do
+      --stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
+      pure (a, stt)
+    | .error e _ => do
+      IO.println s!"failed {c.name}"
+      throw (IO.userError (<- e.pretty))
+    let (anon, meta) <- match stt.names.find? c.name with
+    | .some (a, m) => pure (a, m)
+    | .none => throw (IO.userError "name {n} not in env")
+    IO.println s!"✓ {c.name} -> {anon}:{meta}"
+    cstt := stt
   IO.println s!"compiled env"
+  IO.println s!"decompiling env"
   let denv := DecompileEnv.init cstt.names cstt.store
-  let mut dstt := default
-  for (n, (anon, meta)) in denv.names do
-    IO.println s!"decompiling {n} {anon}:{meta}"
-    match (ensureBlock n anon meta).run denv dstt with
-    | .ok _ s => do
-      IO.println s!"✓ {n} @ {anon}:{meta}"
-      dstt := s
+  let dstt <- match decompileEnv.run denv default with
+    | .ok _ s => pure s
+      --IO.println s!"✓ {n} @ {anon}:{meta}"
     | .error e _ => do
-      IO.println s!"{repr <| cstt.env.constants.find! n}"
       throw (IO.userError e.pretty)
+  IO.println s!"decompiled env"
   let mut res := true
-  for (n, c) in delta do
+  for (n, (anon, meta)) in denv.names do
+    let c <- match env.constants.find? n with
+    | .some c => pure c
+    | .none => throw (IO.userError "name {n} not in env")
     match dstt.constants.find? n with
-    | .some c2 => res := (res && c == c2)
+    | .some c2 =>
+      if c == c2 
+      then
+        IO.println s!"✓ {n} @ {anon}:{meta}"
+      else
+        IO.println s!"× {n} @ {anon}:{meta}"
+        IO.println s!"× {repr c}"
+        IO.println s!"× {repr c2}"
+        res := false
+        break
     | .none => do
       let e' := (DecompileError.unknownName default n).pretty
       throw (IO.userError e')
   return test "env compile roundtrip" (res == true)
 
 def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
-  test1,
-  testRoundtripGetEnv
+   --testMutual,
+   --testInductives,
+   --testInductivesRoundtrip,
+   testRoundtripGetEnv
 ]
diff --git a/Tests/Ix/Fixtures.lean b/Tests/Ix/Fixtures.lean
index 721a93ef..1189aba6 100644
--- a/Tests/Ix/Fixtures.lean
+++ b/Tests/Ix/Fixtures.lean
@@ -1,6 +1,7 @@
 import Tests.Ix.Fixtures.Export
 
-set_option linter.all false -- prevent error messages from runFrontend
+namespace Test.Ix.Fixtures
+
 namespace WellFounded
 
 mutual
@@ -165,7 +166,6 @@ end Inductives
 
 namespace Import
 
-
 def Foo := MyNat -- triggering the compilation of `MyNat`
 def Bar := Nat   -- triggering the compilation of `Nat`
 
@@ -174,3 +174,6 @@ inductive MyOtherNat
   | mais : MyOtherNat → MyOtherNat
 
 end Import
+
+end Test.Ix.Fixtures
+
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index 4575997d..60fa726b 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -66,15 +66,15 @@ def genConst : Gen Ix.Const := getSize >>= go
       let mode <- genDefMode
       let value <- genExpr
       let hints <- genReducibilityHints
-      let isPartial <- genBool
+      let safety <- oneOf #[pure .safe, pure .partial, pure .unsafe]
       let all <- genNames
-      return ⟨n, lvls, type, mode, value, hints, isPartial, all⟩
+      return ⟨n, lvls, type, mode, value, hints, safety, all⟩
     genCtor : Gen Ix.Constructor := 
-      .mk <$> genName <*> genNames <*> genExpr <*> genNat' <*> genNat' <*> genNat'
+      .mk <$> genName <*> genNames <*> genExpr <*> genNat' <*> genNat' <*> genNat' <*> genBool
     genRecr : Gen Ix.Recursor := 
       .mk <$> genName <*> genNames <*> genExpr <*> genNat' <*> genNat' <*> genNat' <*> genNat'
         <*> resizeListOf (.mk <$> genName <*> genNat' <*> genExpr)
-        <*> genBool
+        <*> genBool <*> genBool
     genInd : Gen Ix.Inductive := do
       let n <- genName
       let lvls <- genNames
@@ -85,25 +85,25 @@ def genConst : Gen Ix.Const := getSize >>= go
       let ctors <- resizeListOf genCtor
       let recrs <- resizeListOf genRecr
       let nested <- genNat'
-      let (isRec, isRefl) <- Prod.mk <$> genBool <*> genBool
-      return ⟨n, lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl⟩
+      let (isRec, isRefl, isUnsafe) <- (·,·,·) <$> genBool <*> genBool <*> genBool
+      return ⟨n, lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl, isUnsafe⟩
     genMutDef : Gen Ix.MutualBlock := do
       let nns <- resizeListOf (genListSize genName 1 5)
       let ds <- nns.mapM fun ns => do
         let x <- genDef
         ns.mapM (fun _ => pure x)
-      return .mk ds nns
+      return .mk ds
     genMutInd : Gen Ix.InductiveBlock := do
       let nns <- resizeListOf (genListSize genName 1 5)
       let ds <- nns.mapM fun ns => do
         let x <- genInd
         ns.mapM (fun _ => pure x)
-      return .mk ds nns
+      return .mk ds
     go : Nat -> Gen Ix.Const
-    | 0 => return .«axiom» (.mk .anonymous [] (Ix.Expr.sort (Ix.Level.zero)))
+    | 0 => return .«axiom» (.mk .anonymous [] (Ix.Expr.sort (Ix.Level.zero)) false)
     | Nat.succ _ =>
       frequency [
-        (100, .«axiom» <$> (.mk <$> genName <*> genNames <*> genExpr)),
+        (100, .«axiom» <$> (.mk <$> genName <*> genNames <*> genExpr <*> genBool)),
         (100, .«definition» <$> genDef),
         (100, .quotient <$> (.mk <$> genName <*> genNames <*> genExpr <*> genQuotKind)),
         (100, .inductiveProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat')),
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 4dbee645..ec508370 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -90,29 +90,29 @@ def genMetadata : Gen Metadata := do
 
 -- Const
 
-def genAxiom : Gen Axiom := .mk <$> genNat' <*> genExpr
+def genAxiom : Gen Axiom := .mk <$> genNat' <*> genExpr <*> genBool
 
 def genDefinition : Gen Definition := do
   let lvls <- genNat'
   let type <- genExpr
   let mode <- genDefMode
   let value <- genExpr
-  let isPartial <- genBool
-  return .mk lvls type mode value isPartial
+  let safety <- oneOf #[pure .safe, pure .unsafe, pure .partial]
+  return .mk lvls type mode value safety
 
 def genConstructor : Gen Constructor :=
-  .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat'
+  .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat' <*> genBool
 
 def genRecursorRule : Gen RecursorRule := .mk <$> genNat' <*> genExpr
 
 def genRecursor : Gen Recursor :=
   .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat'
-    <*> genNat' <*> genList' genRecursorRule <*> genBool
+    <*> genNat' <*> genList' genRecursorRule <*> genBool <*> genBool
 
 def genInductive : Gen Inductive :=
   .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat'
     <*> genList' genConstructor <*> genList' genRecursor <*> genNat'
-    <*> genBool <*> genBool
+    <*> genBool <*> genBool <*> genBool
 
 def genConstructorProj : Gen ConstructorProj :=
   .mk <$> genAddress <*> genNat' <*> genNat'
@@ -130,7 +130,7 @@ def genInductiveProj : Gen InductiveProj :=
 def genConst : Gen Ixon.Const := getSize >>= go
   where
     go : Nat -> Gen Ixon.Const
-    | 0 => return .axio ⟨0, .vari 0⟩
+    | 0 => return .axio ⟨0, .vari 0, false⟩
     | Nat.succ _ =>
       frequency [
         (100, .axio <$> genAxiom),

From 8322be75a91d319b268d002c53453c0a37fb56c6 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 23 May 2025 12:13:31 -0400
Subject: [PATCH 22/74] roundtrip compilation decompilation tests now passing

---
 Ix/Common.lean        | 22 ++++++++++++++++++++++
 Ix/DecompileM.lean    |  2 +-
 Tests/Ix/Compile.lean | 17 +++++++----------
 3 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/Ix/Common.lean b/Ix/Common.lean
index d62436f2..dc669544 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -244,4 +244,26 @@ def runFrontend (input : String) (filePath : FilePath) : IO Environment := do
       (← msgs.toList.mapM (·.toString)).map String.trim
   else return s.commandState.env
 
+def Expr.stripMData : Expr -> Expr
+| .mdata _ x => x.stripMData
+| .app f a => .app f.stripMData a.stripMData
+| .lam bn bt b bi => .lam bn bt.stripMData b.stripMData bi
+| .forallE bn bt b bi => .forallE bn bt.stripMData b.stripMData bi
+| .letE ln t v b nd => .letE ln t.stripMData v.stripMData b.stripMData nd
+| .proj tn i s => .proj tn i s.stripMData
+| x => x
+
+def RecursorRule.stripMData : RecursorRule -> RecursorRule
+| ⟨c, nf, rhs⟩ => ⟨c, nf, rhs.stripMData⟩
+
+def ConstantInfo.stripMData : Lean.ConstantInfo -> Lean.ConstantInfo
+| .axiomInfo x => .axiomInfo { x with type := x.type.stripMData }
+| .defnInfo x => .defnInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+| .thmInfo x => .thmInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+| .quotInfo x => .quotInfo { x with type := x.type.stripMData }
+| .opaqueInfo x => .opaqueInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+| .inductInfo x => .inductInfo { x with type := x.type.stripMData }
+| .ctorInfo x => .ctorInfo { x with type := x.type.stripMData }
+| .recInfo x => .recInfo { x with type := x.type.stripMData, rules := x.rules.map (·.stripMData) }
 end Lean
+
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index 010d8318..38cf8c59 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -334,7 +334,7 @@ partial def decompileDefn (x: Ix.Definition)
     | .definition => return .defnInfo <|
       Lean.mkDefinitionValEx x.name x.levelParams type val x.hints x.safety x.all
     | .opaque => return .opaqueInfo <|
-      Lean.mkOpaqueValEx x.name x.levelParams type val true x.all
+      Lean.mkOpaqueValEx x.name x.levelParams type val (x.safety == .unsafe) x.all
     | .theorem => return .thmInfo <|
       Lean.mkTheoremValEx x.name x.levelParams type val x.all
 
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 3ac8f126..ece9acdd 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -169,12 +169,12 @@ def testInductivesRoundtrip : IO TestSeq := do
     | .none => throw (IO.userError "name {n} not in env")
     match dstt.constants.find? n with
     | .some c2 =>
-      if c == c2 then
+      if c.stripMData == c2.stripMData then
         IO.println s!"✓ {n} @ {anon}:{meta}"
       else
         IO.println s!"× {n} @ {anon}:{meta}"
-        IO.println s!"× {repr c}"
-        IO.println s!"× {repr c2}"
+        IO.println s!"× {repr c.stripMData}"
+        IO.println s!"× {repr c2.stripMData}"
         res := false
         break
     | .none => do
@@ -184,11 +184,8 @@ def testInductivesRoundtrip : IO TestSeq := do
 
 def testRoundtripGetEnv : IO TestSeq := do
   let env <- get_env!
-  let delta := env.getDelta
-  let consts := env.getConstMap
-  IO.println s!"env with delta {delta.toList.length}, constMap {consts.toList.length}"
   let mut cstt : CompileState := .init env 0
-  IO.println s!"compiling env"
+  --IO.println s!"compiling env"
   for (_, c) in env.getDelta do
     let (_, stt) <- match (compileConst c).run (.init 200000) cstt with
     | .ok a stt => do
@@ -218,13 +215,13 @@ def testRoundtripGetEnv : IO TestSeq := do
     | .none => throw (IO.userError "name {n} not in env")
     match dstt.constants.find? n with
     | .some c2 =>
-      if c == c2 
+      if c.stripMData == c2.stripMData
       then
         IO.println s!"✓ {n} @ {anon}:{meta}"
       else
         IO.println s!"× {n} @ {anon}:{meta}"
-        IO.println s!"× {repr c}"
-        IO.println s!"× {repr c2}"
+        IO.FS.writeFile "c.out" s!"{repr c.stripMData}"
+        IO.FS.writeFile "c2.out" s!"{repr c2.stripMData}"
         res := false
         break
     | .none => do

From 347268bd58ffafcd1ad1e67d0204d3b69aa40dd5 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 23 May 2025 12:19:10 -0400
Subject: [PATCH 23/74] add count to roundtrip

---
 Tests/Ix/Compile.lean | 58 ++++---------------------------------------
 1 file changed, 5 insertions(+), 53 deletions(-)

diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index ece9acdd..b3691956 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -132,56 +132,6 @@ def testInductives : IO TestSeq := do
   let nss := dss.map fun ds => ds.map (·.name)
   return test "test inductives" (res == nss)
 
-
-def testInductivesRoundtrip : IO TestSeq := do
-  let namesp := `Test.Ix.Inductives
-  let env <- get_env!
-  let delta := env.getDelta.filter fun n _ => namesp.isPrefixOf n
-  --IO.println s!"env with delta {delta.toList.map fun (n, _) => n}"
-  let mut cstt : CompileState := .init env 0
-  for (_, c) in delta do
-    let (_, stt) <- match (compileConst c).run (.init 200000) cstt with
-    | .ok a stt => do
-      stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
-      pure (a, stt)
-    | .error e _ => do
-      IO.println s!"failed {c.name}"
-      throw (IO.userError (<- e.pretty))
-    let (anon, meta) <- match stt.names.find? c.name with
-    | .some (a, m) => pure (a, m)
-    | .none => throw (IO.userError "name {n} not in env")
-    IO.println s!"✓ {c.name} -> {anon}:{meta}"
-    cstt := stt
-  let denv := DecompileEnv.init cstt.names cstt.store
-  let mut dstt := default
-  for (n, (a, m)) in denv.names do
-    let (_, stt) <- match (ensureBlock n a m).run denv dstt with
-    | .ok a stt => pure (a, stt)
-    | .error e _ => do
-      IO.println s!"decompilation failed {n}->{a}:{m}"
-      throw (IO.userError e.pretty)
-    IO.println ""
-    dstt := stt
-  let mut res := true
-  for (n, (anon, meta)) in denv.names do
-    let c <- match env.constants.find? n with
-    | .some c => pure c
-    | .none => throw (IO.userError "name {n} not in env")
-    match dstt.constants.find? n with
-    | .some c2 =>
-      if c.stripMData == c2.stripMData then
-        IO.println s!"✓ {n} @ {anon}:{meta}"
-      else
-        IO.println s!"× {n} @ {anon}:{meta}"
-        IO.println s!"× {repr c.stripMData}"
-        IO.println s!"× {repr c2.stripMData}"
-        res := false
-        break
-    | .none => do
-      let e' := (DecompileError.unknownName default n).pretty
-      throw (IO.userError e')
-  return test "env compile roundtrip" (res == true)
-
 def testRoundtripGetEnv : IO TestSeq := do
   let env <- get_env!
   let mut cstt : CompileState := .init env 0
@@ -227,11 +177,13 @@ def testRoundtripGetEnv : IO TestSeq := do
     | .none => do
       let e' := (DecompileError.unknownName default n).pretty
       throw (IO.userError e')
+  IO.println s!"input delta: {env.getDelta.toList.length}"
+  IO.println s!"input env: {env.constants.toList.length}"
+  IO.println s!"output env: {dstt.constants.toList.length}"
   return test "env compile roundtrip" (res == true)
 
 def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
-   --testMutual,
-   --testInductives,
-   --testInductivesRoundtrip,
+   testMutual,
+   testInductives,
    testRoundtripGetEnv
 ]

From 32f85d3c550294ab06ba09b08db4ac48f12f93dc Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 23 May 2025 12:35:50 -0400
Subject: [PATCH 24/74] fixup merge

---
 Ix/CompileM.lean | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index c9599bd5..8f0d8f17 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -936,8 +936,7 @@ Open references are variables that point to names which aren't present in the
 `Lean.ConstMap`.
 -/
 def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
-  : CompileM Unit := do
-  delta.forM fun _ c => discard $ compileConst c else pure ()
+  : CompileM Unit := delta.forM fun _ c => discard $ compileConst c
 
 def compileEnv (env: Lean.Environment)
   : CompileM Unit := do

From 7ebf0eea41abd9faf52278a92219de3e9576481b Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 23 May 2025 12:36:54 -0400
Subject: [PATCH 25/74] fixup merge

---
 Ix/Cli/StoreCmd.lean | 3 ---
 Ix/Meta.lean         | 2 +-
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/Ix/Cli/StoreCmd.lean b/Ix/Cli/StoreCmd.lean
index bd9d6913..797d8514 100644
--- a/Ix/Cli/StoreCmd.lean
+++ b/Ix/Cli/StoreCmd.lean
@@ -2,10 +2,7 @@ import Cli
 import Ix.Cronos
 import Ix.Common
 import Ix.CompileM
-<<<<<<< HEAD
 import Ix.TransportM
-=======
->>>>>>> 67a1eaccb887ff00d2d4434c86582045667f076d
 import Ix.Store
 import Ix.Address
 import Lean
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index d439e56f..2bfb1a7b 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -39,7 +39,7 @@ macro "get_env!" : term =>
   `(getFileEnv this_file!)
 
 def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO Address := do
-  let ((a, _), _) <- Ix.Compile.compileConstIO env const
+  let ((a, _), _) <- (Ix.Compile.compileConst const).runIO env
   return a
 
 def runCore (f : CoreM α) (env : Environment) : IO α :=

From 2c5d0db8b76ebc5a839caab2c209a26a8250b420 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 23 May 2025 12:38:16 -0400
Subject: [PATCH 26/74] fixup merge test

---
 Tests/Main.lean | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/Tests/Main.lean b/Tests/Main.lean
index 42bad32a..ad760ee5 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -13,11 +13,6 @@ def main (args: List String) : IO UInt32 := do
   then LSpec.lspecEachIO Tests.Ix.Compile.suiteIO id
   else
     LSpec.lspecIO (.ofList [
-      ("arith-expr", Tests.ArithExpr.suite),
-      ("boundary", Tests.Boundary.suite),
-      ("binius-bindings", Tests.Binius.bindingsSuite),
-      ("binius-witness", Tests.Binius.witnessSuite),
-      ("binius-transparent", Tests.Binius.transparentSuite),
       ("aiur", Tests.Aiur.suite),
       ("archon", Tests.Archon.suite),
       ("ffi-consistency", Tests.FFIConsistency.suite),

From 87fc22d1c57fc885229a008ec5d66dfb9c31268f Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Sat, 24 May 2025 04:58:02 -0400
Subject: [PATCH 27/74] remove style guide

---
 STYLE.md | 38 --------------------------------------
 1 file changed, 38 deletions(-)
 delete mode 100644 STYLE.md

diff --git a/STYLE.md b/STYLE.md
deleted file mode 100644
index 513356bb..00000000
--- a/STYLE.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# Ix Style Guide
-
-Keep all lines under 80 columns. This is restrictive, but is the only way to
-ensure readability in every environment.
-
-Indent using two-spaces, never put tabs in a source file.
-
-Structure declarations should not align the type-signatures of their parameters.
-Prefer
-
-```lean
-structure Foo where
-  parameterAcme : A
-  condition1 : B
-```
-
-over
-
-```lean4
-structure Foo where
-  parameterAcme : A
-  condition1    : B
-```
-
-Minimize usage of unicode where ascii equivalents exist. Prefer
-
-```lean4
-def foo (A: Type) (x: A) : Foo -> Bar
-| foo => bar
-```
-
-over
-
-```
-def foo (α: Type) (x: α) : Foo → Bar
-| foo => bar
-```
-

From f4129dc28ca2fa5b7786ad48ffba43f368b1ffda Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 17 Jul 2025 10:34:23 -0400
Subject: [PATCH 28/74] merge

---
 Ix/Cli/ProveCmd.lean  |  1 -
 Tests/Ix/Compile.lean | 13 +++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean
index 8d748ac4..6d7ca722 100644
--- a/Ix/Cli/ProveCmd.lean
+++ b/Ix/Cli/ProveCmd.lean
@@ -23,7 +23,6 @@ def runProveCheck
   let signature <- runMeta (Lean.PrettyPrinter.ppSignature constInfo.name) env
   IO.println "typechecking:"
   IO.println signature.fmt.pretty
-  let ((claim, _, _), _stt) <- 
   let ((claim, _, _), _stt) <-
     (checkClaim constInfo.name constInfo.type constSort constInfo.levelParams commit).runIO env
   IO.println $ s!"claim: {claim}"
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index d84f0398..9ab23afb 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -102,6 +102,19 @@ def testRoundtripGetEnv : IO TestSeq := do
     | .none => throw (IO.userError "name {n} not in env")
     IO.println s!"✓ {c.name} -> {anon}:{meta}"
     cstt := stt
+  for (_, c) in env.getConstMap do
+    let (_, stt) <- match (compileConst c).run (.init 200000) cstt with
+    | .ok a stt => do
+      --stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
+      pure (a, stt)
+    | .error e _ => do
+      IO.println s!"failed {c.name}"
+      throw (IO.userError (<- e.pretty))
+    let (anon, meta) <- match stt.names.find? c.name with
+    | .some (a, m) => pure (a, m)
+    | .none => throw (IO.userError "name {n} not in env")
+    IO.println s!"✓ {c.name} -> {anon}:{meta}"
+    cstt := stt
   IO.println s!"compiled env"
   IO.println s!"decompiling env"
   let denv := DecompileEnv.init cstt.names cstt.store

From 75405a0f877603d5a04a821fe174ca7d1141759f Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Thu, 24 Jul 2025 12:07:07 -0300
Subject: [PATCH 29/74] Aiur2 prove/verify (#183)

* prove and verify for Aiur2
* env var to opt out of parallelism
* bump the Rust toolchain

---------

Co-authored-by: Gabriel Barreto <gabriel.aquino.barreto@gmail.com>
Co-authored-by: Samuel Burnham <45365069+samuelburnham@users.noreply.github.com>
---
 Cargo.lock                       | 541 ++++++++++++++++++++-----------
 Cargo.toml                       |   9 +-
 Ix/Aiur2/Bytecode.lean           |  27 +-
 Ix/Aiur2/Compile.lean            | 212 ++++++------
 Ix/Aiur2/Goldilocks.lean         |  11 +-
 Ix/Aiur2/Match.lean              |   2 +-
 Ix/Aiur2/Meta.lean               |   2 +-
 Ix/Aiur2/Protocol.lean           |  49 +++
 Ix/Aiur2/Simple.lean             |   3 +-
 Tests/Aiur2.lean                 |  20 +-
 c/aiur.c                         | 106 +++++-
 c/rust.h                         |  32 +-
 ix.nix                           |   2 +-
 lakefile.lean                    |   7 +-
 rust-toolchain.toml              |   2 +-
 src/aiur/execute.rs              |   4 +-
 src/aiur/frontend/expr.rs        |  10 +-
 src/aiur/synthesis.rs            |   9 +-
 src/aiur2/bytecode.rs            |  28 +-
 src/aiur2/constraints.rs         | 325 +++++++++++++++++++
 src/aiur2/execute.rs             |  36 +-
 src/aiur2/memory.rs              | 124 +++++++
 src/aiur2/mod.rs                 |   6 +
 src/aiur2/synthesis.rs           | 133 ++++++++
 src/aiur2/trace.rs               | 304 +++++++++++++++++
 src/archon/populate.rs           |   6 +-
 src/archon/precompiles/blake3.rs |  73 +++--
 src/lean/boxed.rs                |  10 +-
 src/lean/ffi/aiur2/mod.rs        |  22 ++
 src/lean/ffi/aiur2/protocol.rs   | 136 ++++++++
 src/lean/ffi/aiur2/toplevel.rs   | 108 ++----
 src/lean/ffi/mod.rs              |  39 ++-
 src/lean/mod.rs                  |   1 +
 src/lean/string.rs               |  27 ++
 34 files changed, 1937 insertions(+), 489 deletions(-)
 create mode 100644 Ix/Aiur2/Protocol.lean
 create mode 100644 src/aiur2/constraints.rs
 create mode 100644 src/aiur2/memory.rs
 create mode 100644 src/aiur2/synthesis.rs
 create mode 100644 src/aiur2/trace.rs
 create mode 100644 src/lean/ffi/aiur2/protocol.rs
 create mode 100644 src/lean/string.rs

diff --git a/Cargo.lock b/Cargo.lock
index 5d504cf1..f68fcb7f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -282,7 +282,7 @@ checksum = "965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
  "synstructure",
 ]
 
@@ -294,7 +294,7 @@ checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -305,9 +305,9 @@ checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
 
 [[package]]
 name = "async-channel"
-version = "2.3.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b47800b0be77592da0afd425cc03468052844aff33b84e33cc696f64e77b6a"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
 dependencies = [
  "concurrent-queue",
  "event-listener-strategy",
@@ -323,7 +323,7 @@ checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -351,14 +351,14 @@ checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
 name = "autocfg"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "backon"
@@ -427,6 +427,26 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597bb81c80a54b6a4381b23faba8d7774b144c94cbd1d6fe3f1329bd776554ab"
 
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
 [[package]]
 name = "binius_circuits"
 version = "0.2.0"
@@ -546,7 +566,7 @@ source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679ee
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -680,9 +700,9 @@ checksum = "102dbef1187b1893e6dfe05a774e79fd52265f49f214f6879c8ff49f52c8188b"
 
 [[package]]
 name = "bumpalo"
-version = "3.18.1"
+version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db76d6187cd04dff33004d8e6c9cc4e05cd330500379d2394209271b4aeee"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
 name = "byte-slice-cast"
@@ -701,13 +721,13 @@ dependencies = [
 
 [[package]]
 name = "bytemuck_derive"
-version = "1.9.3"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ecc273b49b3205b83d648f0690daa588925572cc5063745bfe547fe7ec8e1a1"
+checksum = "441473f2b4b0459a68628c744bc61d23e730fb00128b841d30fa4bb3972257e4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -727,9 +747,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.26"
+version = "1.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956a5e21988b87f372569b66183b78babf23ebc2e744b733e4350a752c4dafac"
+checksum = "deec109607ca693028562ed836a5f1c4b8bd77755c4e132fc5ce11b0b6211ae7"
 dependencies = [
  "shlex",
 ]
@@ -785,9 +805,12 @@ dependencies = [
 
 [[package]]
 name = "cobs"
-version = "0.2.3"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.12",
+]
 
 [[package]]
 name = "concurrent-queue"
@@ -941,9 +964,9 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crunchy"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "crypto-bigint"
@@ -1026,7 +1049,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -1069,7 +1092,7 @@ checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -1102,7 +1125,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustc_version 0.4.1",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -1131,7 +1154,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
  "unicode-xid",
 ]
 
@@ -1143,7 +1166,7 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
  "unicode-xid",
 ]
 
@@ -1182,7 +1205,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -1238,9 +1261,9 @@ dependencies = [
 
 [[package]]
 name = "ed25519-dalek"
-version = "2.1.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
+checksum = "70e796c081cee67dc755e1a36a0a172b897fab85fc3f6bc48307991f64e4eca9"
 dependencies = [
  "curve25519-dalek",
  "ed25519",
@@ -1297,7 +1320,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -1317,7 +1340,7 @@ checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -1343,12 +1366,12 @@ checksum = "a02a5d186d7bf1cb21f1f95e1a9cfa5c1f2dcd803a47aad454423ceec13525c5"
 
 [[package]]
 name = "errno"
-version = "0.3.12"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea14ef9355e3beab063703aa9dab15afd25f0667c341310c1e5274bb1d0da18"
+checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1555,7 +1578,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -1630,7 +1653,7 @@ dependencies = [
  "libc",
  "log",
  "rustversion",
- "windows 0.61.1",
+ "windows 0.61.3",
 ]
 
 [[package]]
@@ -1673,14 +1696,14 @@ dependencies = [
 
 [[package]]
 name = "getset"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3586f256131df87204eb733da72e3d3eb4f343c639f4b7be279ac7c48baeafe"
+checksum = "9cf0fc11e47561d47397154977bc219f4cf809b2974facc3ccb3b89e2436f912"
 dependencies = [
  "proc-macro-error2",
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -1729,9 +1752,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9421a676d1b147b16b82c9225157dc629087ef8ec4d5e2960f9437a90dac0a5"
+checksum = "17da50a276f1e01e0ba6c029e47b7100754904ee8a278f886546e98575380785"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -1783,9 +1806,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hermit-abi"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f154ce46856750ed433c8649605bf7ed2de3bc35fd9d2a9f30cddd873c80cb08"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "hex"
@@ -1809,7 +1832,7 @@ dependencies = [
  "idna",
  "ipnet",
  "once_cell",
- "rand 0.9.1",
+ "rand 0.9.2",
  "ring",
  "thiserror 2.0.12",
  "tinyvec",
@@ -1831,7 +1854,7 @@ dependencies = [
  "moka",
  "once_cell",
  "parking_lot",
- "rand 0.9.1",
+ "rand 0.9.2",
  "resolv-conf",
  "smallvec",
  "thiserror 2.0.12",
@@ -1962,14 +1985,14 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots 1.0.0",
+ "webpki-roots 1.0.2",
 ]
 
 [[package]]
 name = "hyper-util"
-version = "0.1.14"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc2fdfdbff08affe55bb779f33b053aa1fe5dd5b54c257343c17edfa55711bdb"
+checksum = "7f66d5bd4c6f02bf0542fad85d626775bab9258cf795a4256dcaf3161114d1df"
 dependencies = [
  "base64",
  "bytes",
@@ -2158,17 +2181,18 @@ checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.4",
+ "rayon",
 ]
 
 [[package]]
@@ -2210,6 +2234,17 @@ dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "io-uring"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d93587f37623a1a17d94ef2bc9ada592f5465fe7732084ab7beefabe5c77c0c4"
+dependencies = [
+ "bitflags 2.9.1",
+ "cfg-if",
+ "libc",
+]
+
 [[package]]
 name = "ipconfig"
 version = "0.3.2"
@@ -2537,10 +2572,9 @@ dependencies = [
  "iroh",
  "iroh-base",
  "iroh-blobs",
- "p3-field",
- "p3-goldilocks",
+ "multi-stark",
  "proptest",
- "rand 0.9.1",
+ "rand 0.9.2",
  "rayon",
  "rustc-hash",
  "tiny-keccak",
@@ -2600,9 +2634,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "libm"
@@ -2689,15 +2723,9 @@ checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 
 [[package]]
 name = "memchr"
-version = "2.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
-
-[[package]]
-name = "mime"
-version = "0.3.17"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
 
 [[package]]
 name = "minimal-lexical"
@@ -2744,6 +2772,28 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "multi-stark"
+version = "0.1.0"
+source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=f3017f7f1ad5f3e3149b552e188e9f9e09370a97#f3017f7f1ad5f3e3149b552e188e9f9e09370a97"
+dependencies = [
+ "bincode",
+ "p3-air",
+ "p3-challenger",
+ "p3-commit",
+ "p3-dft",
+ "p3-field",
+ "p3-fri",
+ "p3-goldilocks",
+ "p3-keccak",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-merkle-tree",
+ "p3-symmetric",
+ "p3-util",
+ "serde",
+]
+
 [[package]]
 name = "n0-future"
 version = "0.1.3"
@@ -3037,23 +3087,24 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
+checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a"
 dependencies = [
  "num_enum_derive",
+ "rustversion",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
+checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -3114,11 +3165,45 @@ dependencies = [
  "sha2",
 ]
 
+[[package]]
+name = "p3-air"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "p3-field",
+ "p3-matrix",
+]
+
+[[package]]
+name = "p3-challenger"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "p3-field",
+ "p3-maybe-rayon",
+ "p3-symmetric",
+ "p3-util",
+ "tracing",
+]
+
+[[package]]
+name = "p3-commit"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "itertools 0.14.0",
+ "p3-challenger",
+ "p3-dft",
+ "p3-field",
+ "p3-matrix",
+ "p3-util",
+ "serde",
+]
+
 [[package]]
 name = "p3-dft"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b2764a3982d22d62aa933c8de6f9d71d8a474c9110b69e675dea1887bdeffc"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
  "itertools 0.14.0",
  "p3-field",
@@ -3131,15 +3216,33 @@ dependencies = [
 [[package]]
 name = "p3-field"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc13a73509fe09c67b339951ca8d4cc6e61c9bf08c130dbc90dda52452918cc2"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
  "itertools 0.14.0",
  "num-bigint",
  "p3-maybe-rayon",
  "p3-util",
  "paste",
- "rand 0.9.1",
+ "rand 0.9.2",
+ "serde",
+ "tracing",
+]
+
+[[package]]
+name = "p3-fri"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "itertools 0.14.0",
+ "p3-challenger",
+ "p3-commit",
+ "p3-dft",
+ "p3-field",
+ "p3-interpolation",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-util",
+ "rand 0.9.2",
  "serde",
  "tracing",
 ]
@@ -3147,8 +3250,7 @@ dependencies = [
 [[package]]
 name = "p3-goldilocks"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "552849f6309ffde34af0d31aa9a2d0a549cb0ec138d9792bfbf4a17800742362"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
  "num-bigint",
  "p3-dft",
@@ -3158,21 +3260,42 @@ dependencies = [
  "p3-symmetric",
  "p3-util",
  "paste",
- "rand 0.9.1",
+ "rand 0.9.2",
  "serde",
 ]
 
+[[package]]
+name = "p3-interpolation"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "p3-field",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-util",
+]
+
+[[package]]
+name = "p3-keccak"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "p3-field",
+ "p3-symmetric",
+ "p3-util",
+ "tiny-keccak",
+]
+
 [[package]]
 name = "p3-matrix"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e1e9f69c2fe15768b3ceb2915edb88c47398aa22c485d8163deab2a47fe194"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
  "itertools 0.14.0",
  "p3-field",
  "p3-maybe-rayon",
  "p3-util",
- "rand 0.9.1",
+ "rand 0.9.2",
  "serde",
  "tracing",
  "transpose",
@@ -3181,40 +3304,56 @@ dependencies = [
 [[package]]
 name = "p3-maybe-rayon"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33f765046b763d046728b3246b690f81dfa7ccd7523b7a1582c74f616fbce6a0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "rayon",
+]
 
 [[package]]
 name = "p3-mds"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c90541c6056712daf2ee69ec328db8b5605ae8dbafe60226c8eb75eaac0e1f9"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
  "p3-dft",
  "p3-field",
  "p3-symmetric",
  "p3-util",
- "rand 0.9.1",
+ "rand 0.9.2",
+]
+
+[[package]]
+name = "p3-merkle-tree"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "itertools 0.14.0",
+ "p3-commit",
+ "p3-field",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-symmetric",
+ "p3-util",
+ "rand 0.9.2",
+ "serde",
+ "tracing",
 ]
 
 [[package]]
 name = "p3-poseidon2"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88e9f053f120a78ad27e9c1991a0ea547777328ca24025c42364d6ee2667d59a"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
  "p3-field",
  "p3-mds",
  "p3-symmetric",
  "p3-util",
- "rand 0.9.1",
+ "rand 0.9.2",
 ]
 
 [[package]]
 name = "p3-symmetric"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72d5db8f05a26d706dfd8aaf7aa4272ca4f3e7a075db897ec7108f24fad78759"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
  "itertools 0.14.0",
  "p3-field",
@@ -3224,8 +3363,7 @@ dependencies = [
 [[package]]
 name = "p3-util"
 version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dfee67245d9ce78a15176728da2280032f0a84b5819a39a953e7ec03cfd9bd7"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
  "serde",
 ]
@@ -3281,7 +3419,7 @@ dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -3346,9 +3484,9 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.8.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "198db74531d58c70a361c42201efde7e2591e976d518caf7662a47dc5720e7b6"
+checksum = "1db05f56d34358a8b1066f67cbb203ee3e7ed2ba674a6263a1d5ec6db2204323"
 dependencies = [
  "memchr",
  "thiserror 2.0.12",
@@ -3357,9 +3495,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.8.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d725d9cfd79e87dccc9341a2ef39d1b6f6353d68c4b33c177febbe1a402c97c5"
+checksum = "bb056d9e8ea77922845ec74a1c4e8fb17e7c218cc4fc11a15c5d25e189aa40bc"
 dependencies = [
  "pest",
  "pest_generator",
@@ -3367,24 +3505,23 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.8.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db7d01726be8ab66ab32f9df467ae8b1148906685bbe75c82d1e65d7f5b3f841"
+checksum = "87e404e638f781eb3202dc82db6760c8ae8a1eeef7fb3fa8264b2ef280504966"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.8.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f9f832470494906d1fca5329f8ab5791cc60beb230c74815dff541cbd2b5ca0"
+checksum = "edd1101f170f5903fde0914f899bb503d9ff5271d7ba76bbb70bea63690cc0d5"
 dependencies = [
- "once_cell",
  "pest",
  "sha2",
 ]
@@ -3406,7 +3543,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -3484,7 +3621,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -3565,9 +3702,9 @@ dependencies = [
 
 [[package]]
 name = "postcard"
-version = "1.1.1"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "170a2601f67cc9dba8edd8c4870b15f71a6a2dc196daec8c83f72b59dff628a8"
+checksum = "6c1de96e20f51df24ca73cafcc4690e044854d803259db27a00a461cb3b9d17a"
 dependencies = [
  "cobs",
  "embedded-io 0.4.0",
@@ -3578,13 +3715,13 @@ dependencies = [
 
 [[package]]
 name = "postcard-derive"
-version = "0.1.2"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0239fa9c1d225d4b7eb69925c25c5e082307a141e470573fbbe3a817ce6a7a37"
+checksum = "68f049d94cb6dda6938cc8a531d2898e7c08d71c6de63d8e67123cca6cdde2cc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -3719,7 +3856,7 @@ dependencies = [
  "proc-macro-error-attr2",
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -3757,7 +3894,7 @@ checksum = "440f724eba9f6996b75d63681b0a92b06947f1457076d503a4d2e2c8f56442b8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -3771,7 +3908,7 @@ dependencies = [
  "bitflags 2.9.1",
  "lazy_static",
  "num-traits",
- "rand 0.9.1",
+ "rand 0.9.2",
  "rand_chacha 0.9.0",
  "rand_xorshift",
  "regex-syntax 0.8.5",
@@ -3849,7 +3986,7 @@ dependencies = [
  "bytes",
  "getrandom 0.3.3",
  "lru-slab",
- "rand 0.9.1",
+ "rand 0.9.2",
  "ring",
  "rustc-hash",
  "rustls",
@@ -3863,9 +4000,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.12"
+version = "0.5.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee4e529991f949c5e25755532370b8af5d114acae52326361d68d47af64aa842"
+checksum = "fcebb1209ee276352ef14ff8732e24cc2b02bbac986cd74a4c81bcb2f9881970"
 dependencies = [
  "cfg_aliases",
  "libc",
@@ -3896,9 +4033,9 @@ dependencies = [
 
 [[package]]
 name = "r-efi"
-version = "5.2.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "radium"
@@ -3919,9 +4056,9 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
@@ -4030,9 +4167,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.12"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928fca9cf2aa042393a8325b9ead81d2f0df4cb12e1e24cef072922ccd99c5af"
+checksum = "7e8af0dde094006011e6a740d4879319439489813bd0bcdc7d821beaeeff48ec"
 dependencies = [
  "bitflags 2.9.1",
 ]
@@ -4054,7 +4191,7 @@ checksum = "1165225c21bff1f3bbce98f5a1f889949bc902d3575308cc7b0de30b4f6d27c7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -4066,7 +4203,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "rustix",
- "windows 0.61.1",
+ "windows 0.61.3",
 ]
 
 [[package]]
@@ -4121,9 +4258,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "reqwest"
-version = "0.12.19"
+version = "0.12.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2f8e5513d63f2e5b386eb5106dc67eaf3f84e95258e210489136b8b92ad6119"
+checksum = "cbc931937e6ca3a06e3b6c0aa7841849b160a90351d6ab467a8b9b9959767531"
 dependencies = [
  "base64",
  "bytes",
@@ -4135,11 +4272,8 @@ dependencies = [
  "hyper",
  "hyper-rustls",
  "hyper-util",
- "ipnet",
  "js-sys",
  "log",
- "mime",
- "once_cell",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
@@ -4160,7 +4294,7 @@ dependencies = [
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots 1.0.0",
+ "webpki-roots 1.0.2",
 ]
 
 [[package]]
@@ -4279,7 +4413,7 @@ dependencies = [
  "primitive-types",
  "proptest",
  "rand 0.8.5",
- "rand 0.9.1",
+ "rand 0.9.2",
  "rlp",
  "ruint-macro",
  "serde",
@@ -4349,28 +4483,28 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
  "bitflags 2.9.1",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.23.27"
+version = "0.23.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "730944ca083c1c233a75c09f199e973ca499344a2b7ba9e755c457e86fb4a321"
+checksum = "2491382039b29b9b11ff08b76ff6c97cf287671dbb74f0be44bda389fffe9bd1"
 dependencies = [
  "log",
  "once_cell",
  "ring",
  "rustls-pki-types",
- "rustls-webpki 0.103.3",
+ "rustls-webpki 0.103.4",
  "subtle",
  "zeroize",
 ]
@@ -4398,9 +4532,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.3"
+version = "0.103.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4a72fe2bcf7a6ac6fd7d0b9e5cb68aeb7d4c0a0271730218b3e92d43b4eb435"
+checksum = "0a17884ae0c1b773f1ccd2bd4a8c72f16da897310a98b0e84bf349ad5ead92fc"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -4558,14 +4692,14 @@ checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
  "itoa",
  "memchr",
@@ -4692,12 +4826,9 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.9"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
-dependencies = [
- "autocfg",
-]
+checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
 
 [[package]]
 name = "smallvec"
@@ -4827,7 +4958,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "struct_iterable_internal",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -4855,7 +4986,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -4879,7 +5010,7 @@ dependencies = [
  "precis-core",
  "precis-profiles",
  "quoted-string-parser",
- "rand 0.9.1",
+ "rand 0.9.2",
 ]
 
 [[package]]
@@ -4897,7 +5028,7 @@ dependencies = [
  "hex",
  "parking_lot",
  "pnet_packet",
- "rand 0.9.1",
+ "rand 0.9.2",
  "socket2",
  "thiserror 1.0.69",
  "tokio",
@@ -4917,9 +5048,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.102"
+version = "2.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6397daf94fa90f058bd0fd88429dd9e5738999cca8d701813c80723add80462"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4954,7 +5085,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -5029,7 +5160,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -5040,17 +5171,16 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
 name = "thread_local"
-version = "1.1.8"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
  "cfg-if",
- "once_cell",
 ]
 
 [[package]]
@@ -5121,16 +5251,18 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.45.1"
+version = "1.46.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75ef51a33ef1da925cea3e4eb122833cb377c61439ca401b770f54902b806779"
+checksum = "0cc3a2344dafbe23a245241fe8b09735b521110d30fcefbbd5feb1797ca35d17"
 dependencies = [
  "backtrace",
  "bytes",
+ "io-uring",
  "libc",
  "mio",
  "pin-project-lite",
  "signal-hook-registry",
+ "slab",
  "socket2",
  "tokio-macros",
  "windows-sys 0.52.0",
@@ -5144,7 +5276,7 @@ checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -5291,13 +5423,13 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.29"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1ffbcf9c6f6b99d386e7444eb608ba646ae452a36b39737deb9663b610f662"
+checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -5367,7 +5499,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568"
 dependencies = [
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -5491,6 +5623,12 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
 [[package]]
 name = "ureq"
 version = "2.12.1"
@@ -5553,6 +5691,12 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
+
 [[package]]
 name = "wait-timeout"
 version = "0.2.1"
@@ -5618,7 +5762,7 @@ dependencies = [
  "log",
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
  "wasm-bindgen-shared",
 ]
 
@@ -5653,7 +5797,7 @@ checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -5706,14 +5850,14 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "webpki-roots 1.0.0",
+ "webpki-roots 1.0.2",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.0"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2853738d1cc4f2da3a225c18ec6c3721abb31961096e9dbf5ab35fa88b19cfdb"
+checksum = "7e8983c3ab33d6fb807cfcdad2491c4ea8cbc8ed839181c7dfd9c67c83e261b2"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -5762,14 +5906,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f919aee0a93304be7f62e8e5027811bbba96bcb1de84d6618be56e43f8a32a1"
 dependencies = [
  "windows-core 0.59.0",
- "windows-targets 0.53.0",
+ "windows-targets 0.53.2",
 ]
 
 [[package]]
 name = "windows"
-version = "0.61.1"
+version = "0.61.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
 dependencies = [
  "windows-collections",
  "windows-core 0.61.2",
@@ -5797,7 +5941,7 @@ dependencies = [
  "windows-interface",
  "windows-result",
  "windows-strings 0.3.1",
- "windows-targets 0.53.0",
+ "windows-targets 0.53.2",
 ]
 
 [[package]]
@@ -5832,7 +5976,7 @@ checksum = "83577b051e2f49a058c308f17f273b570a6a758386fc291b5f6a934dd84e48c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -5843,7 +5987,7 @@ checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -5854,14 +5998,14 @@ checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
 name = "windows-link"
-version = "0.1.1"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
 
 [[package]]
 name = "windows-numerics"
@@ -5927,6 +6071,15 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.2",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.48.5"
@@ -5960,9 +6113,9 @@ dependencies = [
 
 [[package]]
 name = "windows-targets"
-version = "0.53.0"
+version = "0.53.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1e4c7e8ceaaf9cb7d7507c974735728ab453b67ef8f18febdd7c11fe59dca8b"
+checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
 dependencies = [
  "windows_aarch64_gnullvm 0.53.0",
  "windows_aarch64_msvc 0.53.0",
@@ -6123,9 +6276,9 @@ checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
 
 [[package]]
 name = "winnow"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd"
+checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
 dependencies = [
  "memchr",
 ]
@@ -6198,9 +6351,9 @@ dependencies = [
 
 [[package]]
 name = "xml-rs"
-version = "0.8.26"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a62ce76d9b56901b19a74f19431b0d8b3bc7ca4ad685a746dfd78ca8f4fc6bda"
+checksum = "6fd8403733700263c6eb89f192880191f1b83e332f7a20371ddcf421c4a337c7"
 
 [[package]]
 name = "xmltree"
@@ -6240,7 +6393,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
  "synstructure",
 ]
 
@@ -6252,22 +6405,22 @@ checksum = "2164e798d9e3d84ee2c91139ace54638059a3b23e361f5c11781c2c6459bde0f"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.25"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb"
+checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.25"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef"
+checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -6287,7 +6440,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
  "synstructure",
 ]
 
@@ -6308,7 +6461,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
 
 [[package]]
@@ -6341,5 +6494,5 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.102",
+ "syn 2.0.104",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index a51be32d..b04f4e39 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,12 +21,11 @@ binius_utils = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "23
 bumpalo = "3"
 groestl_crypto = { package = "groestl", version = "0.10.1" }
 proptest = "1"
-p3-goldilocks = "0.3.0"
-p3-field = "0.3.0"
-rayon = "1"
+multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "f3017f7f1ad5f3e3149b552e188e9f9e09370a97" }
+rayon = "1.7.0"
 rand = "0.9.1"
 rustc-hash = "2"
-indexmap = "2"
+indexmap = { version = "2", features = ["rayon"] }
 bytes = "1.10.1"
 tiny-keccak = { version = "2.0.2", features = ["keccak"] }
 
@@ -37,4 +36,4 @@ iroh-base = "0.34.0"
 iroh-blobs = { version = "0.34.0", features = ["rpc"] }
 
 [features]
-default = []
+parallel = ["multi-stark/parallel"]
diff --git a/Ix/Aiur2/Bytecode.lean b/Ix/Aiur2/Bytecode.lean
index 0fd97c30..6ec1011c 100644
--- a/Ix/Aiur2/Bytecode.lean
+++ b/Ix/Aiur2/Bytecode.lean
@@ -13,9 +13,9 @@ inductive Op
   | add : ValIdx → ValIdx → Op
   | sub : ValIdx → ValIdx → Op
   | mul : ValIdx → ValIdx → Op
-  | call : FunIdx → Array ValIdx → Op
+  | call : FunIdx → Array ValIdx → (outputSize : Nat) → Op
   | store : Array ValIdx → Op
-  | load : (width : Nat) → ValIdx → Op
+  | load : (size : Nat) → ValIdx → Op
   deriving Repr
 
 mutual
@@ -33,37 +33,30 @@ mutual
 end
 
 /-- The circuit layout of a function -/
-structure CircuitLayout where
+structure FunctionLayout where
+  inputSize : Nat
+  outputSize : Nat
   /-- Bit values that identify which path the computation took.
     Exactly one selector must be set. -/
   selectors : Nat
   /-- Represent registers that hold temporary values and can be shared by
     different circuit paths, since they never overlap. -/
   auxiliaries : Nat
-  /-- Constraint slots that can be shared in different paths of the circuit. -/
-  sharedConstraints : Nat
+  /-- Lookups can be shared across calls, stores, loads and returns from
+    different paths. -/
+  lookups : Nat
   deriving Inhabited, Repr
 
 structure Function where
-  inputSize : Nat
-  outputSize : Nat
   body : Block
-  circuitLayout: CircuitLayout
+  layout: FunctionLayout
   deriving Inhabited, Repr
 
 structure Toplevel where
   functions : Array Function
-  memoryWidths : Array Nat
+  memorySizes : Array Nat
   deriving Repr
 
-@[extern "c_rs_toplevel_execute_test"]
-private opaque Toplevel.executeTest' :
-  @& Toplevel → @& FunIdx → @& Array G → USize → Array G
-
-def Toplevel.executeTest (toplevel : Toplevel) (funIdx : FunIdx) (args : Array G) : Array G :=
-  let function := toplevel.functions[funIdx]!
-  toplevel.executeTest' funIdx args function.outputSize.toUSize
-
 end Bytecode
 
 end Aiur
diff --git a/Ix/Aiur2/Compile.lean b/Ix/Aiur2/Compile.lean
index 8706cff1..3fe442e1 100644
--- a/Ix/Aiur2/Compile.lean
+++ b/Ix/Aiur2/Compile.lean
@@ -1,4 +1,5 @@
 import Std.Data.HashMap
+import Lean.Data.RBTree
 import Ix.Aiur2.Term
 import Ix.Aiur2.Bytecode
 
@@ -8,57 +9,93 @@ namespace Bytecode
 
 structure SharedData where
   auxiliaries : Nat
-  constraints : Nat
+  lookups : Nat
 
 def SharedData.maximals (a b : SharedData) : SharedData := {
   auxiliaries := a.auxiliaries.max b.auxiliaries
-  constraints := a.constraints.max b.constraints
+  lookups := a.lookups.max b.lookups
 }
 
+abbrev MemSizes := Lean.RBTree Nat compare
+
 structure LayoutMState where
-  circuitLayout : CircuitLayout
-  memWidths : Array Nat
-  deriving Inhabited
+  functionLayout : FunctionLayout
+  memSizes : MemSizes
+  degrees : Array Nat
+
+/-- A new `LayoutMState` starts with one auxiliar for the multiplicity. -/
+@[inline] def LayoutMState.new (inputSize outputSize : Nat) : LayoutMState :=
+  ⟨{ inputSize, outputSize, selectors := 0, auxiliaries := 1, lookups := 0 }, .empty, Array.mkArray inputSize 1⟩
 
 abbrev LayoutM := StateM LayoutMState
 
 @[inline] def bumpSelectors : LayoutM Unit :=
   modify fun stt => { stt with
-    circuitLayout := { stt.circuitLayout with selectors := stt.circuitLayout.selectors + 1 } }
+    functionLayout := { stt.functionLayout with selectors := stt.functionLayout.selectors + 1 } }
 
-@[inline] def bumpSharedConstraints (n : Nat) : LayoutM Unit :=
+@[inline] def bumpLookups : LayoutM Unit :=
   modify fun stt => { stt with
-    circuitLayout := { stt.circuitLayout with sharedConstraints := stt.circuitLayout.sharedConstraints + n } }
+    functionLayout := { stt.functionLayout with lookups := stt.functionLayout.lookups + 1 } }
 
 @[inline] def bumpAuxiliaries (n : Nat) : LayoutM Unit :=
   modify fun stt => { stt with
-    circuitLayout := { stt.circuitLayout with auxiliaries := stt.circuitLayout.auxiliaries + n } }
-
-@[inline] def addMemWidth (memWidth : Nat) : LayoutM Unit :=
-  modify fun stt =>
-    let memWidths := if stt.memWidths.contains memWidth
-      then stt.memWidths
-      else stt.memWidths.push memWidth
-    { stt with memWidths }
-
-def getSharedData : LayoutM SharedData := do
-  let stt ← get
-  pure {
-    auxiliaries := stt.circuitLayout.auxiliaries
-    constraints := stt.circuitLayout.sharedConstraints
-  }
+    functionLayout := { stt.functionLayout with auxiliaries := stt.functionLayout.auxiliaries + n } }
+
+@[inline] def addMemSize (size : Nat) : LayoutM Unit :=
+  modify fun stt => { stt with memSizes := stt.memSizes.insert size }
+
+@[inline] def pushDegree (degree : Nat) : LayoutM Unit :=
+  modify fun stt => { stt with degrees := stt.degrees.push degree }
+
+@[inline] def pushDegrees (degrees : Array Nat) : LayoutM Unit :=
+  modify fun stt => { stt with degrees := stt.degrees ++ degrees }
+
+@[inline] def getDegree (v : ValIdx) : LayoutM Nat :=
+  get >>= fun stt => pure stt.degrees[v]!
+
+def getSharedData : LayoutM SharedData :=
+  get >>= fun stt =>
+    pure {
+      auxiliaries := stt.functionLayout.auxiliaries
+      lookups := stt.functionLayout.lookups
+    }
 
 def setSharedData (sharedData : SharedData) : LayoutM Unit :=
-  modify fun stt => { stt with circuitLayout := { stt.circuitLayout with
+  modify fun stt => { stt with functionLayout := { stt.functionLayout with
     auxiliaries := sharedData.auxiliaries
-    sharedConstraints := sharedData.constraints } }
+    lookups := sharedData.lookups } }
 
 def opLayout : Bytecode.Op → LayoutM Unit
-  | .store values => addMemWidth values.size
-  | .load width _ => addMemWidth width
-  | _ => pure () -- TODO
-
-partial def blockLayout (block : Bytecode.Block) : LayoutM Unit := do -- TODO
+  | .const _ => pushDegree 0
+  | .add a b | .sub a b => do
+    let aDegree ← getDegree a
+    let bDegree ← getDegree b
+    pushDegree $ aDegree.max bDegree
+  | .mul a b => do
+    let aDegree ← getDegree a
+    let bDegree ← getDegree b
+    let degree := aDegree + bDegree
+    if degree < 2 then
+      pushDegree degree
+    else
+      pushDegree 1
+      bumpAuxiliaries 1
+  | .call _ _ outputSize => do
+    pushDegrees $ .mkArray outputSize 1
+    bumpAuxiliaries outputSize
+    bumpLookups
+  | .store values => do
+    pushDegree 1
+    bumpAuxiliaries 1
+    bumpLookups
+    addMemSize values.size
+  | .load size _ => do
+    pushDegrees $ .mkArray size 1
+    bumpAuxiliaries size
+    bumpLookups
+    addMemSize size
+
+partial def blockLayout (block : Bytecode.Block) : LayoutM Unit := do
   block.ops.forM opLayout
   match block.ctrl with
   | .match _ branches defaultBranch =>
@@ -66,23 +103,20 @@ partial def blockLayout (block : Bytecode.Block) : LayoutM Unit := do -- TODO
     let mut maximalSharedData := initSharedData
     for (_, block) in branches do
       setSharedData initSharedData
-      -- This auxiliary is for proving inequality
-      bumpAuxiliaries 1
       blockLayout block
       let blockSharedData ← getSharedData
       maximalSharedData := maximalSharedData.maximals blockSharedData
     if let some defaultBlock := defaultBranch then
       setSharedData initSharedData
+      -- An auxiliary per case for proving inequality
+      bumpAuxiliaries branches.size
       blockLayout defaultBlock
       let defaultBlockSharedData ← getSharedData
       maximalSharedData := maximalSharedData.maximals defaultBlockSharedData
     setSharedData maximalSharedData
-  | .return _ out =>
-    -- One selector per return
+  | .return .. =>
     bumpSelectors
-    -- Each output must equal its respective return variable,
-    -- thus one constraint per return variable
-    bumpSharedConstraints out.size
+    bumpLookups
 
 end Bytecode
 
@@ -124,28 +158,24 @@ def TypedDecls.layoutMap (decls : TypedDecls) : LayoutMap :=
       let layoutMap := layoutMap.insert dataType.name (.dataType { size := dataTypeSize })
       let pass := fun (acc, index) constructor =>
         let offsets := constructor.argTypes.foldl (init := #[0])
-          (fun offsets typ => offsets.push (offsets[offsets.size - 1]! + typ.size decls))
+          fun offsets typ => offsets.push (offsets[offsets.size - 1]! + typ.size decls)
         let decl := .constructor { size := dataTypeSize, offsets, index }
         let name := dataType.name.pushNamespace constructor.nameHead
         (acc.insert name decl, index + 1)
       let (layoutMap, _) := dataType.constructors.foldl (init := (layoutMap, 0)) pass
       (layoutMap, funcIdx, gadgetIdx)
     | .function function =>
-      let inputSize := function.inputs.foldl (init := 0) (fun acc (_, typ) => acc + typ.size decls)
+      let inputSize := function.inputs.foldl (init := 0) fun acc (_, typ) => acc + typ.size decls
       let outputSize := function.output.size decls
       let offsets := function.inputs.foldl (init := #[0])
-        (fun offsets (_, typ) => offsets.push (offsets[offsets.size - 1]! + typ.size decls))
-      let layoutMap := layoutMap.insert function.name (.function { index := funcIdx, inputSize, outputSize, offsets })
+        fun offsets (_, typ) => offsets.push (offsets[offsets.size - 1]! + typ.size decls)
+      let layoutMap := layoutMap.insert function.name $
+        .function { index := funcIdx, inputSize, outputSize, offsets }
       (layoutMap, funcIdx + 1, gadgetIdx)
     | .constructor .. => (layoutMap, funcIdx, gadgetIdx)
   let (layoutMap, _) := decls.foldl pass ({}, 0, 0)
   layoutMap
 
-structure CompiledFunction where
-  inputSize : Nat
-  outputSize : Nat
-  body : Bytecode.Block
-
 def typSize (layoutMap : LayoutMap) : Typ → Nat
 | Typ.field .. => 1
 | Typ.pointer .. => 1
@@ -156,19 +186,19 @@ def typSize (layoutMap : LayoutMap) : Typ → Nat
   | _ => unreachable!
 
 structure CompilerState where
-  index : Bytecode.ValIdx
+  valIdx : Bytecode.ValIdx
   ops : Array Bytecode.Op
-  returnIdent : Bytecode.SelIdx
+  selIdx : Bytecode.SelIdx
   deriving Inhabited
 
 def pushOp (op : Bytecode.Op) (size : Nat := 1) : StateM CompilerState (Array Bytecode.ValIdx) :=
   modifyGet (fun s =>
-    let index := s.index
+    let valIdx := s.valIdx
     let ops := s.ops
-    (Array.range' index size, { s with index := index + size, ops := ops.push op}))
+    (Array.range' valIdx size, { s with valIdx := valIdx + size, ops := ops.push op}))
 
 def extractOps : StateM CompilerState (Array Bytecode.Op) :=
-  modifyGet (fun s => (s.ops, {s with ops := #[]}))
+  modifyGet fun s => (s.ops, {s with ops := #[]})
 
 partial def toIndex
  (layoutMap : LayoutMap)
@@ -182,10 +212,10 @@ partial def toIndex
     pure (bindings[name]!)
   | .ref name => match layoutMap[name]! with
     | .function layout => do
-      pushOp (.const (.ofNat' gSize layout.index))
+      pushOp (.const (.ofNat layout.index))
     | .constructor layout => do
       let size := layout.size
-      let paddingOp := .const (.ofNat' gSize layout.index)
+      let paddingOp := .const (.ofNat layout.index)
       let index ← pushOp paddingOp
       if index.size < size then
         let padding := (← pushOp paddingOp)[0]!
@@ -203,12 +233,6 @@ partial def toIndex
     let val ← toIndex layoutMap bindings val
     toIndex layoutMap (bindings.insert var val) bod
   | .let .. => panic! "should not happen after simplifying"
-  -- | .xor a b => do
-  --   let a ← toIndex layoutMap bindings a
-  --   assert! (a.size == 1)
-  --   let b ← toIndex layoutMap bindings b
-  --   assert! (b.size == 1)
-  --   pushOp (.xor (a.get' 0) (b.get' 0))
   | .add a b => do
     let a ← toIndex layoutMap bindings a
     assert! (a.size == 1)
@@ -227,25 +251,19 @@ partial def toIndex
     let b ← toIndex layoutMap bindings b
     assert! (b.size == 1)
     pushOp (.mul (a[0]!) (b[0]!))
-  -- | .and a b => do
-  --   let a ← toIndex layoutMap bindings a
-  --   assert! (a.size == 1)
-  --   let b ← toIndex layoutMap bindings b
-  --   assert! (b.size == 1)
-  --   pushOp (.and (a.get' 0) (b.get' 0))
   | .app name@(⟨.str .anonymous unqualifiedName⟩) args =>
     match bindings.get? (.str unqualifiedName) with
     | some _ => panic! "dynamic calls not yet implemented"
     | none => match layoutMap[name]! with
       | .function layout => do
         let args ← buildArgs args
-        pushOp (Bytecode.Op.call layout.index args) layout.outputSize
+        pushOp (Bytecode.Op.call layout.index args layout.outputSize) layout.outputSize
       | .constructor layout => do
         let size := layout.size
-        let index ← pushOp (.const (.ofNat' gSize layout.index))
+        let index ← pushOp (.const (.ofNat layout.index))
         let index ← buildArgs args index
         if index.size < size then
-          let padding := (← pushOp (.const (.ofNat' gSize 0)))[0]!
+          let padding := (← pushOp (.const (.ofNat 0)))[0]!
           pure $ index ++ Array.mkArray (size - index.size) padding
         else
           pure index
@@ -253,13 +271,13 @@ partial def toIndex
   | .app name args => match layoutMap[name]! with
     | .function layout => do
       let args ← buildArgs args
-      pushOp (Bytecode.Op.call layout.index args) layout.outputSize
+      pushOp (Bytecode.Op.call layout.index args layout.outputSize) layout.outputSize
     | .constructor layout => do
       let size := layout.size
-      let index ← pushOp (.const (.ofNat' gSize layout.index))
+      let index ← pushOp (.const (.ofNat layout.index))
       let index ← buildArgs args index
       if index.size < size then
-        let padding := (← pushOp (.const (.ofNat' gSize 0)))[0]!
+        let padding := (← pushOp (.const (.ofNat 0)))[0]!
         pure $ index ++ Array.mkArray (size - index.size) padding
       else
         pure index
@@ -358,27 +376,27 @@ partial def TypedTerm.compile
     | _ => do
       let idxs ← toIndex layoutMap bindings term
       let ops ← extractOps
-      let minSelIncluded := (← get).returnIdent
+      let minSelIncluded := (← get).selIdx
       let (cases, default) ← cases.foldlM (init := default)
         (addCase layoutMap bindings returnTyp idxs)
-      let maxSelExcluded := (← get).returnIdent
+      let maxSelExcluded := (← get).selIdx
       let ctrl := .match (idxs[0]!) cases default
       pure { ops, ctrl, minSelIncluded, maxSelExcluded }
   | .ret term => do
     let idxs ← toIndex layoutMap bindings term
     let state ← get
-    let state := { state with returnIdent := state.returnIdent + 1 }
+    let state := { state with selIdx := state.selIdx + 1 }
     set state
     let ops := state.ops
-    let id := state.returnIdent
+    let id := state.selIdx
     pure { ops, ctrl := .return (id - 1) idxs, minSelIncluded := id - 1, maxSelExcluded := id }
   | _ => do
     let idxs ← toIndex layoutMap bindings term
     let state ← get
-    let state := { state with returnIdent := state.returnIdent + 1 }
+    let state := { state with selIdx := state.selIdx + 1 }
     set state
     let ops := state.ops
-    let id := state.returnIdent
+    let id := state.selIdx
     pure { ops, ctrl := .return (id - 1) idxs, minSelIncluded := id - 1, maxSelExcluded := id }
 
 partial def addCase
@@ -395,7 +413,7 @@ partial def addCase
   | .field g => do
     let initState ← get
     let term ← term.compile returnTyp layoutMap bindings
-    set { initState with returnIdent := (← get).returnIdent }
+    set { initState with selIdx := (← get).selIdx }
     let cases' := cases.push (g, term)
     pure (cases', default)
   | .ref global pats => do
@@ -420,44 +438,44 @@ partial def addCase
     let bindings := bindArgs bindings pats offsets idxs
     let initState ← get
     let term ← term.compile returnTyp layoutMap bindings
-    set { initState with returnIdent := (← get).returnIdent }
-    let cases' := cases.push (.ofNat' gSize index, term)
+    set { initState with selIdx := (← get).selIdx }
+    let cases' := cases.push (.ofNat index, term)
     pure (cases', default)
   | .wildcard => do
     let initState ← get
     let term ← term.compile returnTyp layoutMap bindings
-    set { initState with returnIdent := (← get).returnIdent }
+    set { initState with selIdx := (← get).selIdx }
     pure (cases, .some term)
   | _ => unreachable!
 
 end
 
 def TypedFunction.compile (layoutMap : LayoutMap) (f : TypedFunction) :
-    CompiledFunction × Bytecode.LayoutMState :=
+    Bytecode.Block × Bytecode.LayoutMState :=
   let (inputSize, outputSize) := match layoutMap[f.name]? with
     | some (.function layout) => (layout.inputSize, layout.outputSize)
     | _ => panic! s!"`{f.name}` should be a function"
-  let (index, bindings) := f.inputs.foldl (init := (0, default))
-    fun (index, bindings) (arg, typ) =>
+  let (valIdx, bindings) := f.inputs.foldl (init := (0, default))
+    fun (valIdx, bindings) (arg, typ) =>
       let len := typSize layoutMap typ
-      let indices := Array.range' index len
-      (index + len, bindings.insert arg indices)
-  let state := { index, returnIdent := 0, ops := #[] }
+      let indices := Array.range' valIdx len
+      (valIdx + len, bindings.insert arg indices)
+  let state := { valIdx, selIdx := 0, ops := #[] }
   let body := f.body.compile f.output layoutMap bindings |>.run' state
-  let (_, layoutMState) := Bytecode.blockLayout body |>.run default
-  ({ inputSize, outputSize, body }, layoutMState)
+  let (_, layoutMState) := Bytecode.blockLayout body |>.run $ .new inputSize outputSize
+  (body, layoutMState)
 
 def TypedDecls.compile (decls : TypedDecls) : Bytecode.Toplevel :=
   let layout := decls.layoutMap
-  let (functions, memWidths) := decls.foldl (init := (#[], #[]))
-    fun acc@(functions, memWidths) (_, decl) => match decl with
+  let initMemSizes : Bytecode.MemSizes := .empty
+  let (functions, memSizes) := decls.foldl (init := (#[], initMemSizes))
+    fun acc@(functions, memSizes) (_, decl) => match decl with
       | .function function =>
-        let (compiledFunction, layoutMState) := function.compile layout
-        let function := { compiledFunction with circuitLayout := layoutMState.circuitLayout }
-        let memWidths := layoutMState.memWidths.foldl (init := memWidths) fun memWidths memWidth =>
-          if memWidths.contains memWidth then memWidths else memWidths.push memWidth
-        (functions.push function, memWidths)
+        let (body, layoutMState) := function.compile layout
+        let function := ⟨body, layoutMState.functionLayout⟩
+        let memSizes := layoutMState.memSizes.fold (·.insert ·) memSizes
+        (functions.push function, memSizes)
       | _ => acc
-  ⟨functions, memWidths.qsort⟩
+  ⟨functions, memSizes.toArray⟩
 
 end Aiur
diff --git a/Ix/Aiur2/Goldilocks.lean b/Ix/Aiur2/Goldilocks.lean
index 65651817..0e3339fa 100644
--- a/Ix/Aiur2/Goldilocks.lean
+++ b/Ix/Aiur2/Goldilocks.lean
@@ -1,6 +1,13 @@
 namespace Aiur
 
-abbrev gSize := 0xFFFFFFFF00000001
-abbrev G := Fin gSize
+abbrev gSize : UInt64 := 0xFFFFFFFF00000001
+abbrev G := { u : UInt64 // u < gSize }
+
+@[inline] def G.ofNat (n : Nat) : G :=
+  let n := n.toUInt64
+  if h : n < gSize then ⟨n, h⟩
+  else ⟨n % gSize, UInt64.mod_lt n (by decide)⟩
+
+instance : OfNat G n := ⟨G.ofNat n⟩
 
 end Aiur
diff --git a/Ix/Aiur2/Match.lean b/Ix/Aiur2/Match.lean
index f3f7d82d..2370374f 100644
--- a/Ix/Aiur2/Match.lean
+++ b/Ix/Aiur2/Match.lean
@@ -89,7 +89,7 @@ def modifyDiagnostics (f : Diagnostics → Diagnostics) : CompilerM Unit :=
   modify fun stt => { stt with diagnostics := f stt.diagnostics }
 
 def patTypeLength (decls : Decls) : SPattern → Nat
-  | .field _ => gSize
+  | .field _ => gSize.toNat
   | .tuple _ => 1
   | .ref global _ => typeLookup global |>.constructors.length
 where
diff --git a/Ix/Aiur2/Meta.lean b/Ix/Aiur2/Meta.lean
index deac0b54..0e457f47 100644
--- a/Ix/Aiur2/Meta.lean
+++ b/Ix/Aiur2/Meta.lean
@@ -33,7 +33,7 @@ def elabEmptyList (listEltTypeName : Name) : TermElabM Expr :=
   mkListLit (mkConst listEltTypeName) []
 
 def elabG (n : TSyntax `num) : TermElabM Expr :=
-  mkAppM ``Fin.ofNat' #[mkConst ``gSize, mkNatLit n.getNat]
+  mkAppM ``G.ofNat #[mkNatLit n.getNat]
 
 partial def elabPattern : ElabStxCat `pattern
   | `(pattern| $v:ident($p:pattern $[, $ps:pattern]*)) => do
diff --git a/Ix/Aiur2/Protocol.lean b/Ix/Aiur2/Protocol.lean
new file mode 100644
index 00000000..a515ebd3
--- /dev/null
+++ b/Ix/Aiur2/Protocol.lean
@@ -0,0 +1,49 @@
+import Ix.Aiur2.Bytecode
+
+namespace Aiur
+
+private opaque PoofNonempty : NonemptyType
+def Proof : Type := PoofNonempty.type
+instance : Nonempty Proof := PoofNonempty.property
+
+namespace Proof
+
+@[extern "c_rs_aiur_proof_to_bytes"]
+opaque toBytes : @& Proof → ByteArray
+
+@[extern "c_rs_aiur_proof_of_bytes"]
+opaque ofBytes : @& ByteArray → Proof
+
+end Proof
+
+structure FriParameters where
+  logBlowup : Nat
+  logFinalPolyLen : Nat
+  numQueries : Nat
+  proofOfWorkBits : Nat
+
+private opaque AiurSystemNonempty : NonemptyType
+def AiurSystem : Type := AiurSystemNonempty.type
+instance : Nonempty AiurSystem := AiurSystemNonempty.property
+
+namespace AiurSystem
+
+@[extern "c_rs_aiur_system_build"]
+opaque build : @&Bytecode.Toplevel → AiurSystem
+
+@[extern "c_rs_aiur_system_prove"]
+opaque prove : @& AiurSystem → @& FriParameters →
+  @& Bytecode.FunIdx → @& Array G → Array G × Proof
+
+@[extern "c_rs_aiur_system_verify"]
+opaque verify : @& AiurSystem → @& FriParameters →
+  @& Array G → @& Proof → Except String Unit
+
+end AiurSystem
+
+abbrev functionChannel : G := .ofNat 0
+
+def buildClaim (funIdx : Bytecode.FunIdx) (input output : Array G) :=
+  #[functionChannel, .ofNat funIdx] ++ input ++ output
+
+end Aiur
diff --git a/Ix/Aiur2/Simple.lean b/Ix/Aiur2/Simple.lean
index c0a5cf5b..e165ae68 100644
--- a/Ix/Aiur2/Simple.lean
+++ b/Ix/Aiur2/Simple.lean
@@ -29,7 +29,7 @@ where
 def Toplevel.checkAndSimplify (toplevel : Toplevel) : Except CheckError TypedDecls := do
   let decls ← toplevel.mkDecls
   wellFormedDecls decls
-  -- TODO: do not duplicate type inference. I.e. do simplification on typed expressions
+  -- The first check happens on the original terms.
   toplevel.functions.forM fun function => do
     let _ ← (checkFunction function) (getFunctionContext function decls)
   let decls := decls.map fun decl => match decl with
@@ -39,6 +39,7 @@ def Toplevel.checkAndSimplify (toplevel : Toplevel) : Except CheckError TypedDec
     | .constructor d c => pure $ typedDecls.insert name (.constructor d c)
     | .dataType d => pure $ typedDecls.insert name (.dataType d)
     | .function f => do
+      -- The second check happens on the simplified terms.
       let f ← (checkFunction f) (getFunctionContext f decls)
       pure $ typedDecls.insert name (.function f)
 
diff --git a/Tests/Aiur2.lean b/Tests/Aiur2.lean
index eeb76d88..8d087ec8 100644
--- a/Tests/Aiur2.lean
+++ b/Tests/Aiur2.lean
@@ -2,6 +2,7 @@ import LSpec
 import Ix.Aiur2.Meta
 import Ix.Aiur2.Simple
 import Ix.Aiur2.Compile
+import Ix.Aiur2.Protocol
 
 open LSpec
 
@@ -139,15 +140,28 @@ def testCases : List TestCase := [
     ⟨`slice_and_get, #[1, 2, 3, 4], #[4]⟩,
   ]
 
+def friParameters : Aiur.FriParameters := {
+  logBlowup := 1
+  logFinalPolyLen := 0
+  numQueries := 100
+  proofOfWorkBits := 20
+}
+
 def aiurTest : TestSeq :=
   withExceptOk "Check and simplification works" toplevel.checkAndSimplify fun decls =>
     let bytecodeToplevel := decls.compile
+    let aiurSystem := Aiur.AiurSystem.build bytecodeToplevel
     let runTestCase := fun testCase =>
       let functionName := testCase.functionName
       let funIdx := toplevel.getFuncIdx functionName |>.get!
-      let output := bytecodeToplevel.executeTest funIdx testCase.input
-      test s!"Result of {functionName} with arguments {testCase.input} is correct"
-        (output == testCase.expectedOutput)
+      let (claim, proof) := aiurSystem.prove friParameters funIdx testCase.input
+      let caseDescr := s!"{functionName} with arguments {testCase.input}"
+      let ioTest := test s!"Claim matches for {caseDescr}"
+        (claim == Aiur.buildClaim funIdx testCase.input testCase.expectedOutput)
+      let proof := .ofBytes proof.toBytes
+      let pvTest := withExceptOk s!"Prove/verify works for {caseDescr}"
+        (aiurSystem.verify friParameters claim proof) fun _ => .done
+      ioTest ++ pvTest
     testCases.foldl (init := .done) fun tSeq testCase =>
       tSeq ++ runTestCase testCase
 
diff --git a/c/aiur.c b/c/aiur.c
index 00ed809c..f7fb9a37 100644
--- a/c/aiur.c
+++ b/c/aiur.c
@@ -1,13 +1,105 @@
 #include "lean/lean.h"
+#include "common.h"
 #include "rust.h"
 
-extern lean_obj_res c_rs_toplevel_execute_test(
-    b_lean_obj_arg toplevel,
+static lean_external_class *g_aiur_proof_class = NULL;
+
+static lean_external_class *get_aiur_proof_class() {
+    if (g_aiur_proof_class == NULL) {
+        g_aiur_proof_class = lean_register_external_class(
+            &rs_aiur_proof_free,
+            &noop_foreach
+        );
+    }
+    return g_aiur_proof_class;
+}
+
+extern lean_obj_res c_rs_aiur_proof_to_bytes(b_lean_obj_arg proof) {
+    bytes_data *proof_bytes = rs_aiur_proof_to_bytes(lean_get_external_data(proof));
+    size_t proof_size = proof_bytes->size;
+    lean_object *byte_array = lean_alloc_sarray(1, proof_size, proof_size);
+    rs_move_bytes(proof_bytes, byte_array);
+    return byte_array;
+}
+
+extern lean_obj_res c_rs_aiur_proof_of_bytes(b_lean_obj_arg bytes) {
+    void *proof = rs_aiur_proof_of_bytes(bytes);
+    return lean_alloc_external(get_aiur_proof_class(), proof);
+}
+
+static lean_external_class *g_aiur_system_class = NULL;
+
+static lean_external_class *get_aiur_system_class() {
+    if (g_aiur_system_class == NULL) {
+        g_aiur_system_class = lean_register_external_class(
+            &rs_aiur_system_free,
+            &noop_foreach
+        );
+    }
+    return g_aiur_system_class;
+}
+
+extern lean_obj_res c_rs_aiur_system_build(b_lean_obj_arg toplevel) {
+    void *aiur_system = rs_aiur_system_build(toplevel);
+    return lean_alloc_external(get_aiur_system_class(), aiur_system);
+}
+
+extern lean_obj_res c_rs_aiur_system_prove(
+    b_lean_obj_arg aiur_system,
+    b_lean_obj_arg fri_parameters,
     b_lean_obj_arg fun_idx,
-    b_lean_obj_arg args,
-    size_t output_size
+    b_lean_obj_arg args
+) {
+    assert(lean_is_scalar(fun_idx));
+    prove_data *pd = rs_aiur_system_prove(
+        lean_get_external_data(aiur_system),
+        fri_parameters,
+        fun_idx,
+        args
+    );
+
+    // Build the claim object
+    size_t claim_size = pd->claim_size;
+    lean_object *claim = lean_alloc_array(claim_size, claim_size);
+    lean_object **claim_data = lean_array_cptr(claim);
+    for (size_t i = 0; i < claim_size; i++) {
+        claim_data[i] = lean_box_uint64(0);
+    }
+    rs_set_aiur_claim_args(claim, pd->claim);
+    rs_aiur_claim_free(pd->claim);
+
+    // Build the tuple for return
+    lean_object *tuple = lean_alloc_ctor(0, 2, 0);
+    lean_ctor_set(tuple, 0, claim);
+    lean_ctor_set(tuple, 1, lean_alloc_external(get_aiur_proof_class(), pd->proof));
+
+    rs_aiur_prove_data_free(pd);
+
+    return tuple;
+}
+
+extern lean_obj_res c_rs_aiur_system_verify(
+    b_lean_obj_arg aiur_system,
+    b_lean_obj_arg fri_parameters,
+    b_lean_obj_arg claim,
+    b_lean_obj_arg proof
 ) {
-    lean_obj_res output = lean_alloc_array(output_size, output_size);
-    rs_toplevel_execute_test(toplevel, fun_idx, args, output);
-    return output;
+    c_result *result = rs_aiur_system_verify(
+        lean_get_external_data(aiur_system),
+        fri_parameters,
+        claim,
+        lean_get_external_data(proof)
+    );
+
+    lean_object *except;
+    if (result->is_ok) {
+        except = lean_alloc_ctor(1, 1, 0);
+        lean_ctor_set(except, 0, lean_box(0));
+    } else {
+        except = lean_alloc_ctor(0, 1, 0);
+        lean_ctor_set(except, 0, lean_mk_string(result->data));
+    }
+    rs__c_result_unit_string_free(result);
+
+    return except;
 }
diff --git a/c/rust.h b/c/rust.h
index 1796e524..10c3b384 100644
--- a/c/rust.h
+++ b/c/rust.h
@@ -2,15 +2,39 @@
 
 #include "lean/lean.h"
 
-void rs_toplevel_execute_test(
-    b_lean_obj_arg, b_lean_obj_arg, b_lean_obj_arg, lean_obj_arg
-);
-
 typedef struct {
     bool is_ok;
     void *data;
 } c_result;
 
+typedef struct {
+    size_t size;
+    void *bytes_vec;
+} bytes_data;
+
+void rs_move_bytes(bytes_data*, lean_obj_arg);
+
+bytes_data *rs_aiur_proof_to_bytes(void*);
+void *rs_aiur_proof_of_bytes(b_lean_obj_arg);
+
+void rs_aiur_system_free(void*);
+void *rs_aiur_system_build(b_lean_obj_arg);
+
+typedef struct {
+    size_t claim_size;
+    void *claim;
+    void *proof;
+} prove_data;
+
+void rs_aiur_claim_free(void*);
+void rs_aiur_proof_free(void*);
+void rs_aiur_prove_data_free(prove_data*);
+
+prove_data *rs_aiur_system_prove(void*, b_lean_obj_arg, b_lean_obj_arg, b_lean_obj_arg);
+void rs_set_aiur_claim_args(lean_obj_arg, void*);
+
+c_result *rs_aiur_system_verify(void*, b_lean_obj_arg, b_lean_obj_arg, void*);
+
 /* --- WitnessModule --- */
 
 void rs_witness_module_free(void*);
diff --git a/ix.nix b/ix.nix
index 93b0690b..c7f30039 100644
--- a/ix.nix
+++ b/ix.nix
@@ -3,7 +3,7 @@ let
   # Pins the Rust toolchain
   rustToolchain = fenix.packages.${system}.fromToolchainFile {
     file = ./rust-toolchain.toml;
-    sha256 = "sha256-hpWM7NzUvjHg0xtIgm7ftjKCc1qcAeev45XqD3KMeQo=";
+    sha256 = "sha256-pyALh2dsNqnioKUs2BY07gOU96ZNB7D4esEmcxym//4=";
   };
 
   # Rust package
diff --git a/lakefile.lean b/lakefile.lean
index cfc748ee..1f071fc3 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -56,7 +56,12 @@ section FFI
 
 /-- Build the static lib for the Rust crate -/
 extern_lib ix_rs pkg := do
-  proc { cmd := "cargo", args := #["build", "--release"], cwd := pkg.dir } (quiet := true)
+  let ixNoPar ← IO.getEnv "IX_NO_PAR"
+  let buildArgs := #["build", "--release"]
+  let args := if ixNoPar == some "1"
+    then buildArgs
+    else buildArgs ++ #["--features", "parallel"]
+  proc { cmd := "cargo", args, cwd := pkg.dir } (quiet := true)
   let libName := nameToStaticLib "ix_rs"
   inputBinFile $ pkg.dir / "target" / "release" / libName
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 1f413de0..10df8ffe 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -2,4 +2,4 @@
 [toolchain]
 # The default profile includes rustc, rust-std, cargo, rust-docs, rustfmt and clippy.
 profile = "default"
-channel = "nightly-2025-01-08"
+channel = "nightly-2025-05-08"
diff --git a/src/aiur/execute.rs b/src/aiur/execute.rs
index 11718983..ab797f3f 100644
--- a/src/aiur/execute.rs
+++ b/src/aiur/execute.rs
@@ -83,9 +83,9 @@ impl Toplevel {
     /// Implementation of the execution algorithm
     ///
     /// 1) The values from the input are the very first values in the inner stack of the execution
-    ///     algorithm
+    ///    algorithm
     /// 2) You can write additional input values (for example if you need some constants) into the
-    ///     stack while implementing particular block of the program
+    ///    stack while implementing particular block of the program
     pub fn execute(&self, mut func_idx: FuncIdx, input: Vec<u64>) -> QueryRecord {
         let func = &self.functions[func_idx.to_usize()];
         assert_eq!(input.len(), func.input_size as usize);
diff --git a/src/aiur/frontend/expr.rs b/src/aiur/frontend/expr.rs
index 2cdc1f1d..1c381ef4 100644
--- a/src/aiur/frontend/expr.rs
+++ b/src/aiur/frontend/expr.rs
@@ -45,8 +45,8 @@ impl std::fmt::Display for Var {
 impl std::fmt::Display for Ident {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Ident::User(n) => write!(f, "{}", n),
-            Ident::Internal(n) => write!(f, "${}", n),
+            Ident::User(n) => write!(f, "{n}"),
+            Ident::Internal(n) => write!(f, "${n}"),
         }
     }
 }
@@ -82,9 +82,9 @@ impl std::fmt::Display for VarVec {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s = self.var_list_str();
         if self.as_slice().len() == 1 {
-            write!(f, "{}", s)
+            write!(f, "{s}")
         } else {
-            write!(f, "({})", s)
+            write!(f, "({s})")
         }
     }
 }
@@ -188,7 +188,7 @@ impl OpE {
     pub fn pretty(&self) -> String {
         match self {
             OpE::Prim(x, c) => {
-                format!("let {x} = {:?};", c)
+                format!("let {x} = {c:?};")
             }
             OpE::Add(x, y, z) => {
                 format!("let {x} = add({y}, {z});")
diff --git a/src/aiur/synthesis.rs b/src/aiur/synthesis.rs
index 6eb6c225..4e865b0a 100644
--- a/src/aiur/synthesis.rs
+++ b/src/aiur/synthesis.rs
@@ -578,10 +578,11 @@ fn require(
 ) {
     let mut receive_args = send_args.clone();
     let index = builder
-        .add_linear_combination(format!("index-{channel_id}"), log_n, [(
-            prev_index,
-            MULT_GEN.into(),
-        )])
+        .add_linear_combination(
+            format!("index-{channel_id}"),
+            log_n,
+            [(prev_index, MULT_GEN.into())],
+        )
         .unwrap();
     if let Some(witness) = builder.witness() {
         (
diff --git a/src/aiur2/bytecode.rs b/src/aiur2/bytecode.rs
index e075047f..edb22ffb 100644
--- a/src/aiur2/bytecode.rs
+++ b/src/aiur2/bytecode.rs
@@ -1,26 +1,32 @@
-// TODO: remove
-#![allow(dead_code)]
-
 use indexmap::IndexMap;
-use p3_goldilocks::Goldilocks as G;
 use rustc_hash::FxBuildHasher;
 
+use super::G;
+
 pub struct Toplevel {
     pub(crate) functions: Vec<Function>,
-    pub(crate) memory_widths: Vec<usize>,
+    pub(crate) memory_sizes: Vec<usize>,
 }
 
 pub struct Function {
-    pub(crate) input_size: usize,
-    pub(crate) output_size: usize,
     pub(crate) body: Block,
-    pub(crate) circuit_layout: CircuitLayout,
+    pub(crate) layout: FunctionLayout,
 }
 
-pub struct CircuitLayout {
+#[allow(dead_code)]
+#[derive(Clone, Copy)]
+pub struct FunctionLayout {
+    pub(crate) input_size: usize,
+    pub(crate) output_size: usize,
     pub(crate) selectors: usize,
     pub(crate) auxiliaries: usize,
-    pub(crate) shared_constraints: usize,
+    pub(crate) lookups: usize,
+}
+
+impl FunctionLayout {
+    pub fn width(&self) -> usize {
+        self.input_size + self.selectors + self.auxiliaries
+    }
 }
 
 pub type FxIndexMap<K, V> = IndexMap<K, V, FxBuildHasher>;
@@ -37,7 +43,7 @@ pub enum Op {
     Add(ValIdx, ValIdx),
     Sub(ValIdx, ValIdx),
     Mul(ValIdx, ValIdx),
-    Call(FunIdx, Vec<ValIdx>),
+    Call(FunIdx, Vec<ValIdx>, usize),
     Store(Vec<ValIdx>),
     Load(usize, ValIdx),
 }
diff --git a/src/aiur2/constraints.rs b/src/aiur2/constraints.rs
new file mode 100644
index 00000000..8d9384b9
--- /dev/null
+++ b/src/aiur2/constraints.rs
@@ -0,0 +1,325 @@
+use multi_stark::{
+    builder::symbolic::SymbolicExpression, lookup::Lookup, p3_field::PrimeCharacteristicRing,
+};
+use std::ops::Range;
+
+use super::{
+    G,
+    bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel},
+    trace::Channel,
+};
+
+#[macro_export]
+macro_rules! sym_var {
+    ($a:expr) => {{
+        use multi_stark::builder::symbolic::*;
+        let entry = Entry::Main { offset: 0 };
+        SymbolicExpression::Variable(SymbolicVariable::new(entry, $a))
+    }};
+}
+
+type Expr = SymbolicExpression<G>;
+type Degree = u8;
+
+/// Holds data for a function circuit.
+pub struct Constraints {
+    pub zeros: Vec<Expr>,
+    pub selectors: Range<usize>,
+    pub width: usize,
+}
+
+struct ConstraintState {
+    function_index: G,
+    layout: FunctionLayout,
+    column: usize,
+    lookup: usize,
+    lookups: Vec<Lookup<Expr>>,
+    map: Vec<(Expr, Degree)>,
+    constraints: Constraints,
+}
+
+struct SharedState {
+    column: usize,
+    lookup: usize,
+    map_len: usize,
+}
+
+impl ConstraintState {
+    fn selector_index(&self, sel: usize) -> usize {
+        sel + self.layout.input_size
+    }
+
+    fn next_lookup(&mut self) -> &mut Lookup<Expr> {
+        let lookup = &mut self.lookups[self.lookup];
+        self.lookup += 1;
+        lookup
+    }
+
+    fn next_auxiliary(&mut self) -> Expr {
+        self.column += 1;
+        sym_var!(self.column - 1)
+    }
+
+    fn save(&mut self) -> SharedState {
+        SharedState {
+            column: self.column,
+            lookup: self.lookup,
+            map_len: self.map.len(),
+        }
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    fn restore(&mut self, init: SharedState) {
+        self.column = init.column;
+        self.lookup = init.lookup;
+        self.map.truncate(init.map_len);
+    }
+}
+
+impl Toplevel {
+    pub fn build_constraints(&self, function_index: usize) -> (Constraints, Vec<Lookup<Expr>>) {
+        let function = &self.functions[function_index];
+        let empty_lookup = Lookup {
+            multiplicity: Expr::Constant(G::ZERO),
+            args: vec![],
+        };
+        let constraints = Constraints {
+            zeros: vec![],
+            selectors: 0..0,
+            width: function.layout.width(),
+        };
+        let mut state = ConstraintState {
+            function_index: G::from_usize(function_index),
+            layout: function.layout,
+            column: 0,
+            lookup: 0,
+            map: vec![],
+            lookups: vec![empty_lookup; function.layout.lookups],
+            constraints,
+        };
+        function.build_constraints(&mut state, self);
+        (state.constraints, state.lookups)
+    }
+}
+
+impl Function {
+    fn build_constraints(&self, state: &mut ConstraintState, toplevel: &Toplevel) {
+        // 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((sym_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 = sym_var!(state.column);
+        state.column += 1;
+        // the return lookup occupies the first lookup slot
+        state.lookups[0].multiplicity = -multiplicity.clone();
+        state.lookup += 1;
+        // the multiplicity can only be set if one and only one selector is set
+        let sel = self.body.get_block_selector(state);
+        state
+            .constraints
+            .zeros
+            .push(multiplicity * (Expr::from(G::ONE) - sel.clone()));
+        self.body.collect_constraints(sel, state, toplevel);
+    }
+}
+
+impl Block {
+    fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState, toplevel: &Toplevel) {
+        self.ops
+            .iter()
+            .for_each(|op| op.collect_constraints(&sel, state));
+        self.ctrl.collect_constraints(sel, state, toplevel);
+    }
+
+    fn get_block_selector(&self, state: &mut ConstraintState) -> Expr {
+        (self.min_sel_included..self.max_sel_excluded)
+            .map(|i| sym_var!(state.selector_index(i)))
+            .fold(Expr::Constant(G::ZERO), |var, acc| var + acc)
+    }
+}
+
+impl Ctrl {
+    #[allow(clippy::needless_pass_by_value)]
+    fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState, toplevel: &Toplevel) {
+        match self {
+            Ctrl::Return(_, values) => {
+                // channel and function index
+                let mut vector = vec![
+                    sel.clone() * Channel::Function.to_field(),
+                    sel.clone() * state.function_index,
+                ];
+                // input
+                vector.extend(
+                    (0..state.layout.input_size).map(|arg| sel.clone() * state.map[arg].0.clone()),
+                );
+                // output
+                vector.extend(
+                    values
+                        .iter()
+                        .map(|arg| sel.clone() * state.map[*arg].0.clone()),
+                );
+                let mut values_iter = vector.into_iter();
+                let lookup = &mut state.lookups[0];
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                // multiplicity is already set
+            }
+            Ctrl::Match(var, cases, def) => {
+                let (var, _) = state.map[*var].clone();
+                for (&value, branch) in cases.iter() {
+                    let init = state.save();
+                    let branch_sel = branch.get_block_selector(state);
+                    state
+                        .constraints
+                        .zeros
+                        .push(branch_sel.clone() * (var.clone() - Expr::from(value)));
+                    branch.collect_constraints(branch_sel, state, toplevel);
+                    state.restore(init);
+                }
+                def.iter().for_each(|branch| {
+                    let init = state.save();
+                    let branch_sel = branch.get_block_selector(state);
+                    for &value in cases.keys() {
+                        let inverse = state.next_auxiliary();
+                        state.constraints.zeros.push(
+                            branch_sel.clone()
+                                * ((var.clone() - Expr::from(value)) * inverse
+                                    - Expr::from(G::ONE)),
+                        );
+                    }
+                    branch.collect_constraints(branch_sel, state, toplevel);
+                    state.restore(init);
+                })
+            }
+        }
+    }
+}
+
+impl Op {
+    fn collect_constraints(&self, sel: &Expr, state: &mut ConstraintState) {
+        match self {
+            Op::Const(f) => state.map.push(((*f).into(), 0)),
+            Op::Add(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg.max(b_deg);
+                state.map.push((a.clone() + b.clone(), *deg));
+            }
+            Op::Sub(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg.max(b_deg);
+                state.map.push((a.clone() - b.clone(), *deg));
+            }
+            Op::Mul(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg + b_deg;
+                let mul = a.clone() * b.clone();
+                if deg < 2 {
+                    state.map.push((mul, deg));
+                } else {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    state.constraints.zeros.push(sel.clone() * (col - mul));
+                }
+            }
+            Op::Call(function_index, inputs, output_size) => {
+                // channel and function index
+                let mut vector = vec![
+                    sel.clone() * Channel::Function.to_field(),
+                    sel.clone() * G::from_usize(*function_index),
+                ];
+                // input
+                vector.extend(
+                    inputs
+                        .iter()
+                        .map(|arg| sel.clone() * state.map[*arg].0.clone()),
+                );
+                // output
+                let output = (0..*output_size).map(|_| {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    col
+                });
+                vector.extend(output);
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
+            Op::Store(values) => {
+                let size = values.len();
+                // channel, function index and pointer
+                let ptr = state.next_auxiliary();
+                state.map.push((ptr.clone(), 1));
+                let mut vector = vec![
+                    sel.clone() * Channel::Memory.to_field(),
+                    sel.clone() * G::from_usize(size),
+                    sel.clone() * ptr.clone(),
+                ];
+                // stored values
+                vector.extend(
+                    values
+                        .iter()
+                        .map(|value| sel.clone() * state.map[*value].0.clone()),
+                );
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
+            Op::Load(size, ptr) => {
+                // channel, size and pointer
+                let mut vector = vec![
+                    sel.clone() * Channel::Memory.to_field(),
+                    sel.clone() * G::from_usize(*size),
+                    sel.clone() * state.map[*ptr].0.clone(),
+                ];
+                // loaded values
+                let values = (0..*size).map(|_| {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    col
+                });
+                vector.extend(values);
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
+        }
+    }
+}
diff --git a/src/aiur2/execute.rs b/src/aiur2/execute.rs
index 2f671590..7c3ab38a 100644
--- a/src/aiur2/execute.rs
+++ b/src/aiur2/execute.rs
@@ -1,7 +1,9 @@
-use p3_field::{PrimeCharacteristicRing, PrimeField64};
-use p3_goldilocks::Goldilocks as G;
+use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
 
-use crate::aiur2::bytecode::{Ctrl, FunIdx, Function, FxIndexMap, Op, Toplevel};
+use super::{
+    G,
+    bytecode::{Ctrl, FunIdx, Function, FxIndexMap, Op, Toplevel},
+};
 
 pub struct QueryResult {
     pub(crate) output: Vec<G>,
@@ -23,7 +25,7 @@ impl QueryRecord {
             .map(|_| QueryMap::default())
             .collect();
         let memory_queries = toplevel
-            .memory_widths
+            .memory_sizes
             .iter()
             .map(|width| (*width, QueryMap::default()))
             .collect();
@@ -35,11 +37,11 @@ impl QueryRecord {
 }
 
 impl Toplevel {
-    pub fn execute(&self, fun_idx: FunIdx, args: Vec<G>) -> QueryRecord {
+    pub fn execute(&self, fun_idx: FunIdx, args: Vec<G>) -> (QueryRecord, Vec<G>) {
         let mut record = QueryRecord::new(self);
         let function = &self.functions[fun_idx];
-        function.execute(fun_idx, args, self, &mut record);
-        record
+        let output = function.execute(fun_idx, args, self, &mut record);
+        (record, output)
     }
 }
 
@@ -60,7 +62,7 @@ impl Function {
         mut map: Vec<G>,
         toplevel: &Toplevel,
         record: &mut QueryRecord,
-    ) {
+    ) -> Vec<G> {
         let mut exec_entries_stack = vec![];
         let mut callers_states_stack = vec![];
         macro_rules! push_block_exec_entries {
@@ -88,7 +90,7 @@ impl Function {
                     let b = map[*b];
                     map.push(a * b);
                 }
-                ExecEntry::Op(Op::Call(callee_idx, args)) => {
+                ExecEntry::Op(Op::Call(callee_idx, args, _)) => {
                     let args = args.iter().map(|i| map[*i]).collect();
                     if let Some(result) = record.function_queries[*callee_idx].get_mut(&args) {
                         result.multiplicity += G::ONE;
@@ -108,11 +110,11 @@ impl Function {
                 }
                 ExecEntry::Op(Op::Store(values)) => {
                     let values = values.iter().map(|v| map[*v]).collect::<Vec<_>>();
-                    let width = values.len();
+                    let size = values.len();
                     let memory_queries = record
                         .memory_queries
-                        .get_mut(&width)
-                        .expect("Invalid memory width");
+                        .get_mut(&size)
+                        .expect("Invalid memory size");
                     if let Some(result) = memory_queries.get_mut(&values) {
                         result.multiplicity += G::ONE;
                         map.extend(&result.output);
@@ -126,11 +128,11 @@ impl Function {
                         map.push(ptr);
                     }
                 }
-                ExecEntry::Op(Op::Load(width, ptr)) => {
+                ExecEntry::Op(Op::Load(size, ptr)) => {
                     let memory_queries = record
                         .memory_queries
-                        .get_mut(width)
-                        .expect("Invalid memory width");
+                        .get_mut(size)
+                        .expect("Invalid memory size");
                     let ptr = &map[*ptr];
                     let ptr_u64 = ptr.as_canonical_u64();
                     let ptr_usize = usize::try_from(ptr_u64).expect("Pointer is too big");
@@ -151,7 +153,7 @@ impl Function {
                 }
                 ExecEntry::Ctrl(Ctrl::Return(_, output)) => {
                     // Register the query.
-                    let input_size = toplevel.functions[fun_idx].input_size;
+                    let input_size = toplevel.functions[fun_idx].layout.input_size;
                     let args = map[..input_size].to_vec();
                     let output = output.iter().map(|i| map[*i]).collect::<Vec<_>>();
                     let result = QueryResult {
@@ -171,10 +173,12 @@ impl Function {
                     } else {
                         // No outer caller. About to exit.
                         assert!(exec_entries_stack.is_empty());
+                        map = output;
                         break;
                     }
                 }
             }
         }
+        map
     }
 }
diff --git a/src/aiur2/memory.rs b/src/aiur2/memory.rs
new file mode 100644
index 00000000..583f4949
--- /dev/null
+++ b/src/aiur2/memory.rs
@@ -0,0 +1,124 @@
+use multi_stark::{
+    builder::symbolic::SymbolicExpression,
+    lookup::Lookup,
+    p3_air::{Air, AirBuilder, BaseAir},
+    p3_field::PrimeCharacteristicRing,
+    p3_matrix::{Matrix, dense::RowMajorMatrix},
+};
+use rayon::{
+    iter::{
+        IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator,
+        ParallelIterator,
+    },
+    slice::ParallelSliceMut,
+};
+
+use crate::{
+    aiur2::{G, execute::QueryRecord, trace::Channel},
+    sym_var,
+};
+
+pub struct Memory {
+    width: usize,
+}
+
+impl Memory {
+    pub(super) fn lookup(multiplicity: G, size: G, ptr: G, values: &[G]) -> Lookup<G> {
+        let mut args = vec![Channel::Memory.to_field(), size, ptr];
+        args.extend(values);
+        Lookup { multiplicity, args }
+    }
+
+    fn width(size: usize) -> usize {
+        // Multiplicity, selector, pointer and values.
+        3 + size
+    }
+
+    pub fn build(size: usize) -> (Self, Lookup<SymbolicExpression<G>>) {
+        let multiplicity = -sym_var!(0);
+        let selector = sym_var!(1);
+        let pointer = sym_var!(2);
+        let mut args = Vec::with_capacity(3 + size);
+        args.push(selector.clone() * Channel::Memory.to_field());
+        args.push(selector.clone() * G::from_usize(size));
+        args.push(selector.clone() * pointer);
+        for val_idx in 0..size {
+            args.push(selector.clone() * sym_var!(3 + val_idx));
+        }
+        let width = Self::width(size);
+        (Self { width }, Lookup { multiplicity, args })
+    }
+
+    pub fn generate_trace(
+        size: usize,
+        record: &QueryRecord,
+    ) -> (RowMajorMatrix<G>, Vec<Vec<Lookup<G>>>) {
+        let queries = record.memory_queries.get(&size).expect("Invalid size");
+        let width = Self::width(size);
+        let height_no_padding = queries.len();
+        let height = height_no_padding.next_power_of_two();
+
+        let mut rows = vec![G::ZERO; height * width];
+        let rows_no_padding = &mut rows[0..height_no_padding * width];
+
+        let empty_lookup = Lookup {
+            multiplicity: G::ZERO,
+            args: vec![],
+        };
+        let mut lookups = vec![vec![empty_lookup]; height];
+        let lookups_no_padding = &mut lookups[0..height_no_padding];
+
+        rows_no_padding
+            .par_chunks_mut(width)
+            .zip(queries.par_iter())
+            .zip(lookups_no_padding.par_iter_mut())
+            .enumerate()
+            .for_each(|(i, ((row, (values, result)), row_lookups))| {
+                row[0] = result.multiplicity;
+                row[1] = G::ONE;
+                row[2] = G::from_usize(i);
+                row[3..].copy_from_slice(values);
+
+                row_lookups[0] = Self::lookup(-row[0], G::from_usize(size), row[2], &row[3..]);
+            });
+
+        let trace = RowMajorMatrix::new(rows, width);
+        (trace, lookups)
+    }
+}
+
+impl BaseAir<G> for Memory {
+    fn width(&self) -> usize {
+        self.width
+    }
+}
+
+impl<AB> Air<AB> for Memory
+where
+    AB: AirBuilder<F = G>,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local: &[AB::Var] = &main.row_slice(0).unwrap();
+        let next: &[AB::Var] = &main.row_slice(1).unwrap();
+
+        let (is_real, ptr) = (local[1].clone(), local[2].clone());
+        let (is_real_next, ptr_next) = (next[1].clone(), next[2].clone());
+
+        builder.assert_bool(is_real.clone());
+
+        // Whether the next row is real.
+        let is_real_transition = is_real_next * builder.is_transition();
+
+        // If the next row is real, the current row is real.
+        builder.when(is_real_transition.clone()).assert_one(is_real);
+
+        // Is this necessary?
+        // builder.when_first_row().when(is_real).assert_zero(ptr);
+
+        // Pointer increases by one
+        builder
+            .when(is_real_transition)
+            .assert_eq(ptr + AB::Expr::ONE, ptr_next);
+    }
+}
diff --git a/src/aiur2/mod.rs b/src/aiur2/mod.rs
index 72c93fe7..ec2e5cd2 100644
--- a/src/aiur2/mod.rs
+++ b/src/aiur2/mod.rs
@@ -1,2 +1,8 @@
 pub mod bytecode;
+pub mod constraints;
 pub mod execute;
+pub mod memory;
+pub mod synthesis;
+pub mod trace;
+
+pub type G = multi_stark::p3_goldilocks::Goldilocks;
diff --git a/src/aiur2/synthesis.rs b/src/aiur2/synthesis.rs
new file mode 100644
index 00000000..d0080627
--- /dev/null
+++ b/src/aiur2/synthesis.rs
@@ -0,0 +1,133 @@
+use multi_stark::{
+    lookup::LookupAir,
+    p3_air::{Air, AirBuilder, BaseAir},
+    p3_field::PrimeCharacteristicRing,
+    p3_matrix::Matrix,
+    prover::Proof,
+    system::{Circuit, System, SystemWitness},
+    types::{FriParameters, PcsError, new_stark_config},
+    verifier::VerificationError,
+};
+
+use crate::aiur2::{
+    G,
+    bytecode::{FunIdx, Toplevel},
+    constraints::Constraints,
+    memory::Memory,
+    trace::Channel,
+};
+
+pub struct AiurSystem {
+    toplevel: Toplevel,
+    system: System<AiurCircuit>,
+}
+
+enum AiurCircuit {
+    Function(Constraints),
+    Memory(Memory),
+}
+
+impl BaseAir<G> for AiurCircuit {
+    fn width(&self) -> usize {
+        // Even though the inner types might have `width` attributes, we dispatch
+        // to their trait implementations for correctness.
+        match self {
+            Self::Function(constraints) => constraints.width(),
+            Self::Memory(memory) => memory.width(),
+        }
+    }
+}
+
+impl<AB> Air<AB> for AiurCircuit
+where
+    AB: AirBuilder<F = G>,
+{
+    fn eval(&self, builder: &mut AB) {
+        match self {
+            Self::Function(constraints) => constraints.eval(builder),
+            Self::Memory(memory) => memory.eval(builder),
+        }
+    }
+}
+
+impl BaseAir<G> for Constraints {
+    fn width(&self) -> usize {
+        self.width
+    }
+}
+
+impl<AB> Air<AB> for Constraints
+where
+    AB: AirBuilder<F = G>,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let row = main.row_slice(0).unwrap();
+        for zero in self.zeros.iter() {
+            builder.assert_zero(zero.interpret(&row));
+        }
+        for sel in self.selectors.clone() {
+            builder.assert_bool(row[sel].clone());
+        }
+    }
+}
+
+impl AiurSystem {
+    pub fn build(toplevel: Toplevel) -> Self {
+        let function_circuits = (0..toplevel.functions.len()).map(|i| {
+            let (constraints, lookups) = toplevel.build_constraints(i);
+            let air = LookupAir::new(AiurCircuit::Function(constraints), lookups);
+            Circuit::from_air(air).unwrap()
+        });
+        let memory_circuits = toplevel.memory_sizes.iter().map(|&width| {
+            let (memory, lookup) = Memory::build(width);
+            let air = LookupAir::new(AiurCircuit::Memory(memory), vec![lookup]);
+            Circuit::from_air(air).unwrap()
+        });
+        let system = System::new(function_circuits.chain(memory_circuits));
+        AiurSystem { system, toplevel }
+    }
+
+    pub fn prove(
+        &self,
+        fri_parameters: &FriParameters,
+        fun_idx: FunIdx,
+        input: &[G],
+    ) -> (Vec<G>, Proof) {
+        let (query_record, output) = self.toplevel.execute(fun_idx, input.to_vec());
+        let mut witness = SystemWitness {
+            traces: vec![],
+            lookups: vec![],
+        };
+        // TODO: parallelize
+        for function_index in 0..self.toplevel.functions.len() {
+            let (trace, lookups_per_function) =
+                self.toplevel.generate_trace(function_index, &query_record);
+            witness.traces.push(trace);
+            witness.lookups.push(lookups_per_function);
+        }
+        // TODO: parallelize
+        for width in &self.toplevel.memory_sizes {
+            let (trace, lookups) = Memory::generate_trace(*width, &query_record);
+            witness.traces.push(trace);
+            witness.lookups.push(lookups);
+        }
+        let mut claim = vec![Channel::Function.to_field(), G::from_usize(fun_idx)];
+        claim.extend(input);
+        claim.extend(output);
+        let config = new_stark_config(fri_parameters);
+        let proof = self.system.prove(&config, &claim, witness);
+        (claim, proof)
+    }
+
+    #[inline]
+    pub fn verify(
+        &self,
+        fri_parameters: &FriParameters,
+        claim: &[G],
+        proof: &Proof,
+    ) -> Result<(), VerificationError<PcsError>> {
+        let config = new_stark_config(fri_parameters);
+        self.system.verify(&config, claim, proof)
+    }
+}
diff --git a/src/aiur2/trace.rs b/src/aiur2/trace.rs
new file mode 100644
index 00000000..ee92836f
--- /dev/null
+++ b/src/aiur2/trace.rs
@@ -0,0 +1,304 @@
+use multi_stark::{
+    lookup::Lookup,
+    p3_field::{Field, PrimeCharacteristicRing, PrimeField64},
+    p3_matrix::dense::RowMajorMatrix,
+};
+use rayon::{
+    iter::{IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator},
+    slice::ParallelSliceMut,
+};
+
+use super::{
+    G,
+    bytecode::{Block, Ctrl, Function, Op, Toplevel},
+    execute::QueryRecord,
+    memory::Memory,
+};
+
+pub enum Channel {
+    Function,
+    Memory,
+}
+
+impl Channel {
+    pub fn to_field(&self) -> G {
+        match self {
+            Channel::Function => G::ZERO,
+            Channel::Memory => G::ONE,
+        }
+    }
+}
+
+struct ColumnIndex {
+    auxiliary: usize,
+    lookup: usize,
+}
+
+struct ColumnMutSlice<'a> {
+    inputs: &'a mut [G],
+    selectors: &'a mut [G],
+    auxiliaries: &'a mut [G],
+    lookups: &'a mut [Lookup<G>],
+}
+
+type Degree = u8;
+
+impl<'a> ColumnMutSlice<'a> {
+    fn from_slice(function: &Function, slice: &'a mut [G], lookups: &'a mut [Lookup<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());
+        Self {
+            inputs,
+            selectors,
+            auxiliaries,
+            lookups,
+        }
+    }
+
+    fn push_auxiliary(&mut self, index: &mut ColumnIndex, t: G) {
+        self.auxiliaries[index.auxiliary] = t;
+        index.auxiliary += 1;
+    }
+
+    fn push_lookup(&mut self, index: &mut ColumnIndex, t: Lookup<G>) {
+        self.lookups[index.lookup] = t;
+        index.lookup += 1;
+    }
+}
+
+#[derive(Clone, Copy)]
+struct TraceContext<'a> {
+    function_index: G,
+    multiplicity: G,
+    inputs: &'a [G],
+    output: &'a [G],
+    query_record: &'a QueryRecord,
+}
+
+impl Toplevel {
+    pub fn generate_trace(
+        &self,
+        function_index: usize,
+        query_record: &QueryRecord,
+    ) -> (RowMajorMatrix<G>, Vec<Vec<Lookup<G>>>) {
+        let func = &self.functions[function_index];
+        let width = func.width();
+        let queries = &query_record.function_queries[function_index];
+        let height_no_padding = queries.len();
+        let height = height_no_padding.next_power_of_two();
+        let mut rows = vec![G::ZERO; height * width];
+        let rows_no_padding = &mut rows[0..height_no_padding * width];
+        let empty_lookup = Lookup {
+            multiplicity: G::ZERO,
+            args: vec![],
+        };
+        let mut lookups = vec![vec![empty_lookup; func.layout.lookups]; height];
+        let lookups_no_padding = &mut lookups[0..height_no_padding];
+        rows_no_padding
+            .par_chunks_mut(width)
+            .zip(lookups_no_padding.par_iter_mut())
+            .enumerate()
+            .for_each(|(i, (row, lookups))| {
+                let (inputs, result) = queries.get_index(i).unwrap();
+                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 context = TraceContext {
+                    function_index: G::from_usize(function_index),
+                    inputs,
+                    multiplicity: result.multiplicity,
+                    output: &result.output,
+                    query_record,
+                };
+                func.populate_row(index, slice, context);
+            });
+        let trace = RowMajorMatrix::new(rows, width);
+        (trace, lookups)
+    }
+}
+
+impl Function {
+    pub fn width(&self) -> usize {
+        self.layout.input_size + self.layout.auxiliaries + self.layout.selectors
+    }
+
+    fn populate_row(
+        &self,
+        index: &mut ColumnIndex,
+        slice: &mut ColumnMutSlice<'_>,
+        context: TraceContext<'_>,
+    ) {
+        debug_assert_eq!(
+            self.layout.input_size,
+            context.inputs.len(),
+            "Argument mismatch"
+        );
+        // Variable to value map
+        let map = &mut context.inputs.iter().map(|arg| (*arg, 1)).collect();
+        // One column per input
+        context
+            .inputs
+            .iter()
+            .enumerate()
+            .for_each(|(i, arg)| slice.inputs[i] = *arg);
+        // Push the multiplicity
+        slice.push_auxiliary(index, context.multiplicity);
+        self.body.populate_row(map, index, slice, context);
+    }
+}
+
+impl Block {
+    fn populate_row(
+        &self,
+        map: &mut Vec<(G, Degree)>,
+        index: &mut ColumnIndex,
+        slice: &mut ColumnMutSlice<'_>,
+        context: TraceContext<'_>,
+    ) {
+        self.ops
+            .iter()
+            .for_each(|op| op.populate_row(map, index, slice, context));
+        self.ctrl.populate_row(map, index, slice, context);
+    }
+}
+
+impl Ctrl {
+    fn populate_row(
+        &self,
+        map: &mut Vec<(G, Degree)>,
+        index: &mut ColumnIndex,
+        slice: &mut ColumnMutSlice<'_>,
+        context: TraceContext<'_>,
+    ) {
+        match self {
+            Ctrl::Return(sel, _) => {
+                slice.selectors[*sel] = G::ONE;
+                let lookup = function_lookup(
+                    -context.multiplicity,
+                    context.function_index,
+                    context.inputs,
+                    context.output,
+                );
+                slice.lookups[0] = lookup;
+            }
+            Ctrl::Match(var, cases, def) => {
+                let val = map[*var].0;
+                let branch = cases
+                    .get(&val)
+                    .or_else(|| {
+                        for &case in cases.keys() {
+                            // the witness shows that val is different from case
+                            let witness = (val - case).inverse();
+                            slice.push_auxiliary(index, witness);
+                        }
+                        def.as_deref()
+                    })
+                    .expect("No match");
+                branch.populate_row(map, index, slice, context);
+            }
+        }
+    }
+}
+
+impl Op {
+    fn populate_row(
+        &self,
+        map: &mut Vec<(G, Degree)>,
+        index: &mut ColumnIndex,
+        slice: &mut ColumnMutSlice<'_>,
+        context: TraceContext<'_>,
+    ) {
+        match self {
+            Op::Const(f) => map.push((*f, 0)),
+            Op::Add(a, b) => {
+                let (a, a_deg) = map[*a];
+                let (b, b_deg) = map[*b];
+                let deg = a_deg.max(b_deg);
+                map.push((a + b, deg));
+            }
+            Op::Sub(a, b) => {
+                let (a, a_deg) = map[*a];
+                let (b, b_deg) = map[*b];
+                let deg = a_deg.max(b_deg);
+                map.push((a - b, deg));
+            }
+            Op::Mul(a, b) => {
+                let (a, a_deg) = map[*a];
+                let (b, b_deg) = map[*b];
+                let deg = a_deg + b_deg;
+                let f = a * b;
+                if deg < 2 {
+                    map.push((f, deg));
+                } else {
+                    map.push((f, 1));
+                    slice.push_auxiliary(index, f);
+                }
+            }
+            Op::Call(function_index, inputs, _) => {
+                let inputs = inputs.iter().map(|a| map[*a].0).collect::<Vec<_>>();
+                let queries = &context.query_record.function_queries[*function_index];
+                let result = queries.get(&inputs).expect("Cannot find query result");
+                for f in result.output.iter() {
+                    map.push((*f, 1));
+                    slice.push_auxiliary(index, *f);
+                }
+                let lookup = function_lookup(
+                    G::ONE,
+                    G::from_usize(*function_index),
+                    &inputs,
+                    &result.output,
+                );
+                slice.push_lookup(index, lookup);
+            }
+            Op::Store(values) => {
+                let size = values.len();
+                let memory_queries = context
+                    .query_record
+                    .memory_queries
+                    .get(&size)
+                    .expect("Invalid memory size");
+                let values = values.iter().map(|a| map[*a].0).collect::<Vec<_>>();
+                let ptr = G::from_usize(
+                    memory_queries
+                        .get_index_of(&values)
+                        .expect("Unbound pointer"),
+                );
+                map.push((ptr, 1));
+                slice.push_auxiliary(index, ptr);
+                let lookup = Memory::lookup(G::ONE, G::from_usize(size), ptr, &values);
+                slice.push_lookup(index, lookup);
+            }
+            Op::Load(size, ptr) => {
+                let memory_queries = context
+                    .query_record
+                    .memory_queries
+                    .get(size)
+                    .expect("Invalid memory size");
+                let (ptr, _) = map[*ptr];
+                let ptr_u64 = ptr.as_canonical_u64();
+                let ptr_usize = usize::try_from(ptr_u64).expect("Pointer is too big");
+                let (values, _) = memory_queries
+                    .get_index(ptr_usize)
+                    .expect("Unbound pointer");
+                for f in values.iter() {
+                    map.push((*f, 1));
+                    slice.push_auxiliary(index, *f);
+                }
+                let lookup = Memory::lookup(G::ONE, G::from_usize(*size), ptr, values);
+                slice.push_lookup(index, lookup);
+            }
+        }
+    }
+}
+
+fn function_lookup(multiplicity: G, function_index: G, inputs: &[G], output: &[G]) -> Lookup<G> {
+    let mut args = vec![Channel::Function.to_field(), function_index];
+    args.extend(inputs);
+    args.extend(output);
+    Lookup { multiplicity, args }
+}
diff --git a/src/archon/populate.rs b/src/archon/populate.rs
index 7c9234e0..a8a5d3f6 100644
--- a/src/archon/populate.rs
+++ b/src/archon/populate.rs
@@ -16,7 +16,7 @@ use rayon::{
     slice::{ParallelSlice, ParallelSliceMut},
 };
 use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
-use std::{collections::hash_map::Entry, iter::repeat, mem::transmute};
+use std::{collections::hash_map::Entry, iter::repeat_n, mem::transmute};
 
 use super::{
     ModuleMode, OracleIdx, OracleKind, RelativeHeight,
@@ -108,7 +108,7 @@ impl WitnessModule {
 
         // Pad missing bytes with zeros.
         for (entry_id, num_missing_bytes) in missing_bytes_map {
-            self.push_u8s_to(repeat(0).take(num_missing_bytes), entry_id);
+            self.push_u8s_to(repeat_n(0, num_missing_bytes), entry_id);
         }
 
         // The incoming code block aims to calculate a compute order for the
@@ -647,7 +647,7 @@ impl WitnessModule {
                                 let pad_len = projected_field_elements.len() % DIVISOR;
                                 if pad_len != 0 {
                                     projected_field_elements
-                                        .extend(repeat($ty::ZERO).take(DIVISOR - pad_len));
+                                        .extend(repeat_n($ty::ZERO, DIVISOR - pad_len));
                                 }
 
                                 // Compose underliers in parallel
diff --git a/src/archon/precompiles/blake3.rs b/src/archon/precompiles/blake3.rs
index a85865ce..40fa61ce 100644
--- a/src/archon/precompiles/blake3.rs
+++ b/src/archon/precompiles/blake3.rs
@@ -114,12 +114,12 @@ fn state_transition_module(
     let mut circuit_module = CircuitModule::new(id);
     let state_transitions: [OracleIdx; STATE_SIZE] = array_util::try_from_fn(|xy| {
         circuit_module
-            .add_committed::<B32>(&format!("state-transition-{:?}", xy), RelativeHeight::Base)
+            .add_committed::<B32>(&format!("state-transition-{xy:?}"), RelativeHeight::Base)
     })?;
 
     let input: [OracleIdx; STATE_SIZE] = array_util::try_from_fn(|xy| {
         circuit_module.add_projected(
-            &format!("input-{:?}", xy),
+            &format!("input-{xy:?}"),
             state_transitions[xy],
             PROJECTED_SELECTOR_INPUT,
             SINGLE_COMPRESSION_HEIGHT,
@@ -128,7 +128,7 @@ fn state_transition_module(
 
     let output: [OracleIdx; STATE_SIZE] = array_util::try_from_fn(|xy| {
         circuit_module.add_projected(
-            &format!("output-{:?}", xy),
+            &format!("output-{xy:?}"),
             state_transitions[xy],
             PROJECTED_SELECTOR_OUTPUT,
             SINGLE_COMPRESSION_HEIGHT,
@@ -238,11 +238,11 @@ fn additions_xor_rotates_module(
     )?;
 
     let couts: [OracleIdx; ADDITION_OPERATIONS_NUMBER] = array_util::try_from_fn(|xy| {
-        circuit_module.add_committed::<B1>(&format!("cout-{:?}", xy), RelativeHeight::Base)
+        circuit_module.add_committed::<B1>(&format!("cout-{xy:?}"), RelativeHeight::Base)
     })?;
     let cins: [OracleIdx; ADDITION_OPERATIONS_NUMBER] = array_util::try_from_fn(|xy| {
         circuit_module.add_shifted(
-            &format!("cin-{:?}", xy),
+            &format!("cin-{xy:?}"),
             couts[xy],
             1,
             5,
@@ -813,36 +813,39 @@ pub mod tests {
             compression_offset += SINGLE_COMPRESSION_HEIGHT;
         }
 
-        (expected, Trace {
-            state_trace,
-            a_in_trace,
-            b_in_trace,
-            c_in_trace,
-            d_in_trace,
-            mx_in_trace,
-            my_in_trace,
-            a_0_tmp_trace,
-            a_0_trace,
-            d_in_xor_a_0_trace,
-            d_0_trace,
-            c_0_trace,
-            _b_in_xor_c_0_trace: b_in_xor_c_0_trace,
-            b_0_trace,
-            a_1_tmp_trace,
-            a_1_trace,
-            _d_0_xor_a_1_trace: d_0_xor_a_1_trace,
-            d_1_trace,
-            c_1_trace,
-            _b_0_xor_c_1_trace: b_0_xor_c_1_trace,
-            _b_1_trace: b_1_trace,
-            _cin_trace: cin_trace,
-            cout_trace,
-            cv_trace,
-            state_i_trace,
-            state_i_8_trace,
-            _state_i_xor_state_i_8_trace: state_i_xor_state_i_8_trace,
-            _state_i_8_xor_cv_trace: state_i_8_xor_cv_trace,
-        })
+        (
+            expected,
+            Trace {
+                state_trace,
+                a_in_trace,
+                b_in_trace,
+                c_in_trace,
+                d_in_trace,
+                mx_in_trace,
+                my_in_trace,
+                a_0_tmp_trace,
+                a_0_trace,
+                d_in_xor_a_0_trace,
+                d_0_trace,
+                c_0_trace,
+                _b_in_xor_c_0_trace: b_in_xor_c_0_trace,
+                b_0_trace,
+                a_1_tmp_trace,
+                a_1_trace,
+                _d_0_xor_a_1_trace: d_0_xor_a_1_trace,
+                d_1_trace,
+                c_1_trace,
+                _b_0_xor_c_1_trace: b_0_xor_c_1_trace,
+                _b_1_trace: b_1_trace,
+                _cin_trace: cin_trace,
+                cout_trace,
+                cv_trace,
+                state_i_trace,
+                state_i_8_trace,
+                _state_i_xor_state_i_8_trace: state_i_xor_state_i_8_trace,
+                _state_i_8_xor_cv_trace: state_i_8_xor_cv_trace,
+            },
+        )
     }
 
     const COMPRESSIONS_LOG_TEST: u32 = 5;
diff --git a/src/lean/boxed.rs b/src/lean/boxed.rs
index f89e6feb..d3095332 100644
--- a/src/lean/boxed.rs
+++ b/src/lean/boxed.rs
@@ -1,8 +1,16 @@
 use super::object::LeanObject;
 
-/// This is equivalent to `lean_ctor_object` with `*m_objs` cast to `size_t`.
+/// This is equivalent to a `lean_ctor_object` with `m_objs` of size 1.
 #[repr(C)]
 pub struct BoxedUSize {
     m_header: LeanObject,
     pub value: usize,
 }
+
+/// This is equivalent to a `lean_ctor_object` with `m_objs` of size 1 on x64
+/// and 2 on x32.
+#[repr(C)]
+pub struct BoxedU64 {
+    m_header: LeanObject,
+    pub value: u64,
+}
diff --git a/src/lean/ffi/aiur2/mod.rs b/src/lean/ffi/aiur2/mod.rs
index 05fb861a..ad8596e1 100644
--- a/src/lean/ffi/aiur2/mod.rs
+++ b/src/lean/ffi/aiur2/mod.rs
@@ -1 +1,23 @@
+use multi_stark::p3_field::integers::QuotientMap;
+use std::ffi::c_void;
+
+use crate::{
+    aiur2::G,
+    lean::ffi::{lean_is_scalar, lean_unbox_u64},
+    lean_unbox,
+};
+
+pub mod protocol;
 pub mod toplevel;
+
+#[inline]
+pub(super) fn lean_unbox_nat_as_usize(ptr: *const c_void) -> usize {
+    assert!(lean_is_scalar(ptr));
+    lean_unbox!(usize, ptr)
+}
+
+#[inline]
+pub(super) fn lean_unbox_g(ptr: *const c_void) -> G {
+    let u64 = lean_unbox_u64(ptr);
+    unsafe { G::from_canonical_unchecked(u64) }
+}
diff --git a/src/lean/ffi/aiur2/protocol.rs b/src/lean/ffi/aiur2/protocol.rs
new file mode 100644
index 00000000..8dd3bc67
--- /dev/null
+++ b/src/lean/ffi/aiur2/protocol.rs
@@ -0,0 +1,136 @@
+use multi_stark::{p3_field::PrimeField64, prover::Proof, types::FriParameters};
+use std::ffi::{CString, c_void};
+
+use crate::{
+    aiur2::{G, synthesis::AiurSystem},
+    lean::{
+        array::LeanArrayObject,
+        boxed::BoxedU64,
+        ctor::LeanCtorObject,
+        ffi::{
+            BytesData, CResult,
+            aiur2::{lean_unbox_g, lean_unbox_nat_as_usize, toplevel::lean_ctor_to_toplevel},
+            as_mut_unsafe, drop_raw, to_raw,
+        },
+        sarray::LeanSArrayObject,
+    },
+};
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_proof_to_bytes(proof: &Proof) -> *const BytesData {
+    let bytes = proof.to_bytes().expect("Serialization error");
+    let bytes_data = BytesData::from_vec(bytes);
+    to_raw(bytes_data)
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_proof_of_bytes(byte_array: &LeanSArrayObject) -> *const Proof {
+    let proof = Proof::from_bytes(byte_array.data()).expect("Deserialization error");
+    to_raw(proof)
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_system_free(ptr: *mut AiurSystem) {
+    drop_raw(ptr);
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_system_build(toplevel: &LeanCtorObject) -> *const AiurSystem {
+    to_raw(AiurSystem::build(lean_ctor_to_toplevel(toplevel)))
+}
+
+fn lean_ctor_to_fri_parameters(ctor: &LeanCtorObject) -> FriParameters {
+    let [
+        log_blowup_ptr,
+        log_final_poly_len_ptr,
+        num_queries_ptr,
+        proof_of_work_bits_ptr,
+    ] = ctor.objs();
+    let log_blowup = lean_unbox_nat_as_usize(log_blowup_ptr);
+    let log_final_poly_len = lean_unbox_nat_as_usize(log_final_poly_len_ptr);
+    let num_queries = lean_unbox_nat_as_usize(num_queries_ptr);
+    let proof_of_work_bits = lean_unbox_nat_as_usize(proof_of_work_bits_ptr);
+    FriParameters {
+        log_blowup,
+        log_final_poly_len,
+        num_queries,
+        proof_of_work_bits,
+    }
+}
+
+#[repr(C)]
+struct ProveData {
+    claim_size: usize,
+    claim: *const Vec<G>,
+    proof: *const Proof,
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_claim_free(ptr: *mut Vec<G>) {
+    drop_raw(ptr);
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_proof_free(ptr: *mut Proof) {
+    drop_raw(ptr);
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_prove_data_free(ptr: *mut ProveData) {
+    drop_raw(ptr);
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_system_prove(
+    aiur_system: &AiurSystem,
+    fri_parameters: &LeanCtorObject,
+    fun_idx: *const c_void,
+    args: &LeanArrayObject,
+) -> *const ProveData {
+    let fri_parameters = lean_ctor_to_fri_parameters(fri_parameters);
+    let fun_idx = lean_unbox_nat_as_usize(fun_idx);
+    let args = args.to_vec(lean_unbox_g);
+    let (claim, proof) = aiur_system.prove(&fri_parameters, fun_idx, &args);
+    let claim_size = claim.len();
+    let prove_data = ProveData {
+        claim_size,
+        claim: to_raw(claim),
+        proof: to_raw(proof),
+    };
+    to_raw(prove_data)
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_set_aiur_claim_args(claim_array: &mut LeanArrayObject, claim: &Vec<G>) {
+    let claim_data = claim_array.data();
+    assert_eq!(claim_data.len(), claim.len());
+    claim_data.iter().zip(claim).for_each(|(ptr, g)| {
+        let boxed_u64 = as_mut_unsafe(*ptr as *mut BoxedU64);
+        boxed_u64.value = g.as_canonical_u64();
+    });
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_system_verify(
+    aiur_system: &AiurSystem,
+    fri_parameters: &LeanCtorObject,
+    claim: &LeanArrayObject,
+    proof: &Proof,
+) -> *const CResult {
+    let fri_parameters = lean_ctor_to_fri_parameters(fri_parameters);
+    let claim = claim.to_vec(lean_unbox_g);
+    let c_result = match aiur_system.verify(&fri_parameters, &claim, proof) {
+        Ok(()) => CResult {
+            is_ok: true,
+            data: std::ptr::null(),
+        },
+        Err(err) => {
+            let msg = CString::new(format!("{err:?}")).expect("CString::new failure");
+            CResult {
+                is_ok: false,
+                data: msg.into_raw().cast(),
+            }
+        }
+    };
+    to_raw(c_result)
+}
diff --git a/src/lean/ffi/aiur2/toplevel.rs b/src/lean/ffi/aiur2/toplevel.rs
index 83975443..310b881d 100644
--- a/src/lean/ffi/aiur2/toplevel.rs
+++ b/src/lean/ffi/aiur2/toplevel.rs
@@ -1,30 +1,20 @@
-// TODO: remove
-#![allow(dead_code)]
-
-use p3_field::PrimeCharacteristicRing;
-use p3_goldilocks::Goldilocks as G;
-use std::{ffi::c_void, mem::transmute};
+use std::ffi::c_void;
 
 use crate::{
-    aiur2::bytecode::{Block, CircuitLayout, Ctrl, Function, FxIndexMap, Op, Toplevel, ValIdx},
+    aiur2::{
+        G,
+        bytecode::{Block, Ctrl, Function, FunctionLayout, FxIndexMap, Op, Toplevel, ValIdx},
+    },
     lean::{
         array::LeanArrayObject,
         ctor::LeanCtorObject,
-        ffi::{as_ref_unsafe, lean_is_scalar},
+        ffi::{
+            aiur2::{lean_unbox_g, lean_unbox_nat_as_usize},
+            as_ref_unsafe, lean_is_scalar,
+        },
     },
-    lean_unbox,
 };
 
-fn lean_unbox_nat_as_usize(ptr: *const c_void) -> usize {
-    assert!(lean_is_scalar(ptr));
-    lean_unbox!(usize, ptr)
-}
-
-fn lean_unbox_nat_as_g(ptr: *const c_void) -> G {
-    assert!(lean_is_scalar(ptr));
-    G::from_usize(lean_unbox!(usize, ptr))
-}
-
 fn lean_ptr_to_vec_val_idx(ptr: *const c_void) -> Vec<ValIdx> {
     let array: &LeanArrayObject = as_ref_unsafe(ptr.cast());
     array.to_vec(lean_unbox_nat_as_usize)
@@ -35,7 +25,7 @@ fn lean_ptr_to_op(ptr: *const c_void) -> Op {
     match ctor.tag() {
         0 => {
             let [const_val_ptr] = ctor.objs();
-            Op::Const(lean_unbox_nat_as_g(const_val_ptr))
+            Op::Const(lean_unbox_g(const_val_ptr))
         }
         1 => {
             let [a_ptr, b_ptr] = ctor.objs();
@@ -59,10 +49,11 @@ fn lean_ptr_to_op(ptr: *const c_void) -> Op {
             )
         }
         4 => {
-            let [fun_idx_ptr, val_idxs_ptr] = ctor.objs();
+            let [fun_idx_ptr, val_idxs_ptr, output_size_ptr] = ctor.objs();
             let fun_idx = lean_unbox_nat_as_usize(fun_idx_ptr);
             let val_idxs = lean_ptr_to_vec_val_idx(val_idxs_ptr);
-            Op::Call(fun_idx, val_idxs)
+            let output_size = lean_unbox_nat_as_usize(output_size_ptr);
+            Op::Call(fun_idx, val_idxs, output_size)
         }
         5 => {
             let [val_idxs_ptr] = ctor.objs();
@@ -82,7 +73,7 @@ fn lean_ptr_to_op(ptr: *const c_void) -> Op {
 fn lean_ptr_to_g_block_pair(ptr: *const c_void) -> (G, Block) {
     let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
     let [g_ptr, block_ptr] = ctor.objs();
-    let g = lean_unbox_nat_as_g(g_ptr);
+    let g = lean_unbox_g(g_ptr);
     let block = lean_ctor_to_block(as_ref_unsafe(block_ptr.cast()));
     (g, block)
 }
@@ -135,70 +126,39 @@ fn lean_ctor_to_block(ctor: &LeanCtorObject) -> Block {
     }
 }
 
-fn lean_ctor_to_circuit_layout(ctor: &LeanCtorObject) -> CircuitLayout {
-    let [selectors_ptr, auxiliaries_ptr, shared_constraints_ptr] = ctor.objs();
-    CircuitLayout {
+fn lean_ctor_to_function_layout(ctor: &LeanCtorObject) -> FunctionLayout {
+    let [
+        input_size_ptr,
+        output_size_ptr,
+        selectors_ptr,
+        auxiliaries_ptr,
+        lookups_ptr,
+    ] = ctor.objs();
+    FunctionLayout {
+        input_size: lean_unbox_nat_as_usize(input_size_ptr),
+        output_size: lean_unbox_nat_as_usize(output_size_ptr),
         selectors: lean_unbox_nat_as_usize(selectors_ptr),
         auxiliaries: lean_unbox_nat_as_usize(auxiliaries_ptr),
-        shared_constraints: lean_unbox_nat_as_usize(shared_constraints_ptr),
+        lookups: lean_unbox_nat_as_usize(lookups_ptr),
     }
 }
 
 fn lean_ptr_to_function(ptr: *const c_void) -> Function {
     let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [
-        input_size_ptr,
-        output_size_ptr,
-        body_ptr,
-        circuit_layout_ptr,
-    ] = ctor.objs();
-    let input_size = lean_unbox_nat_as_usize(input_size_ptr);
-    let output_size = lean_unbox_nat_as_usize(output_size_ptr);
+    let [body_ptr, layout_ptr] = ctor.objs();
     let body = lean_ctor_to_block(as_ref_unsafe(body_ptr.cast()));
-    let circuit_layout = lean_ctor_to_circuit_layout(as_ref_unsafe(circuit_layout_ptr.cast()));
-    Function {
-        input_size,
-        output_size,
-        body,
-        circuit_layout,
-    }
+    let layout = lean_ctor_to_function_layout(as_ref_unsafe(layout_ptr.cast()));
+    Function { body, layout }
 }
 
-fn lean_ctor_to_toplevel(ctor: &LeanCtorObject) -> Toplevel {
-    let [functions_ptr, memory_widths_ptr] = ctor.objs();
+pub(crate) fn lean_ctor_to_toplevel(ctor: &LeanCtorObject) -> Toplevel {
+    let [functions_ptr, memory_sizes_ptr] = ctor.objs();
     let functions_array: &LeanArrayObject = as_ref_unsafe(functions_ptr.cast());
     let functions = functions_array.to_vec(lean_ptr_to_function);
-    let memory_widths_array: &LeanArrayObject = as_ref_unsafe(memory_widths_ptr.cast());
-    let memory_widths = memory_widths_array.to_vec(lean_unbox_nat_as_usize);
+    let memory_sizes_array: &LeanArrayObject = as_ref_unsafe(memory_sizes_ptr.cast());
+    let memory_sizes = memory_sizes_array.to_vec(lean_unbox_nat_as_usize);
     Toplevel {
         functions,
-        memory_widths,
+        memory_sizes,
     }
 }
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_toplevel_execute_test(
-    toplevel: &LeanCtorObject,
-    fun_idx: *const c_void,
-    args: &LeanArrayObject,
-    output: &mut LeanArrayObject,
-) {
-    let fun_idx = lean_unbox_nat_as_usize(fun_idx);
-    let toplevel = lean_ctor_to_toplevel(toplevel);
-    let args = args.to_vec(lean_unbox_nat_as_g);
-    let record = toplevel.execute(fun_idx, args.clone());
-    let output_values = record.function_queries[fun_idx]
-        .get(&args)
-        .map(|res| &res.output)
-        .unwrap();
-    let boxed_values = output_values
-        .iter()
-        .map(|g| {
-            let g_u64 = unsafe { transmute::<G, u64>(*g) };
-            let g_usize = usize::try_from(g_u64).unwrap();
-            let g_boxed = (g_usize << 1) | 1;
-            g_boxed as *const c_void
-        })
-        .collect::<Vec<_>>();
-    output.set_data(&boxed_values);
-}
diff --git a/src/lean/ffi/mod.rs b/src/lean/ffi/mod.rs
index aa75935c..25a33281 100644
--- a/src/lean/ffi/mod.rs
+++ b/src/lean/ffi/mod.rs
@@ -8,7 +8,9 @@ pub mod keccak;
 use std::ffi::{CStr, CString, c_char, c_void};
 
 use crate::lean::{
-    array::LeanArrayObject, boxed::BoxedUSize, external::LeanExternalObject,
+    array::LeanArrayObject,
+    boxed::{BoxedU64, BoxedUSize},
+    external::LeanExternalObject,
     sarray::LeanSArrayObject,
 };
 
@@ -61,6 +63,12 @@ pub(super) fn as_ref_unsafe<'a, T>(ptr: *const T) -> &'a T {
     t_ref.expect("Null pointer dereference")
 }
 
+#[inline]
+pub(super) fn as_mut_unsafe<'a, T>(ptr: *mut T) -> &'a mut T {
+    let t_ref = unsafe { ptr.as_mut() };
+    t_ref.expect("Null pointer dereference")
+}
+
 /// ```c
 /// bool lean_is_scalar(lean_object * o) { return ((size_t)(o) & 1) == 1; }
 /// ```
@@ -120,8 +128,8 @@ extern "C" fn rs_boxed_u32s_are_equivalent_to_bytes(
 /// ```
 #[inline]
 pub(super) fn lean_unbox_u64(ptr: *const c_void) -> u64 {
-    let boxed_usize: &BoxedUSize = as_ref_unsafe(ptr.cast());
-    boxed_usize.value as u64
+    let boxed_usize: &BoxedU64 = as_ref_unsafe(ptr.cast());
+    boxed_usize.value
 }
 
 pub(super) fn boxed_usize_ptr_to_usize(ptr: *const c_void) -> usize {
@@ -140,3 +148,28 @@ extern "C" fn rs_exterior_mul_u64(a: u64, b: u64) -> *const u128 {
     let c = a as u128 * b as u128;
     to_raw(c)
 }
+
+#[repr(C)]
+pub struct BytesData {
+    size: usize,
+    bytes_vec: *const Vec<u8>,
+}
+
+impl BytesData {
+    #[inline]
+    pub(super) fn from_vec(vec: Vec<u8>) -> Self {
+        Self {
+            size: vec.len(),
+            bytes_vec: to_raw(vec),
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_move_bytes(bytes_data: *mut BytesData, byte_array: &mut LeanSArrayObject) {
+    let bytes_data = unsafe { Box::from_raw(bytes_data) };
+    let bytes_vec = unsafe { Box::from_raw(bytes_data.bytes_vec as *mut Vec<_>) };
+    byte_array.set_data(&bytes_vec);
+    drop(bytes_vec);
+    drop(bytes_data);
+}
diff --git a/src/lean/mod.rs b/src/lean/mod.rs
index acf8c7d2..69c68671 100644
--- a/src/lean/mod.rs
+++ b/src/lean/mod.rs
@@ -11,6 +11,7 @@ pub mod external;
 pub mod ffi;
 pub mod object;
 pub mod sarray;
+pub mod string;
 
 /// Emulates arrays of flexible size from C.
 #[repr(C)]
diff --git a/src/lean/string.rs b/src/lean/string.rs
new file mode 100644
index 00000000..d527caf4
--- /dev/null
+++ b/src/lean/string.rs
@@ -0,0 +1,27 @@
+use crate::lean::{CArray, object::LeanObject};
+
+/// ```c
+/// typedef struct {
+///     lean_object m_header;
+///     size_t      m_size;     /* byte length including '\0' terminator */
+///     size_t      m_capacity;
+///     size_t      m_length;   /* UTF8 length */
+///     char        m_data[];
+/// } lean_string_object;
+/// ```
+#[repr(C)]
+pub struct LeanStringObject {
+    m_header: LeanObject,
+    m_size: usize,
+    m_capacity: usize,
+    m_length: usize,
+    m_data: CArray<u8>,
+}
+
+impl LeanStringObject {
+    #[inline]
+    pub fn as_string(&self) -> String {
+        let bytes = self.m_data.slice(self.m_size);
+        unsafe { String::from_utf8_unchecked(bytes.to_vec()) }
+    }
+}

From 5c1a9c4f65a052eff0e765f026044b9fe10cc60e Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Thu, 24 Jul 2025 14:51:47 -0300
Subject: [PATCH 30/74] Remove binius (#185)

* chore: drop Binius

* Drop the dependency on Binius
* Remove Aiur
* Rename Aiur2 to Aiur

* chore: deactivate Iroh

* update the hash for the Rust toolchain

* satisfy ci
---
 Cargo.lock                               | 6576 +---------------------
 Cargo.toml                               |   30 +-
 Ix/Aiur/Bytecode.lean                    |  642 +--
 Ix/Aiur/Check.lean                       |  177 +-
 Ix/{Aiur2 => Aiur}/Compile.lean          |    4 +-
 Ix/Aiur/Constraints.lean                 |  276 -
 Ix/Aiur/Execute.lean                     |  225 -
 Ix/Aiur/Gadget.lean                      |   35 -
 Ix/{Aiur2 => Aiur}/Goldilocks.lean       |    0
 Ix/Aiur/Match.lean                       |   20 +-
 Ix/Aiur/Meta.lean                        |  104 +-
 Ix/{Aiur2 => Aiur}/Protocol.lean         |    2 +-
 Ix/Aiur/Simple.lean                      |   23 +-
 Ix/Aiur/Synthesis.lean                   |  310 -
 Ix/Aiur/Term.lean                        |   65 +-
 Ix/Aiur/Trace.lean                       |  326 --
 Ix/Aiur/Witness.lean                     |  182 -
 Ix/Aiur2/Bytecode.lean                   |   62 -
 Ix/Aiur2/Check.lean                      |  368 --
 Ix/Aiur2/Match.lean                      |  218 -
 Ix/Aiur2/Meta.lean                       |  235 -
 Ix/Aiur2/Simple.lean                     |   46 -
 Ix/Aiur2/Term.lean                       |  204 -
 Ix/Archon/ArithExpr.lean                 |   62 -
 Ix/Archon/Circuit.lean                   |   99 -
 Ix/Archon/ModuleMode.lean                |   31 -
 Ix/Archon/OracleIdx.lean                 |    7 -
 Ix/Archon/OracleOrConst.lean             |   33 -
 Ix/Archon/Protocol.lean                  |   53 -
 Ix/Archon/RelativeHeight.lean            |   32 -
 Ix/Archon/TowerField.lean                |   30 -
 Ix/Archon/Transparent.lean               |   29 -
 Ix/Archon/Witness.lean                   |   72 -
 Ix/Binius/Boundary.lean                  |   37 -
 Ix/Binius/Common.lean                    |   48 -
 Ix/Iroh/Transfer.lean                    |    9 +-
 Ix/Unsigned.lean                         |   58 -
 Main.lean                                |   10 +-
 Tests/Aiur.lean                          |  186 +-
 Tests/Aiur2.lean                         |  168 -
 Tests/Archon.lean                        |  188 -
 Tests/Blake3.lean                        |  747 ---
 Tests/Common.lean                        |    3 -
 Tests/FFIConsistency.lean                |  133 -
 Tests/Main.lean                          |    8 +-
 Tests/Unsigned.lean                      |   21 -
 c/archon.c                               |  563 --
 c/iroh.c                                 |   61 +-
 c/rust.h                                 |   65 +-
 c/unsigned.c                             |  103 -
 ix.nix                                   |    2 +-
 rust-toolchain.toml                      |    3 +-
 src/aiur/arithmetic.rs                   |  313 -
 src/{aiur2 => aiur}/bytecode.rs          |    0
 src/aiur/constraints.rs                  |  648 +--
 src/aiur/execute.rs                      |  476 +-
 src/aiur/frontend/expr.rs                |  604 --
 src/aiur/frontend/macros.rs              |  184 -
 src/aiur/frontend/mod.rs                 |    2 -
 src/aiur/gadgets/binius.rs               |   15 -
 src/aiur/gadgets/mod.rs                  |   52 -
 src/aiur/gadgets/uint_add.rs             |  171 -
 src/aiur/gadgets/uint_sub.rs             |  162 -
 src/aiur/ir.rs                           |  101 -
 src/aiur/layout.rs                       |  175 -
 src/aiur/memory.rs                       |  207 +-
 src/aiur/mod.rs                          |    9 +-
 src/aiur/synthesis.rs                    |  866 +--
 src/aiur/trace.rs                        |  530 +-
 src/aiur/transparent.rs                  |   85 -
 src/aiur2/constraints.rs                 |  325 --
 src/aiur2/execute.rs                     |  184 -
 src/aiur2/memory.rs                      |  124 -
 src/aiur2/mod.rs                         |    8 -
 src/aiur2/synthesis.rs                   |  133 -
 src/aiur2/trace.rs                       |  304 -
 src/archon/arith_expr.rs                 |   75 -
 src/archon/canonical.rs                  |  421 --
 src/archon/circuit.rs                    |  606 --
 src/archon/mod.rs                        |  111 -
 src/archon/populate.rs                   | 1400 -----
 src/archon/precompiles/blake3.rs         | 1015 ----
 src/archon/precompiles/mod.rs            |    1 -
 src/archon/protocol.rs                   |  255 -
 src/archon/transparent.rs                |  178 -
 src/archon/witness.rs                    |  227 -
 src/lean/ffi/{aiur2 => aiur}/mod.rs      |   10 +-
 src/lean/ffi/{aiur2 => aiur}/protocol.rs |    7 +-
 src/lean/ffi/{aiur2 => aiur}/toplevel.rs |    7 +-
 src/lean/ffi/archon/arith_expr.rs        |  102 -
 src/lean/ffi/archon/circuit.rs           |  234 -
 src/lean/ffi/archon/mod.rs               |   33 -
 src/lean/ffi/archon/module_mode.rs       |   49 -
 src/lean/ffi/archon/oracle_or_const.rs   |   55 -
 src/lean/ffi/archon/protocol.rs          |  186 -
 src/lean/ffi/archon/relative_height.rs   |   49 -
 src/lean/ffi/archon/transparent.rs       |   50 -
 src/lean/ffi/archon/witness.rs           |  197 -
 src/lean/ffi/binius.rs                   |  112 -
 src/lean/ffi/mod.rs                      |   91 +-
 src/lean/mod.rs                          |   74 +
 src/lib.rs                               |   10 +-
 102 files changed, 1510 insertions(+), 22714 deletions(-)
 rename Ix/{Aiur2 => Aiur}/Compile.lean (99%)
 delete mode 100644 Ix/Aiur/Constraints.lean
 delete mode 100644 Ix/Aiur/Execute.lean
 delete mode 100644 Ix/Aiur/Gadget.lean
 rename Ix/{Aiur2 => Aiur}/Goldilocks.lean (100%)
 rename Ix/{Aiur2 => Aiur}/Protocol.lean (97%)
 delete mode 100644 Ix/Aiur/Synthesis.lean
 delete mode 100644 Ix/Aiur/Trace.lean
 delete mode 100644 Ix/Aiur/Witness.lean
 delete mode 100644 Ix/Aiur2/Bytecode.lean
 delete mode 100644 Ix/Aiur2/Check.lean
 delete mode 100644 Ix/Aiur2/Match.lean
 delete mode 100644 Ix/Aiur2/Meta.lean
 delete mode 100644 Ix/Aiur2/Simple.lean
 delete mode 100644 Ix/Aiur2/Term.lean
 delete mode 100644 Ix/Archon/ArithExpr.lean
 delete mode 100644 Ix/Archon/Circuit.lean
 delete mode 100644 Ix/Archon/ModuleMode.lean
 delete mode 100644 Ix/Archon/OracleIdx.lean
 delete mode 100644 Ix/Archon/OracleOrConst.lean
 delete mode 100644 Ix/Archon/Protocol.lean
 delete mode 100644 Ix/Archon/RelativeHeight.lean
 delete mode 100644 Ix/Archon/TowerField.lean
 delete mode 100644 Ix/Archon/Transparent.lean
 delete mode 100644 Ix/Archon/Witness.lean
 delete mode 100644 Ix/Binius/Boundary.lean
 delete mode 100644 Ix/Binius/Common.lean
 delete mode 100644 Tests/Aiur2.lean
 delete mode 100644 Tests/Archon.lean
 delete mode 100644 Tests/Blake3.lean
 delete mode 100644 Tests/Unsigned.lean
 delete mode 100644 c/archon.c
 delete mode 100644 src/aiur/arithmetic.rs
 rename src/{aiur2 => aiur}/bytecode.rs (100%)
 delete mode 100644 src/aiur/frontend/expr.rs
 delete mode 100644 src/aiur/frontend/macros.rs
 delete mode 100644 src/aiur/frontend/mod.rs
 delete mode 100644 src/aiur/gadgets/binius.rs
 delete mode 100644 src/aiur/gadgets/mod.rs
 delete mode 100644 src/aiur/gadgets/uint_add.rs
 delete mode 100644 src/aiur/gadgets/uint_sub.rs
 delete mode 100644 src/aiur/ir.rs
 delete mode 100644 src/aiur/layout.rs
 delete mode 100644 src/aiur/transparent.rs
 delete mode 100644 src/aiur2/constraints.rs
 delete mode 100644 src/aiur2/execute.rs
 delete mode 100644 src/aiur2/memory.rs
 delete mode 100644 src/aiur2/mod.rs
 delete mode 100644 src/aiur2/synthesis.rs
 delete mode 100644 src/aiur2/trace.rs
 delete mode 100644 src/archon/arith_expr.rs
 delete mode 100644 src/archon/canonical.rs
 delete mode 100644 src/archon/circuit.rs
 delete mode 100644 src/archon/mod.rs
 delete mode 100644 src/archon/populate.rs
 delete mode 100644 src/archon/precompiles/blake3.rs
 delete mode 100644 src/archon/precompiles/mod.rs
 delete mode 100644 src/archon/protocol.rs
 delete mode 100644 src/archon/transparent.rs
 delete mode 100644 src/archon/witness.rs
 rename src/lean/ffi/{aiur2 => aiur}/mod.rs (87%)
 rename src/lean/ffi/{aiur2 => aiur}/protocol.rs (95%)
 rename src/lean/ffi/{aiur2 => aiur}/toplevel.rs (97%)
 delete mode 100644 src/lean/ffi/archon/arith_expr.rs
 delete mode 100644 src/lean/ffi/archon/circuit.rs
 delete mode 100644 src/lean/ffi/archon/mod.rs
 delete mode 100644 src/lean/ffi/archon/module_mode.rs
 delete mode 100644 src/lean/ffi/archon/oracle_or_const.rs
 delete mode 100644 src/lean/ffi/archon/protocol.rs
 delete mode 100644 src/lean/ffi/archon/relative_height.rs
 delete mode 100644 src/lean/ffi/archon/transparent.rs
 delete mode 100644 src/lean/ffi/archon/witness.rs
 delete mode 100644 src/lean/ffi/binius.rs

diff --git a/Cargo.lock b/Cargo.lock
index f68fcb7f..68ef234d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3,6496 +3,540 @@
 version = 4
 
 [[package]]
-name = "addr2line"
-version = "0.24.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
-dependencies = [
- "gimli",
-]
-
-[[package]]
-name = "adler2"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
-
-[[package]]
-name = "aead"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
-dependencies = [
- "bytes",
- "crypto-common",
- "generic-array",
-]
-
-[[package]]
-name = "ahash"
-version = "0.8.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
-dependencies = [
- "cfg-if",
- "once_cell",
- "version_check",
- "zerocopy",
-]
-
-[[package]]
-name = "aho-corasick"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "allocator-api2"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
-
-[[package]]
-name = "alloy-primitives"
-version = "0.8.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c77490fe91a0ce933a1f219029521f20fc28c2c0ca95d53fa4da9c00b8d9d4e"
-dependencies = [
- "alloy-rlp",
- "bytes",
- "cfg-if",
- "const-hex",
- "derive_more 2.0.1",
- "foldhash",
- "hashbrown 0.15.4",
- "indexmap",
- "itoa",
- "k256",
- "keccak-asm",
- "paste",
- "proptest",
- "rand 0.8.5",
- "ruint",
- "rustc-hash",
- "serde",
- "sha3",
- "tiny-keccak",
-]
-
-[[package]]
-name = "alloy-rlp"
-version = "0.3.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f70d83b765fdc080dbcd4f4db70d8d23fe4761f2f02ebfa9146b833900634b4"
-dependencies = [
- "arrayvec",
- "bytes",
-]
-
-[[package]]
-name = "android-tzdata"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
-
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.98"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
-
-[[package]]
-name = "ark-ff"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b3235cc41ee7a12aaaf2c575a2ad7b46713a8a50bda2fc3b003a04845c05dd6"
-dependencies = [
- "ark-ff-asm 0.3.0",
- "ark-ff-macros 0.3.0",
- "ark-serialize 0.3.0",
- "ark-std 0.3.0",
- "derivative",
- "num-bigint",
- "num-traits",
- "paste",
- "rustc_version 0.3.3",
- "zeroize",
-]
-
-[[package]]
-name = "ark-ff"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba"
-dependencies = [
- "ark-ff-asm 0.4.2",
- "ark-ff-macros 0.4.2",
- "ark-serialize 0.4.2",
- "ark-std 0.4.0",
- "derivative",
- "digest 0.10.7",
- "itertools 0.10.5",
- "num-bigint",
- "num-traits",
- "paste",
- "rustc_version 0.4.1",
- "zeroize",
-]
-
-[[package]]
-name = "ark-ff-asm"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db02d390bf6643fb404d3d22d31aee1c4bc4459600aef9113833d17e786c6e44"
-dependencies = [
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "ark-ff-asm"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348"
-dependencies = [
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "ark-ff-macros"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db2fd794a08ccb318058009eefdf15bcaaaaf6f8161eb3345f907222bac38b20"
-dependencies = [
- "num-bigint",
- "num-traits",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "ark-ff-macros"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565"
-dependencies = [
- "num-bigint",
- "num-traits",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "ark-serialize"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d6c2b318ee6e10f8c2853e73a83adc0ccb88995aa978d8a3408d492ab2ee671"
-dependencies = [
- "ark-std 0.3.0",
- "digest 0.9.0",
-]
-
-[[package]]
-name = "ark-serialize"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5"
-dependencies = [
- "ark-std 0.4.0",
- "digest 0.10.7",
- "num-bigint",
-]
-
-[[package]]
-name = "ark-std"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c"
-dependencies = [
- "num-traits",
- "rand 0.8.5",
-]
-
-[[package]]
-name = "ark-std"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
-dependencies = [
- "num-traits",
- "rand 0.8.5",
-]
-
-[[package]]
-name = "array-util"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e509844de8f09b90a2c3444684a2b6695f4071360e13d2fda0af9f749cc2ed6"
-dependencies = [
- "arrayvec",
-]
-
-[[package]]
-name = "arrayref"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
-
-[[package]]
-name = "arrayvec"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
-
-[[package]]
-name = "asn1-rs"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5493c3bedbacf7fd7382c6346bbd66687d12bbaad3a89a2d2c303ee6cf20b048"
-dependencies = [
- "asn1-rs-derive",
- "asn1-rs-impl",
- "displaydoc",
- "nom",
- "num-traits",
- "rusticata-macros",
- "thiserror 1.0.69",
- "time",
-]
-
-[[package]]
-name = "asn1-rs-derive"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
- "synstructure",
-]
-
-[[package]]
-name = "asn1-rs-impl"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "assert_matches"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
-
-[[package]]
-name = "async-channel"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
-dependencies = [
- "concurrent-queue",
- "event-listener-strategy",
- "futures-core",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-trait"
-version = "0.1.88"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "atomic-waker"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
-
-[[package]]
-name = "attohttpc"
-version = "0.24.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d9a9bf8b79a749ee0b911b91b671cc2b6c670bdbc7e3dfd537576ddc94bb2a2"
-dependencies = [
- "http 0.2.12",
- "log",
- "url",
-]
-
-[[package]]
-name = "auto_impl"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "autocfg"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
-
-[[package]]
-name = "backon"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "302eaff5357a264a2c42f127ecb8bac761cf99749fc3dc95677e2743991f99e7"
-dependencies = [
- "fastrand",
- "gloo-timers",
- "tokio",
-]
-
-[[package]]
-name = "backtrace"
-version = "0.3.75"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002"
-dependencies = [
- "addr2line",
- "cfg-if",
- "libc",
- "miniz_oxide",
- "object",
- "rustc-demangle",
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "bao-tree"
-version = "0.15.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff16d65e48353db458be63ee395c03028f24564fd48668389bd65fd945f5ac36"
-dependencies = [
- "blake3",
- "bytes",
- "futures-lite",
- "genawaiter",
- "iroh-io",
- "positioned-io",
- "range-collections",
- "self_cell",
- "smallvec",
-]
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64"
-version = "0.22.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
-
-[[package]]
-name = "base64ct"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba"
-
-[[package]]
-name = "binary-merge"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597bb81c80a54b6a4381b23faba8d7774b144c94cbd1d6fe3f1329bd776554ab"
-
-[[package]]
-name = "bincode"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
-dependencies = [
- "bincode_derive",
- "serde",
- "unty",
-]
-
-[[package]]
-name = "bincode_derive"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
-dependencies = [
- "virtue",
-]
-
-[[package]]
-name = "binius_circuits"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "alloy-primitives",
- "anyhow",
- "array-util",
- "binius_core",
- "binius_field",
- "binius_hash",
- "binius_macros",
- "binius_math",
- "binius_maybe_rayon",
- "binius_utils",
- "bumpalo",
- "bytemuck",
- "itertools 0.14.0",
- "rand 0.8.5",
- "tiny-keccak",
- "tracing",
-]
-
-[[package]]
-name = "binius_core"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "assert_matches",
- "auto_impl",
- "binius_field",
- "binius_hal",
- "binius_hash",
- "binius_macros",
- "binius_math",
- "binius_maybe_rayon",
- "binius_ntt",
- "binius_utils",
- "bytemuck",
- "bytes",
- "digest 0.10.7",
- "either",
- "getset",
- "inventory",
- "itertools 0.14.0",
- "rand 0.8.5",
- "serde",
- "serde_json",
- "serde_json_any_key",
- "stackalloc",
- "thiserror 2.0.12",
- "tracing",
- "transpose",
-]
-
-[[package]]
-name = "binius_field"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "binius_maybe_rayon",
- "binius_utils",
- "bytemuck",
- "cfg-if",
- "derive_more 0.99.20",
- "rand 0.8.5",
- "seq-macro",
- "subtle",
- "thiserror 2.0.12",
- "tracing",
- "trait-set",
- "transpose",
-]
-
-[[package]]
-name = "binius_hal"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "auto_impl",
- "binius_field",
- "binius_math",
- "binius_maybe_rayon",
- "binius_utils",
- "bytemuck",
- "itertools 0.14.0",
- "rand 0.8.5",
- "stackalloc",
- "thiserror 2.0.12",
- "tracing",
-]
-
-[[package]]
-name = "binius_hash"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "binius_field",
- "binius_maybe_rayon",
- "binius_ntt",
- "binius_utils",
- "bytemuck",
- "bytes",
- "cfg-if",
- "digest 0.10.7",
- "itertools 0.14.0",
- "lazy_static",
- "sha2",
- "stackalloc",
- "thiserror 2.0.12",
-]
-
-[[package]]
-name = "binius_macros"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "binius_math"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "auto_impl",
- "binius_field",
- "binius_macros",
- "binius_maybe_rayon",
- "binius_utils",
- "bytemuck",
- "bytes",
- "either",
- "getset",
- "itertools 0.14.0",
- "lazy_static",
- "rand 0.8.5",
- "stackalloc",
- "thiserror 2.0.12",
- "tracing",
-]
-
-[[package]]
-name = "binius_maybe_rayon"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "cfg-if",
- "either",
- "itertools 0.14.0",
- "rayon",
-]
-
-[[package]]
-name = "binius_ntt"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "binius_field",
- "binius_math",
- "binius_maybe_rayon",
- "binius_utils",
- "rand 0.8.5",
- "thiserror 2.0.12",
-]
-
-[[package]]
-name = "binius_utils"
-version = "0.2.0"
-source = "git+https://github.com/IrreducibleOSS/binius.git?rev=2326ae9b78a9679eeed86d30188a9bcc5eea55e0#2326ae9b78a9679eeed86d30188a9bcc5eea55e0"
-dependencies = [
- "auto_impl",
- "binius_maybe_rayon",
- "bytemuck",
- "bytes",
- "cfg-if",
- "generic-array",
- "itertools 0.14.0",
- "thiserror 2.0.12",
- "thread_local",
-]
-
-[[package]]
-name = "bit-set"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
-dependencies = [
- "bit-vec",
-]
-
-[[package]]
-name = "bit-vec"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitflags"
-version = "2.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blake3"
-version = "1.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
-dependencies = [
- "arrayref",
- "arrayvec",
- "cc",
- "cfg-if",
- "constant_time_eq",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "bounded-integer"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "102dbef1187b1893e6dfe05a774e79fd52265f49f214f6879c8ff49f52c8188b"
-
-[[package]]
-name = "bumpalo"
-version = "3.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
-
-[[package]]
-name = "byte-slice-cast"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7575182f7272186991736b70173b0ea045398f984bf5ebbb3804736ce1330c9d"
-
-[[package]]
-name = "bytemuck"
-version = "1.23.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c76a5792e44e4abe34d3abf15636779261d45a7450612059293d1d2cfc63422"
-dependencies = [
- "bytemuck_derive",
-]
-
-[[package]]
-name = "bytemuck_derive"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "441473f2b4b0459a68628c744bc61d23e730fb00128b841d30fa4bb3972257e4"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "bytes"
-version = "1.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "cc"
-version = "1.2.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "deec109607ca693028562ed836a5f1c4b8bd77755c4e132fc5ce11b0b6211ae7"
-dependencies = [
- "shlex",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
-
-[[package]]
-name = "cfg_aliases"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
-
-[[package]]
-name = "chacha20"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
-dependencies = [
- "cfg-if",
- "cipher",
- "cpufeatures",
-]
-
-[[package]]
-name = "chrono"
-version = "0.4.41"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
-dependencies = [
- "android-tzdata",
- "iana-time-zone",
- "js-sys",
- "num-traits",
- "serde",
- "wasm-bindgen",
- "windows-link",
-]
-
-[[package]]
-name = "cipher"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
-dependencies = [
- "crypto-common",
- "inout",
- "zeroize",
-]
-
-[[package]]
-name = "cobs"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
-dependencies = [
- "thiserror 2.0.12",
-]
-
-[[package]]
-name = "concurrent-queue"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "const-hex"
-version = "1.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83e22e0ed40b96a48d3db274f72fd365bd78f67af39b6bbd47e8a15e1c6207ff"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "hex",
- "proptest",
- "serde",
-]
-
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "const_format"
-version = "0.2.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "126f97965c8ad46d6d9163268ff28432e8f6a1196a55578867832e3049df63dd"
-dependencies = [
- "const_format_proc_macros",
-]
-
-[[package]]
-name = "const_format_proc_macros"
-version = "0.2.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "constant_time_eq"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
-
-[[package]]
-name = "convert_case"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
-
-[[package]]
-name = "cordyceps"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "688d7fbb8092b8de775ef2536f36c8c31f2bc4006ece2e8d8ad2d17d00ce0a2a"
-dependencies = [
- "loom",
- "tracing",
-]
-
-[[package]]
-name = "core-foundation"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crc"
-version = "3.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9710d3b3739c2e349eb44fe848ad0b7c8cb1e42bd87ee49371df2f7acaf3e675"
-dependencies = [
- "crc-catalog",
-]
-
-[[package]]
-name = "crc-catalog"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
-
-[[package]]
-name = "critical-section"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
-
-[[package]]
-name = "crunchy"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
-dependencies = [
- "generic-array",
- "rand_core 0.6.4",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "rand_core 0.6.4",
- "typenum",
-]
-
-[[package]]
-name = "crypto_box"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16182b4f39a82ec8a6851155cc4c0cda3065bb1db33651726a29e1951de0f009"
-dependencies = [
- "aead",
- "chacha20",
- "crypto_secretbox",
- "curve25519-dalek",
- "salsa20",
- "serdect",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto_secretbox"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d6cf87adf719ddf43a805e92c6870a531aedda35ff640442cbaf8674e141e1"
-dependencies = [
- "aead",
- "chacha20",
- "cipher",
- "generic-array",
- "poly1305",
- "salsa20",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "curve25519-dalek"
-version = "4.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "curve25519-dalek-derive",
- "digest 0.10.7",
- "fiat-crypto",
- "rand_core 0.6.4",
- "rustc_version 0.4.1",
- "serde",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "curve25519-dalek-derive"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "data-encoding"
-version = "2.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
-
-[[package]]
-name = "der"
-version = "0.7.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
-dependencies = [
- "const-oid",
- "der_derive",
- "pem-rfc7468",
- "zeroize",
-]
-
-[[package]]
-name = "der-parser"
-version = "9.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cd0a5c643689626bec213c4d8bd4d96acc8ffdb4ad4bb6bc16abf27d5f4b553"
-dependencies = [
- "asn1-rs",
- "displaydoc",
- "nom",
- "num-bigint",
- "num-traits",
- "rusticata-macros",
-]
-
-[[package]]
-name = "der_derive"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "deranged"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
-dependencies = [
- "powerfmt",
-]
-
-[[package]]
-name = "derivative"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "derive_more"
-version = "0.99.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
-dependencies = [
- "convert_case",
- "proc-macro2",
- "quote",
- "rustc_version 0.4.1",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "derive_more"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
-dependencies = [
- "derive_more-impl 1.0.0",
-]
-
-[[package]]
-name = "derive_more"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
-dependencies = [
- "derive_more-impl 2.0.1",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
- "unicode-xid",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
- "unicode-xid",
-]
-
-[[package]]
-name = "diatomic-waker"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab03c107fafeb3ee9f5925686dbb7a73bc76e3932abb0d2b365cb64b169cf04c"
-
-[[package]]
-name = "digest"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "displaydoc"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "dlopen2"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b4f5f101177ff01b8ec4ecc81eead416a8aa42819a2869311b3420fa114ffa"
-dependencies = [
- "libc",
- "once_cell",
- "winapi",
-]
-
-[[package]]
-name = "document-features"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
-dependencies = [
- "litrs",
-]
-
-[[package]]
-name = "dtoa"
-version = "1.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6add3b8cff394282be81f3fc1a0605db594ed69890078ca6e2cab1c408bcf04"
-
-[[package]]
-name = "ecdsa"
-version = "0.16.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
-dependencies = [
- "der",
- "digest 0.10.7",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "ed25519"
-version = "2.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
-dependencies = [
- "pkcs8",
- "serde",
- "signature",
-]
-
-[[package]]
-name = "ed25519-dalek"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70e796c081cee67dc755e1a36a0a172b897fab85fc3f6bc48307991f64e4eca9"
-dependencies = [
- "curve25519-dalek",
- "ed25519",
- "rand_core 0.6.4",
- "serde",
- "sha2",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "either"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest 0.10.7",
- "ff",
- "generic-array",
- "group",
- "pkcs8",
- "rand_core 0.6.4",
- "sec1",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "embedded-io"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
-
-[[package]]
-name = "embedded-io"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
-
-[[package]]
-name = "enum-as-inner"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "enumflags2"
-version = "0.7.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
-dependencies = [
- "enumflags2_derive",
-]
-
-[[package]]
-name = "enumflags2_derive"
-version = "0.7.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "equivalent"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
-
-[[package]]
-name = "erased-serde"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c138974f9d5e7fe373eb04df7cae98833802ae4b11c24ac7039a21d5af4b26c"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "erased_set"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a02a5d186d7bf1cb21f1f95e1a9cfa5c1f2dcd803a47aad454423ceec13525c5"
-
-[[package]]
-name = "errno"
-version = "0.3.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
-dependencies = [
- "libc",
- "windows-sys 0.60.2",
-]
-
-[[package]]
-name = "event-listener"
-version = "5.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3492acde4c3fc54c845eaab3eed8bd00c7a7d881f78bfc801e43a93dec1331ae"
-dependencies = [
- "concurrent-queue",
- "parking",
- "pin-project-lite",
-]
-
-[[package]]
-name = "event-listener-strategy"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
-dependencies = [
- "event-listener",
- "pin-project-lite",
-]
-
-[[package]]
-name = "fallible-iterator"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
-
-[[package]]
-name = "fastrand"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
-
-[[package]]
-name = "fastrlp"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "139834ddba373bbdd213dffe02c8d110508dcf1726c2be27e8d1f7d7e1856418"
-dependencies = [
- "arrayvec",
- "auto_impl",
- "bytes",
-]
-
-[[package]]
-name = "fastrlp"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce8dba4714ef14b8274c371879b175aa55b16b30f269663f19d576f380018dc4"
-dependencies = [
- "arrayvec",
- "auto_impl",
- "bytes",
-]
-
-[[package]]
-name = "ff"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
-dependencies = [
- "rand_core 0.6.4",
- "subtle",
-]
-
-[[package]]
-name = "fiat-crypto"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
-
-[[package]]
-name = "fixed-hash"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534"
-dependencies = [
- "byteorder",
- "rand 0.8.5",
- "rustc-hex",
- "static_assertions",
-]
-
-[[package]]
-name = "flume"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
-dependencies = [
- "futures-core",
- "futures-sink",
- "nanorand",
- "spin",
-]
-
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
-[[package]]
-name = "foldhash"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
-
-[[package]]
-name = "form_urlencoded"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
-dependencies = [
- "percent-encoding",
-]
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "futures"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-buffered"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe940397c8b744b9c2c974791c2c08bca2c3242ce0290393249e98f215a00472"
-dependencies = [
- "cordyceps",
- "diatomic-waker",
- "futures-core",
- "pin-project-lite",
- "spin",
-]
-
-[[package]]
-name = "futures-channel"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
-dependencies = [
- "futures-core",
- "futures-sink",
-]
-
-[[package]]
-name = "futures-core"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
-
-[[package]]
-name = "futures-executor"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
-dependencies = [
- "futures-core",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-io"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
-
-[[package]]
-name = "futures-lite"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5edaec856126859abb19ed65f39e90fea3a9574b9707f13539acf4abf7eb532"
-dependencies = [
- "fastrand",
- "futures-core",
- "futures-io",
- "parking",
- "pin-project-lite",
-]
-
-[[package]]
-name = "futures-macro"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "futures-sink"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
-
-[[package]]
-name = "futures-task"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
-
-[[package]]
-name = "futures-util"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite",
- "pin-utils",
- "slab",
-]
-
-[[package]]
-name = "genawaiter"
-version = "0.99.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c86bd0361bcbde39b13475e6e36cb24c329964aa2611be285289d1e4b751c1a0"
-dependencies = [
- "futures-core",
- "genawaiter-macro",
- "genawaiter-proc-macro",
- "proc-macro-hack",
-]
-
-[[package]]
-name = "genawaiter-macro"
-version = "0.99.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b32dfe1fdfc0bbde1f22a5da25355514b5e450c33a6af6770884c8750aedfbc"
-
-[[package]]
-name = "genawaiter-proc-macro"
-version = "0.99.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784f84eebc366e15251c4a8c3acee82a6a6f427949776ecb88377362a9621738"
-dependencies = [
- "proc-macro-error",
- "proc-macro-hack",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "generator"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d18470a76cb7f8ff746cf1f7470914f900252ec36bbc40b569d74b1258446827"
-dependencies = [
- "cc",
- "cfg-if",
- "libc",
- "log",
- "rustversion",
- "windows 0.61.3",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
-dependencies = [
- "cfg-if",
- "js-sys",
- "libc",
- "wasi 0.11.1+wasi-snapshot-preview1",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
-dependencies = [
- "cfg-if",
- "js-sys",
- "libc",
- "r-efi",
- "wasi 0.14.2+wasi-0.2.4",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "getset"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf0fc11e47561d47397154977bc219f4cf809b2974facc3ccb3b89e2436f912"
-dependencies = [
- "proc-macro-error2",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "gimli"
-version = "0.31.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
-
-[[package]]
-name = "glob"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
-
-[[package]]
-name = "gloo-timers"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994"
-dependencies = [
- "futures-channel",
- "futures-core",
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "groestl"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "343cfc165f92a988fd60292f7a0bfde4352a5a0beff9fbec29251ca4e9676e4d"
-dependencies = [
- "digest 0.10.7",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core 0.6.4",
- "subtle",
-]
-
-[[package]]
-name = "h2"
-version = "0.4.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17da50a276f1e01e0ba6c029e47b7100754904ee8a278f886546e98575380785"
-dependencies = [
- "atomic-waker",
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "http 1.3.1",
- "indexmap",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.14.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
-dependencies = [
- "ahash",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.15.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
-dependencies = [
- "allocator-api2",
- "equivalent",
- "foldhash",
-]
-
-[[package]]
-name = "hashlink"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
-dependencies = [
- "hashbrown 0.14.5",
-]
-
-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
-[[package]]
-name = "hermit-abi"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hickory-proto"
-version = "0.25.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8a6fe56c0038198998a6f217ca4e7ef3a5e51f46163bd6dd60b5c71ca6c6502"
-dependencies = [
- "async-trait",
- "cfg-if",
- "data-encoding",
- "enum-as-inner",
- "futures-channel",
- "futures-io",
- "futures-util",
- "idna",
- "ipnet",
- "once_cell",
- "rand 0.9.2",
- "ring",
- "thiserror 2.0.12",
- "tinyvec",
- "tokio",
- "tracing",
- "url",
-]
-
-[[package]]
-name = "hickory-resolver"
-version = "0.25.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc62a9a99b0bfb44d2ab95a7208ac952d31060efc16241c87eaf36406fecf87a"
-dependencies = [
- "cfg-if",
- "futures-util",
- "hickory-proto",
- "ipconfig",
- "moka",
- "once_cell",
- "parking_lot",
- "rand 0.9.2",
- "resolv-conf",
- "smallvec",
- "thiserror 2.0.12",
- "tokio",
- "tracing",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest 0.10.7",
-]
-
-[[package]]
-name = "hmac-sha1"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b05da5b9e5d4720bfb691eebb2b9d42da3570745da71eac8a1f5bb7e59aab88"
-dependencies = [
- "hmac",
- "sha1",
-]
-
-[[package]]
-name = "hmac-sha256"
-version = "1.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad6880c8d4a9ebf39c6e8b77007ce223f646a4d21ce29d99f70cb16420545425"
-
-[[package]]
-name = "hostname-validator"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f558a64ac9af88b5ba400d99b579451af0d39c6d360980045b91aac966d705e2"
-
-[[package]]
-name = "http"
-version = "0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
-dependencies = [
- "bytes",
- "fnv",
- "itoa",
-]
-
-[[package]]
-name = "http"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
-dependencies = [
- "bytes",
- "fnv",
- "itoa",
-]
-
-[[package]]
-name = "http-body"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
-dependencies = [
- "bytes",
- "http 1.3.1",
-]
-
-[[package]]
-name = "http-body-util"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
-dependencies = [
- "bytes",
- "futures-core",
- "http 1.3.1",
- "http-body",
- "pin-project-lite",
-]
-
-[[package]]
-name = "httparse"
-version = "1.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
-
-[[package]]
-name = "httpdate"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
-
-[[package]]
-name = "hyper"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80"
-dependencies = [
- "bytes",
- "futures-channel",
- "futures-util",
- "h2",
- "http 1.3.1",
- "http-body",
- "httparse",
- "httpdate",
- "itoa",
- "pin-project-lite",
- "smallvec",
- "tokio",
- "want",
-]
-
-[[package]]
-name = "hyper-rustls"
-version = "0.27.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
-dependencies = [
- "http 1.3.1",
- "hyper",
- "hyper-util",
- "rustls",
- "rustls-pki-types",
- "tokio",
- "tokio-rustls",
- "tower-service",
- "webpki-roots 1.0.2",
-]
-
-[[package]]
-name = "hyper-util"
-version = "0.1.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f66d5bd4c6f02bf0542fad85d626775bab9258cf795a4256dcaf3161114d1df"
-dependencies = [
- "base64",
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "http 1.3.1",
- "http-body",
- "hyper",
- "ipnet",
- "libc",
- "percent-encoding",
- "pin-project-lite",
- "socket2",
- "tokio",
- "tower-service",
- "tracing",
-]
-
-[[package]]
-name = "iana-time-zone"
-version = "0.1.63"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
-dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "iana-time-zone-haiku",
- "js-sys",
- "log",
- "wasm-bindgen",
- "windows-core 0.61.2",
-]
-
-[[package]]
-name = "iana-time-zone-haiku"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
-dependencies = [
- "cc",
-]
-
-[[package]]
-name = "icu_collections"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
-dependencies = [
- "displaydoc",
- "potential_utf",
- "yoke",
- "zerofrom",
- "zerovec",
-]
-
-[[package]]
-name = "icu_locale_core"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
-dependencies = [
- "displaydoc",
- "litemap",
- "tinystr",
- "writeable",
- "zerovec",
-]
-
-[[package]]
-name = "icu_normalizer"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
-dependencies = [
- "displaydoc",
- "icu_collections",
- "icu_normalizer_data",
- "icu_properties",
- "icu_provider",
- "smallvec",
- "zerovec",
-]
-
-[[package]]
-name = "icu_normalizer_data"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
-
-[[package]]
-name = "icu_properties"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
-dependencies = [
- "displaydoc",
- "icu_collections",
- "icu_locale_core",
- "icu_properties_data",
- "icu_provider",
- "potential_utf",
- "zerotrie",
- "zerovec",
-]
-
-[[package]]
-name = "icu_properties_data"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
-
-[[package]]
-name = "icu_provider"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
-dependencies = [
- "displaydoc",
- "icu_locale_core",
- "stable_deref_trait",
- "tinystr",
- "writeable",
- "yoke",
- "zerofrom",
- "zerotrie",
- "zerovec",
-]
-
-[[package]]
-name = "idna"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
-dependencies = [
- "idna_adapter",
- "smallvec",
- "utf8_iter",
-]
-
-[[package]]
-name = "idna_adapter"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
-dependencies = [
- "icu_normalizer",
- "icu_properties",
-]
-
-[[package]]
-name = "igd-next"
-version = "0.15.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76b0d7d4541def58a37bf8efc559683f21edce7c82f0d866c93ac21f7e098f93"
-dependencies = [
- "async-trait",
- "attohttpc",
- "bytes",
- "futures",
- "http 1.3.1",
- "http-body-util",
- "hyper",
- "hyper-util",
- "log",
- "rand 0.8.5",
- "tokio",
- "url",
- "xmltree",
-]
-
-[[package]]
-name = "impl-codec"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba6a270039626615617f3f36d15fc827041df3b78c439da2cadfa47455a77f2f"
-dependencies = [
- "parity-scale-codec",
-]
-
-[[package]]
-name = "impl-trait-for-tuples"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "indexmap"
-version = "2.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
-dependencies = [
- "equivalent",
- "hashbrown 0.15.4",
- "rayon",
-]
-
-[[package]]
-name = "inout"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "inplace-vec-builder"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf64c2edc8226891a71f127587a2861b132d2b942310843814d5001d99a1d307"
-dependencies = [
- "smallvec",
-]
-
-[[package]]
-name = "instant"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
-dependencies = [
- "cfg-if",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "inventory"
-version = "0.3.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab08d7cd2c5897f2c949e5383ea7c7db03fb19130ffcfbf7eda795137ae3cb83"
-dependencies = [
- "rustversion",
-]
-
-[[package]]
-name = "io-uring"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d93587f37623a1a17d94ef2bc9ada592f5465fe7732084ab7beefabe5c77c0c4"
-dependencies = [
- "bitflags 2.9.1",
- "cfg-if",
- "libc",
-]
-
-[[package]]
-name = "ipconfig"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"
-dependencies = [
- "socket2",
- "widestring",
- "windows-sys 0.48.0",
- "winreg",
-]
-
-[[package]]
-name = "ipnet"
-version = "2.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
-
-[[package]]
-name = "iri-string"
-version = "0.7.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2"
-dependencies = [
- "memchr",
- "serde",
-]
-
-[[package]]
-name = "iroh"
-version = "0.34.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37432887a6836e7a832fccb121b5f0ee6cd953c506f99b0278bdbedf8dee0e88"
-dependencies = [
- "aead",
- "anyhow",
- "atomic-waker",
- "backon",
- "bytes",
- "cfg_aliases",
- "concurrent-queue",
- "crypto_box",
- "data-encoding",
- "der",
- "derive_more 1.0.0",
- "ed25519-dalek",
- "futures-util",
- "hickory-resolver",
- "http 1.3.1",
- "igd-next",
- "instant",
- "iroh-base",
- "iroh-metrics",
- "iroh-quinn",
- "iroh-quinn-proto",
- "iroh-quinn-udp",
- "iroh-relay",
- "n0-future",
- "netdev",
- "netwatch",
- "pin-project",
- "pkarr",
- "portmapper",
- "rand 0.8.5",
- "rcgen",
- "reqwest",
- "ring",
- "rustls",
- "rustls-webpki 0.102.8",
- "serde",
- "smallvec",
- "strum",
- "stun-rs",
- "surge-ping",
- "thiserror 2.0.12",
- "time",
- "tokio",
- "tokio-stream",
- "tokio-util",
- "tracing",
- "url",
- "wasm-bindgen-futures",
- "webpki-roots 0.26.11",
- "x509-parser",
- "z32",
-]
-
-[[package]]
-name = "iroh-base"
-version = "0.34.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cd952d9e25e521d6aeb5b79f2fe32a0245da36aae3569e50f6010b38a5f0923"
-dependencies = [
- "curve25519-dalek",
- "data-encoding",
- "derive_more 1.0.0",
- "ed25519-dalek",
- "postcard",
- "rand_core 0.6.4",
- "serde",
- "thiserror 2.0.12",
- "url",
-]
-
-[[package]]
-name = "iroh-blobs"
-version = "0.34.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fa596a999c2df0269942918ec51abc64766433872f3c64ba9e9be8d9d2c7200"
-dependencies = [
- "anyhow",
- "async-channel",
- "bao-tree",
- "blake3",
- "bytes",
- "chrono",
- "data-encoding",
- "derive_more 1.0.0",
- "futures-buffered",
- "futures-lite",
- "futures-util",
- "genawaiter",
- "hashlink",
- "hex",
- "iroh",
- "iroh-base",
- "iroh-io",
- "iroh-metrics",
- "nested_enum_utils",
- "num_cpus",
- "oneshot",
- "parking_lot",
- "portable-atomic",
- "postcard",
- "quic-rpc",
- "quic-rpc-derive",
- "rand 0.8.5",
- "range-collections",
- "redb",
- "reflink-copy",
- "self_cell",
- "serde",
- "serde-error",
- "smallvec",
- "ssh-key",
- "strum",
- "tempfile",
- "thiserror 2.0.12",
- "tokio",
- "tokio-util",
- "tracing",
- "tracing-futures",
- "tracing-test",
- "walkdir",
-]
-
-[[package]]
-name = "iroh-io"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a5feb781017b983ff1b155cd1faf8174da2acafd807aa482876da2d7e6577a"
-dependencies = [
- "bytes",
- "futures-lite",
- "pin-project",
- "smallvec",
- "tokio",
-]
-
-[[package]]
-name = "iroh-metrics"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0f7cd1ffe3b152a5f4f4c1880e01e07d96001f20e02cc143cb7842987c616b3"
-dependencies = [
- "erased_set",
- "prometheus-client",
- "serde",
- "struct_iterable",
- "thiserror 2.0.12",
- "tracing",
-]
-
-[[package]]
-name = "iroh-quinn"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76c6245c9ed906506ab9185e8d7f64857129aee4f935e899f398a3bd3b70338d"
-dependencies = [
- "bytes",
- "cfg_aliases",
- "iroh-quinn-proto",
- "iroh-quinn-udp",
- "pin-project-lite",
- "rustc-hash",
- "rustls",
- "socket2",
- "thiserror 2.0.12",
- "tokio",
- "tracing",
- "web-time",
-]
-
-[[package]]
-name = "iroh-quinn-proto"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "929d5d8fa77d5c304d3ee7cae9aede31f13908bd049f9de8c7c0094ad6f7c535"
-dependencies = [
- "bytes",
- "getrandom 0.2.16",
- "rand 0.8.5",
- "ring",
- "rustc-hash",
- "rustls",
- "rustls-pki-types",
- "slab",
- "thiserror 2.0.12",
- "tinyvec",
- "tracing",
- "web-time",
-]
-
-[[package]]
-name = "iroh-quinn-udp"
-version = "0.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c53afaa1049f7c83ea1331f5ebb9e6ebc5fdd69c468b7a22dd598b02c9bcc973"
-dependencies = [
- "cfg_aliases",
- "libc",
- "once_cell",
- "socket2",
- "tracing",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "iroh-relay"
-version = "0.34.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40d2d7b50d999922791c6c14c25e13f55711e182618cb387bafa0896ffe0b930"
-dependencies = [
- "anyhow",
- "bytes",
- "cfg_aliases",
- "data-encoding",
- "derive_more 1.0.0",
- "hickory-resolver",
- "http 1.3.1",
- "http-body-util",
- "hyper",
- "hyper-util",
- "iroh-base",
- "iroh-metrics",
- "iroh-quinn",
- "iroh-quinn-proto",
- "lru",
- "n0-future",
- "num_enum",
- "pin-project",
- "pkarr",
- "postcard",
- "rand 0.8.5",
- "reqwest",
- "rustls",
- "rustls-webpki 0.102.8",
- "serde",
- "strum",
- "stun-rs",
- "thiserror 2.0.12",
- "tokio",
- "tokio-rustls",
- "tokio-tungstenite-wasm",
- "tokio-util",
- "tracing",
- "url",
- "webpki-roots 0.26.11",
- "z32",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itertools"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
-
-[[package]]
-name = "ix_rs"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "array-util",
- "binius_circuits",
- "binius_core",
- "binius_field",
- "binius_hal",
- "binius_hash",
- "binius_macros",
- "binius_math",
- "binius_maybe_rayon",
- "binius_utils",
- "bumpalo",
- "bytes",
- "groestl",
- "indexmap",
- "iroh",
- "iroh-base",
- "iroh-blobs",
- "multi-stark",
- "proptest",
- "rand 0.9.2",
- "rayon",
- "rustc-hash",
- "tiny-keccak",
- "tokio",
-]
-
-[[package]]
-name = "js-sys"
-version = "0.3.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
-dependencies = [
- "once_cell",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "k256"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "once_cell",
- "sha2",
-]
-
-[[package]]
-name = "keccak"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
-dependencies = [
- "cpufeatures",
-]
-
-[[package]]
-name = "keccak-asm"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "505d1856a39b200489082f90d897c3f07c455563880bc5952e38eabf731c83b6"
-dependencies = [
- "digest 0.10.7",
- "sha3-asm",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-dependencies = [
- "spin",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.174"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
-
-[[package]]
-name = "libm"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
-
-[[package]]
-name = "litemap"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
-
-[[package]]
-name = "litrs"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
-
-[[package]]
-name = "lock_api"
-version = "0.4.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
-
-[[package]]
-name = "loom"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
-dependencies = [
- "cfg-if",
- "generator",
- "scoped-tls",
- "tracing",
- "tracing-subscriber",
-]
-
-[[package]]
-name = "lru"
-version = "0.12.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38"
-dependencies = [
- "hashbrown 0.15.4",
-]
-
-[[package]]
-name = "lru-slab"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
-
-[[package]]
-name = "matchers"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
-dependencies = [
- "regex-automata 0.1.10",
-]
-
-[[package]]
-name = "md5"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
-
-[[package]]
-name = "memchr"
-version = "2.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
-
-[[package]]
-name = "minimal-lexical"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-
-[[package]]
-name = "miniz_oxide"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
-dependencies = [
- "adler2",
-]
-
-[[package]]
-name = "mio"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
-dependencies = [
- "libc",
- "wasi 0.11.1+wasi-snapshot-preview1",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "moka"
-version = "0.12.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9321642ca94a4282428e6ea4af8cc2ca4eac48ac7a6a4ea8f33f76d0ce70926"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-epoch",
- "crossbeam-utils",
- "loom",
- "parking_lot",
- "portable-atomic",
- "rustc_version 0.4.1",
- "smallvec",
- "tagptr",
- "thiserror 1.0.69",
- "uuid",
-]
-
-[[package]]
-name = "multi-stark"
-version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=f3017f7f1ad5f3e3149b552e188e9f9e09370a97#f3017f7f1ad5f3e3149b552e188e9f9e09370a97"
-dependencies = [
- "bincode",
- "p3-air",
- "p3-challenger",
- "p3-commit",
- "p3-dft",
- "p3-field",
- "p3-fri",
- "p3-goldilocks",
- "p3-keccak",
- "p3-matrix",
- "p3-maybe-rayon",
- "p3-merkle-tree",
- "p3-symmetric",
- "p3-util",
- "serde",
-]
-
-[[package]]
-name = "n0-future"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bb0e5d99e681ab3c938842b96fcb41bf8a7bb4bfdb11ccbd653a7e83e06c794"
-dependencies = [
- "cfg_aliases",
- "derive_more 1.0.0",
- "futures-buffered",
- "futures-lite",
- "futures-util",
- "js-sys",
- "pin-project",
- "send_wrapper",
- "tokio",
- "tokio-util",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-time",
-]
-
-[[package]]
-name = "nanorand"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3"
-dependencies = [
- "getrandom 0.2.16",
-]
-
-[[package]]
-name = "nested_enum_utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f256ef99e7ac37428ef98c89bef9d84b590172de4bbfbe81b68a4cd3abadb32"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "netdev"
-version = "0.31.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f901362e84cd407be6f8cd9d3a46bccf09136b095792785401ea7d283c79b91d"
-dependencies = [
- "dlopen2",
- "ipnet",
- "libc",
- "netlink-packet-core",
- "netlink-packet-route 0.17.1",
- "netlink-sys",
- "once_cell",
- "system-configuration",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "netlink-packet-core"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72724faf704479d67b388da142b186f916188505e7e0b26719019c525882eda4"
-dependencies = [
- "anyhow",
- "byteorder",
- "netlink-packet-utils",
-]
-
-[[package]]
-name = "netlink-packet-route"
-version = "0.17.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053998cea5a306971f88580d0829e90f270f940befd7cf928da179d4187a5a66"
-dependencies = [
- "anyhow",
- "bitflags 1.3.2",
- "byteorder",
- "libc",
- "netlink-packet-core",
- "netlink-packet-utils",
-]
-
-[[package]]
-name = "netlink-packet-route"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74c171cd77b4ee8c7708da746ce392440cb7bcf618d122ec9ecc607b12938bf4"
-dependencies = [
- "anyhow",
- "byteorder",
- "libc",
- "log",
- "netlink-packet-core",
- "netlink-packet-utils",
-]
-
-[[package]]
-name = "netlink-packet-utils"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ede8a08c71ad5a95cdd0e4e52facd37190977039a4704eb82a283f713747d34"
-dependencies = [
- "anyhow",
- "byteorder",
- "paste",
- "thiserror 1.0.69",
-]
-
-[[package]]
-name = "netlink-proto"
-version = "0.11.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72452e012c2f8d612410d89eea01e2d9b56205274abb35d53f60200b2ec41d60"
-dependencies = [
- "bytes",
- "futures",
- "log",
- "netlink-packet-core",
- "netlink-sys",
- "thiserror 2.0.12",
-]
-
-[[package]]
-name = "netlink-sys"
-version = "0.8.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16c903aa70590cb93691bf97a767c8d1d6122d2cc9070433deb3bbf36ce8bd23"
-dependencies = [
- "bytes",
- "futures",
- "libc",
- "log",
- "tokio",
-]
-
-[[package]]
-name = "netwatch"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7879c2cfdf30d92f2be89efa3169b3d78107e3ab7f7b9a37157782569314e1"
-dependencies = [
- "atomic-waker",
- "bytes",
- "cfg_aliases",
- "derive_more 1.0.0",
- "iroh-quinn-udp",
- "js-sys",
- "libc",
- "n0-future",
- "netdev",
- "netlink-packet-core",
- "netlink-packet-route 0.19.0",
- "netlink-sys",
- "rtnetlink 0.13.1",
- "rtnetlink 0.14.1",
- "serde",
- "socket2",
- "thiserror 2.0.12",
- "time",
- "tokio",
- "tokio-util",
- "tracing",
- "web-sys",
- "windows 0.59.0",
- "windows-result",
- "wmi",
-]
-
-[[package]]
-name = "nix"
-version = "0.26.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
-dependencies = [
- "bitflags 1.3.2",
- "cfg-if",
- "libc",
-]
-
-[[package]]
-name = "nix"
-version = "0.27.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053"
-dependencies = [
- "bitflags 2.9.1",
- "cfg-if",
- "libc",
-]
-
-[[package]]
-name = "no-std-net"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43794a0ace135be66a25d3ae77d41b91615fb68ae937f904090203e81f755b65"
-
-[[package]]
-name = "nom"
-version = "7.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
-dependencies = [
- "memchr",
- "minimal-lexical",
-]
-
-[[package]]
-name = "nu-ansi-term"
-version = "0.46.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
-dependencies = [
- "overload",
- "winapi",
-]
-
-[[package]]
-name = "num-bigint"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
-dependencies = [
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-bigint-dig"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc84195820f291c7697304f3cbdadd1cb7199c0efc917ff5eafd71225c136151"
-dependencies = [
- "byteorder",
- "lazy_static",
- "libm",
- "num-integer",
- "num-iter",
- "num-traits",
- "rand 0.8.5",
- "smallvec",
- "zeroize",
-]
-
-[[package]]
-name = "num-conv"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
-
-[[package]]
-name = "num-integer"
-version = "0.1.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-iter"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
- "libm",
-]
-
-[[package]]
-name = "num_cpus"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
-dependencies = [
- "hermit-abi",
- "libc",
-]
-
-[[package]]
-name = "num_enum"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a"
-dependencies = [
- "num_enum_derive",
- "rustversion",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "object"
-version = "0.36.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "oid-registry"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d8034d9489cdaf79228eb9f6a3b8d7bb32ba00d6645ebd48eef4077ceb5bd9"
-dependencies = [
- "asn1-rs",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
-dependencies = [
- "critical-section",
- "portable-atomic",
-]
-
-[[package]]
-name = "oneshot"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce411919553d3f9fa53a0880544cda985a112117a0444d5ff1e870a893d6ea"
-
-[[package]]
-name = "opaque-debug"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
-
-[[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
-[[package]]
-name = "p256"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b"
-dependencies = [
- "ecdsa",
- "elliptic-curve",
- "primeorder",
- "sha2",
-]
-
-[[package]]
-name = "p3-air"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "p3-field",
- "p3-matrix",
-]
-
-[[package]]
-name = "p3-challenger"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "p3-field",
- "p3-maybe-rayon",
- "p3-symmetric",
- "p3-util",
- "tracing",
-]
-
-[[package]]
-name = "p3-commit"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "itertools 0.14.0",
- "p3-challenger",
- "p3-dft",
- "p3-field",
- "p3-matrix",
- "p3-util",
- "serde",
-]
-
-[[package]]
-name = "p3-dft"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "itertools 0.14.0",
- "p3-field",
- "p3-matrix",
- "p3-maybe-rayon",
- "p3-util",
- "tracing",
-]
-
-[[package]]
-name = "p3-field"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "itertools 0.14.0",
- "num-bigint",
- "p3-maybe-rayon",
- "p3-util",
- "paste",
- "rand 0.9.2",
- "serde",
- "tracing",
-]
-
-[[package]]
-name = "p3-fri"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "itertools 0.14.0",
- "p3-challenger",
- "p3-commit",
- "p3-dft",
- "p3-field",
- "p3-interpolation",
- "p3-matrix",
- "p3-maybe-rayon",
- "p3-util",
- "rand 0.9.2",
- "serde",
- "tracing",
-]
-
-[[package]]
-name = "p3-goldilocks"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "num-bigint",
- "p3-dft",
- "p3-field",
- "p3-mds",
- "p3-poseidon2",
- "p3-symmetric",
- "p3-util",
- "paste",
- "rand 0.9.2",
- "serde",
-]
-
-[[package]]
-name = "p3-interpolation"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "p3-field",
- "p3-matrix",
- "p3-maybe-rayon",
- "p3-util",
-]
-
-[[package]]
-name = "p3-keccak"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "p3-field",
- "p3-symmetric",
- "p3-util",
- "tiny-keccak",
-]
-
-[[package]]
-name = "p3-matrix"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "itertools 0.14.0",
- "p3-field",
- "p3-maybe-rayon",
- "p3-util",
- "rand 0.9.2",
- "serde",
- "tracing",
- "transpose",
-]
-
-[[package]]
-name = "p3-maybe-rayon"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "rayon",
-]
-
-[[package]]
-name = "p3-mds"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "p3-dft",
- "p3-field",
- "p3-symmetric",
- "p3-util",
- "rand 0.9.2",
-]
-
-[[package]]
-name = "p3-merkle-tree"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "itertools 0.14.0",
- "p3-commit",
- "p3-field",
- "p3-matrix",
- "p3-maybe-rayon",
- "p3-symmetric",
- "p3-util",
- "rand 0.9.2",
- "serde",
- "tracing",
-]
-
-[[package]]
-name = "p3-poseidon2"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "p3-field",
- "p3-mds",
- "p3-symmetric",
- "p3-util",
- "rand 0.9.2",
-]
-
-[[package]]
-name = "p3-symmetric"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "itertools 0.14.0",
- "p3-field",
- "serde",
-]
-
-[[package]]
-name = "p3-util"
-version = "0.3.0"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "p384"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe42f1670a52a47d448f14b6a5c61dd78fce51856e68edaa38f7ae3a46b8d6b6"
-dependencies = [
- "ecdsa",
- "elliptic-curve",
- "primeorder",
- "sha2",
-]
-
-[[package]]
-name = "p521"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fc9e2161f1f215afdfce23677034ae137bbd45016a880c2eb3ba8eb95f085b2"
-dependencies = [
- "base16ct",
- "ecdsa",
- "elliptic-curve",
- "primeorder",
- "rand_core 0.6.4",
- "sha2",
-]
-
-[[package]]
-name = "parity-scale-codec"
-version = "3.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "799781ae679d79a948e13d4824a40970bfa500058d245760dd857301059810fa"
-dependencies = [
- "arrayvec",
- "bitvec",
- "byte-slice-cast",
- "const_format",
- "impl-trait-for-tuples",
- "parity-scale-codec-derive",
- "rustversion",
- "serde",
-]
-
-[[package]]
-name = "parity-scale-codec-derive"
-version = "3.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34b4653168b563151153c9e4c08ebed57fb8262bebfa79711552fa983c623e7a"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "parking"
-version = "2.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
-
-[[package]]
-name = "parking_lot"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "paste"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
-
-[[package]]
-name = "pem"
-version = "3.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38af38e8470ac9dee3ce1bae1af9c1671fffc44ddfd8bd1d0a3445bf349a8ef3"
-dependencies = [
- "base64",
- "serde",
-]
-
-[[package]]
-name = "pem-rfc7468"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
-dependencies = [
- "base64ct",
-]
-
-[[package]]
-name = "percent-encoding"
-version = "2.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
-
-[[package]]
-name = "pest"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1db05f56d34358a8b1066f67cbb203ee3e7ed2ba674a6263a1d5ec6db2204323"
-dependencies = [
- "memchr",
- "thiserror 2.0.12",
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb056d9e8ea77922845ec74a1c4e8fb17e7c218cc4fc11a15c5d25e189aa40bc"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87e404e638f781eb3202dc82db6760c8ae8a1eeef7fb3fa8264b2ef280504966"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd1101f170f5903fde0914f899bb503d9ff5271d7ba76bbb70bea63690cc0d5"
-dependencies = [
- "pest",
- "sha2",
-]
-
-[[package]]
-name = "pin-project"
-version = "1.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
-dependencies = [
- "pin-project-internal",
-]
-
-[[package]]
-name = "pin-project-internal"
-version = "1.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "pin-project-lite"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
-
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
-[[package]]
-name = "pkarr"
-version = "2.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92eff194c72f00f3076855b413ad2d940e3a6e307fa697e5c7733e738341aed4"
-dependencies = [
- "bytes",
- "document-features",
- "ed25519-dalek",
- "flume",
- "futures",
- "js-sys",
- "lru",
- "self_cell",
- "simple-dns",
- "thiserror 2.0.12",
- "tracing",
- "ureq",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "z32",
-]
-
-[[package]]
-name = "pkcs1"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
-dependencies = [
- "der",
- "pkcs8",
- "spki",
-]
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "pnet_base"
-version = "0.34.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe4cf6fb3ab38b68d01ab2aea03ed3d1132b4868fa4e06285f29f16da01c5f4c"
-dependencies = [
- "no-std-net",
-]
-
-[[package]]
-name = "pnet_macros"
-version = "0.34.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "688b17499eee04a0408aca0aa5cba5fc86401d7216de8a63fdf7a4c227871804"
-dependencies = [
- "proc-macro2",
- "quote",
- "regex",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "pnet_macros_support"
-version = "0.34.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eea925b72f4bd37f8eab0f221bbe4c78b63498350c983ffa9dd4bcde7e030f56"
-dependencies = [
- "pnet_base",
-]
-
-[[package]]
-name = "pnet_packet"
-version = "0.34.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9a005825396b7fe7a38a8e288dbc342d5034dac80c15212436424fef8ea90ba"
-dependencies = [
- "glob",
- "pnet_base",
- "pnet_macros",
- "pnet_macros_support",
-]
-
-[[package]]
-name = "poly1305"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
-dependencies = [
- "cpufeatures",
- "opaque-debug",
- "universal-hash",
-]
-
-[[package]]
-name = "portable-atomic"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
-
-[[package]]
-name = "portmapper"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "247dcb75747c53cc433d6d8963a064187eec4a676ba13ea33143f1c9100e754f"
-dependencies = [
- "base64",
- "bytes",
- "derive_more 1.0.0",
- "futures-lite",
- "futures-util",
- "igd-next",
- "iroh-metrics",
- "libc",
- "netwatch",
- "num_enum",
- "rand 0.8.5",
- "serde",
- "smallvec",
- "socket2",
- "thiserror 2.0.12",
- "time",
- "tokio",
- "tokio-util",
- "tracing",
- "url",
-]
-
-[[package]]
-name = "positioned-io"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8078ce4d22da5e8f57324d985cc9befe40c49ab0507a192d6be9e59584495c9"
-dependencies = [
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "postcard"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c1de96e20f51df24ca73cafcc4690e044854d803259db27a00a461cb3b9d17a"
-dependencies = [
- "cobs",
- "embedded-io 0.4.0",
- "embedded-io 0.6.1",
- "postcard-derive",
- "serde",
-]
-
-[[package]]
-name = "postcard-derive"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f049d94cb6dda6938cc8a531d2898e7c08d71c6de63d8e67123cca6cdde2cc"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "potential_utf"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585"
-dependencies = [
- "zerovec",
-]
-
-[[package]]
-name = "powerfmt"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "precis-core"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c2e7b31f132e0c6f8682cfb7bf4a5340dbe925b7986618d0826a56dfe0c8e56"
-dependencies = [
- "precis-tools",
- "ucd-parse",
- "unicode-normalization",
-]
-
-[[package]]
-name = "precis-profiles"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc4f67f78f50388f03494794766ba824a704db16fb5d400fe8d545fa7bc0d3f1"
-dependencies = [
- "lazy_static",
- "precis-core",
- "precis-tools",
- "unicode-normalization",
-]
-
-[[package]]
-name = "precis-tools"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cc1eb2d5887ac7bfd2c0b745764db89edb84b856e4214e204ef48ef96d10c4a"
-dependencies = [
- "lazy_static",
- "regex",
- "ucd-parse",
-]
-
-[[package]]
-name = "primeorder"
-version = "0.13.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"
-dependencies = [
- "elliptic-curve",
-]
-
-[[package]]
-name = "primitive-types"
-version = "0.12.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
-dependencies = [
- "fixed-hash",
- "impl-codec",
- "uint",
-]
-
-[[package]]
-name = "proc-macro-crate"
-version = "3.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edce586971a4dfaa28950c6f18ed55e0406c1ab88bbce2c6f6293a7aaba73d35"
-dependencies = [
- "toml_edit",
-]
-
-[[package]]
-name = "proc-macro-error"
-version = "0.4.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18f33027081eba0a6d8aba6d1b1c3a3be58cbb12106341c2d5759fcd9b5277e7"
-dependencies = [
- "proc-macro-error-attr",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-error-attr"
-version = "0.4.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a5b4b77fdb63c1eca72173d68d24501c54ab1269409f6b672c85deb18af69de"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
- "syn-mid",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-error-attr2"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
-dependencies = [
- "proc-macro2",
- "quote",
-]
-
-[[package]]
-name = "proc-macro-error2"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
-dependencies = [
- "proc-macro-error-attr2",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "proc-macro-hack"
-version = "0.5.20+deprecated"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.95"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "prometheus-client"
-version = "0.22.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "504ee9ff529add891127c4827eb481bd69dc0ebc72e9a682e187db4caa60c3ca"
-dependencies = [
- "dtoa",
- "itoa",
- "parking_lot",
- "prometheus-client-derive-encode",
-]
-
-[[package]]
-name = "prometheus-client-derive-encode"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "440f724eba9f6996b75d63681b0a92b06947f1457076d503a4d2e2c8f56442b8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "proptest"
-version = "1.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fcdab19deb5195a31cf7726a210015ff1496ba1464fd42cb4f537b8b01b471f"
-dependencies = [
- "bit-set",
- "bit-vec",
- "bitflags 2.9.1",
- "lazy_static",
- "num-traits",
- "rand 0.9.2",
- "rand_chacha 0.9.0",
- "rand_xorshift",
- "regex-syntax 0.8.5",
- "rusty-fork",
- "tempfile",
- "unarray",
-]
-
-[[package]]
-name = "quic-rpc"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89561e5343bcad1c9f84321d9d9bd1619128ad44293faad55a0001b0e52d312b"
-dependencies = [
- "anyhow",
- "document-features",
- "flume",
- "futures-lite",
- "futures-sink",
- "futures-util",
- "pin-project",
- "serde",
- "slab",
- "smallvec",
- "time",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
-[[package]]
-name = "quic-rpc-derive"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a99f334af6f23b3de91f6df9ac17237e8b533b676f596c69dcb3b58c3cf8dea"
-dependencies = [
- "proc-macro2",
- "quic-rpc",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "quick-error"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
-
-[[package]]
-name = "quinn"
-version = "0.11.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "626214629cda6781b6dc1d316ba307189c85ba657213ce642d9c77670f8202c8"
-dependencies = [
- "bytes",
- "cfg_aliases",
- "pin-project-lite",
- "quinn-proto",
- "quinn-udp",
- "rustc-hash",
- "rustls",
- "socket2",
- "thiserror 2.0.12",
- "tokio",
- "tracing",
- "web-time",
-]
-
-[[package]]
-name = "quinn-proto"
-version = "0.11.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49df843a9161c85bb8aae55f101bc0bac8bcafd637a620d9122fd7e0b2f7422e"
-dependencies = [
- "bytes",
- "getrandom 0.3.3",
- "lru-slab",
- "rand 0.9.2",
- "ring",
- "rustc-hash",
- "rustls",
- "rustls-pki-types",
- "slab",
- "thiserror 2.0.12",
- "tinyvec",
- "tracing",
- "web-time",
-]
-
-[[package]]
-name = "quinn-udp"
-version = "0.5.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcebb1209ee276352ef14ff8732e24cc2b02bbac986cd74a4c81bcb2f9881970"
-dependencies = [
- "cfg_aliases",
- "libc",
- "once_cell",
- "socket2",
- "tracing",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "quoted-string-parser"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc75379cdb451d001f1cb667a9f74e8b355e9df84cc5193513cbe62b96fc5e9"
-dependencies = [
- "pest",
- "pest_derive",
-]
-
-[[package]]
-name = "r-efi"
-version = "5.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha 0.3.1",
- "rand_core 0.6.4",
-]
-
-[[package]]
-name = "rand"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
-dependencies = [
- "rand_chacha 0.9.0",
- "rand_core 0.9.3",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.6.4",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.9.3",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom 0.2.16",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
-dependencies = [
- "getrandom 0.3.3",
-]
-
-[[package]]
-name = "rand_xorshift"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
-dependencies = [
- "rand_core 0.9.3",
-]
-
-[[package]]
-name = "range-collections"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "861706ea9c4aded7584c5cd1d241cec2ea7f5f50999f236c22b65409a1f1a0d0"
-dependencies = [
- "binary-merge",
- "inplace-vec-builder",
- "ref-cast",
- "smallvec",
-]
-
-[[package]]
-name = "rayon"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
-dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "rcgen"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75e669e5202259b5314d1ea5397316ad400819437857b90861765f24c4cf80a2"
-dependencies = [
- "pem",
- "ring",
- "rustls-pki-types",
- "time",
- "yasna",
-]
-
-[[package]]
-name = "redb"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cef6a6d3a65ea334d6cdfb31fa2525c20184b7aa7bd1ad1e2e37502610d4609f"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e8af0dde094006011e6a740d4879319439489813bd0bcdc7d821beaeeff48ec"
-dependencies = [
- "bitflags 2.9.1",
-]
-
-[[package]]
-name = "ref-cast"
-version = "1.0.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0ae411dbe946a674d89546582cea4ba2bb8defac896622d6496f14c23ba5cf"
-dependencies = [
- "ref-cast-impl",
-]
-
-[[package]]
-name = "ref-cast-impl"
-version = "1.0.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1165225c21bff1f3bbce98f5a1f889949bc902d3575308cc7b0de30b4f6d27c7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "reflink-copy"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78c81d000a2c524133cc00d2f92f019d399e57906c3b7119271a2495354fe895"
-dependencies = [
- "cfg-if",
- "libc",
- "rustix",
- "windows 0.61.3",
-]
-
-[[package]]
-name = "regex"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata 0.4.9",
- "regex-syntax 0.8.5",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-dependencies = [
- "regex-syntax 0.6.29",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax 0.8.5",
-]
-
-[[package]]
-name = "regex-lite"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
-
-[[package]]
-name = "reqwest"
-version = "0.12.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc931937e6ca3a06e3b6c0aa7841849b160a90351d6ab467a8b9b9959767531"
-dependencies = [
- "base64",
- "bytes",
- "futures-core",
- "futures-util",
- "http 1.3.1",
- "http-body",
- "http-body-util",
- "hyper",
- "hyper-rustls",
- "hyper-util",
- "js-sys",
- "log",
- "percent-encoding",
- "pin-project-lite",
- "quinn",
- "rustls",
- "rustls-pki-types",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "sync_wrapper",
- "tokio",
- "tokio-rustls",
- "tokio-util",
- "tower",
- "tower-http",
- "tower-service",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-streams",
- "web-sys",
- "webpki-roots 1.0.2",
-]
-
-[[package]]
-name = "resolv-conf"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95325155c684b1c89f7765e30bc1c42e4a6da51ca513615660cb8a62ef9a88e3"
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "ring"
-version = "0.17.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
-dependencies = [
- "cc",
- "cfg-if",
- "getrandom 0.2.16",
- "libc",
- "untrusted",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "rlp"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec"
-dependencies = [
- "bytes",
- "rustc-hex",
-]
-
-[[package]]
-name = "rsa"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78928ac1ed176a5ca1d17e578a1825f3d81ca54cf41053a592584b020cfd691b"
-dependencies = [
- "const-oid",
- "digest 0.10.7",
- "num-bigint-dig",
- "num-integer",
- "num-traits",
- "pkcs1",
- "pkcs8",
- "rand_core 0.6.4",
- "sha2",
- "signature",
- "spki",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "rtnetlink"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a552eb82d19f38c3beed3f786bd23aa434ceb9ac43ab44419ca6d67a7e186c0"
-dependencies = [
- "futures",
- "log",
- "netlink-packet-core",
- "netlink-packet-route 0.17.1",
- "netlink-packet-utils",
- "netlink-proto",
- "netlink-sys",
- "nix 0.26.4",
- "thiserror 1.0.69",
- "tokio",
-]
-
-[[package]]
-name = "rtnetlink"
-version = "0.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b684475344d8df1859ddb2d395dd3dac4f8f3422a1aa0725993cb375fc5caba5"
-dependencies = [
- "futures",
- "log",
- "netlink-packet-core",
- "netlink-packet-route 0.19.0",
- "netlink-packet-utils",
- "netlink-proto",
- "netlink-sys",
- "nix 0.27.1",
- "thiserror 1.0.69",
- "tokio",
-]
-
-[[package]]
-name = "ruint"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11256b5fe8c68f56ac6f39ef0720e592f33d2367a4782740d9c9142e889c7fb4"
-dependencies = [
- "alloy-rlp",
- "ark-ff 0.3.0",
- "ark-ff 0.4.2",
- "bytes",
- "fastrlp 0.3.1",
- "fastrlp 0.4.0",
- "num-bigint",
- "num-integer",
- "num-traits",
- "parity-scale-codec",
- "primitive-types",
- "proptest",
- "rand 0.8.5",
- "rand 0.9.2",
- "rlp",
- "ruint-macro",
- "serde",
- "valuable",
- "zeroize",
-]
-
-[[package]]
-name = "ruint-macro"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18"
-
-[[package]]
-name = "rustc-demangle"
-version = "0.1.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "989e6739f80c4ad5b13e0fd7fe89531180375b18520cc8c82080e4dc4035b84f"
-
-[[package]]
-name = "rustc-hash"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
-
-[[package]]
-name = "rustc-hex"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
-
-[[package]]
-name = "rustc_version"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-dependencies = [
- "semver 0.9.0",
-]
-
-[[package]]
-name = "rustc_version"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
-dependencies = [
- "semver 0.11.0",
-]
-
-[[package]]
-name = "rustc_version"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
-dependencies = [
- "semver 1.0.26",
-]
-
-[[package]]
-name = "rusticata-macros"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
-dependencies = [
- "nom",
-]
-
-[[package]]
-name = "rustix"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
-dependencies = [
- "bitflags 2.9.1",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys 0.60.2",
-]
-
-[[package]]
-name = "rustls"
-version = "0.23.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2491382039b29b9b11ff08b76ff6c97cf287671dbb74f0be44bda389fffe9bd1"
-dependencies = [
- "log",
- "once_cell",
- "ring",
- "rustls-pki-types",
- "rustls-webpki 0.103.4",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "rustls-pki-types"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79"
-dependencies = [
- "web-time",
- "zeroize",
-]
-
-[[package]]
-name = "rustls-webpki"
-version = "0.102.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
-dependencies = [
- "ring",
- "rustls-pki-types",
- "untrusted",
-]
-
-[[package]]
-name = "rustls-webpki"
-version = "0.103.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a17884ae0c1b773f1ccd2bd4a8c72f16da897310a98b0e84bf349ad5ead92fc"
-dependencies = [
- "ring",
- "rustls-pki-types",
- "untrusted",
-]
-
-[[package]]
-name = "rustversion"
-version = "1.0.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
-
-[[package]]
-name = "rusty-fork"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
-dependencies = [
- "fnv",
- "quick-error",
- "tempfile",
- "wait-timeout",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
-
-[[package]]
-name = "salsa20"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
-dependencies = [
- "cipher",
-]
-
-[[package]]
-name = "same-file"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "scoped-tls"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
-
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "self_cell"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
-
-[[package]]
-name = "semver"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser 0.7.0",
-]
-
-[[package]]
-name = "semver"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
-dependencies = [
- "semver-parser 0.10.3",
-]
-
-[[package]]
-name = "semver"
-version = "1.0.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0"
-
-[[package]]
-name = "semver-parser"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-
-[[package]]
-name = "semver-parser"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9900206b54a3527fdc7b8a938bffd94a568bac4f4aa8113b209df75a09c0dec2"
-dependencies = [
- "pest",
-]
-
-[[package]]
-name = "send_wrapper"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
-
-[[package]]
-name = "seq-macro"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
-
-[[package]]
-name = "serde"
-version = "1.0.219"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde-error"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "342110fb7a5d801060c885da03bf91bfa7c7ca936deafcc64bb6706375605d47"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.219"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.141"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
-dependencies = [
- "itoa",
- "memchr",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serde_json_any_key"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2c409ca1209f6c4741028b9e1e56d973c868ffaef25ffbaf2471e486c2a74b3"
-dependencies = [
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "serde_urlencoded"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
-dependencies = [
- "form_urlencoded",
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serdect"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a84f14a19e9a014bb9f4512488d9829a68e04ecabffb0f9904cd1ace94598177"
-dependencies = [
- "base16ct",
- "serde",
-]
-
-[[package]]
-name = "sha1"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest 0.10.7",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest 0.10.7",
-]
-
-[[package]]
-name = "sha3"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
-dependencies = [
- "digest 0.10.7",
- "keccak",
-]
-
-[[package]]
-name = "sha3-asm"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28efc5e327c837aa837c59eae585fc250715ef939ac32881bcc11677cd02d46"
-dependencies = [
- "cc",
- "cfg-if",
-]
-
-[[package]]
-name = "sharded-slab"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
-dependencies = [
- "lazy_static",
-]
-
-[[package]]
-name = "shlex"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
-[[package]]
-name = "signal-hook-registry"
-version = "1.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "digest 0.10.7",
- "rand_core 0.6.4",
-]
-
-[[package]]
-name = "simple-dns"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dee851d0e5e7af3721faea1843e8015e820a234f81fda3dea9247e15bac9a86a"
-dependencies = [
- "bitflags 2.9.1",
-]
-
-[[package]]
-name = "slab"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
-
-[[package]]
-name = "smallvec"
-version = "1.15.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "socket2"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
-dependencies = [
- "libc",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "spin"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
-dependencies = [
- "lock_api",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "ssh-cipher"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "caac132742f0d33c3af65bfcde7f6aa8f62f0e991d80db99149eb9d44708784f"
-dependencies = [
- "cipher",
- "ssh-encoding",
-]
-
-[[package]]
-name = "ssh-encoding"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb9242b9ef4108a78e8cd1a2c98e193ef372437f8c22be363075233321dd4a15"
-dependencies = [
- "base64ct",
- "pem-rfc7468",
- "sha2",
-]
-
-[[package]]
-name = "ssh-key"
-version = "0.6.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b86f5297f0f04d08cabaa0f6bff7cb6aec4d9c3b49d87990d63da9d9156a8c3"
-dependencies = [
- "ed25519-dalek",
- "p256",
- "p384",
- "p521",
- "rand_core 0.6.4",
- "rsa",
- "sec1",
- "sha2",
- "signature",
- "ssh-cipher",
- "ssh-encoding",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "stable_deref_trait"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
-
-[[package]]
-name = "stackalloc"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b5b7088084b7f78305a42468c9a3693918620f0b8ec86260f1132dc0521e78"
-dependencies = [
- "cc",
- "rustc_version 0.2.3",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "strength_reduce"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
-
-[[package]]
-name = "struct_iterable"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "849a064c6470a650b72e41fa6c057879b68f804d113af92900f27574828e7712"
-dependencies = [
- "struct_iterable_derive",
- "struct_iterable_internal",
-]
-
-[[package]]
-name = "struct_iterable_derive"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bb939ce88a43ea4e9d012f2f6b4cc789deb2db9d47bad697952a85d6978662c"
-dependencies = [
- "erased-serde",
- "proc-macro2",
- "quote",
- "struct_iterable_internal",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "struct_iterable_internal"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9426b2a0c03e6cc2ea8dbc0168dbbf943f88755e409fb91bcb8f6a268305f4a"
-
-[[package]]
-name = "strum"
-version = "0.26.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
-dependencies = [
- "strum_macros",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.26.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "stun-rs"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb921f10397d5669e1af6455e9e2d367bf1f9cebcd6b1dd1dc50e19f6a9ac2ac"
-dependencies = [
- "base64",
- "bounded-integer",
- "byteorder",
- "crc",
- "enumflags2",
- "fallible-iterator",
- "hmac-sha1",
- "hmac-sha256",
- "hostname-validator",
- "lazy_static",
- "md5",
- "paste",
- "precis-core",
- "precis-profiles",
- "quoted-string-parser",
- "rand 0.9.2",
-]
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
-
-[[package]]
-name = "surge-ping"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fda78103d8016bb25c331ddc54af634e801806463682cc3e549d335df644d95"
-dependencies = [
- "hex",
- "parking_lot",
- "pnet_packet",
- "rand 0.9.2",
- "socket2",
- "thiserror 1.0.69",
- "tokio",
- "tracing",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.104"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn-mid"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea305d57546cc8cd04feb14b62ec84bf17f50e3f7b12560d7bfa9265f39d9ed"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "sync_wrapper"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
-dependencies = [
- "futures-core",
-]
-
-[[package]]
-name = "synstructure"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "system-configuration"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
-dependencies = [
- "bitflags 2.9.1",
- "core-foundation",
- "system-configuration-sys",
-]
-
-[[package]]
-name = "system-configuration-sys"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
-[[package]]
-name = "tagptr"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "tempfile"
-version = "3.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
-dependencies = [
- "fastrand",
- "getrandom 0.3.3",
- "once_cell",
- "rustix",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
-dependencies = [
- "thiserror-impl 1.0.69",
-]
-
-[[package]]
-name = "thiserror"
-version = "2.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
-dependencies = [
- "thiserror-impl 2.0.12",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "2.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "thread_local"
-version = "1.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "time"
-version = "0.3.41"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
-dependencies = [
- "deranged",
- "itoa",
- "js-sys",
- "num-conv",
- "powerfmt",
- "serde",
- "time-core",
- "time-macros",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
-
-[[package]]
-name = "time-macros"
-version = "0.2.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3526739392ec93fd8b359c8e98514cb3e8e021beb4e5f597b00a0221f8ed8a49"
-dependencies = [
- "num-conv",
- "time-core",
-]
-
-[[package]]
-name = "tiny-keccak"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
-
-[[package]]
-name = "tinystr"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
-dependencies = [
- "displaydoc",
- "zerovec",
-]
-
-[[package]]
-name = "tinyvec"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
-[[package]]
-name = "tokio"
-version = "1.46.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cc3a2344dafbe23a245241fe8b09735b521110d30fcefbbd5feb1797ca35d17"
-dependencies = [
- "backtrace",
- "bytes",
- "io-uring",
- "libc",
- "mio",
- "pin-project-lite",
- "signal-hook-registry",
- "slab",
- "socket2",
- "tokio-macros",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "tokio-macros"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "tokio-rustls"
-version = "0.26.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e727b36a1a0e8b74c376ac2211e40c2c8af09fb4013c60d910495810f008e9b"
-dependencies = [
- "rustls",
- "tokio",
-]
-
-[[package]]
-name = "tokio-stream"
-version = "0.1.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
-dependencies = [
- "futures-core",
- "pin-project-lite",
- "tokio",
- "tokio-util",
-]
-
-[[package]]
-name = "tokio-tungstenite"
-version = "0.24.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9"
-dependencies = [
- "futures-util",
- "log",
- "tokio",
- "tungstenite",
-]
-
-[[package]]
-name = "tokio-tungstenite-wasm"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e21a5c399399c3db9f08d8297ac12b500e86bca82e930253fdc62eaf9c0de6ae"
-dependencies = [
- "futures-channel",
- "futures-util",
- "http 1.3.1",
- "httparse",
- "js-sys",
- "thiserror 1.0.69",
- "tokio",
- "tokio-tungstenite",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "tokio-util"
-version = "0.7.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66a539a9ad6d5d281510d5bd368c973d636c02dbf8a67300bfb6b950696ad7df"
-dependencies = [
- "bytes",
- "futures-core",
- "futures-sink",
- "futures-util",
- "hashbrown 0.15.4",
- "pin-project-lite",
- "slab",
- "tokio",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.6.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
-
-[[package]]
-name = "toml_edit"
-version = "0.22.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
-dependencies = [
- "indexmap",
- "toml_datetime",
- "winnow",
-]
-
-[[package]]
-name = "tower"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
-dependencies = [
- "futures-core",
- "futures-util",
- "pin-project-lite",
- "sync_wrapper",
- "tokio",
- "tower-layer",
- "tower-service",
-]
-
-[[package]]
-name = "tower-http"
-version = "0.6.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
-dependencies = [
- "bitflags 2.9.1",
- "bytes",
- "futures-util",
- "http 1.3.1",
- "http-body",
- "iri-string",
- "pin-project-lite",
- "tower",
- "tower-layer",
- "tower-service",
-]
-
-[[package]]
-name = "tower-layer"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
-
-[[package]]
-name = "tower-service"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
-
-[[package]]
-name = "tracing"
-version = "0.1.41"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
-dependencies = [
- "log",
- "pin-project-lite",
- "tracing-attributes",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-attributes"
-version = "0.1.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "tracing-core"
-version = "0.1.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
-dependencies = [
- "once_cell",
- "valuable",
-]
-
-[[package]]
-name = "tracing-futures"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
-dependencies = [
- "pin-project",
- "tracing",
-]
-
-[[package]]
-name = "tracing-log"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
-dependencies = [
- "log",
- "once_cell",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-subscriber"
-version = "0.3.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
-dependencies = [
- "matchers",
- "nu-ansi-term",
- "once_cell",
- "regex",
- "sharded-slab",
- "smallvec",
- "thread_local",
- "tracing",
- "tracing-core",
- "tracing-log",
-]
-
-[[package]]
-name = "tracing-test"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "557b891436fe0d5e0e363427fc7f217abf9ccd510d5136549847bdcbcd011d68"
-dependencies = [
- "tracing-core",
- "tracing-subscriber",
- "tracing-test-macro",
-]
-
-[[package]]
-name = "tracing-test-macro"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568"
-dependencies = [
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "trait-set"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b79e2e9c9ab44c6d7c20d5976961b47e8f49ac199154daa514b77cd1ab536625"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "transpose"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
-dependencies = [
- "num-integer",
- "strength_reduce",
-]
-
-[[package]]
-name = "try-lock"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
-
-[[package]]
-name = "tungstenite"
-version = "0.24.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
-dependencies = [
- "byteorder",
- "bytes",
- "data-encoding",
- "http 1.3.1",
- "httparse",
- "log",
- "rand 0.8.5",
- "sha1",
- "thiserror 1.0.69",
- "utf-8",
-]
-
-[[package]]
-name = "typenum"
-version = "1.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
-
-[[package]]
-name = "ucd-parse"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06ff81122fcbf4df4c1660b15f7e3336058e7aec14437c9f85c6b31a0f279b9"
-dependencies = [
- "regex-lite",
-]
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
-
-[[package]]
-name = "uint"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52"
-dependencies = [
- "byteorder",
- "crunchy",
- "hex",
- "static_assertions",
-]
-
-[[package]]
-name = "unarray"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
-
-[[package]]
-name = "universal-hash"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
-dependencies = [
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "untrusted"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
-
-[[package]]
-name = "unty"
-version = "0.0.4"
+name = "anyhow"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
-name = "ureq"
-version = "2.12.1"
+name = "autocfg"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
-dependencies = [
- "base64",
- "log",
- "once_cell",
- "rustls",
- "rustls-pki-types",
- "url",
- "webpki-roots 0.26.11",
-]
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
-name = "url"
-version = "2.5.4"
+name = "bincode"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
 dependencies = [
- "form_urlencoded",
- "idna",
- "percent-encoding",
+ "bincode_derive",
  "serde",
+ "unty",
 ]
 
 [[package]]
-name = "utf-8"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
-
-[[package]]
-name = "utf8_iter"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
-
-[[package]]
-name = "uuid"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cf4199d1e5d15ddd86a694e4d0dffa9c323ce759fea589f00fef9d81cc1931d"
-dependencies = [
- "getrandom 0.3.3",
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "valuable"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "virtue"
-version = "0.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
-
-[[package]]
-name = "wait-timeout"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "walkdir"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
-dependencies = [
- "same-file",
- "winapi-util",
-]
-
-[[package]]
-name = "want"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
-dependencies = [
- "try-lock",
-]
-
-[[package]]
-name = "wasi"
-version = "0.11.1+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
-
-[[package]]
-name = "wasi"
-version = "0.14.2+wasi-0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
-dependencies = [
- "wit-bindgen-rt",
-]
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
-dependencies = [
- "cfg-if",
- "once_cell",
- "rustversion",
- "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
-dependencies = [
- "bumpalo",
- "log",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-futures"
-version = "0.4.50"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
-dependencies = [
- "cfg-if",
- "js-sys",
- "once_cell",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+name = "bincode_derive"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
+ "virtue",
 ]
 
 [[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.100"
+name = "crossbeam-deque"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
 dependencies = [
- "unicode-ident",
+ "crossbeam-epoch",
+ "crossbeam-utils",
 ]
 
 [[package]]
-name = "wasm-streams"
-version = "0.4.2"
+name = "crossbeam-epoch"
+version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
- "futures-util",
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
+ "crossbeam-utils",
 ]
 
 [[package]]
-name = "web-sys"
-version = "0.3.77"
+name = "crossbeam-utils"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
-name = "web-time"
-version = "1.1.0"
+name = "crunchy"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
-name = "webpki-roots"
-version = "0.26.11"
+name = "either"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
-dependencies = [
- "webpki-roots 1.0.2",
-]
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
-name = "webpki-roots"
+name = "equivalent"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e8983c3ab33d6fb807cfcdad2491c4ea8cbc8ed839181c7dfd9c67c83e261b2"
-dependencies = [
- "rustls-pki-types",
-]
-
-[[package]]
-name = "widestring"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd7cf3379ca1aac9eea11fba24fd7e315d621f8dfe35c8d7d2be8b793726e07d"
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
+name = "hashbrown"
+version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
 
 [[package]]
-name = "winapi-util"
-version = "0.1.9"
+name = "indexmap"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
 dependencies = [
- "windows-sys 0.59.0",
+ "equivalent",
+ "hashbrown",
+ "rayon",
 ]
 
 [[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows"
-version = "0.59.0"
+name = "itertools"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f919aee0a93304be7f62e8e5027811bbba96bcb1de84d6618be56e43f8a32a1"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
 dependencies = [
- "windows-core 0.59.0",
- "windows-targets 0.53.2",
+ "either",
 ]
 
 [[package]]
-name = "windows"
-version = "0.61.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+name = "ix_rs"
+version = "0.1.0"
 dependencies = [
- "windows-collections",
- "windows-core 0.61.2",
- "windows-future",
- "windows-link",
- "windows-numerics",
+ "anyhow",
+ "indexmap",
+ "multi-stark",
+ "rayon",
+ "rustc-hash",
+ "tiny-keccak",
 ]
 
 [[package]]
-name = "windows-collections"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+name = "multi-stark"
+version = "0.1.0"
+source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=f3017f7f1ad5f3e3149b552e188e9f9e09370a97#f3017f7f1ad5f3e3149b552e188e9f9e09370a97"
 dependencies = [
- "windows-core 0.61.2",
+ "bincode",
+ "p3-air",
+ "p3-challenger",
+ "p3-commit",
+ "p3-dft",
+ "p3-field",
+ "p3-fri",
+ "p3-goldilocks",
+ "p3-keccak",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-merkle-tree",
+ "p3-symmetric",
+ "p3-util",
+ "serde",
 ]
 
 [[package]]
-name = "windows-core"
-version = "0.59.0"
+name = "num-bigint"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "810ce18ed2112484b0d4e15d022e5f598113e220c53e373fb31e67e21670c1ce"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
- "windows-implement 0.59.0",
- "windows-interface",
- "windows-result",
- "windows-strings 0.3.1",
- "windows-targets 0.53.2",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
-name = "windows-core"
-version = "0.61.2"
+name = "num-integer"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "windows-implement 0.60.0",
- "windows-interface",
- "windows-link",
- "windows-result",
- "windows-strings 0.4.2",
+ "num-traits",
 ]
 
 [[package]]
-name = "windows-future"
-version = "0.2.1"
+name = "num-traits"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
- "windows-core 0.61.2",
- "windows-link",
- "windows-threading",
+ "autocfg",
 ]
 
 [[package]]
-name = "windows-implement"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83577b051e2f49a058c308f17f273b570a6a758386fc291b5f6a934dd84e48c1"
+name = "p3-air"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
+ "p3-field",
+ "p3-matrix",
 ]
 
 [[package]]
-name = "windows-implement"
-version = "0.60.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+name = "p3-challenger"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
+ "p3-field",
+ "p3-maybe-rayon",
+ "p3-symmetric",
+ "p3-util",
+ "tracing",
 ]
 
 [[package]]
-name = "windows-interface"
-version = "0.59.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+name = "p3-commit"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
+ "itertools",
+ "p3-challenger",
+ "p3-dft",
+ "p3-field",
+ "p3-matrix",
+ "p3-util",
+ "serde",
 ]
 
 [[package]]
-name = "windows-link"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
-
-[[package]]
-name = "windows-numerics"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+name = "p3-dft"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-core 0.61.2",
- "windows-link",
+ "itertools",
+ "p3-field",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-util",
+ "tracing",
 ]
 
 [[package]]
-name = "windows-result"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+name = "p3-field"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-link",
+ "itertools",
+ "num-bigint",
+ "p3-maybe-rayon",
+ "p3-util",
+ "paste",
+ "rand",
+ "serde",
+ "tracing",
 ]
 
 [[package]]
-name = "windows-strings"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87fa48cc5d406560701792be122a10132491cff9d0aeb23583cc2dcafc847319"
+name = "p3-fri"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-link",
+ "itertools",
+ "p3-challenger",
+ "p3-commit",
+ "p3-dft",
+ "p3-field",
+ "p3-interpolation",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-util",
+ "rand",
+ "serde",
+ "tracing",
 ]
 
 [[package]]
-name = "windows-strings"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+name = "p3-goldilocks"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-link",
+ "num-bigint",
+ "p3-dft",
+ "p3-field",
+ "p3-mds",
+ "p3-poseidon2",
+ "p3-symmetric",
+ "p3-util",
+ "paste",
+ "rand",
+ "serde",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+name = "p3-interpolation"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-targets 0.48.5",
+ "p3-field",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-util",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+name = "p3-keccak"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-targets 0.52.6",
+ "p3-field",
+ "p3-symmetric",
+ "p3-util",
+ "tiny-keccak",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+name = "p3-matrix"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-targets 0.52.6",
+ "itertools",
+ "p3-field",
+ "p3-maybe-rayon",
+ "p3-util",
+ "rand",
+ "serde",
+ "tracing",
+ "transpose",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+name = "p3-maybe-rayon"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-targets 0.53.2",
+ "rayon",
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+name = "p3-mds"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
+ "p3-dft",
+ "p3-field",
+ "p3-symmetric",
+ "p3-util",
+ "rand",
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+name = "p3-merkle-tree"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
+ "itertools",
+ "p3-commit",
+ "p3-field",
+ "p3-matrix",
+ "p3-maybe-rayon",
+ "p3-symmetric",
+ "p3-util",
+ "rand",
+ "serde",
+ "tracing",
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.53.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
+name = "p3-poseidon2"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows_aarch64_gnullvm 0.53.0",
- "windows_aarch64_msvc 0.53.0",
- "windows_i686_gnu 0.53.0",
- "windows_i686_gnullvm 0.53.0",
- "windows_i686_msvc 0.53.0",
- "windows_x86_64_gnu 0.53.0",
- "windows_x86_64_gnullvm 0.53.0",
- "windows_x86_64_msvc 0.53.0",
+ "p3-field",
+ "p3-mds",
+ "p3-symmetric",
+ "p3-util",
+ "rand",
 ]
 
 [[package]]
-name = "windows-threading"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+name = "p3-symmetric"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
 dependencies = [
- "windows-link",
+ "itertools",
+ "p3-field",
+ "serde",
 ]
 
 [[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+name = "p3-util"
+version = "0.3.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d#e9ab5a4b3d39c3a03de7d32dabd63dbfb310f74d"
+dependencies = [
+ "serde",
+]
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.0"
+name = "paste"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
-name = "winnow"
-version = "0.7.12"
+name = "pin-project-lite"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
-dependencies = [
- "memchr",
-]
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
-name = "winreg"
-version = "0.50.0"
+name = "proc-macro2"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
- "cfg-if",
- "windows-sys 0.48.0",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "wit-bindgen-rt"
-version = "0.39.0"
+name = "quote"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
 dependencies = [
- "bitflags 2.9.1",
+ "proc-macro2",
 ]
 
 [[package]]
-name = "wmi"
-version = "0.14.5"
+name = "rand"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7787dacdd8e71cbc104658aade4009300777f9b5fda6a75f19145fedb8a18e71"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
- "chrono",
- "futures",
- "log",
- "serde",
- "thiserror 2.0.12",
- "windows 0.59.0",
- "windows-core 0.59.0",
+ "rand_core",
 ]
 
 [[package]]
-name = "writeable"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
+name = "rand_core"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 
 [[package]]
-name = "x509-parser"
-version = "0.16.0"
+name = "rayon"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcbc162f30700d6f3f82a24bf7cc62ffe7caea42c0b2cba8bf7f3ae50cf51f69"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
- "asn1-rs",
- "data-encoding",
- "der-parser",
- "lazy_static",
- "nom",
- "oid-registry",
- "rusticata-macros",
- "thiserror 1.0.69",
- "time",
+ "either",
+ "rayon-core",
 ]
 
 [[package]]
-name = "xml-rs"
-version = "0.8.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fd8403733700263c6eb89f192880191f1b83e332f7a20371ddcf421c4a337c7"
-
-[[package]]
-name = "xmltree"
-version = "0.10.3"
+name = "rayon-core"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7d8a75eaf6557bb84a65ace8609883db44a29951042ada9b393151532e41fcb"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
- "xml-rs",
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
-name = "yasna"
-version = "0.5.2"
+name = "rustc-hash"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd"
-dependencies = [
- "time",
-]
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
-name = "yoke"
-version = "0.8.0"
+name = "serde"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
 dependencies = [
- "serde",
- "stable_deref_trait",
- "yoke-derive",
- "zerofrom",
+ "serde_derive",
 ]
 
 [[package]]
-name = "yoke-derive"
-version = "0.8.0"
+name = "serde_derive"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.104",
- "synstructure",
+ "syn",
 ]
 
 [[package]]
-name = "z32"
-version = "1.3.0"
+name = "strength_reduce"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2164e798d9e3d84ee2c91139ace54638059a3b23e361f5c11781c2c6459bde0f"
+checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
 
 [[package]]
-name = "zerocopy"
-version = "0.8.26"
+name = "syn"
+version = "2.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
 dependencies = [
- "zerocopy-derive",
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "zerocopy-derive"
-version = "0.8.26"
+name = "tiny-keccak"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
+ "crunchy",
 ]
 
 [[package]]
-name = "zerofrom"
-version = "0.1.6"
+name = "tracing"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
- "zerofrom-derive",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
 ]
 
 [[package]]
-name = "zerofrom-derive"
-version = "0.1.6"
+name = "tracing-attributes"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.104",
- "synstructure",
+ "syn",
 ]
 
 [[package]]
-name = "zeroize"
-version = "1.8.1"
+name = "tracing-core"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
-dependencies = [
- "zeroize_derive",
-]
+checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
 
 [[package]]
-name = "zeroize_derive"
-version = "1.4.2"
+name = "transpose"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
+checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
+ "num-integer",
+ "strength_reduce",
 ]
 
 [[package]]
-name = "zerotrie"
-version = "0.2.2"
+name = "unicode-ident"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
-dependencies = [
- "displaydoc",
- "yoke",
- "zerofrom",
-]
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
-name = "zerovec"
-version = "0.11.2"
+name = "unty"
+version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428"
-dependencies = [
- "yoke",
- "zerofrom",
- "zerovec-derive",
-]
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
 
 [[package]]
-name = "zerovec-derive"
-version = "0.11.1"
+name = "virtue"
+version = "0.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
diff --git a/Cargo.toml b/Cargo.toml
index b04f4e39..197b6c12 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,32 +8,18 @@ crate-type = ["staticlib"]
 
 [dependencies]
 anyhow = "1"
-array-util = "1.0.2"
-binius_core = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-binius_circuits = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-binius_field = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-binius_macros = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-binius_maybe_rayon = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-binius_math = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-binius_hal = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-binius_hash = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-binius_utils = { git = "https://github.com/IrreducibleOSS/binius.git", rev = "2326ae9b78a9679eeed86d30188a9bcc5eea55e0" }
-bumpalo = "3"
-groestl_crypto = { package = "groestl", version = "0.10.1" }
-proptest = "1"
 multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "f3017f7f1ad5f3e3149b552e188e9f9e09370a97" }
-rayon = "1.7.0"
-rand = "0.9.1"
+rayon = "1"
 rustc-hash = "2"
 indexmap = { version = "2", features = ["rayon"] }
-bytes = "1.10.1"
-tiny-keccak = { version = "2.0.2", features = ["keccak"] }
+tiny-keccak = { version = "2", features = ["keccak"] }
 
-[target.'cfg(not(all(target_os = "macos", target_arch = "aarch64")))'.dependencies]
-iroh = "0.34.0"
-tokio = "1.44.1"
-iroh-base = "0.34.0"
-iroh-blobs = { version = "0.34.0", features = ["rpc"] }
+# bytes = "1.10.1"
+# [target.'cfg(not(all(target_os = "macos", target_arch = "aarch64")))'.dependencies]
+# iroh = "0.34.0"
+# tokio = "1.44.1"
+# iroh-base = "0.34.0"
+# iroh-blobs = { version = "0.34.0", features = ["rpc"] }
 
 [features]
 parallel = ["multi-stark/parallel"]
diff --git a/Ix/Aiur/Bytecode.lean b/Ix/Aiur/Bytecode.lean
index 3ec4713c..5042c1ec 100644
--- a/Ix/Aiur/Bytecode.lean
+++ b/Ix/Aiur/Bytecode.lean
@@ -1,636 +1,62 @@
-import Std.Data.HashMap
-import Ix.Aiur.Term
-import Ix.Aiur.Gadget
+import Ix.Aiur.Goldilocks
 
-open Std
+namespace Aiur
+
+namespace Bytecode
 
-abbrev Name := Aiur.Global
+abbrev FunIdx := Nat
 abbrev ValIdx := Nat
 abbrev SelIdx := Nat
-abbrev FuncIdx := Nat
-abbrev MemIdx := Nat
-abbrev GadgetIdx := Nat
-
-def Std.HashMap.get' [Inhabited β] [BEq α] [Hashable α] [Repr α] (m : HashMap α β) (a : α) : β :=
-  match m.get? a with
-  | .some b => b
-  | .none => panic! s!"could not find key `{(repr a).pretty}`"
 
-def List.get' [Inhabited A] (as : List A) (n : Nat) : A :=
-  match as[n]? with
-  | .some a => a
-  | .none => panic! s!"index {n} out of bounds {as.length}"
-
-def Array.get' [Inhabited A] (as : Array A) (n : Nat) : A :=
-  match as[n]? with
-  | .some a => a
-  | .none => panic! s!"index {n} out of bounds {as.size}"
-
-namespace Aiur.Bytecode
-
-inductive Op where
-  | prim : Primitive → Op
+inductive Op
+  | const : G → Op
   | add : ValIdx → ValIdx → Op
   | sub : ValIdx → ValIdx → Op
   | mul : ValIdx → ValIdx → Op
-  | xor : ValIdx → ValIdx → Op
-  | and : ValIdx → ValIdx → Op
-  | lt: ValIdx → ValIdx → Op
+  | call : FunIdx → Array ValIdx → (outputSize : Nat) → Op
   | store : Array ValIdx → Op
-  | load : MemIdx → ValIdx → Op
-  | call : FuncIdx → Array ValIdx → Nat → Op
-  | dynCall : ValIdx → Array ValIdx → ValIdx → Op
-  | preimg : FuncIdx → Array ValIdx → ValIdx → Op
-  | dynPreimg : ValIdx → Array ValIdx → ValIdx → Op
-  | ffi : GadgetIdx → Array ValIdx → Nat → Op
-  | trace : String → Array ValIdx → Op
-  deriving Repr, Inhabited
+  | load : (size : Nat) → ValIdx → Op
+  deriving Repr
 
 mutual
   inductive Ctrl where
-    | if : ValIdx → Block → Block → Ctrl
-    | match : ValIdx → List (UInt64 × Block) -> Option Block → Ctrl
-    | ret : SelIdx → Array ValIdx → Ctrl
-    deriving Repr, Inhabited
+    | match : ValIdx → Array (G × Block) → Option Block → Ctrl
+    | return : SelIdx → Array ValIdx → Ctrl
+    deriving Inhabited, Repr
 
   structure Block where
     ops : Array Op
     ctrl : Ctrl
-    returnIdents : SelIdx × SelIdx
-    deriving Repr, Inhabited
+    minSelIncluded: SelIdx
+    maxSelExcluded: SelIdx
+    deriving Inhabited, Repr
 end
 
-structure Function where
-  name : Name
-  inputSize : Nat
-  outputSize : Nat
-  body : Block
-  deriving Repr, Inhabited
-
-end Bytecode
-
-namespace Circuit
-
-/--
-The circuit layout of a function.
-
-`selectors` are bit values that identify which path the computation
-took. Exactly one selector must be set.
-
-`u*Auxiliaries` represent registers that hold temporary values
-and can be shared by different circuit paths, since they never
-overlap.
-
-`sharedConstraints` are constraint slots that can be shared in
-different paths of the circuit.
--/
-structure Layout where
-  inputs : Nat
-  outputs : Nat
-  selectors : Nat
-  u1Auxiliaries : Nat
-  u8Auxiliaries : Nat
-  u64Auxiliaries : Nat
-  sharedConstraints : Nat
-  deriving Repr, Inhabited
-
-structure SharedData where
-  u1Auxiliaries : Nat
-  u8Auxiliaries : Nat
-  u64Auxiliaries : Nat
-  constraints : Nat
-
-def SharedData.maximals (a b : SharedData) : SharedData := {
-  u1Auxiliaries := a.u1Auxiliaries.max b.u1Auxiliaries
-  u8Auxiliaries := a.u8Auxiliaries.max b.u8Auxiliaries
-  u64Auxiliaries := a.u64Auxiliaries.max b.u64Auxiliaries
-  constraints := a.constraints.max b.constraints
-}
-
-@[inline] def Layout.init (inputs outputs : Nat) : Layout :=
-  ⟨inputs, outputs, 0, 0, 0, 0, 0⟩
-
-structure LayoutMState where
-  layout : Layout
-  memWidths : Array Nat
-
-abbrev LayoutM := StateM LayoutMState
-
-@[inline] def bumpSelectors : LayoutM Unit :=
-  modify fun stt => { stt with
-    layout := { stt.layout with selectors := stt.layout.selectors + 1 } }
-
-@[inline] def bumpSharedConstraints (n : Nat) : LayoutM Unit :=
-  modify fun stt => { stt with
-    layout := { stt.layout with sharedConstraints := stt.layout.sharedConstraints + n } }
-
-@[inline] def bumpU1Auxiliaries : LayoutM Unit :=
-  modify fun stt => { stt with
-    layout := { stt.layout with u1Auxiliaries := stt.layout.u1Auxiliaries + 1 } }
-
-@[inline] def bumpU64Auxiliaries (n : Nat) : LayoutM Unit :=
-  modify fun stt => { stt with
-    layout := { stt.layout with u64Auxiliaries := stt.layout.u64Auxiliaries + n } }
-
-@[inline] def addMemWidth (memWidth : Nat) : LayoutM Unit :=
-  modify fun stt =>
-    let memWidths := if stt.memWidths.contains memWidth
-      then stt.memWidths
-      else stt.memWidths.push memWidth
-    { stt with memWidths }
-
-def getSharedData : LayoutM SharedData := do
-  let stt ← get
-  pure {
-    u1Auxiliaries := stt.layout.u1Auxiliaries
-    u8Auxiliaries := stt.layout.u8Auxiliaries
-    u64Auxiliaries := stt.layout.u64Auxiliaries
-    constraints := stt.layout.sharedConstraints
-  }
-
-def setSharedData (sharedData : SharedData) : LayoutM Unit :=
-  modify fun stt => { stt with layout := { stt.layout with
-    u1Auxiliaries := sharedData.u1Auxiliaries
-    u8Auxiliaries := sharedData.u8Auxiliaries
-    u64Auxiliaries := sharedData.u64Auxiliaries
-    sharedConstraints := sharedData.constraints } }
-
-def opLayout : Bytecode.Op → LayoutM Unit
-  | .prim _ | .xor .. => pure ()
-  | .and .. => do
-    -- `and` is achieved by multiplication. Since we do not want
-    -- expressions of order greater than 1, we create a new auxiliary
-    -- and constrain it to be equal to the product of the two expressions
-    bumpSharedConstraints 1
-    bumpU1Auxiliaries
-  | .add .. | .lt .. | .sub .. => do
-    -- Uses the addition gadget which outputs 8 bytes of sum
-    -- plus 1 byte of carry
-    bumpU64Auxiliaries 1
-    bumpU1Auxiliaries
-  | .mul .. => do
-    -- Uses the multiplication gadget which outputs 8 bytes
-    bumpU64Auxiliaries 1
-  | .store values => do
-    addMemWidth values.size
-    -- Outputs a pointer and a require hint
-    bumpU64Auxiliaries 2
-  | .load len _ => do
-    addMemWidth len
-    -- Outputs the loaded values and a require hint
-    bumpU64Auxiliaries (len + 1)
-  | .call _ _ outSize =>
-    -- Outputs the call values and a require hint
-    bumpU64Auxiliaries (outSize + 1)
-  | .ffi _ _ outSize =>
-    -- Outputs the ffi values and a require hint
-    bumpU64Auxiliaries (outSize + 1)
-  | _ => panic! "TODO"
-
-partial def blockLayout (block : Bytecode.Block) : LayoutM Unit := do
-  block.ops.forM opLayout
-  match block.ctrl with
-  | .if _ tt ff =>
-    let initSharedData ← getSharedData
-    -- This auxiliary is for proving inequality
-    bumpU64Auxiliaries 1
-    blockLayout tt
-    let ttSharedData ← getSharedData
-    setSharedData initSharedData
-    blockLayout ff
-    let ffSharedData ← getSharedData
-    setSharedData $ ttSharedData.maximals ffSharedData
-  | .match _ branches defaultBranch =>
-    let initSharedData ← getSharedData
-    let mut maximalSharedData := initSharedData
-    for (_, block) in branches do
-      setSharedData initSharedData
-      -- This auxiliary is for proving inequality
-      bumpU64Auxiliaries 1
-      blockLayout block
-      let blockSharedData ← getSharedData
-      maximalSharedData := maximalSharedData.maximals blockSharedData
-    if let some defaultBlock := defaultBranch then
-      setSharedData initSharedData
-      blockLayout defaultBlock
-      let defaultBlockSharedData ← getSharedData
-      maximalSharedData := maximalSharedData.maximals defaultBlockSharedData
-    setSharedData maximalSharedData
-  | .ret _ out =>
-    -- One selector per return
-    bumpSelectors
-    -- Each output must equal its respective return variable,
-    -- thus one constraint per return variable
-    bumpSharedConstraints out.size
-
-def functionLayout (function : Bytecode.Function) : LayoutMState :=
-  let initLayout :=  (Layout.init function.inputSize function.outputSize)
-  let (_, stt) := blockLayout function.body |>.run ⟨initLayout, #[]⟩
-  stt
-
-end Circuit
-
-namespace Bytecode
-
-structure DataTypeLayout where
-  size: Nat
-  deriving Repr, Inhabited
-
+/-- The circuit layout of a function -/
 structure FunctionLayout where
-  index: Nat
   inputSize : Nat
   outputSize : Nat
-  offsets: Array Nat
-  deriving Repr, Inhabited
-
-structure ConstructorLayout where
-  index: Nat
-  size: Nat
-  offsets: Array Nat
-  deriving Repr, Inhabited
-
-structure GadgetLayout where
-  index : Nat
-  outputSize : Nat
-  deriving Repr, Inhabited
-
-inductive Layout
-  | dataType : DataTypeLayout → Layout
-  | function : FunctionLayout → Layout
-  | constructor : ConstructorLayout → Layout
-  | gadget : GadgetLayout → Layout
-  deriving Repr, Inhabited
+  /-- Bit values that identify which path the computation took.
+    Exactly one selector must be set. -/
+  selectors : Nat
+  /-- Represent registers that hold temporary values and can be shared by
+    different circuit paths, since they never overlap. -/
+  auxiliaries : Nat
+  /-- Lookups can be shared across calls, stores, loads and returns from
+    different paths. -/
+  lookups : Nat
+  deriving Inhabited, Repr
 
-abbrev LayoutMap := HashMap Global Layout
+structure Function where
+  body : Block
+  layout: FunctionLayout
+  deriving Inhabited, Repr
 
 structure Toplevel where
   functions : Array Function
-  memWidths : Array Nat
-  layouts : Array Circuit.Layout
-  gadgets : Array Gadget
-  deriving Repr, Inhabited
+  memorySizes : Array Nat
+  deriving Repr
 
-end Aiur.Bytecode
-
-namespace Aiur
-
-structure CompilerState where
-  index : ValIdx
-  ops : Array Bytecode.Op
-  returnIdent : SelIdx
-  deriving Repr, Inhabited
-
-def pushOp (op : Bytecode.Op) (size : Nat := 1) : StateM CompilerState (Array ValIdx) :=
-  modifyGet (fun s =>
-    let index := s.index
-    let ops := s.ops
-    (Array.range' index size, { s with index := index + size, ops := ops.push op}))
-
-def extractOps : StateM CompilerState (Array Bytecode.Op) :=
-  modifyGet (fun s => (s.ops, {s with ops := #[]}))
-
-def typSize (layoutMap : Bytecode.LayoutMap) : Typ → Nat
-| Typ.primitive .. => 1
-| Typ.pointer .. => 1
-| Typ.function .. => 1
-| Typ.tuple ts => ts.foldl (init := 0) (fun acc t => acc + typSize layoutMap t)
-| Typ.dataType g => match layoutMap.get' g with
-  | .dataType layout => layout.size
-  | _ => unreachable!
-
-partial def toIndex
- (layoutMap : Bytecode.LayoutMap)
- (bindings : HashMap Local (Array ValIdx))
- (term : TypedTerm) : StateM CompilerState (Array ValIdx) :=
-  let typ := term.typ.unwrap
-  match term.inner with
-  | .ret .. => panic! "should not happen after typechecking"
-  | .match .. => panic! "non-tail `match` not yet implemented"
-  | .if .. => panic! "non-tail `if` not yet implemented"
-  | .var name => do
-    pure (bindings.get' name)
-  | .ref name => match layoutMap.get' name with
-    | .function layout => do
-      pushOp (Bytecode.Op.prim (Primitive.u64 layout.index.toUInt64))
-    | .constructor layout => do
-      let size := layout.size
-      let index ← pushOp (Bytecode.Op.prim (Primitive.u64 layout.index.toUInt64))
-      if index.size < size then
-        let padding := (← pushOp (Bytecode.Op.prim (Primitive.u64 0)))[0]!
-        pure $ index ++ Array.mkArray (size - index.size) padding
-      else
-        pure index
-    | _ => panic! "should not happen after typechecking"
-  | .data (.primitive p) => do
-    pushOp (Bytecode.Op.prim p)
-  | .data (.tuple args) =>
-      -- TODO use `buildArgs`
-      let append arg acc := do
-        pure (acc.append (← toIndex layoutMap bindings arg))
-      args.foldrM (init := #[]) append
-  | .let (.var var) val bod => do
-    let val ← toIndex layoutMap bindings val
-    toIndex layoutMap (bindings.insert var val) bod
-  | .let .. => panic! "should not happen after simplifying"
-  | .xor a b => do
-    let a ← toIndex layoutMap bindings a
-    assert! (a.size == 1)
-    let b ← toIndex layoutMap bindings b
-    assert! (b.size == 1)
-    pushOp (.xor (a.get' 0) (b.get' 0))
-  | .addU64 a b => do
-    let a ← toIndex layoutMap bindings a
-    assert! (a.size == 1)
-    let b ← toIndex layoutMap bindings b
-    assert! (b.size == 1)
-    pushOp (.add (a.get' 0) (b.get' 0))
-  | .subU64 a b => do
-    let a ← toIndex layoutMap bindings a
-    assert! (a.size == 1)
-    let b ← toIndex layoutMap bindings b
-    assert! (b.size == 1)
-    pushOp (.sub (a.get' 0) (b.get' 0))
-  | .mulU64 a b => do
-    let a ← toIndex layoutMap bindings a
-    assert! (a.size == 1)
-    let b ← toIndex layoutMap bindings b
-    assert! (b.size == 1)
-    pushOp (.mul (a.get' 0) (b.get' 0))
-  | .and a b => do
-    let a ← toIndex layoutMap bindings a
-    assert! (a.size == 1)
-    let b ← toIndex layoutMap bindings b
-    assert! (b.size == 1)
-    pushOp (.and (a.get' 0) (b.get' 0))
-  | .app name@(⟨.str .anonymous unqualifiedName⟩) args =>
-    match bindings.get? (.str unqualifiedName) with
-    | some _ => panic! "dynamic calls not yet implemented"
-    | none => match layoutMap.get' name with
-      | .function layout => do
-        let args ← buildArgs args
-        pushOp (Bytecode.Op.call layout.index args layout.outputSize) layout.outputSize
-      | .constructor layout => do
-        let size := layout.size
-        let index ← pushOp (Bytecode.Op.prim (Primitive.u64 layout.index.toUInt64))
-        let index ← buildArgs args index
-        if index.size < size then
-          let padding := (← pushOp (Bytecode.Op.prim (Primitive.u64 0)))[0]!
-          pure $ index ++ Array.mkArray (size - index.size) padding
-        else
-          pure index
-      | _ => panic! "should not happen after typechecking"
-  | .app name args => match layoutMap.get' name with
-    | .function layout => do
-      let args ← buildArgs args
-      pushOp (Bytecode.Op.call layout.index args layout.outputSize) layout.outputSize
-    | .constructor layout => do
-      let size := layout.size
-      let index ← pushOp (Bytecode.Op.prim (Primitive.u64 layout.index.toUInt64))
-      let index ← buildArgs args index
-      if index.size < size then
-        let padding := (← pushOp (Bytecode.Op.prim (Primitive.u64 0)))[0]!
-        pure $ index ++ Array.mkArray (size - index.size) padding
-      else
-        pure index
-    | _ => panic! "should not happen after typechecking"
-  | .preimg name@(⟨.str .anonymous unqualifiedName⟩) out =>
-    match bindings.get? (.str unqualifiedName) with
-    | some _ => panic! "dynamic preimage not yet implemented"
-    | none => match layoutMap.get' name with
-      | .function layout => do
-        let out ← toIndex layoutMap bindings out
-        pushOp (Bytecode.Op.preimg layout.index out layout.inputSize) layout.inputSize
-      | _ => panic! "should not happen after typechecking"
-  | .preimg name out => match layoutMap.get' name with
-    | .function layout => do
-      let out ← toIndex layoutMap bindings out
-      pushOp (Bytecode.Op.preimg layout.index out layout.inputSize) layout.inputSize
-    | _ => panic! "should not happen after typechecking"
-  | .ffi name args => match layoutMap.get' name with
-    | .gadget layout => do
-      let args ← buildArgs args
-      pushOp (Bytecode.Op.ffi layout.index args layout.outputSize) layout.outputSize
-    | _ => panic! "should not happen after typechecking"
-  | .get arg i => do
-    let typs := (match arg.typ with
-      | .evaluates (.tuple typs) => typs
-      | _ => panic! "should not happen after typechecking")
-    let offset := (typs.extract 0 i).foldl (init := 0)
-      fun acc typ => typSize layoutMap typ + acc
-    let arg ← toIndex layoutMap bindings arg
-    let length := typSize layoutMap typ
-    pure $ arg.extract offset (offset + length)
-  | .slice arg i j => do
-    let typs := (match arg.typ with
-      | .evaluates (.tuple typs) => typs
-      | _ => panic! "should not happen after typechecking")
-    let offset := (typs.extract 0 i).foldl (init := 0)
-      fun acc typ => typSize layoutMap typ + acc
-    let length := (typs.extract i j).foldl (init := 0)
-      fun acc typ => typSize layoutMap typ + acc
-    let arg ← toIndex layoutMap bindings arg
-    pure $ arg.extract offset (offset + length)
-  | .store arg => do
-    let arg ← toIndex layoutMap bindings arg
-    pushOp (Bytecode.Op.store arg)
-  | .load ptr => do
-    let size := match ptr.typ.unwrap with
-    | .pointer typ => typSize layoutMap typ
-    | _ => unreachable!
-    let ptr ← toIndex layoutMap bindings ptr
-    assert! (ptr.size == 1)
-    pushOp (Bytecode.Op.load size (ptr.get' 0)) size
-  | .pointerAsU64 ptr => toIndex layoutMap bindings ptr
-  | .trace str expr => do
-    let arr ← toIndex layoutMap bindings expr
-    let op := .trace str arr
-    modify (fun state => { state with ops := state.ops.push op})
-    pure arr
-  where
-    buildArgs (args : List TypedTerm) (init : Array ValIdx := #[]) : StateM CompilerState (Array ValIdx) :=
-      let append acc arg := do
-        pure (acc.append (← toIndex layoutMap bindings arg))
-      args.foldlM (init := init) append
-
-mutual
-
-partial def TypedTerm.compile
- (term : TypedTerm)
- (returnTyp : Typ)
- (layoutMap : Bytecode.LayoutMap)
- (bindings : HashMap Local (Array ValIdx))
-: StateM CompilerState Bytecode.Block := match term.inner with
-  | .let (.var var) val bod => do
-    let val ← toIndex layoutMap bindings val
-    bod.compile returnTyp layoutMap (bindings.insert var val)
-  | .let .. => panic! "should not happen after simplifying"
-  | .match term cases =>
-    match term.typ.unwrapOr returnTyp with
-    -- Also do this for tuple-like (one constructor only) datatypes
-    | .tuple typs => match cases with
-      | [(.tuple vars, branch)] => do
-        let bindArgs bindings pats typs idxs :=
-          let n := pats.size
-          let init := (bindings, 0)
-          let (bindings, _) := (List.range n).foldl (init := init) fun (bindings, offset) i =>
-            let pat := (pats.get' i)
-            let typ := (typs.get' i)
-            match pat with
-            | .var var =>
-              let len := typSize layoutMap typ
-              let new_offset := offset + len
-              (bindings.insert var (idxs.extract offset new_offset), new_offset)
-            | _ => panic! "should not happen after simplification"
-          bindings
-        let idxs ← toIndex layoutMap bindings term
-        let bindings := bindArgs bindings vars typs idxs
-        branch.compile returnTyp layoutMap bindings
-      | _ => unreachable!
-    | _ => do
-      let idxs ← toIndex layoutMap bindings term
-      let ops ← extractOps
-      let initIdent := (← get).returnIdent
-      let (cases, default) ← cases.foldlM (init := ([], .none)) (addCase layoutMap bindings returnTyp idxs)
-      let lastIdent := (← get).returnIdent
-      let ctrl := .match (idxs.get' 0) cases.reverse default
-      pure { ops, ctrl, returnIdents := (initIdent, lastIdent) }
-  | .if b t f => do
-    let b ← toIndex layoutMap bindings b
-    assert! (b.size == 1)
-    let ops ← extractOps
-    let initState ← get
-    let initIdent := initState.returnIdent
-    let t ← t.compile returnTyp layoutMap bindings
-    set { initState with returnIdent := (← get).returnIdent }
-    let f ← f.compile returnTyp layoutMap bindings
-    let lastIdent := (← get).returnIdent
-    pure { ops, ctrl := .if (b.get' 0) t f, returnIdents := (initIdent, lastIdent) }
-  | .ret term => do
-    let idxs ← toIndex layoutMap bindings term
-    let state ← get
-    let state := { state with returnIdent := state.returnIdent + 1 }
-    set state
-    let ops := state.ops
-    let id := state.returnIdent
-    pure { ops, ctrl := .ret (id - 1) idxs, returnIdents := (id - 1, id) }
-  | _ => do
-    let idxs ← toIndex layoutMap bindings term
-    let state ← get
-    let state := { state with returnIdent := state.returnIdent + 1 }
-    set state
-    let ops := state.ops
-    let id := state.returnIdent
-    pure { ops, ctrl := .ret (id - 1) idxs, returnIdents := (id - 1, id) }
-
-partial def addCase
-  (layoutMap : Bytecode.LayoutMap)
-  (bindings : HashMap Local (Array ValIdx))
-  (returnTyp : Typ)
-  (idxs : Array ValIdx)
-: (List (UInt64 × Bytecode.Block) × Option Bytecode.Block) →
-  (Pattern × TypedTerm) →
-  StateM CompilerState (List (UInt64 × Bytecode.Block) × Option Bytecode.Block) := fun (cases, default) (pat, term) =>
-  -- If simplified, only one default will exist, and it will appear at the end of the match
-  assert! default.isNone
-  match pat with
-  | .primitive prim => do
-    let initState ← get
-    let term ← term.compile returnTyp layoutMap bindings
-    set { initState with returnIdent := (← get).returnIdent }
-    let cases' := cases.cons (prim.toU64, term)
-    pure (cases', default)
-  | .ref global pats => do
-    let layout := layoutMap.get' global
-    let (index, offsets) := match layout with
-    | .function layout => (layout.index, layout.offsets)
-    | .constructor layout => (layout.index, layout.offsets)
-    | .dataType _
-    | .gadget _ => panic! "impossible after typechecking"
-    let bindArgs bindings pats offsets idxs :=
-      let n := pats.length
-      let bindings := (List.range n).foldl (init := bindings) fun bindings i =>
-        let pat := (pats.get' i)
-        -- the `+ 1` is to account for the tag
-        let offset := (offsets.get' i) + 1
-        let next_offset := (offsets.get' (i + 1)) + 1
-        match pat with
-        | .var var =>
-          bindings.insert var (idxs.extract offset next_offset)
-        | _ => panic! "should not happen after simplification"
-      bindings
-    let bindings := bindArgs bindings pats offsets idxs
-    let initState ← get
-    let term ← term.compile returnTyp layoutMap bindings
-    set { initState with returnIdent := (← get).returnIdent }
-    let cases' := cases.cons (index.toUInt64, term)
-    pure (cases', default)
-  | .wildcard => do
-    let initState ← get
-    let term ← term.compile returnTyp layoutMap bindings
-    set { initState with returnIdent := (← get).returnIdent }
-    pure (cases, .some term)
-  | _ => unreachable!
-
-end
-
-def TypedFunction.compile (layoutMap : Bytecode.LayoutMap) (f : TypedFunction) : Bytecode.Function :=
-  let (inputSize, outputSize) := match layoutMap.get' f.name with
-  | .function layout => (layout.inputSize, layout.outputSize)
-  | _ => panic! s!"`{f.name}` should be a function"
-  let (index, bindings) := f.inputs.foldl (init := (0, default))
-    (fun (index, bindings) (arg, typ) =>
-      let len := typSize layoutMap typ
-      let indices := Array.range' index len
-      (index + len, bindings.insert arg indices))
-  let state := { index, returnIdent := 0, ops := #[] }
-  let body :=  (f.body.compile f.output layoutMap bindings).run' state
-  { name := f.name, inputSize, outputSize, body }
-
-def TypedDecls.dataTypeLayouts (decls : TypedDecls) : Bytecode.LayoutMap :=
-  let pass := fun (layoutMap, funcIdx, gadgetIdx) (_, v) => match v with
-    | .dataType dataType =>
-      let dataTypeSize := dataType.size decls
-      let layoutMap := layoutMap.insert dataType.name (.dataType { size := dataTypeSize })
-      let pass := fun (acc, index) constructor =>
-        let offsets :=
-          constructor.argTypes.foldl (init := #[0])
-            (fun offsets typ => offsets.push (offsets[offsets.size - 1]! + typ.size decls))
-        let decl := .constructor {
-          size := dataTypeSize,
-          offsets,
-          index,
-        }
-        let name := dataType.name.pushNamespace constructor.nameHead
-        (acc.insert name decl, index + 1)
-      let (layoutMap, _) := dataType.constructors.foldl (init := (layoutMap, 0)) pass
-      (layoutMap, funcIdx, gadgetIdx)
-    | .function function =>
-      let inputSize := function.inputs.foldl (init := 0) (fun acc (_, typ) => acc + typ.size decls)
-      let outputSize := function.output.size decls
-      let offsets :=
-        function.inputs.foldl (init := #[0])
-          (fun offsets (_, typ) => offsets.push (offsets[offsets.size - 1]! + typ.size decls))
-      let layoutMap := layoutMap.insert function.name (.function { index := funcIdx, inputSize, outputSize, offsets })
-      (layoutMap, funcIdx + 1, gadgetIdx)
-    | .constructor .. => (layoutMap, funcIdx, gadgetIdx)
-    | .gadget g =>
-      let layoutMap := layoutMap.insert ⟨g.name⟩ (.gadget ⟨gadgetIdx, g.outputSize⟩)
-      (layoutMap, funcIdx, gadgetIdx + 1)
-  let (layoutMap, _) := decls.foldl pass ({}, 0, 0)
-  layoutMap
-
-def TypedDecls.compile (decls : TypedDecls) : Bytecode.Toplevel :=
-  let layout := decls.dataTypeLayouts
-  let (functions, memWidths, layouts, gadgets) := decls.foldl (init := (#[], #[], #[], #[]))
-    fun acc@(functions, memWidths, layouts, gadgets) (_, decl) => match decl with
-      | .function function =>
-        let compiledFunction := function.compile layout
-        let layoutMState := Circuit.functionLayout compiledFunction
-        let memWidths := layoutMState.memWidths.foldl (init := memWidths) fun memWidths memWidth =>
-          if memWidths.contains memWidth then memWidths else memWidths.push memWidth
-        (functions.push compiledFunction, memWidths, layouts.push layoutMState.layout, gadgets)
-      | .gadget gadget => (functions, memWidths, layouts, gadgets.push gadget)
-      | _ => acc
-  ⟨functions, memWidths.qsort, layouts, gadgets⟩
+end Bytecode
 
 end Aiur
diff --git a/Ix/Aiur/Check.lean b/Ix/Aiur/Check.lean
index 48ba4292..228b9e52 100644
--- a/Ix/Aiur/Check.lean
+++ b/Ix/Aiur/Check.lean
@@ -16,7 +16,7 @@ inductive CheckError
   | typeMismatch : Typ → Typ → CheckError
   | illegalReturn : CheckError
   | nonNumeric : Typ → CheckError
-  | notU64 : Typ → CheckError
+  | notAField : Typ → CheckError
   | wrongNumArgs : Global → Nat → Nat → CheckError
   | notATuple : Typ → CheckError
   | indexOoB : Nat → CheckError
@@ -40,9 +40,7 @@ for functions and datatypes.
 def Toplevel.mkDecls (toplevel : Toplevel) : Except CheckError Decls := do
   let map ← toplevel.functions.foldlM (init := default)
     fun acc function => addDecl acc Function.name .function function
-  let map ← toplevel.dataTypes.foldlM (init := map) addDataType
-  toplevel.gadgets.foldlM (init := map)
-    fun map gadget => addDecl map (Global.mk ∘ Gadget.name) .gadget gadget
+  toplevel.dataTypes.foldlM (init := map) addDataType
 where
   ensureUnique name (map : IndexMap Global _) := do
     if map.containsKey name then throw $ .duplicatedDefinition name
@@ -76,13 +74,6 @@ def refLookup (global : Global) : CheckM Typ := do
   | some _ => throw $ .notAValue global
   | none => throw $ .unboundVariable global
 
-def Primitive.type : Primitive → PrimitiveType
-  | u1 _ => .u1
-  | u8 _ => .u8
-  | u16 _ => .u16
-  | u32 _ => .u32
-  | u64 _ => .u64
-
 /-- Extend context with locally bound variables. -/
 def bindIdents (bindings : List (Local × Typ)) (ctx : CheckContext) : CheckContext :=
   { ctx with varTypes := ctx.varTypes.insertMany bindings }
@@ -120,21 +111,6 @@ partial def inferTerm : Term → CheckM TypedTerm
     let body' ← withReader (bindIdents bindings) (inferTerm body)
     pure $ .mk body'.typ (.let pat expr' body')
   | .match term branches => inferMatch term branches
-  | .if b t f => do
-    -- Ensures that the type of the conditional is a number and the type of both branches are equal,
-    -- unless one of them escapes.
-    -- The returned type is the type of the branches.
-    let (numTyp, numInner) ← inferNumber b
-    let inferredNum := .mk (.evaluates numTyp) numInner
-    let inferredT ← inferTerm t
-    let inferredF ← inferTerm f
-    let inner := .if inferredNum inferredT inferredF
-    match (inferredT.typ, inferredF.typ) with
-    | (.evaluates typT, .evaluates typF) => do
-      unless typT == typF do throw $ .typeMismatch typT typF
-      pure $ .mk inferredT.typ inner
-    | (.evaluates _, .escapes) => pure $ .mk inferredT.typ inner
-    | _ => pure $ .mk inferredF.typ inner
   | .app func@(⟨.str .anonymous unqualifiedFunc⟩) args => do
     -- Ensures the function exists in the context and that the arguments, which aren't allowed to
     -- escape, match the function's input types. Returns the function's output type.
@@ -163,84 +139,15 @@ partial def inferTerm : Term → CheckM TypedTerm
       let args ← checkArgsAndInputs func args constr.argTypes
       pure $ .mk (.evaluates (.dataType dataType.name)) (.app func args)
     | _ => throw $ .cannotApply func
-  | .preimg func@(⟨.str .anonymous unqualifiedFunc⟩) arg => do
-    -- Checks if the type of the argument, which isn't allowed to escape, matches the
-    -- output type of the function, and infers the type of the function's inputs as a tuple.
-    -- Errors if the function isn't found in the context.
-    let ctx ← read
-    match ctx.varTypes[Local.str unqualifiedFunc]? with
-    | some (.function inputs output) =>
-      let argInner ← checkNoEscape arg output
-      let arg' := .mk (.evaluates output) argInner
-      pure $ .mk (.evaluates (.tuple inputs.toArray)) (.preimg func arg')
-    | some _ => throw $ .notAFunction func
-    | none => match ctx.decls.getByKey func with
-      | some (.function function) =>
-        let argInner ← checkNoEscape arg function.output
-        let arg' := .mk (.evaluates function.output) argInner
-        let inpTyp := function.inputs.map Prod.snd
-        pure $ .mk (.evaluates (.tuple inpTyp.toArray)) (.preimg func arg')
-      | some _ => throw $ .notAFunction func
-      | _ => throw $ .unboundVariable func
-  | .preimg func arg => do
-    -- Only checks global map if it is not unqualified
-    let ctx ← read
-    match ctx.decls.getByKey func with
-    | some (.function function) =>
-      let argInner ← checkNoEscape arg function.output
-      let arg' := .mk (.evaluates function.output) argInner
-      let inpTyp := function.inputs.map Prod.snd
-      pure $ .mk (.evaluates (.tuple inpTyp.toArray)) (.preimg func arg')
-    | some _ => throw $ .notAFunction func
-    | _ => throw $ .unboundVariable func
-  | .ffi g args => do
-    -- Gadget calls typecheck as tuples of u64s
-    let ctx ← read
-    match ctx.decls.getByKey g with
-    | some (.gadget gadget) =>
-      let mkU64sList := (List.replicate · (.primitive .u64))
-      let args ← checkArgsAndInputs g args $ mkU64sList gadget.inputSize
-      pure $ .mk (.evaluates (.tuple ⟨mkU64sList gadget.outputSize⟩)) (.ffi g args)
-    | some _ => throw $ .notAGadget g
-    | _ => throw $ .unboundVariable g
-  | .xor a b => do
-    let (typ, aInner) ← inferNumber a
-    let bInner ← checkNoEscape b typ
-    let ctxTyp := .evaluates typ
-    let a := .mk ctxTyp aInner
-    let b := .mk ctxTyp bInner
-    pure $ .mk ctxTyp (.xor a b)
-  | .and a b => do
-    let (typ, aInner) ← inferNumber a
-    let bInner ← checkNoEscape b typ
-    let ctxTyp := .evaluates typ
-    let a := .mk ctxTyp aInner
-    let b := .mk ctxTyp bInner
-    pure $ .mk ctxTyp (.and a b)
-  | .addU64 a b => do
-    let (typ, aInner) ← inferNoEscape a
-    unless (typ == .primitive .u64) do throw $ .notU64 typ
-    let bInner ← checkNoEscape b typ
-    let ctxTyp := .evaluates typ
-    let a := .mk ctxTyp aInner
-    let b := .mk ctxTyp bInner
-    pure $ .mk ctxTyp (.addU64 a b)
-  | .subU64 a b => do
-    let (typ, aInner) ← inferNoEscape a
-    unless (typ == .primitive .u64) do throw $ .notU64 typ
-    let bInner ← checkNoEscape b typ
-    let ctxTyp := .evaluates typ
-    let a := .mk ctxTyp aInner
-    let b := .mk ctxTyp bInner
-    pure $ .mk ctxTyp (.subU64 a b)
-  | .mulU64 a b => do
-    let (typ, aInner) ← inferNoEscape a
-    unless (typ == .primitive .u64) do throw $ .notU64 typ
-    let bInner ← checkNoEscape b typ
-    let ctxTyp := .evaluates typ
-    let a := .mk ctxTyp aInner
-    let b := .mk ctxTyp bInner
-    pure $ .mk ctxTyp (.mulU64 a b)
+  | .add a b => do
+    let (ctxTyp, a, b) ← checkArith a b
+    pure $ .mk ctxTyp (.add a b)
+  | .sub a b => do
+    let (ctxTyp, a, b) ← checkArith a b
+    pure $ .mk ctxTyp (.sub a b)
+  | .mul a b => do
+    let (ctxTyp, a, b) ← checkArith a b
+    pure $ .mk ctxTyp (.mul a b)
   | .get tup i => do
     let (typs, tupInner) ← inferTuple tup
     if i < typs.size then
@@ -275,21 +182,18 @@ partial def inferTerm : Term → CheckM TypedTerm
       let load := .load (.mk (.evaluates typ) inner)
       pure $ .mk (.evaluates innerTyp) load
     | _ => throw $ .notAPointer typ
-  | .pointerAsU64 term => do
+  | .ptrVal term => do
     -- Infers the type of the term, which must be a pointer, but returns `.u64`, as in a cast.
     -- The term is not allowed to early return.
     let (typ, inner) ← inferNoEscape term
     match typ with
     | .pointer _ =>
-      let asU64 := .pointerAsU64 (.mk (.evaluates typ) inner)
-      pure $ .mk (.evaluates (.primitive .u64)) asU64
+      let asU64 := .ptrVal (.mk (.evaluates typ) inner)
+      pure $ .mk (.evaluates .field) asU64
     | _ => throw $ .notAPointer typ
   | .ann typ term => do
     let inner ← checkNoEscape term typ
     pure $ .mk (.evaluates typ) inner
-  | .trace str term => do
-    let (typ, inner) ← inferNoEscape term
-    pure $ .mk (.evaluates typ) (.trace str (.mk (.evaluates typ) inner))
 where
   /--
   Ensures that there are as many arguments and as expected types and that
@@ -303,6 +207,14 @@ where
       let inner ← checkNoEscape arg input
       pure $ .mk (.evaluates input) inner
     args.zip inputs |>.mapM pass
+  checkArith a b := do
+    let (typ, aInner) ← inferNoEscape a
+    unless (typ == .field) do throw $ .notAField typ
+    let bInner ← checkNoEscape b typ
+    let ctxTyp := .evaluates typ
+    let a := .mk ctxTyp aInner
+    let b := .mk ctxTyp bInner
+    pure (ctxTyp, a, b)
 
 partial def checkNoEscape (term : Term) (typ : Typ) : CheckM TypedTermInner := do
   let (typ', inner) ← inferNoEscape term
@@ -316,7 +228,7 @@ partial def inferNoEscape (term : Term) : CheckM (Typ × TypedTermInner) := do
   | .evaluates type => pure (type, typedTerm.inner)
 
 partial def inferData : Data → CheckM (Typ × TypedTermInner)
-  | .primitive prim => pure (.primitive prim.type, .data (.primitive prim))
+  | .field g => pure (.field, .data (.field g))
   | .tuple terms => do
     let typsAndInners ← terms.mapM inferNoEscape
     let typs := typsAndInners.map Prod.fst
@@ -362,11 +274,7 @@ where
   aux pat typ := match (pat, typ) with
     | (.var var, _) => pure [(var, typ)]
     | (.wildcard, _)
-    | (.primitive (.u1 _), .primitive .u1)
-    | (.primitive (.u8 _), .primitive .u8)
-    | (.primitive (.u16 _), .primitive .u16)
-    | (.primitive (.u32 _), .primitive .u32)
-    | (.primitive (.u64 _), .primitive .u64) => pure []
+    | (.field _, .field) => pure []
     | (.tuple pats, .tuple typs) => do
       unless pats.size == typs.size do throw $ .incompatiblePattern pat typ
       pats.zip typs |>.foldlM (init := []) fun acc (pat, typ) => acc.append <$> aux pat typ
@@ -392,15 +300,15 @@ where
       if bind != bind' then throw $ .differentBindings bind bind' else pure bind
     | _ => throw $ .incompatiblePattern pat typ
 
-partial def inferNumber (term : Term) : CheckM (Typ × TypedTermInner) := do
-  let (typ, inner) ← inferNoEscape term
-  match typ with
-  | .primitive .u1
-  | .primitive .u8
-  | .primitive .u16
-  | .primitive .u32
-  | .primitive .u64 => pure (typ, inner)
-  | _ => throw $ .nonNumeric typ
+-- partial def inferNumber (term : Term) : CheckM (Typ × TypedTermInner) := do
+--   let (typ, inner) ← inferNoEscape term
+--   match typ with
+--   | .primitive .u1
+--   | .primitive .u8
+--   | .primitive .u16
+--   | .primitive .u32
+--   | .primitive .u64 => pure (typ, inner)
+--   | _ => throw $ .nonNumeric typ
 
 partial def inferTuple (term : Term) : CheckM (Array Typ × TypedTermInner) := do
   let (typ, inner) ← inferNoEscape term
@@ -441,7 +349,6 @@ where
       function.inputs.forM fun (_, typ) => wellFormedType typ
     -- No need to check constructors because they come from datatype declarations.
     | .constructor .. => pure ()
-    | .gadget _ => pure () -- Gadgets don't have inner types to be checked
   wellFormedType : Typ → EStateM CheckError (Std.HashSet Global) Unit
     | .tuple typs => typs.forM wellFormedType
     | .pointer pointerTyp => wellFormedType pointerTyp
@@ -451,27 +358,11 @@ where
       | none => throw $ .undefinedGlobal dataTypeRef
     | _ => pure ()
 
-
 /-- Checks a function to ensure its body's type matches its declared output type. -/
 def checkFunction (function : Function) : CheckM TypedFunction := do
   let body ← inferTerm function.body
   if let .evaluates typ := body.typ then
     unless typ == function.output do throw $ .typeMismatch typ function.output
-  pure { name := function.name, inputs := function.inputs, output := function.output, body := body }
-
-/--
-Checks all top-level definitions in a program, ensuring they are valid and return the map
-of declarations.
--/
-def checkToplevel (toplevel : Toplevel) : Except CheckError TypedDecls := do
-  let decls ← toplevel.mkDecls
-  wellFormedDecls decls
-  decls.foldlM (init := default) fun typedDecls (name, decl) => match decl with
-    | .constructor d c => pure $ typedDecls.insert name (.constructor d c)
-    | .dataType d => pure $ typedDecls.insert name (.dataType d)
-    | .function f => do
-      let f ← (checkFunction f) (getFunctionContext f decls)
-      pure $ typedDecls.insert name (.function f)
-    | .gadget g => pure $ typedDecls.insert name (.gadget g)
+  pure ⟨function.name, function.inputs, function.output, body⟩
 
 end Aiur
diff --git a/Ix/Aiur2/Compile.lean b/Ix/Aiur/Compile.lean
similarity index 99%
rename from Ix/Aiur2/Compile.lean
rename to Ix/Aiur/Compile.lean
index 3fe442e1..cca04a4b 100644
--- a/Ix/Aiur2/Compile.lean
+++ b/Ix/Aiur/Compile.lean
@@ -1,7 +1,7 @@
 import Std.Data.HashMap
 import Lean.Data.RBTree
-import Ix.Aiur2.Term
-import Ix.Aiur2.Bytecode
+import Ix.Aiur.Term
+import Ix.Aiur.Bytecode
 
 namespace Aiur
 
diff --git a/Ix/Aiur/Constraints.lean b/Ix/Aiur/Constraints.lean
deleted file mode 100644
index 56c928af..00000000
--- a/Ix/Aiur/Constraints.lean
+++ /dev/null
@@ -1,276 +0,0 @@
-import Ix.Aiur.Bytecode
-import Ix.Archon.Circuit
-
-namespace Aiur.Circuit
-
-open Archon
-
-structure Columns where
-  inputs : Array OracleIdx
-  outputs : Array OracleIdx
-  u1Auxiliaries : Array OracleIdx
-  u8Auxiliaries : Array OracleIdx
-  u64Auxiliaries : Array OracleIdx
-  multiplicity : OracleIdx
-  selectors : Array OracleIdx
-
-@[inline] def Columns.getSelector (columns : Columns) (selIdx : SelIdx) : OracleIdx :=
-  columns.selectors[selIdx]!
-
-def Columns.ofLayout (circuitModule : CircuitModule) (layout : Layout) : Columns × CircuitModule :=
-  let (inputs, circuitModule) := foldCommit layout.inputs circuitModule (s!"input-{·}") .b64
-  let (outputs, circuitModule) := foldCommit layout.outputs circuitModule (s!"output-{·}") .b64
-  let (u1Auxiliaries, circuitModule) := foldCommit layout.u1Auxiliaries circuitModule (s!"u1-auxiliary-{·}") .b1
-  let (u8Auxiliaries, circuitModule) := foldCommit layout.u8Auxiliaries circuitModule (s!"u8-auxiliary-{·}") .b8
-  let (u64Auxiliaries, circuitModule) := foldCommit layout.u64Auxiliaries circuitModule (s!"u64-auxiliary-{·}") .b64
-  let (multiplicity, circuitModule) := circuitModule.addCommitted "multiplicity" .b64 .base
-  let (selectors, circuitModule) := foldCommit layout.selectors circuitModule (s!"selector-{·}") .b1
-  let columns := { inputs, outputs, u1Auxiliaries, u8Auxiliaries, u64Auxiliaries, multiplicity, selectors }
-  (columns, circuitModule)
-where
-  foldCommit n circuitModule nameFn tf :=
-    n.fold (init := (#[], circuitModule)) fun i _ (oracles, circuitModule) =>
-      let (oracleIdx, circuitModule) := circuitModule.addCommitted (nameFn i) tf .base
-      (oracles.push oracleIdx, circuitModule)
-
-inductive Channel
-  | add
-  | mul
-  | func : FuncIdx → Channel
-  | mem : Nat → Channel
-  | gadget : GadgetIdx → Channel
-
-structure Constraints where
-  sharedConstraints : Array ArithExpr
-  uniqueConstraints : Array ArithExpr
-  recvs : Array (Channel × ArithExpr × Array ArithExpr)
-  requires : Array (Channel × ArithExpr × OracleIdx × Array ArithExpr)
-  topmostSelector : ArithExpr
-  io : Array OracleOrConst
-  multiplicity : OracleIdx
-
-def blockSelector (block : Bytecode.Block) (columns : Columns) : ArithExpr :=
-  let (min, max) := block.returnIdents
-  match List.range' min (max - min) |>.map columns.getSelector with
-  | [] => panic! s!"Invalid block identifiers: ({min}, {max})"
-  | o :: os => os.foldl (init := o) fun acc o => acc + (.oracle o)
-
-namespace Constraints
-
-def new (function : Bytecode.Function) (layout : Layout) (columns : Columns) : Constraints :=
-  { sharedConstraints := .mkArray layout.sharedConstraints 0
-    uniqueConstraints := #[]
-    recvs := #[]
-    requires := #[]
-    topmostSelector := blockSelector function.body columns
-    io := columns.inputs ++ columns.outputs |>.map .oracle
-    multiplicity := columns.multiplicity }
-
-@[inline] def pushUnique (constraints : Constraints) (expr : ArithExpr) : Constraints :=
-  { constraints with uniqueConstraints := constraints.uniqueConstraints.push expr }
-
-@[inline] def recv (constraints : Constraints) (channel : Channel)
-    (sel : ArithExpr) (args : Array ArithExpr) : Constraints :=
-  { constraints with recvs := constraints.recvs.push (channel, sel, args) }
-
-@[inline] def require (constraints : Constraints) (channel : Channel)
-    (sel : ArithExpr) (prevIdx : OracleIdx) (args : Array ArithExpr) : Constraints :=
-  { constraints with requires := constraints.requires.push (channel, sel, prevIdx, args) }
-
-end Constraints
-
-structure ConstraintState where
-  constraintIndex : Nat
-  u1AuxiliaryIndex : Nat
-  u8AuriliaryIndex : Nat
-  u64AuxiliaryIndex : Nat
-  varMap : Array ArithExpr
-  deriving Inhabited
-
-namespace ConstraintState
-
-@[inline] def pushVar (constraintState : ConstraintState) (expr : ArithExpr) : ConstraintState :=
-  { constraintState with varMap := constraintState.varMap.push expr }
-
-@[inline] def getVar (constraintState : ConstraintState) (idx : ValIdx) : ArithExpr :=
-  constraintState.varMap[idx]!
-
-def nextU1Column (constraintState : ConstraintState) (columns : Columns) : OracleIdx × ConstraintState :=
-  let col := columns.u1Auxiliaries[constraintState.u1AuxiliaryIndex]!
-  let constraintState' := { constraintState with
-    u1AuxiliaryIndex := constraintState.u1AuxiliaryIndex + 1 }
-  (col, constraintState')
-
-def nextU64Column (constraintState : ConstraintState) (columns : Columns) : OracleIdx × ConstraintState :=
-  let col := columns.u64Auxiliaries[constraintState.u64AuxiliaryIndex]!
-  let constraintState' := { constraintState with
-    u64AuxiliaryIndex := constraintState.u64AuxiliaryIndex + 1 }
-  (col, constraintState')
-
-def bindU1Column (constraintState : ConstraintState) (columns : Columns) : OracleIdx × ConstraintState :=
-  let (col, constraintState') := constraintState.nextU1Column columns
-  let constraintState'' := { constraintState' with varMap := constraintState'.varMap.push col }
-  (col, constraintState'')
-
-def bindU64Column (constraintState : ConstraintState) (columns : Columns) : OracleIdx × ConstraintState :=
-  let (col, constraintState') := constraintState.nextU64Column columns
-  let constraintState'' := { constraintState' with varMap := constraintState'.varMap.push col }
-  (col, constraintState'')
-
-end ConstraintState
-
-structure CollectMState where
-  constraints : Constraints
-  constraintState : ConstraintState
-
-namespace CollectMState
-
-def addSharedConstraint (stt : CollectMState) (expr : ArithExpr) : CollectMState :=
-  let constraintIndex := stt.constraintState.constraintIndex
-  let sharedConstraints := stt.constraints.sharedConstraints.modify constraintIndex (· + expr)
-  let constraintIndex := constraintIndex + 1
-  { stt with
-    constraints := { stt.constraints with sharedConstraints }
-    constraintState := { stt.constraintState with constraintIndex } }
-
-end CollectMState
-
-abbrev CollectM := StateM CollectMState
-
-@[inline] def modifyConstraintState (f : ConstraintState → ConstraintState) : CollectM Unit :=
-  modify fun stt => { stt with constraintState := f stt.constraintState }
-
-def collectOpConstraints (columns : Columns) (sel : ArithExpr) : Bytecode.Op → CollectM Unit
-  | .prim (.u1 x)
-  | .prim (.u8 x)
-  | .prim (.u16 x)
-  | .prim (.u32 x)
-  | .prim (.u64 x) => modifyConstraintState (·.pushVar (.const (.ofNatWrap x.toNat)))
-  | .add a b => modify fun stt =>
-    let a := stt.constraintState.getVar a
-    let b := stt.constraintState.getVar b
-    -- 8 bytes of result
-    let (c, constraintState) := stt.constraintState.bindU64Column columns
-    -- 1 byte of carry, which is not bound
-    let (carry, constraintState) := constraintState.nextU1Column columns
-    let args := #[a, b, c, carry]
-    let constraints := stt.constraints.recv .add sel args
-    ⟨constraints, constraintState⟩
-  | .sub c b => modify fun stt =>
-    -- `c - b = a` is equivalent to `a + b = c`.
-    let c := stt.constraintState.getVar c
-    let b := stt.constraintState.getVar b
-    let (a, constraintState) := stt.constraintState.bindU64Column columns
-    let (carry, constraintState) := constraintState.nextU1Column columns
-    let args := #[.oracle a, b, c, carry]
-    let constraints := stt.constraints.recv .add sel args
-    ⟨constraints, constraintState⟩
-  | .lt c b => modify fun stt =>
-    -- `c < b` is equivalent to `c - b` underflowing, which is
-    -- equivalent to the addition in `a + b = c` overflowing
-    -- Note that the result of the subtraction is not bound
-    let c := stt.constraintState.getVar c
-    let b := stt.constraintState.getVar b
-    let (a, constraintState) := stt.constraintState.bindU64Column columns
-    -- The carry is bound
-    let (carry, constraintState) := constraintState.bindU1Column columns
-    let args := #[.oracle a, b, c, carry]
-    let constraints := stt.constraints.recv .add sel args
-    ⟨constraints, constraintState⟩
-  | .mul a b => modify fun stt =>
-    let a := stt.constraintState.getVar a
-    let b := stt.constraintState.getVar b
-    -- 8 bytes of result
-    let (c, constraintState) := stt.constraintState.bindU64Column columns
-    let args := #[a, b, c]
-    let constraints := stt.constraints.recv .mul sel args
-    ⟨constraints, constraintState⟩
-  | .xor a b => modify fun stt =>
-    let a := stt.constraintState.getVar a
-    let b := stt.constraintState.getVar b
-    { stt with constraintState := stt.constraintState.pushVar (a + b) }
-  | .and a b => modify fun stt =>
-    let a := stt.constraintState.getVar a
-    let b := stt.constraintState.getVar b
-    let (c, constraintState) := stt.constraintState.bindU1Column columns
-    let constraintState := constraintState.pushVar c
-    let stt' := { stt with constraintState }
-    stt'.addSharedConstraint $ sel * (c - a * b)
-  | .store values => modify fun stt =>
-    let (start, constraintState) := stt.constraintState.bindU64Column columns
-    let args := #[.oracle start] ++ values.map constraintState.getVar
-    let (req, constraintState) := constraintState.nextU64Column columns
-    let constraints := stt.constraints.require (.mem values.size) sel req args
-    ⟨constraints, constraintState⟩
-  | .load len ptr => modify fun stt =>
-    pushAndRequireArgs #[stt.constraintState.getVar ptr] stt len (.mem len)
-  | .call f args outSize => modify fun stt =>
-    pushAndRequireArgs (args.map stt.constraintState.getVar) stt outSize (.func f)
-  | .ffi g args outSize => modify fun stt =>
-    pushAndRequireArgs (args.map stt.constraintState.getVar) stt outSize (.gadget g)
-  | _ => panic! "TODO"
-where
-  pushAndRequireArgs args stt n channel :=
-    let (args, constraintState) := n.fold (init := (args, stt.constraintState))
-      fun _ _ (args, constraintState) =>
-        let (x, constraintState) := constraintState.bindU64Column columns
-        (args.push x, constraintState)
-    let (req, constraintState) := constraintState.nextU64Column columns
-    let constraints := stt.constraints.require channel sel req args
-    ⟨constraints, constraintState⟩
-
-partial def collectBlockConstraints (block : Bytecode.Block) (columns : Columns) : CollectM Unit := do
-  let sel := blockSelector block columns
-  block.ops.forM (collectOpConstraints columns sel)
-  match block.ctrl with
-  | .if b t f =>
-    let stt ← get
-    let b := stt.constraintState.getVar b
-    let saved := stt.constraintState
-    let tSel := blockSelector t columns
-    let (d, constraintState) := stt.constraintState.nextU64Column columns
-    let constraints := stt.constraints.pushUnique (tSel * (b * d - .one))
-    set (CollectMState.mk constraints constraintState)
-    collectBlockConstraints t columns
-    let fSel := blockSelector f columns
-    modify fun stt => { stt with
-      constraints := stt.constraints.pushUnique (fSel * b)
-      constraintState := saved }
-    collectBlockConstraints f columns
-  | .match v branches defaultBranch =>
-    let stt ← get
-    let v := stt.constraintState.getVar v
-    let saved := stt.constraintState
-    branches.forM fun (value, branch) => do
-      let value := ArithExpr.const (UInt128.ofLoHi value 0)
-      let sel := blockSelector branch columns
-      modify fun stt => { stt with constraints := stt.constraints.pushUnique (sel * (v - value)) }
-      collectBlockConstraints branch columns
-      modify fun stt => { stt with constraintState := saved }
-    match defaultBranch with
-    | none => pure ()
-    | some defaultBranch =>
-      let sel := blockSelector defaultBranch columns
-      branches.forM fun (value, _) => do
-        let value := ArithExpr.const (UInt128.ofLoHi value 0)
-        modify fun stt =>
-          let (d, constraintState) := stt.constraintState.nextU64Column columns
-          let constraints := stt.constraints.pushUnique (sel * ((v - value) * d - .one))
-          { stt with constraintState, constraints }
-      collectBlockConstraints defaultBranch columns
-  | .ret id rs =>
-    let selCol := columns.getSelector id
-    modify fun stt =>
-      rs.zip columns.outputs |>.foldl (init := stt) fun acc (r, o) =>
-        let r := stt.constraintState.getVar r
-        acc.addSharedConstraint $ selCol * (r - o)
-
-def buildFuncionConstraints (function : Bytecode.Function) (layout : Layout)
-    (columns : Columns) : Constraints :=
-  let constraintState := columns.inputs.foldl (init := default)
-    fun acc input => acc.pushVar input
-  let (_, constraintState) := collectBlockConstraints function.body columns
-    |>.run ⟨.new function layout columns, constraintState⟩
-  constraintState.constraints
-
-end Aiur.Circuit
diff --git a/Ix/Aiur/Execute.lean b/Ix/Aiur/Execute.lean
deleted file mode 100644
index 91bfa578..00000000
--- a/Ix/Aiur/Execute.lean
+++ /dev/null
@@ -1,225 +0,0 @@
-import Ix.IndexMap
-import Ix.Aiur.Bytecode
-
-namespace Aiur.Bytecode
-
-structure QueryResult where
-  values : Array UInt64
-  multiplicity : UInt64
-  deriving Inhabited
-
-@[inline] def QueryResult.bumpMultiplicity (res : QueryResult) : QueryResult :=
-  { res with multiplicity := res.multiplicity + 1 }
-
-abbrev QueryMap := IndexMap (Array UInt64) QueryResult
-
-structure QueryRecord where
-  funcQueries : Array QueryMap
-  memQueries : Array $ Nat × QueryMap
-  addQueries : Array $ UInt64 × UInt64
-  mulQueries : Array $ UInt64 × UInt64
-  gadgetQueries : Array QueryMap
-
-namespace QueryRecord
-
-def new (toplevel : Toplevel) : QueryRecord :=
-  let funcQueries := toplevel.functions.map fun _ => default
-  let memQueries := toplevel.memWidths.map fun width => (width, default)
-  let gadgetQueries := toplevel.gadgets.map fun _ => default
-  ⟨funcQueries, memQueries, #[], #[], gadgetQueries⟩
-
-def getFuncResult (record : QueryRecord) (funcIdx : FuncIdx) (input : Array UInt64) :
-    Option (Array UInt64) := do
-  let queryMap ← record.funcQueries[funcIdx]?
-  let queryResult ← queryMap.getByKey input
-  some queryResult.values
-
-def getGadgetResult (record : QueryRecord) (gadgetIdx : GadgetIdx) (input : Array UInt64) :
-    Option (Array UInt64) := do
-  let queryMap ← record.gadgetQueries[gadgetIdx]?
-  let queryResult ← queryMap.getByKey input
-  some queryResult.values
-
-def getGadgetEntries (record : QueryRecord) : Array $ Array GadgetEntry :=
-  record.gadgetQueries.map
-    fun queryMap => queryMap.pairs.map
-      fun (input, ⟨output, multiplicity⟩) => ⟨input, output, multiplicity⟩
-
-end QueryRecord
-
-structure ExecuteCtx where
-  toplevel : Toplevel
-  funcIdx : FuncIdx
-  args : Array UInt64
-
-structure ExecuteState where
-  record : QueryRecord
-  map : Array UInt64
-
-namespace ExecuteState
-
-def updateForFunc (stt : ExecuteState) (funcIdx : FuncIdx) (newQueryMap : QueryMap)
-    (mapFn : Array UInt64 → Array UInt64) : ExecuteState :=
-  let newFuncQueries := stt.record.funcQueries.set! funcIdx newQueryMap
-  { stt with
-      record := { stt.record with funcQueries := newFuncQueries }
-      map := mapFn stt.map }
-
-def updateForGadget (stt : ExecuteState) (gadgetIdx : GadgetIdx) (newQueryMap : QueryMap)
-    (mapFn : Array UInt64 → Array UInt64) : ExecuteState :=
-  let newGadgetQueries := stt.record.gadgetQueries.set! gadgetIdx newQueryMap
-  { stt with
-      record := { stt.record with gadgetQueries := newGadgetQueries }
-      map := mapFn stt.map }
-
-def updateForMem (stt : ExecuteState) (memMapIdx : MemIdx) (len : Nat) (newQueryMap : QueryMap)
-    (mapFn : Array UInt64 → Array UInt64) : ExecuteState :=
-  let newMemQueries := stt.record.memQueries.set! memMapIdx (len, newQueryMap)
-  { stt with
-      record := { stt.record with memQueries := newMemQueries }
-      map := mapFn stt.map }
-
-end ExecuteState
-
-abbrev ExecuteM := ReaderT ExecuteCtx $ StateM ExecuteState
-
-@[inline] def pushVal (x : UInt64) : ExecuteM Unit :=
-  modify fun stt => { stt with map := stt.map.push x }
-
-@[inline] def getVal (i : ValIdx) : ExecuteM UInt64 :=
-  get >>= (pure ·.map[i]!)
-
-@[inline] def modifyRecord (f : QueryRecord → QueryRecord) : ExecuteM Unit :=
-  modify fun stt => { stt with record := f stt.record }
-
-@[inline] def getMemMapIdx (len : Nat) : ExecuteM $ Nat × QueryMap := do
-  let stt ← get
-  let idxOpt := stt.record.memQueries.findIdx? (·.fst == len)
-  let idx := idxOpt.get!
-  let queryMap := stt.record.memQueries[idx]!.snd
-  pure (idx, queryMap)
-
-mutual
-
-partial def Block.execute (block : Block) : ExecuteM Unit := do
-  block.ops.forM Op.execute
-  block.ctrl.execute
-
-partial def Op.execute : Op → ExecuteM Unit
-  | .prim (.u1 u) | .prim (.u8 u) | .prim (.u16 u) | .prim (.u32 u) => pushVal u.toUInt64
-  | .prim (.u64 u) => pushVal u
-  | .add a b => do
-    let a ← getVal a
-    let b ← getVal b
-    pushVal (a + b)
-    modifyRecord fun r => { r with addQueries := r.addQueries.push (a, b) }
-  | .sub c b => do
-    let c ← getVal c
-    let b ← getVal b
-    let a := c - b
-    pushVal a
-    modifyRecord fun r => { r with addQueries := r.addQueries.push (a, b) }
-  | .lt c b => do
-    let c ← getVal c
-    let b ← getVal b
-    let a := c - b
-    let underflow := decide (c < b)
-    pushVal underflow.toUInt64
-    modifyRecord fun r => { r with addQueries := r.addQueries.push (a, b) }
-  | .mul a b => do
-    let a ← getVal a
-    let b ← getVal b
-    pushVal (a * b)
-    modifyRecord fun r => { r with mulQueries := r.mulQueries.push (a, b) }
-  | .and a b => do
-    let a ← getVal a
-    let b ← getVal b
-    pushVal (a &&& b)
-  | .xor a b => do
-    let a ← getVal a
-    let b ← getVal b
-    pushVal (a ^^^ b)
-  | .store values => do
-    let len := values.size
-    let (memMapIdx, memMap) ← getMemMapIdx len
-    let values ← values.mapM getVal
-    match memMap.getByKey values with
-    | some res =>
-      let newRes := res.bumpMultiplicity
-      let newMemMap := memMap.insert values newRes
-      modify (·.updateForMem memMapIdx len newMemMap (·.append newRes.values))
-    | none =>
-      let ptr := memMap.size.toUInt64
-      let newRes := QueryResult.mk #[ptr] 1
-      let newMemMap := memMap.insert values newRes
-      modify (·.updateForMem memMapIdx len newMemMap (·.push ptr))
-  | .load len ptr => do
-    let stt ← get
-    let ptr := stt.map[ptr]!
-    let (memMapIdx, memMap) ← getMemMapIdx len
-    let (values, res) := memMap.getByIdx ptr.toNat |>.get!
-    let newRes := res.bumpMultiplicity
-    let newMemMap := memMap.insert values newRes
-    modify (·.updateForMem memMapIdx len newMemMap (·.append values))
-  | .call funcIdx args _ => do
-    let stt ← get
-    let args := args.map (stt.map[·]!)
-    let funcQueryMap := stt.record.funcQueries[funcIdx]!
-    match funcQueryMap.getByKey args with
-    | some res =>
-      let newRes := res.bumpMultiplicity
-      let newFuncQueryMap := funcQueryMap.insert args newRes
-      modify (·.updateForFunc funcIdx newFuncQueryMap (·.append res.values))
-    | none => do
-      let savedMap := stt.map
-      set { stt with map := args }
-      let ctx ← read
-      let func := ctx.toplevel.functions[funcIdx]!
-      withReader (fun ctx => { ctx with funcIdx, args }) func.body.execute
-      let stt ← get
-      let out := stt.map.extract (start := stt.map.size - func.outputSize)
-      set { stt with map := savedMap.append out }
-  | .ffi gadgetIdx args _ => do
-    let stt ← get
-    let args := args.map (stt.map[·]!)
-    let gadgetQueryMap := stt.record.gadgetQueries[gadgetIdx]!
-    let res ← match gadgetQueryMap.getByKey args with
-      | some res => pure res.bumpMultiplicity
-      | none =>
-        let ctx ← read
-        let gadget := ctx.toplevel.gadgets[gadgetIdx]!
-        let out := gadget.execute args
-        pure ⟨out, 1⟩
-    let newGadgetQueryMap := gadgetQueryMap.insert args res
-    modify (·.updateForGadget gadgetIdx newGadgetQueryMap (·.append res.values))
-  | .trace str args => do
-    let stt ← get
-    let args := args.map (stt.map[·]!)
-    dbg_trace s!"{str}{args}"
-  | _ => panic! "TODO"
-
-partial def Ctrl.execute : Ctrl → ExecuteM Unit
-  | .ret _ out => do
-    let ctx ← read
-    let funcIdx := ctx.funcIdx
-    let stt ← get
-    let funcQueryMap := stt.record.funcQueries[funcIdx]!
-    let newRes := ⟨out.map (stt.map[·]!), 1⟩
-    let newFuncQueryMap := funcQueryMap.insert ctx.args newRes
-    let newFuncQueries := stt.record.funcQueries.set! funcIdx newFuncQueryMap
-    set { stt with record := { stt.record with funcQueries := newFuncQueries } }
-  | .if v tt ff => do if (← getVal v) != 0 then tt.execute else ff.execute
-  | .match v branches defaultBranch => do
-    let v ← getVal v
-    match branches.find? fun branch => branch.fst == v with
-    | some branch => branch.snd.execute
-    | none => defaultBranch.get!.execute
-
-end
-
-def Toplevel.execute (toplevel : Toplevel) (funcIdx : FuncIdx) (input : Array UInt64) : QueryRecord :=
-  let block := toplevel.functions[funcIdx]!.body
-  let (_, stt) := block.execute.run ⟨toplevel, funcIdx, input⟩ |>.run ⟨.new toplevel, input⟩
-  stt.record
-
-end Aiur.Bytecode
diff --git a/Ix/Aiur/Gadget.lean b/Ix/Aiur/Gadget.lean
deleted file mode 100644
index b7ff7ade..00000000
--- a/Ix/Aiur/Gadget.lean
+++ /dev/null
@@ -1,35 +0,0 @@
-import Ix.Archon.Circuit
-
-namespace Aiur
-
-open Archon Binius
-
-structure GadgetEntry where
-  input : Array UInt64
-  output : Array UInt64
-  multiplicity : UInt64
-
-structure Gadget where
-  name : Lean.Name
-  inputSize : Nat
-  outputSize : Nat
-  execute : Array UInt64 → Array UInt64
-  synthesize : ChannelId → CircuitModule → CircuitModule × Array OracleIdx
-  populate : Array GadgetEntry → Array OracleIdx → WitnessModule → WitnessModule × ModuleMode
-
-instance : Inhabited Gadget where
-  default :=
-    let synthesize := fun _ circuitModule => (circuitModule, #[])
-    let populate := fun _ _ witnessModule => (witnessModule, .inactive)
-    ⟨.anonymous, 0, 0, id, synthesize, populate⟩
-
-instance : Repr Gadget where
-  reprPrec g _ := s!"[{g.inputSize}] → [{g.outputSize}]"
-
-def Gadget.provide (circuitModule: CircuitModule) (channelId : ChannelId) (multiplicity: OracleIdx)
-    (args : Array OracleOrConst) : CircuitModule :=
-  let circuitModule := circuitModule.flush .push channelId CircuitModule.selector
-    (args.push (.const 1 .b1)) 1
-  circuitModule.flush .pull channelId CircuitModule.selector (args.push (.oracle multiplicity)) 1
-
-end Aiur
diff --git a/Ix/Aiur2/Goldilocks.lean b/Ix/Aiur/Goldilocks.lean
similarity index 100%
rename from Ix/Aiur2/Goldilocks.lean
rename to Ix/Aiur/Goldilocks.lean
diff --git a/Ix/Aiur/Match.lean b/Ix/Aiur/Match.lean
index 00c401a4..6b59ad3f 100644
--- a/Ix/Aiur/Match.lean
+++ b/Ix/Aiur/Match.lean
@@ -7,7 +7,7 @@ abbrev TermId := Nat
 abbrev UniqTerm := TermId × Term
 
 inductive SPattern
-  | primitive : Primitive → SPattern
+  | field : G → SPattern
   | ref : Global → Array Local → SPattern
   | tuple : Array Local → SPattern
   deriving BEq, Hashable, Inhabited
@@ -23,9 +23,6 @@ structure ExtTerm where
   value : Term
   deriving Inhabited
 
-def ExtTerm.modifyRenames (t : ExtTerm) (f : Array (Local × Term) → Array (Local × Term)) : ExtTerm :=
-  { t with renames := f t.renames }
-
 structure Row where
   clauses : Array Clause
   body : ExtTerm
@@ -65,7 +62,7 @@ def dnfProd (branches: List $ Pattern × UniqTerm) (body : ExtTerm) : CompilerM
       pure $ rowsL ++ rowsR
     | (.wildcard, _) :: rest => aux renames clauses rest body
     | (.var var, (_, term)) :: rest => aux (renames.push (var, term)) clauses rest body
-    | (.primitive prim, term) :: rest => aux renames (clauses.push ⟨.primitive prim, #[], term⟩) rest body
+    | (.field g, term) :: rest => aux renames (clauses.push ⟨.field g, #[], term⟩) rest body
     | (.tuple args, term) :: rest => do
       let (vars, guards) ← flattenArgs args
       let clause := ⟨.tuple vars, guards, term⟩
@@ -81,9 +78,6 @@ where
     let guards := args.zip varIds |>.map fun (arg, id) => (arg, (id, .var (.idx id)))
     pure (varIds.map .idx, guards)
 
-def toRows (clause : Pattern × UniqTerm) : ExtTerm → CompilerM (Array Row) :=
-  dnfProd [clause]
-
 inductive Decision
   | success : ExtTerm → Decision
   | failure
@@ -95,11 +89,7 @@ def modifyDiagnostics (f : Diagnostics → Diagnostics) : CompilerM Unit :=
   modify fun stt => { stt with diagnostics := f stt.diagnostics }
 
 def patTypeLength (decls : Decls) : SPattern → Nat
-  | .primitive (.u1 _) => 2
-  | .primitive (.u8 _) => UInt8.size
-  | .primitive (.u16 _) => UInt16.size
-  | .primitive (.u32 _) => UInt32.size
-  | .primitive (.u64 _) => UInt64.size
+  | .field _ => gSize.toNat
   | .tuple _ => 1
   | .ref global _ => typeLookup global |>.constructors.length
 where
@@ -190,7 +180,7 @@ def compile (term : Term) (rules : List (Pattern × Term)) : CompilerM (Decision
 where
   fromRule id rule :=
     let (pat, bod) := rule
-    toRows (pat, (id, term)) ⟨#[], bod⟩
+    dnfProd [(pat, (id, term))] ⟨#[], bod⟩
 
 def runWithNewCompiler (typs : Decls) (f : CompilerM α) : α :=
   StateT.run' f ⟨0, typs, ⟨false, []⟩⟩
@@ -200,7 +190,7 @@ def runMatchCompiler (typs : Decls) (term : Term) (rules : List (Pattern × Term
   runWithNewCompiler typs (compile term rules)
 
 def spatternToPattern : SPattern → Pattern
-  | .primitive prim => .primitive prim
+  | .field g => .field g
   | .ref global vars => .ref global (vars.map .var).toList
   | .tuple vars => .tuple (vars.map .var)
 
diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean
index 1abd5b96..ddeaeec6 100644
--- a/Ix/Aiur/Meta.lean
+++ b/Ix/Aiur/Meta.lean
@@ -7,48 +7,11 @@ open Lean Elab Meta
 
 abbrev ElabStxCat name := TSyntax name → TermElabM Expr
 
-declare_syntax_cat                             primitive
-syntax (name := primitiveU1)  num noWs "u1"  : primitive
-syntax (name := primitiveU8)  num noWs "u8"  : primitive
-syntax (name := primitiveU16) num noWs "u16" : primitive
-syntax (name := primitiveU32) num noWs "u32" : primitive
-syntax (name := primitiveU64) num noWs "u64" : primitive
-
-def elabPrimitive : ElabStxCat `primitive
-  | stx@⟨.node _ ``primitiveU1 ts⟩ =>
-    match getNat ts with
-    | 0 => mkAppM ``Primitive.u1 #[mkConst ``Bool.false]
-    | 1 => mkAppM ``Primitive.u1 #[mkConst ``Bool.true]
-    | n => throwOutOfRange stx n "u1"
-  | stx@⟨.node _ ``primitiveU8 ts⟩ =>
-    let n := getNat ts
-    if h : n < UInt8.size then mkAppM ``Primitive.u8 #[toExpr $ UInt8.ofNatLT n h]
-    else throwOutOfRange stx n "u8"
-  | stx@⟨.node _ ``primitiveU16 ts⟩ =>
-    let n := getNat ts
-    if h : n < UInt16.size then mkAppM ``Primitive.u16 #[toExpr $ UInt16.ofNatLT n h]
-    else throwOutOfRange stx n "u16"
-  | stx@⟨.node _ ``primitiveU32 ts⟩ =>
-    let n := getNat ts
-    if h : n < UInt32.size then mkAppM ``Primitive.u32 #[toExpr $ UInt32.ofNatLT n h]
-    else throwOutOfRange stx n "u32"
-  | stx@⟨.node _ ``primitiveU64 ts⟩ =>
-    let n := getNat ts
-    if h : n < UInt64.size then mkAppM ``Primitive.u64 #[toExpr $ UInt64.ofNatLT n h]
-    else throwOutOfRange stx n "u64"
-  | stx => throw $ .error stx "Invalid syntax for primitive"
-where
-  getNat ts :=
-    let numLit : NumLit := ⟨ts[0]!⟩
-    numLit.getNat
-  throwOutOfRange stx n ty :=
-    throw $ .error stx s!"{n} is out of range for {ty}"
-
 declare_syntax_cat                             pattern
 syntax ("." noWs)? ident                     : pattern
 syntax "_"                                   : pattern
 syntax ident "(" pattern (", " pattern)* ")" : pattern
-syntax primitive                             : pattern
+syntax num                                   : pattern
 syntax "(" pattern (", " pattern)* ")"       : pattern
 syntax pattern "|" pattern                   : pattern
 
@@ -69,6 +32,9 @@ def elabList (head : α) (tail : Array α) (elabFn : α → TermElabM Expr)
 def elabEmptyList (listEltTypeName : Name) : TermElabM Expr :=
   mkListLit (mkConst listEltTypeName) []
 
+def elabG (n : TSyntax `num) : TermElabM Expr :=
+  mkAppM ``G.ofNat #[mkNatLit n.getNat]
+
 partial def elabPattern : ElabStxCat `pattern
   | `(pattern| $v:ident($p:pattern $[, $ps:pattern]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr v.getId]
@@ -84,31 +50,15 @@ partial def elabPattern : ElabStxCat `pattern
       mkAppM ``Pattern.ref #[g, ← elabEmptyList ``Pattern]
     | _ => throw $ .error i "Illegal pattern name"
   | `(pattern| _) => pure $ mkConst ``Pattern.wildcard
-  | `(pattern| $prim:primitive) => do
-    mkAppM ``Pattern.primitive #[← elabPrimitive prim]
+  | `(pattern| $n:num) => do mkAppM ``Pattern.field #[← elabG n]
   | `(pattern| ($p:pattern $[, $ps:pattern]*)) => do
     mkAppM ``Pattern.tuple #[← elabList p ps elabPattern ``Pattern true]
   | `(pattern| $p₁:pattern | $p₂:pattern) => do
     mkAppM ``Pattern.or #[← elabPattern p₁, ← elabPattern p₂]
   | stx => throw $ .error stx "Invalid syntax for pattern"
 
-declare_syntax_cat primitive_type
-syntax "u1"      : primitive_type
-syntax "u8"      : primitive_type
-syntax "u16"     : primitive_type
-syntax "u32"     : primitive_type
-syntax "u64"     : primitive_type
-
-def elabPrimitiveType : ElabStxCat `primitive_type
-  | `(primitive_type| u1) => pure $ mkConst ``PrimitiveType.u1
-  | `(primitive_type| u8) => pure $ mkConst ``PrimitiveType.u8
-  | `(primitive_type| u16) => pure $ mkConst ``PrimitiveType.u16
-  | `(primitive_type| u32) => pure $ mkConst ``PrimitiveType.u32
-  | `(primitive_type| u64) => pure $ mkConst ``PrimitiveType.u64
-  | stx => throw $ .error stx "Invalid syntax for primitive type"
-
 declare_syntax_cat                               typ
-syntax primitive_type                          : typ
+syntax "G"                                     : typ
 syntax "(" typ (", " typ)* ")"                 : typ
 syntax "&" typ                                 : typ
 syntax ("." noWs)? ident                       : typ
@@ -116,8 +66,7 @@ syntax "fn" "(" ")" " -> " typ                 : typ
 syntax "fn" "(" typ (", " typ)* ")" " -> " typ : typ
 
 partial def elabTyp : ElabStxCat `typ
-  | `(typ| $p:primitive_type) => do
-    mkAppM ``Typ.primitive #[← elabPrimitiveType p]
+  | `(typ| G) => pure $ mkConst ``Typ.field
   | `(typ| ($t:typ $[, $ts:typ]*)) => do
     mkAppM ``Typ.tuple #[← elabList t ts elabTyp ``Typ true]
   | `(typ| &$t:typ) => do
@@ -133,18 +82,13 @@ partial def elabTyp : ElabStxCat `typ
 
 declare_syntax_cat                                          trm
 syntax ("." noWs)? ident                                  : trm
-syntax primitive                                          : trm
+syntax num                                                : trm
 syntax "(" trm (", " trm)* ")"                            : trm
 syntax "return " trm                                      : trm
 syntax "let " pattern " = " trm "; " trm                  : trm
 syntax "match " trm " { " (pattern " => " trm ", ")+ " }" : trm
-syntax "if " trm " { " trm " } " " else " " { " trm " } " : trm
 syntax ("." noWs)? ident "(" ")"                          : trm
 syntax ("." noWs)? ident "(" trm (", " trm)* ")"          : trm
-syntax "preimg" "(" ("." noWs)? ident ", " trm ")"        : trm
-syntax "ffi" "(" ident (", " trm)* ")"                    : trm
-syntax "xor" "(" trm ", " trm ")"                         : trm
-syntax "and" "(" trm ", " trm ")"                         : trm
 syntax "add" "(" trm ", " trm ")"                         : trm
 syntax "sub" "(" trm ", " trm ")"                         : trm
 syntax "mul" "(" trm ", " trm ")"                         : trm
@@ -152,8 +96,7 @@ syntax "get" "(" trm ", " num ")"                         : trm
 syntax "slice" "(" trm ", " num ", " num ")"              : trm
 syntax "store" "(" trm ")"                                : trm
 syntax "load" "(" trm ")"                                 : trm
-syntax "pointer_as_u64" "(" trm ")"                       : trm
-syntax "trace" "(" str ", " trm ")"                       : trm
+syntax "ptr_val" "(" trm ")"                              : trm
 syntax trm ": " typ                                       : trm
 
 partial def elabTrm : ElabStxCat `trm
@@ -165,8 +108,8 @@ partial def elabTrm : ElabStxCat `trm
     | name@(.str _ _) => do
       mkAppM ``Term.ref #[← mkAppM ``Global.mk #[toExpr name]]
     | _ => throw $ .error i "Illegal name"
-  | `(trm| $p:primitive) => do
-    let data ← mkAppM ``Data.primitive #[← elabPrimitive p]
+  | `(trm| $n:num) => do
+    let data ← mkAppM ``Data.field #[← elabG n]
     mkAppM ``Term.data #[data]
   | `(trm| ($t:trm $[, $ts:trm]*)) => do
     let data ← mkAppM ``Data.tuple #[← elabList t ts elabTrm ``Term true]
@@ -181,30 +124,18 @@ partial def elabTrm : ElabStxCat `trm
       prods := prods.push $ ← mkAppM ``Prod.mk #[← elabPattern p, ← elabTrm t]
     let prodType ← mkAppM ``Prod #[mkConst ``Pattern, mkConst ``Term]
     mkAppM ``Term.match #[← elabTrm t, ← mkListLit prodType prods.toList]
-  | `(trm| if $b:trm {$t:trm} else {$f:trm}) => do
-    mkAppM ``Term.if #[← elabTrm b, ← elabTrm t, ← elabTrm f]
   | `(trm| $[.]?$f:ident ()) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
     mkAppM ``Term.app #[g, ← elabEmptyList ``Term]
   | `(trm| $[.]?$f:ident ($a:trm $[, $as:trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
     mkAppM ``Term.app #[g, ← elabList a as elabTrm ``Term]
-  | `(trm| preimg($[.]?$f:ident, $t:trm)) => do
-    let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Term.preimg #[g, ← elabTrm t]
-  | `(trm| ffi($g:ident $[, $as:trm]*)) => do
-    let g ← mkAppM ``Global.mk #[toExpr g.getId]
-    mkAppM ``Term.ffi #[g, ← mkListLit (mkConst ``Term) (← as.toList.mapM elabTrm)]
   | `(trm| add($a:trm, $b:trm)) => do
-    mkAppM ``Term.addU64 #[← elabTrm a, ← elabTrm b]
+    mkAppM ``Term.add #[← elabTrm a, ← elabTrm b]
   | `(trm| sub($a:trm, $b:trm)) => do
-    mkAppM ``Term.subU64 #[← elabTrm a, ← elabTrm b]
+    mkAppM ``Term.sub #[← elabTrm a, ← elabTrm b]
   | `(trm| mul($a:trm, $b:trm)) => do
-    mkAppM ``Term.mulU64 #[← elabTrm a, ← elabTrm b]
-  | `(trm| xor($a:trm, $b:trm)) => do
-    mkAppM ``Term.xor #[← elabTrm a, ← elabTrm b]
-  | `(trm| and($a:trm, $b:trm)) => do
-    mkAppM ``Term.and #[← elabTrm a, ← elabTrm b]
+    mkAppM ``Term.mul #[← elabTrm a, ← elabTrm b]
   | `(trm| get($a:trm, $i:num)) => do
     mkAppM ``Term.get #[← elabTrm a, toExpr i.getNat]
   | `(trm| slice($a:trm, $i:num, $j:num)) => do
@@ -213,12 +144,10 @@ partial def elabTrm : ElabStxCat `trm
     mkAppM ``Term.store #[← elabTrm a]
   | `(trm| load($a:trm)) => do
     mkAppM ``Term.load #[← elabTrm a]
-  | `(trm| pointer_as_u64($a:trm)) => do
-    mkAppM ``Term.pointerAsU64 #[← elabTrm a]
+  | `(trm| ptr_val($a:trm)) => do
+    mkAppM ``Term.ptrVal #[← elabTrm a]
   | `(trm| $v:trm : $t:typ) => do
     mkAppM ``Term.ann #[← elabTyp t, ← elabTrm v]
-  | `(trm| trace($s:str, $e:trm)) => do
-    mkAppM ``Term.trace #[mkStrLit s.getString, ← elabTrm e]
   | stx => throw $ .error stx "Invalid syntax for term"
 
 declare_syntax_cat                     constructor
@@ -298,7 +227,6 @@ def elabToplevel : ElabStxCat `toplevel
     mkAppM ``Toplevel.mk #[
       ← mkListLit (mkConst ``DataType) dataTypes.toList,
       ← mkListLit (mkConst ``Function) functions.toList,
-      ← mkArrayLit (mkConst ``Gadget) [],
     ]
   | stx => throw $ .error stx "Invalid syntax for toplevel"
 
diff --git a/Ix/Aiur2/Protocol.lean b/Ix/Aiur/Protocol.lean
similarity index 97%
rename from Ix/Aiur2/Protocol.lean
rename to Ix/Aiur/Protocol.lean
index a515ebd3..196569d3 100644
--- a/Ix/Aiur2/Protocol.lean
+++ b/Ix/Aiur/Protocol.lean
@@ -1,4 +1,4 @@
-import Ix.Aiur2.Bytecode
+import Ix.Aiur.Bytecode
 
 namespace Aiur
 
diff --git a/Ix/Aiur/Simple.lean b/Ix/Aiur/Simple.lean
index 3a623ef9..57211beb 100644
--- a/Ix/Aiur/Simple.lean
+++ b/Ix/Aiur/Simple.lean
@@ -6,9 +6,10 @@ namespace Aiur
 /-- This temporary variable can only be used when it does not shadow any other internal. -/
 private abbrev tmpVar := Local.idx 0
 
-partial def simplifyTerm (decls: Decls) : Term → Term
+partial def simplifyTerm (decls : Decls) : Term → Term
   | .let var@(.var _) val body => .let var (recr val) (recr body)
-  -- NOTE: This would not be safe in case Aiur allows side-effects. A sequencing operation would be needed.
+  -- NOTE: This would not be safe in case Aiur allows side-effects.
+  -- A sequencing operation would be needed.
   | .let .wildcard _ body => recr body
   | .let pat val body =>
     let mtch := .match (.var tmpVar) [(pat, body)]
@@ -20,32 +21,26 @@ partial def simplifyTerm (decls: Decls) : Term → Term
     | none => unreachable!
   | .ret r => .ret (recr r)
   | .app global args => .app global (args.map recr)
-  | .preimg global out => .preimg global (recr out)
-  | .ffi global args => .ffi global (args.map recr)
-  | .if b t f => .if (recr b) (recr t) (recr f)
   | .data (.tuple args) => .data (.tuple (args.map recr))
   | t => t
 where
   recr := simplifyTerm decls
 
-def simplify (decls : Decls) : Decls :=
-  decls.map fun decl => match decl with
-    | .function function => .function { function with body := simplifyTerm decls function.body }
-    | _ => decl
-
-def checkAndSimplifyToplevel (toplevel : Toplevel) : Except CheckError TypedDecls := do
+def Toplevel.checkAndSimplify (toplevel : Toplevel) : Except CheckError TypedDecls := do
   let decls ← toplevel.mkDecls
   wellFormedDecls decls
-  -- TODO: do not duplicate type inference. I.e. do simplification on typed expressions
+  -- The first check happens on the original terms.
   toplevel.functions.forM fun function => do
     let _ ← (checkFunction function) (getFunctionContext function decls)
-  let decls := simplify decls
+  let decls := decls.map fun decl => match decl with
+    | .function f => .function { f with body := simplifyTerm decls f.body }
+    | _ => decl
   decls.foldlM (init := default) fun typedDecls (name, decl) => match decl with
     | .constructor d c => pure $ typedDecls.insert name (.constructor d c)
     | .dataType d => pure $ typedDecls.insert name (.dataType d)
     | .function f => do
+      -- The second check happens on the simplified terms.
       let f ← (checkFunction f) (getFunctionContext f decls)
       pure $ typedDecls.insert name (.function f)
-    | .gadget g => pure $ typedDecls.insert name (.gadget g)
 
 end Aiur
diff --git a/Ix/Aiur/Synthesis.lean b/Ix/Aiur/Synthesis.lean
deleted file mode 100644
index 86a57be6..00000000
--- a/Ix/Aiur/Synthesis.lean
+++ /dev/null
@@ -1,310 +0,0 @@
-import Batteries.Data.RBMap.Basic
-import Ix.Aiur.Constraints
-import Ix.SmallMap
-
-namespace Aiur.Circuit
-
-abbrev B64_MULT_GEN : UInt128 := 508773776270040456
-abbrev B128_MULT_GEN : UInt128 := 61857528091874184034011775247790689018
-
-open Archon Binius
-
-structure AiurChannels where
-  func : Array ChannelId
-  add : ChannelId
-  mul : ChannelId
-  mem : SmallMap Nat ChannelId
-  gad : Array ChannelId
-
-inductive CachedOracleKey
-  | const : UInt128 → CachedOracleKey
-  | lc : ArithExpr → CachedOracleKey
-  deriving Ord
-
-structure SynthState where
-  circuitModule : CircuitModule
-  cachedOracles : Batteries.RBMap CachedOracleKey OracleIdx compare
-
-@[inline] def SynthState.init (circuitModule : CircuitModule) : SynthState :=
-  ⟨circuitModule, default⟩
-
-abbrev SynthM := StateM SynthState
-
-@[inline] def synthesizeM (circuitModuleId : USize) (f : SynthM α) : (CircuitModule × α) :=
-  let (a, stt) := f.run $ .init (CircuitModule.new circuitModuleId)
-  (stt.circuitModule.freezeOracles, a)
-
-@[inline] def flush (direction : FlushDirection) (channelId : ChannelId)
-    (selector : OracleIdx) (args : @& Array OracleOrConst) (multiplicity : UInt64) : SynthM Unit :=
-  modify fun stt =>
-    let circuitModule := stt.circuitModule.flush direction channelId selector
-      args multiplicity
-    { stt with circuitModule }
-
-@[inline] def send (channelId : ChannelId) (args : @& Array OracleOrConst) : SynthM Unit :=
-  flush .push channelId CircuitModule.selector args 1
-
-@[inline] def recv (channelId : ChannelId) (args : @& Array OracleOrConst) : SynthM Unit :=
-  flush .pull channelId CircuitModule.selector args 1
-
-@[inline] def assertZero (name : @& String) (expr : @& ArithExpr) : SynthM Unit :=
-  modify fun stt =>
-    { stt with circuitModule := stt.circuitModule.assertZero name #[] expr }
-
-@[inline] def assertExp (expBits : @& Array OracleIdx) (result : OracleIdx) (base : @& OracleOrConst) :
-    SynthM Unit :=
-  modify fun stt =>
-    { stt with circuitModule := stt.circuitModule.assertExp expBits result base }
-
-def addCommitted (name : @& String) (tf : TowerField) (relativeHeight : RelativeHeight) :
-    SynthM OracleIdx :=
-  modifyGet fun stt =>
-    let (o, circuitModule) := stt.circuitModule.addCommitted name tf relativeHeight
-    (o, { stt with circuitModule })
-
-def addTransparent (name : @& String) (transparent : Transparent) (relativeHeight : RelativeHeight) :
-    SynthM OracleIdx :=
-  modifyGet fun stt =>
-    let (o, circuitModule) := stt.circuitModule.addTransparent name transparent relativeHeight
-    (o, { stt with circuitModule })
-
-def addLinearCombination (name : @& String) (offset : @& UInt128)
-    (inner : @& Array (OracleIdx × UInt128)) (relativeHeight : RelativeHeight) : SynthM OracleIdx :=
-  modifyGet fun stt =>
-    let (o, circuitModule) := stt.circuitModule.addLinearCombination name offset inner relativeHeight
-    (o, { stt with circuitModule })
-
-def addPacked (name : @& String) (inner : OracleIdx) (logDegree : USize) : SynthM OracleIdx :=
-  modifyGet fun stt =>
-    let (o, circuitModule) := stt.circuitModule.addPacked name inner logDegree
-    (o, { stt with circuitModule })
-
-def addShifted (name : @& String) (inner : OracleIdx) (shiftOffset : UInt32)
-    (blockBits : USize) (shiftVariant : ShiftVariant) : SynthM OracleIdx :=
-  modifyGet fun stt =>
-    let (o, circuitModule) := stt.circuitModule.addShifted name inner shiftOffset
-      blockBits shiftVariant
-    (o, { stt with circuitModule })
-
-def addProjected (name : @& String) (inner : OracleIdx) (selection : UInt64)
-    (chunkSize : USize) : SynthM OracleIdx :=
-  modifyGet fun stt =>
-    let (o, circuitModule) := stt.circuitModule.addProjected name inner selection chunkSize
-    (o, { stt with circuitModule })
-
-def cacheLc (expr : ArithExpr) : SynthM OracleIdx :=
-  let key := .lc expr
-  modifyGet fun stt => match stt.cachedOracles.find? key with
-  | some o => (o, stt)
-  | none =>
-    let (summands, offset) := accSummandsAndOffset expr #[] 0
-    let inner := summands.map (·, 1)
-    let (o, circuitModule) := stt.circuitModule.addLinearCombination
-      s!"cached-lc-{expr}" offset inner .base
-    let cachedOracles := stt.cachedOracles.insert key o
-    (o, ⟨circuitModule, cachedOracles⟩)
-where
-  accSummandsAndOffset expr summands (offset : UInt128) := match expr with
-    | .const c => (summands, addUInt128InBinaryField offset c)
-    | .oracle o => (summands.push o, offset)
-    | .add a b =>
-      let (summands', offset') := accSummandsAndOffset a summands offset
-      accSummandsAndOffset b summands' offset'
-    | _ => unreachable!
-
-def provide (channelId : ChannelId) (multiplicity : OracleIdx)
-    (args : Array OracleOrConst) : SynthM Unit := do
-  send channelId (args.push (.const 1 .b1))
-  recv channelId (args.push (.oracle multiplicity))
-
-def require (channelId : ChannelId) (prevIdx : OracleIdx) (args : Array OracleOrConst)
-    (sel : OracleIdx) : SynthM Unit := do
-  let idx ← addLinearCombination s!"index-{channelId.toUSize}" 0 #[(prevIdx, B64_MULT_GEN)] .base
-  flush .pull channelId sel (args.push (.oracle prevIdx)) 1
-  flush .push channelId sel (args.push (.oracle idx)) 1
-
-def synthesizeFunction (funcIdx : FuncIdx) (function : Bytecode.Function)
-    (layout : Layout) (aiurChannels : AiurChannels) : SynthM Columns := do
-  let columns ← modifyGet fun stt =>
-    let (cs, circuitModule) := Columns.ofLayout stt.circuitModule layout
-    (cs, { stt with circuitModule })
-  let constraints := buildFuncionConstraints function layout columns
-  assertZero "func-topmost" (constraints.topmostSelector - CircuitModule.selector)
-  let funcChannel := aiurChannels.func[funcIdx]!
-  provide funcChannel constraints.multiplicity constraints.io
-  constraints.uniqueConstraints.zipIdx.forM fun (expr, i) =>
-    assertZero s!"func-unique-constraint-{i}" expr
-  constraints.sharedConstraints.zipIdx.forM fun (expr, i) =>
-    assertZero s!"func-shared-constraint-{i}" expr
-  constraints.recvs.forM fun (channel, sel, args) => do
-    let sel ← cacheLc sel
-    let args ← args.mapM cacheLc
-    let args := args.map .oracle
-    match channel with
-    | .add => flush .pull aiurChannels.add sel args 1
-    | .mul => flush .pull aiurChannels.mul sel args 1
-    | _ => unreachable!
-  constraints.requires.forM fun (channel, sel, prevIdx, values) => do
-    let sel ← cacheLc sel
-    let values ← values.mapM cacheLc
-    let values := values.map .oracle
-    match channel with
-    | .func funcIdx =>
-      let funcChannel := aiurChannels.func[funcIdx]!
-      require funcChannel prevIdx values sel
-    | .mem width =>
-      let channelId := aiurChannels.mem.get width |>.get!
-      require channelId prevIdx values sel
-    | .gadget gadgetIdx =>
-      let gadgetChannel := aiurChannels.gad[gadgetIdx]!
-      require gadgetChannel prevIdx values sel
-    | _ => unreachable!
-  pure columns
-
-structure AddColumns where
-  xin : OracleIdx
-  yin : OracleIdx
-  zout : OracleIdx
-  cout : OracleIdx
-
-def synthesizeAdd (channelId : ChannelId) : SynthM AddColumns := do
-  let xin ← addCommitted "add-xin" .b1 (.mul2 6)
-  let yin ← addCommitted "add-yin" .b1 (.mul2 6)
-  let zout ← addCommitted "add-zout" .b1 (.mul2 6)
-  let cout ← addCommitted "add-cout" .b1 (.mul2 6)
-  let cin ← addShifted "add-cin" cout 1 TowerField.b64.logDegree .logicalLeft
-  let xinPacked ← addPacked "add-xin-packed" xin TowerField.b64.logDegree
-  let yinPacked ← addPacked "add-yin-packed" yin TowerField.b64.logDegree
-  let zoutPacked ← addPacked "add-zout-packed" zout TowerField.b64.logDegree
-  let coutProjected ← addProjected "add-cout-projected" cout 63 64
-  assertZero "add-sum" $ xin + yin + cin - zout
-  assertZero "add-carry" $ (xin + cin) * (yin + cin) + cin - cout
-  send channelId $ #[xinPacked, yinPacked, zoutPacked, coutProjected].map .oracle
-  pure { xin, yin, zout, cout }
-
-structure MulColumns where
-  xin : OracleIdx
-  yin : OracleIdx
-  zout : OracleIdx
-  xinBits : Array OracleIdx
-  yinBits : Array OracleIdx
-  zoutBits : Array OracleIdx
-  xinExpResult : OracleIdx
-  yinExpResult : OracleIdx
-  zoutLowExpResult : OracleIdx
-  zoutHighExpResult : OracleIdx
-
-def B128GenPow2To64 : UInt128 :=
-  let outSize := 64
-  outSize.fold (init := B128_MULT_GEN)
-    fun _ _ g => mulUInt128InBinaryField g g
-
-def synthesizeMul (channelId : ChannelId) : SynthM MulColumns := do
-  let xin ← addCommitted "mul-xin" .b64 .base
-  let yin ← addCommitted "mul-yin" .b64 .base
-  let zout ← addCommitted "mul-zout" .b64 .base
-  let xinBits ← Array.range 64 |>.mapM (addCommitted s!"mul-xin-bit-{·}" .b1 .base)
-  let yinBits ← Array.range 64 |>.mapM (addCommitted s!"mul-yin-bit-{·}" .b1 .base)
-  bitDecomposition "mul-bit-decomposition-xin" xinBits xin
-  bitDecomposition "mul-bit-decomposition-yin" yinBits yin
-  let (xinExpResult, yinExpResult, zoutLowExpResult, zoutHighExpResult, zoutBits)
-    ← mul xinBits yinBits
-  let zoutLow := zoutBits.extract (stop := 64)
-  bitDecomposition "mul-bit-decomposition-zout" zoutLow zout
-  send channelId $ #[xin, yin, zout].map .oracle
-  pure {
-    xin,
-    yin,
-    zout,
-    xinBits,
-    yinBits,
-    zoutBits,
-    xinExpResult,
-    yinExpResult,
-    zoutLowExpResult,
-    zoutHighExpResult, }
-where
-  bitDecomposition name bits word :=
-    let (expr, _) := bits.foldl (init := (.oracle word, (1 : UInt64)))
-      fun (expr, coeff) bit => (expr - (.const (.ofLoHi coeff 0)) * bit, coeff <<< 1)
-    assertZero name expr
-  mul xinBits yinBits := do
-    let outSize : Nat := 64
-    let xinExpResult ← addCommitted "mul-xin-exp-result" .b128 .base
-    let yinExpResult ← addCommitted "mul-yin-exp-result" .b128 .base
-    let zoutLowExpResult ← addCommitted "mul-zout-low-exp-result" .b128 .base
-    let zoutHighExpResult ← addCommitted "mul-zout-high-exp-result" .b128 .base
-    let zoutBits ← Array.range (2 * outSize) |>.mapM (addCommitted s!"mul-zout-bit-{·}" .b1 .base)
-
-    let xin0 := xinBits[0]!
-    let yin0 := yinBits[0]!
-    let zout0 := zoutBits[0]!
-    assertZero "mul-bit0" $ xin0 * yin0 - zout0
-
-    let yin := yinExpResult
-    let low := zoutLowExpResult
-    let high := zoutHighExpResult
-    assertZero "mul-yin-zout-low-high" $ low * high - yin
-
-    let zoutLow := zoutBits.extract (stop := outSize)
-    let zoutHigh := zoutBits.extract (start := outSize)
-
-    assertExp xinBits xinExpResult (.const B128_MULT_GEN .b128)
-    assertExp yinBits yinExpResult (.oracle xinExpResult)
-    assertExp zoutLow zoutLowExpResult (.const B128_MULT_GEN .b128)
-    assertExp zoutHigh zoutHighExpResult (.const B128GenPow2To64 .b128)
-
-    pure (xinExpResult, yinExpResult, zoutLowExpResult, zoutHighExpResult, zoutBits)
-
-structure MemoryColumns where
-  values : Array OracleIdx
-  multiplicity : OracleIdx
-
-def synthesizeMemory (channelId : ChannelId) (width : Nat) : SynthM MemoryColumns := do
-  let address ← addTransparent s!"mem-{width}-address" .incremental .base
-  let values ← Array.range width |>.mapM (addCommitted s!"mem-{width}-value-{·}" .b64 .base)
-  let multiplicity ← addCommitted s!"mem-{width}-multiplicity" .b64 .base
-  let args := #[address] ++ values |>.map .oracle
-  provide channelId multiplicity args
-  pure { values, multiplicity }
-
-structure AiurCircuits where
-  funcs : Array (CircuitModule × Columns)
-  add : CircuitModule × AddColumns
-  mul : CircuitModule × MulColumns
-  mem : Array (CircuitModule × MemoryColumns)
-  gad : Array (CircuitModule × Array OracleIdx)
-
-def AiurCircuits.circuitModules (self : AiurCircuits) : Array CircuitModule :=
-  self.funcs.map (·.fst)
-    ++ #[self.add.fst, self.mul.fst]
-    ++ self.mem.map (·.fst)
-    ++ self.gad.map (·.fst)
-
-def synthesize (toplevel : Bytecode.Toplevel) : AiurCircuits × Array ChannelId :=
-  let (funcChannels, channelAllocator) := ChannelAllocator.init.nextN toplevel.functions.size
-  let (addChannel, channelAllocator) := channelAllocator.next
-  let (mulChannel, channelAllocator) := channelAllocator.next
-  let (memChannels, channelAllocator) := channelAllocator.nextN toplevel.memWidths.size
-  let (gadgetChannels, _) := channelAllocator.nextN toplevel.gadgets.size
-  let memChannelsMap := ⟨toplevel.memWidths.zip memChannels⟩
-  let aiurChannels := ⟨funcChannels, addChannel, mulChannel, memChannelsMap, gadgetChannels⟩
-  let funcsModules := toplevel.functions.zip toplevel.layouts |>.zipIdx.map
-    fun ((function, layout), functionIdx) => synthesizeM functionIdx.toUSize
-      (synthesizeFunction functionIdx function layout aiurChannels)
-  let numFunctions := toplevel.functions.size.toUSize
-  let addModule := synthesizeM numFunctions (synthesizeAdd addChannel)
-  let mulModule := synthesizeM (numFunctions + 1) (synthesizeMul mulChannel)
-  let memIdStart := numFunctions + 2
-  let memModules := memChannelsMap.pairs.zipIdx.map
-    fun ((width, channelId), memIdx) =>
-      synthesizeM (memIdStart + memIdx.toUSize) (synthesizeMemory channelId width)
-  let gadgetIdStart := memIdStart + memModules.size.toUSize
-  let gadgetsModules := toplevel.gadgets.zip gadgetChannels |>.zipIdx.map
-    fun ((gadget, channelId), gadgetIdx) =>
-      let circuitModule := CircuitModule.new $ gadgetIdStart + gadgetIdx.toUSize
-      let (circuitModule, oracles) := gadget.synthesize channelId circuitModule
-      (circuitModule.freezeOracles, oracles)
-  (⟨funcsModules, addModule, mulModule, memModules, gadgetsModules⟩, aiurChannels.func)
-
-end Aiur.Circuit
diff --git a/Ix/Aiur/Term.lean b/Ix/Aiur/Term.lean
index d9d89ef3..bc54f9a2 100644
--- a/Ix/Aiur/Term.lean
+++ b/Ix/Aiur/Term.lean
@@ -1,5 +1,5 @@
 import Std.Data.HashSet.Basic
-import Ix.Aiur.Gadget
+import Ix.Aiur.Goldilocks
 import Ix.IndexMap
 
 namespace Aiur
@@ -38,36 +38,17 @@ def Global.popNamespace (global : Global) : Option (String × Global) :=
   | .str tail head => some (head, ⟨tail⟩)
   | _ => none
 
-inductive Primitive
-  | u1 : Bool → Primitive
-  | u8 : UInt8 → Primitive
-  | u16 : UInt16 → Primitive
-  | u32 : UInt32 → Primitive
-  | u64 : UInt64 → Primitive
-  deriving Repr, BEq, Hashable
-
-def Primitive.toU64 : Primitive → UInt64
-| .u1 n => n.toUInt64
-| .u8 n => n.toUInt64
-| .u16 n => n.toUInt64
-| .u32 n => n.toUInt64
-| .u64 n => n
-
 inductive Pattern
   | var : Local → Pattern
   | wildcard : Pattern
   | ref : Global → List Pattern → Pattern
-  | primitive : Primitive → Pattern
+  | field : G → Pattern
   | tuple : Array Pattern → Pattern
   | or : Pattern → Pattern → Pattern
   deriving Repr, BEq, Hashable, Inhabited
 
-inductive PrimitiveType
-  | u1 | u8 | u16 | u32 | u64
-  deriving Repr, BEq, Hashable
-
 inductive Typ where
-  | primitive : PrimitiveType → Typ
+  | field
   | tuple : Array Typ → Typ
   | pointer : Typ → Typ
   | dataType : Global → Typ
@@ -83,26 +64,20 @@ inductive Term
   | ret : Term → Term
   | let : Pattern → Term → Term → Term
   | match : Term → List (Pattern × Term) → Term
-  | if : Term → Term → Term → Term
   | app : Global → List Term → Term
-  | preimg : Global → Term → Term
-  | ffi : Global → List Term → Term
-  | xor : Term → Term → Term
-  | and : Term → Term → Term
-  | addU64 : Term → Term → Term
-  | subU64 : Term → Term → Term
-  | mulU64 : Term → Term → Term
+  | add : Term → Term → Term
+  | sub : Term → Term → Term
+  | mul : Term → Term → Term
   | get : Term → Nat → Term
   | slice : Term → Nat → Nat → Term
   | store : Term → Term
   | load : Term → Term
-  | pointerAsU64 : Term → Term
+  | ptrVal : Term → Term
   | ann : Typ → Term → Term
-  | trace : String → Term → Term
   deriving Repr, BEq, Hashable, Inhabited
 
 inductive Data
-  | primitive : Primitive → Data
+  | field : G → Data
   | tuple : Array Term → Data
   deriving Repr
 
@@ -129,21 +104,15 @@ inductive TypedTermInner
   | ret : TypedTerm → TypedTermInner
   | let : Pattern → TypedTerm → TypedTerm → TypedTermInner
   | match : TypedTerm → List (Pattern × TypedTerm) → TypedTermInner
-  | if : TypedTerm → TypedTerm → TypedTerm → TypedTermInner
   | app : Global → List TypedTerm → TypedTermInner
-  | preimg : Global → TypedTerm → TypedTermInner
-  | ffi : Global → List TypedTerm → TypedTermInner
-  | xor : TypedTerm → TypedTerm → TypedTermInner
-  | and : TypedTerm → TypedTerm → TypedTermInner
-  | addU64 : TypedTerm → TypedTerm → TypedTermInner
-  | subU64 : TypedTerm → TypedTerm → TypedTermInner
-  | mulU64 : TypedTerm → TypedTerm → TypedTermInner
+  | add : TypedTerm → TypedTerm → TypedTermInner
+  | sub : TypedTerm → TypedTerm → TypedTermInner
+  | mul : TypedTerm → TypedTerm → TypedTermInner
   | get : TypedTerm → Nat → TypedTermInner
   | slice : TypedTerm → Nat → Nat → TypedTermInner
   | store : TypedTerm → TypedTermInner
   | load : TypedTerm → TypedTermInner
-  | pointerAsU64 : TypedTerm → TypedTermInner
-  | trace : String → TypedTerm → TypedTermInner
+  | ptrVal : TypedTerm → TypedTermInner
   deriving Repr, Inhabited
 
 structure TypedTerm where
@@ -152,7 +121,7 @@ structure TypedTerm where
   deriving Repr, Inhabited
 
 inductive TypedData
-  | primitive : Primitive → TypedData
+  | field : G → TypedData
   | tuple : Array TypedTerm → TypedData
   deriving Repr
 
@@ -178,20 +147,15 @@ structure Function where
 structure Toplevel where
   dataTypes : List DataType
   functions : List Function
-  gadgets : Array Gadget
   deriving Repr
 
 def Toplevel.getFuncIdx (toplevel : Toplevel) (funcName : Lean.Name) : Option Nat := do
   toplevel.functions.findIdx? fun function => function.name.toName == funcName
 
-@[inline] def Toplevel.addGadget (toplevel : Toplevel) (gadget : Gadget) : Toplevel :=
-  { toplevel with gadgets := toplevel.gadgets.push gadget }
-
 inductive Declaration
   | function : Function → Declaration
   | dataType : DataType → Declaration
   | constructor : DataType → Constructor → Declaration
-  | gadget : Gadget → Declaration
   deriving Repr, Inhabited
 
 abbrev Decls := IndexMap Global Declaration
@@ -207,7 +171,6 @@ inductive TypedDeclaration
   | function : TypedFunction → TypedDeclaration
   | dataType : DataType → TypedDeclaration
   | constructor : DataType → Constructor → TypedDeclaration
-  | gadget : Gadget → TypedDeclaration
   deriving Repr, Inhabited
 
 abbrev TypedDecls := IndexMap Global TypedDeclaration
@@ -217,7 +180,7 @@ mutual
 open Std (HashSet)
 
 partial def Typ.size (decls : TypedDecls) (visited : HashSet Global := {}) : Typ → Nat
-  | Typ.primitive .. => 1
+  | Typ.field .. => 1
   | Typ.pointer .. => 1
   | Typ.function .. => 1
   | Typ.tuple ts => ts.foldl (init := 0) (fun acc t => acc + t.size decls visited)
diff --git a/Ix/Aiur/Trace.lean b/Ix/Aiur/Trace.lean
deleted file mode 100644
index 349a7b6d..00000000
--- a/Ix/Aiur/Trace.lean
+++ /dev/null
@@ -1,326 +0,0 @@
-import Ix.Archon.ModuleMode
-import Ix.Archon.TowerField
-import Ix.Binius.Common
-import Ix.Aiur.Term
-import Ix.Aiur.Execute
-import Ix.Aiur.Bytecode
-
--- TODO: generic definition
-def Aiur.MultiplicativeGenerator : UInt64 := 0x070f870dcd9c1d88
-
-namespace Aiur.Circuit
-
-structure FunctionTrace where
-  numQueries : Nat
-  height : Nat
-  inputs: Array (Array UInt64)
-  outputs: Array (Array UInt64)
-  u1Auxiliaries: Array (Array Bool)
-  u8Auxiliaries: Array (Array UInt8)
-  u64Auxiliaries: Array (Array UInt64)
-  selectors: Array (Array Bool)
-  multiplicity: Array UInt64
-  deriving Inhabited, Repr
-
-def FunctionTrace.mode (trace : FunctionTrace) : Archon.ModuleMode :=
-  if trace.height == 0
-  then .inactive
-  else .active trace.height.log2.toUInt8 trace.numQueries.toUInt64
-
-structure ArithmeticTrace where
-  xs : Array UInt64
-  ys : Array UInt64
-  mode : Archon.ModuleMode
-  deriving Repr
-
-def ArithmeticTrace.add (pairs : Array $ UInt64 × UInt64) : ArithmeticTrace :=
-  if pairs.size == 0 then
-    ⟨#[], #[], .inactive⟩
-  else
-    let depth := pairs.size
-    let targetNumPairs := pairs.size.nextPowerOfTwo.max 2 -- to fill 128 bits
-    let logHeight := targetNumPairs.log2.toUInt8
-    let (xs, ys) := pairs.unzip
-    ⟨xs, ys, .active logHeight depth.toUInt64⟩
-
-def ArithmeticTrace.mul (pairs : Array $ UInt64 × UInt64) : ArithmeticTrace :=
-  if pairs.size == 0 then
-    ⟨#[], #[], .inactive⟩
-  else
-    let depth := pairs.size
-    let targetNumPairs := pairs.size.nextPowerOfTwo.max 128 -- xin-bits require a minimum of 128 elements
-    let logHeight := targetNumPairs.log2.toUInt8
-    let (xs, ys) := pairs.unzip
-    ⟨xs, ys, .active logHeight depth.toUInt64⟩
-
-structure MemoryTrace where
-  numQueries : Nat
-  height : Nat
-  multiplicity: Array UInt64
-  values: Array (Array UInt64)
-  deriving Inhabited, Repr
-
-def MemoryTrace.mode (trace : MemoryTrace) : Archon.ModuleMode :=
-  if trace.height == 0
-  then .inactive
-  else .active trace.height.log2.toUInt8 trace.numQueries.toUInt64
-
-structure ColumnIndex where
-  u1Auxiliary : Nat
-  u8Auxiliary : Nat
-  u64Auxiliary : Nat
-  input : Nat
-  output : Nat
-  deriving Inhabited
-
-inductive Query where
-| Func : FuncIdx → Array UInt64 → Query
-| Mem : Nat → Array UInt64 → Query
-| Gadget : GadgetIdx → Array UInt64 → Query
-deriving BEq, Hashable
-
-structure AiurTrace where
-  functions : Array FunctionTrace
-  add : ArithmeticTrace
-  mul : ArithmeticTrace
-  mem : Array MemoryTrace
-  gadgets : Array $ Array GadgetEntry
-
-def FunctionTrace.blank (layout : Layout) (numQueries : Nat) : FunctionTrace :=
-  let height := if numQueries == 0 then 0 else numQueries.nextPowerOfTwo.max 128
-  let arr1 := Array.mkArray height false
-  let arr8 := Array.mkArray height 0
-  let arr64 := Array.mkArray height 0
-  let inputs := Array.mkArray layout.inputs arr64
-  let outputs := Array.mkArray layout.outputs arr64
-  let u1Auxiliaries := Array.mkArray layout.u1Auxiliaries arr1
-  let u8Auxiliaries := Array.mkArray layout.u8Auxiliaries arr8
-  let u64Auxiliaries := Array.mkArray layout.u64Auxiliaries arr64
-  let selectors := Array.mkArray layout.selectors arr1
-  let multiplicity := arr64
-  { height, numQueries, inputs, outputs, u1Auxiliaries, u8Auxiliaries, u64Auxiliaries, selectors, multiplicity }
-
-end Aiur.Circuit
-
-namespace Aiur.Bytecode
-
-open Binius
-
-structure TraceState where
-  row : Nat
-  trace : Circuit.FunctionTrace
-  map : Array UInt64
-  col : Circuit.ColumnIndex
-  prevCounts : Std.HashMap Circuit.Query UInt64
-  deriving Inhabited
-
-abbrev TraceM := ReaderT QueryRecord (StateM TraceState)
-
-def TraceM.run (query : QueryRecord) (initialState : TraceState) (action : TraceM A) : A × TraceState :=
-  StateT.run (ReaderT.run action query) initialState
-
-def TraceM.pushVar (c : UInt64) : TraceM Unit :=
-  modify fun s => { s with map := s.map.push c }
-
-def TraceM.pushU1 (b : Bool) : TraceM Unit :=
-  modify fun s =>
-    let trace := { s.trace with u1Auxiliaries := s.trace.u1Auxiliaries.modify s.col.u1Auxiliary fun col => col.set! s.row b }
-    let col := { s.col with u1Auxiliary := s.col.u1Auxiliary + 1 }
-    { s with trace, col }
-
-def TraceM.pushU64 (b : UInt64) : TraceM Unit :=
-  modify fun s =>
-    let trace := { s.trace with u64Auxiliaries := s.trace.u64Auxiliaries.modify s.col.u64Auxiliary fun col => col.set! s.row b }
-    let col := { s.col with u64Auxiliary := s.col.u64Auxiliary + 1 }
-    { s with trace, col }
-
-def TraceM.pushInput (b : UInt64) : TraceM Unit :=
-  modify fun s =>
-    let trace := { s.trace with inputs := s.trace.inputs.modify s.col.input fun col => col.set! s.row b }
-    let col := { s.col with input := s.col.input + 1 }
-    { s with trace, col }
-
-def TraceM.pushOutput (b : UInt64) : TraceM Unit :=
-  modify fun s =>
-    let trace := { s.trace with outputs := s.trace.outputs.modify s.col.output fun col => col.set! s.row b }
-    let col := { s.col with output := s.col.output + 1 }
-    { s with trace, col }
-
-def TraceM.pushCount (query : Circuit.Query) : TraceM Unit := do
-  modify fun s =>
-    let prevCount := (s.prevCounts.get? query).getD 1
-    let trace := { s.trace with u64Auxiliaries := s.trace.u64Auxiliaries.modify s.col.u64Auxiliary fun col => col.set! s.row prevCount }
-    let col := { s.col with u64Auxiliary := s.col.u64Auxiliary + 1 }
-    let prevCounts := s.prevCounts.insert query $ mulUInt64InBinaryField prevCount MultiplicativeGenerator
-    { s with prevCounts, trace, col }
-
-def TraceM.loadMemMap (len : Nat) : TraceM QueryMap := do
-  let queries := (← read).memQueries
-  let idx := (queries.findIdx? (·.fst == len)).get!
-  pure queries[idx]!.snd
-
-def TraceM.setSelector (sel : SelIdx) : TraceM Unit :=
-  modify fun s =>
-    let trace := { s.trace with selectors := s.trace.selectors.modify sel fun col => col.set! s.row true }
-    { s with trace }
-
-def TraceM.populateIO
-  (inputValues : Array UInt64)
-  (result : QueryResult)
-: TraceM Unit := do
-  inputValues.forM pushInput
-  result.values.forM pushOutput
-  modify fun s =>
-    let m := powUInt64InBinaryField MultiplicativeGenerator result.multiplicity
-    let trace := { s.trace with multiplicity := s.trace.multiplicity.set! s.row m }
-    { s with trace }
-
-mutual
-partial def Block.populateRow (block : Block) : TraceM Unit := do
-  block.ops.forM fun op => op.populateRow
-  block.ctrl.populateRow
-
-partial def Ctrl.populateRow : Ctrl → TraceM Unit
-| .ret sel _ => TraceM.setSelector sel
-| .if b t f => do
-  let val := (← get).map[b]!
-  if val != 0
-  then
-    TraceM.pushU64 $ invUInt64InBinaryField val
-    t.populateRow
-  else f.populateRow
-| .match v branches defaultBranch => do
-  let val := (← get).map[v]!
-  match branches.find? fun branch => branch.fst == val with
-  | some branch => branch.snd.populateRow
-  | none =>
-    branches.forM fun (case, _) =>
-      TraceM.pushU64 $ invUInt64InBinaryField (val.xor case)
-    defaultBranch.get!.populateRow
-
-partial def Op.populateRow : Op → TraceM Unit
-| .prim a => TraceM.pushVar a.toU64
-| .xor a b => do
-  let map := (← get).map
-  let c := map[a]!.xor map[b]!
-  TraceM.pushVar c
-| .and a b => do
-  let map := (← get).map
-  let c := map[a]!.land map[b]!
-  TraceM.pushU1 (c == 1)
-  TraceM.pushVar c
-| .add a b => do
-  let map := (← get).map
-  let a := map[a]!
-  let c := a + map[b]!
-  let overflow := decide (c < a)
-  TraceM.pushU64 c
-  TraceM.pushU1 overflow
-  TraceM.pushVar c
-| .sub c b => do
-  let map := (← get).map
-  let c := map[c]!
-  let b := map[b]!
-  let a := c - b
-  let overflow := decide (c < b)
-  TraceM.pushU64 a
-  TraceM.pushVar a
-  TraceM.pushU1 overflow
-| .mul a b => do
-  let map := (← get).map
-  let c := map[a]! * map[b]!
-  TraceM.pushU64 c
-  TraceM.pushVar c
-| .lt c b => do
-  let map := (← get).map
-  let c := map[c]!
-  let b := map[b]!
-  let a := c.sub b
-  let overflow := decide (c < b)
-  TraceM.pushU64 a
-  TraceM.pushU1 overflow
-  TraceM.pushVar overflow.toUInt64
-| .store values => do
-  let len := values.size
-  let mem ← TraceM.loadMemMap len
-  let map := (← get).map
-  let values := values.map fun value => map[value]!
-  let result := (mem.getByKey values).get!
-  result.values.forM fun value => do
-    TraceM.pushU64 value
-    TraceM.pushVar value
-  TraceM.pushCount (.Mem len values)
-| .load len ptr => do
-  let mem ← TraceM.loadMemMap len
-  let map := (← get).map
-  let ptr := map[ptr]!
-  let (values, _) := (mem.getByIdx ptr.toNat).get!
-  values.forM fun value => do
-    TraceM.pushU64 value
-    TraceM.pushVar value
-  TraceM.pushCount (.Mem len values)
-| .call fIdx args _ => do
-  let map := (← get).map
-  let args := args.map fun arg => map[arg]!
-  let output := ((← read).getFuncResult fIdx args).get!
-  output.forM fun value => do
-    TraceM.pushU64 value
-    TraceM.pushVar value
-  TraceM.pushCount (.Func fIdx args)
-| .ffi gIdx args _ => do
-  let map := (← get).map
-  let args := args.map fun arg => map[arg]!
-  let output := ((← read).getGadgetResult gIdx args).get!
-  output.forM fun value => do
-    TraceM.pushU64 value
-    TraceM.pushVar value
-  TraceM.pushCount (.Gadget gIdx args)
-| .trace _ _ => pure ()
-| _ => panic! "TODO"
-end
-
-def Function.populateTrace
-  (function : Function)
-  (funcMap : QueryMap)
-  (layout : Circuit.Layout)
-: TraceM Unit := do
-  let numQueries := funcMap.size
-  modify fun s => { s with trace := Circuit.FunctionTrace.blank layout numQueries }
-  for ((inputs, result), row) in funcMap.pairs.zipIdx do
-    modify fun s => { s with map := inputs, row, col := default }
-    TraceM.populateIO inputs result
-    function.body.populateRow
-
-def QueryMap.generateTrace (map : QueryMap) (width : Nat) : Id Circuit.MemoryTrace := do
-  let height := map.size.nextPowerOfTwo.max 128
-  let blankColumn : Array UInt64 := Array.mkArray height 0
-  let mut multiplicity := blankColumn
-  let mut values := Array.mkArray width blankColumn
-  let numQueries := map.size
-  for ((input, result), i) in map.pairs.zipIdx do
-    multiplicity := multiplicity.set! i $ powUInt64InBinaryField MultiplicativeGenerator result.multiplicity
-    values := (values.zip input).map fun (value, res) => value.set! i res
-  pure { height, multiplicity, values, numQueries }
-
-def Toplevel.generateTraces
-  (toplevel : Toplevel)
-  (queries : QueryRecord)
-: Circuit.AiurTrace :=
-  let action := do
-    let mut traces := #[]
-    for i in [0:toplevel.functions.size] do
-      let function := toplevel.functions[i]!
-      let functionMap := queries.funcQueries[i]!
-      let layout := toplevel.layouts[i]!
-      function.populateTrace functionMap layout
-      let trace := (← get).trace
-      traces := traces.push trace
-    pure traces
-  let functions := (action.run queries default).fst
-  let add := .add queries.addQueries
-  let mul := .mul queries.mulQueries
-  let mem := queries.memQueries.map fun (width, map) => map.generateTrace width
-  let gadgets := queries.getGadgetEntries
-  { functions, add, mul, mem, gadgets }
-
-end Aiur.Bytecode
diff --git a/Ix/Aiur/Witness.lean b/Ix/Aiur/Witness.lean
deleted file mode 100644
index 67b0c2e4..00000000
--- a/Ix/Aiur/Witness.lean
+++ /dev/null
@@ -1,182 +0,0 @@
-import Ix.Aiur.Trace
-import Ix.Aiur.Synthesis
-import Ix.Archon.Circuit
-import Ix.Archon.TowerField
-import Ix.Binius.Boundary
-
-namespace Aiur.Circuit
-
-open Archon Binius
-
-def packBools (bits : Array Bool) : Array UInt8 :=
-  let n := (bits.size + 7) / 8
-  Array.range n |>.map fun i => Id.run do
-    let mut byte : UInt8 := 0
-    for j in [:8] do
-      let idx := i * 8 + j
-      if h : idx < bits.size then
-        if bits[idx] then
-          byte := byte ||| (1 <<< j).toUInt8
-    byte
-
-def extractBits (nums : Array UInt64) : Id (Array (Array Bool)) := do
-  let numBits := 64
-  let mut bitVectors := Array.mkArray numBits #[]
-  for num in nums do
-    for i in [0:numBits] do
-      let bit := num.toNat.testBit i
-      bitVectors := bitVectors.modify i (fun lst => lst.push bit)
-  bitVectors
-
-def extractBits128 (nums : Array UInt128) : Id (Array (Array Bool)) := do
-  let numBits := 128
-  let mut bitVectors := Array.mkArray numBits #[]
-  for num in nums do
-    for i in [0:numBits] do
-      let bit := num.toNat.testBit i
-      bitVectors := bitVectors.modify i (fun lst => lst.push bit)
-  bitVectors
-
-def pushData (witnessModule : WitnessModule)
-    (pushFn : WitnessModule → Array α → EntryId → WitnessModule)
-    (data : Array α) (oracle : OracleIdx) (tf : TowerField) : WitnessModule :=
-  let (entry, witnessModule) := witnessModule.addEntry
-  let witnessModule := witnessModule.bindOracleTo oracle entry tf
-  pushFn witnessModule data entry
-
-def populateWitness (circuits : AiurCircuits) (trace : AiurTrace)
-    (gadgets : Array Gadget) : Id Witness := do
-  let mut witnessModules := #[]
-  let mut modes := #[]
-
-  -- Functions
-  for ((mod, cols), funcTrace) in circuits.funcs.zip trace.functions do
-    modes := modes.push funcTrace.mode
-    let mut witnessModule := mod.initWitnessModule
-    -- Inputs
-    for (data, oracle) in funcTrace.inputs.zip cols.inputs do
-      witnessModule := pushData witnessModule .pushUInt64sTo data oracle .b64
-    -- Outputs
-    for (data, oracle) in funcTrace.outputs.zip cols.outputs do
-      witnessModule := pushData witnessModule .pushUInt64sTo data oracle .b64
-    -- u1Auxiliaries
-    for (data, oracle) in funcTrace.u1Auxiliaries.zip cols.u1Auxiliaries do
-      witnessModule := pushData witnessModule .pushUInt8sTo (packBools data) oracle .b1
-    -- u8Auxiliaries
-    for (data, oracle) in funcTrace.u8Auxiliaries.zip cols.u8Auxiliaries do
-      witnessModule := pushData witnessModule .pushUInt8sTo data oracle .b8
-    -- u64Auxiliaries
-    for (data, oracle) in funcTrace.u64Auxiliaries.zip cols.u64Auxiliaries do
-      witnessModule := pushData witnessModule .pushUInt64sTo data oracle .b64
-    -- selectors
-    for (data, oracle) in funcTrace.selectors.zip cols.selectors do
-      witnessModule := pushData witnessModule .pushUInt8sTo (packBools data) oracle .b1
-    -- multiplicity
-    witnessModule := pushData witnessModule .pushUInt64sTo funcTrace.multiplicity
-      cols.multiplicity .b64
-    -- Collect the witness module
-    witnessModules := witnessModules.push witnessModule
-
-  -- Add
-  let xins := trace.add.xs
-  let yins := trace.add.ys
-  modes := modes.push trace.add.mode
-  let mut addZout := Array.mkEmpty xins.size
-  let mut addCout := Array.mkEmpty xins.size
-  for (xin, yin) in xins.zip yins do
-    let zout := xin + yin
-    let carry := (decide (zout < xin)).toUInt64
-    let cin := xin ^^^ yin ^^^ zout
-    addZout := addZout.push zout
-    addCout := addCout.push $ (carry <<< 63) ||| (cin >>> 1)
-  let (circuitModule, cols) := circuits.add
-  let mut addWitnessModule := circuitModule.initWitnessModule
-  -- xin
-  addWitnessModule := pushData addWitnessModule .pushUInt64sTo xins cols.xin .b1
-  -- yin
-  addWitnessModule := pushData addWitnessModule .pushUInt64sTo yins cols.yin .b1
-  -- zout
-  addWitnessModule := pushData addWitnessModule .pushUInt64sTo addZout cols.zout .b1
-  -- cout
-  addWitnessModule := pushData addWitnessModule .pushUInt64sTo addCout cols.cout .b1
-  -- Collect addWitnessModule
-  witnessModules := witnessModules.push addWitnessModule
-
-  -- Mul
-  let xins := trace.mul.xs
-  let yins := trace.mul.ys
-  modes := modes.push trace.mul.mode
-  let mut zouts := Array.mkEmpty xins.size
-  let mut zoutsLow := Array.mkEmpty xins.size
-  let mut zoutsHigh := Array.mkEmpty xins.size
-  for (xin, yin) in xins.zip yins do
-    let zout := UInt128.exteriorMul xin yin
-    zouts := zouts.push zout
-    let (zoutLow, zoutHigh) := UInt128.toLoHi zout
-    zoutsLow := zoutsLow.push zoutLow
-    zoutsHigh := zoutsHigh.push zoutHigh
-  let (circuitModule, cols) := circuits.mul
-  let mut mulWitnessModule := circuitModule.initWitnessModule
-  -- xin
-  mulWitnessModule := pushData mulWitnessModule .pushUInt64sTo xins cols.xin .b64
-  -- yin
-  mulWitnessModule := pushData mulWitnessModule .pushUInt64sTo yins cols.yin .b64
-  -- zout
-  mulWitnessModule := pushData mulWitnessModule .pushUInt64sTo zoutsLow cols.zout .b64
-  -- xinBits
-  for (oracle, xinBits) in cols.xinBits.zip (extractBits xins) do
-    mulWitnessModule := pushData mulWitnessModule .pushUInt8sTo (packBools xinBits) oracle .b1
-  -- yinBits
-  for (oracle, yinBits) in cols.yinBits.zip (extractBits yins) do
-    mulWitnessModule := pushData mulWitnessModule .pushUInt8sTo (packBools yinBits) oracle .b1
-  -- zoutBits
-  for (oracle, zoutBits) in cols.zoutBits.zip (extractBits128 zouts) do
-    mulWitnessModule := pushData mulWitnessModule .pushUInt8sTo (packBools zoutBits) oracle .b1
-  -- TODO: exponentials require manual padding. For some reason, Binius' exponential constraints are not working properly
-  -- xinExpResult
-  let xinExpResult := xins.map fun xin => powUInt128InBinaryField B128_MULT_GEN xin
-  mulWitnessModule := pushData mulWitnessModule .pushUInt128sTo xinExpResult cols.xinExpResult .b128
-  -- yinExpResult
-  let yinExpResult := (yins.zip xinExpResult).map fun (yin, xinExp) => powUInt128InBinaryField xinExp yin
-  mulWitnessModule := pushData mulWitnessModule .pushUInt128sTo yinExpResult cols.yinExpResult .b128
-  -- zoutLowExpResult
-  let zoutLowExpResult := zoutsLow.map fun zoutLow => powUInt128InBinaryField B128_MULT_GEN zoutLow
-  mulWitnessModule := pushData mulWitnessModule .pushUInt128sTo zoutLowExpResult cols.zoutLowExpResult .b128
-  -- zoutHighExpResult
-  let zoutHighExpResult := zoutsHigh.map fun zoutHigh => powUInt128InBinaryField B128GenPow2To64 zoutHigh
-  mulWitnessModule := pushData mulWitnessModule .pushUInt128sTo zoutHighExpResult cols.zoutHighExpResult .b128
-  -- Collect mulWitnessModule
-  witnessModules := witnessModules.push mulWitnessModule
-
-  -- Memory
-  for ((mod, cols), memTrace) in circuits.mem.zip trace.mem do
-    modes := modes.push memTrace.mode
-    let mut witnessModule := mod.initWitnessModule
-    for (oracle, data) in cols.values.zip memTrace.values do
-      witnessModule := pushData witnessModule .pushUInt64sTo data oracle .b64
-    -- multiplicity
-    witnessModule := pushData witnessModule .pushUInt64sTo memTrace.multiplicity
-      cols.multiplicity .b64
-    -- Collect the witness module
-    witnessModules := witnessModules.push witnessModule
-
-  -- Gadgets
-  for (((mod, cols), gadgetEntries), gadget) in
-      circuits.gad.zip trace.gadgets |>.zip gadgets do
-    let (witnessModule, mode) := gadget.populate gadgetEntries cols mod.initWitnessModule
-    modes := modes.push mode
-    witnessModules := witnessModules.push witnessModule
-
-  -- Populate in parallel
-  witnessModules := WitnessModule.parPopulate witnessModules modes
-
-  pure $ Archon.compileWitnessModules witnessModules modes
-
-open Binius in
-def mkBoundaries (input output : Array UInt64) (funcChannel : ChannelId) : Array Boundary :=
-  let io := input ++ output |>.map (.ofLoHi · 0)
-  let pushBoundary := ⟨io.push B64_MULT_GEN, funcChannel, .push, 1⟩
-  let pullBoundary := ⟨io.push 1, funcChannel, .pull, 1⟩
-  #[pushBoundary, pullBoundary]
-
-end Aiur.Circuit
diff --git a/Ix/Aiur2/Bytecode.lean b/Ix/Aiur2/Bytecode.lean
deleted file mode 100644
index 6ec1011c..00000000
--- a/Ix/Aiur2/Bytecode.lean
+++ /dev/null
@@ -1,62 +0,0 @@
-import Ix.Aiur2.Goldilocks
-
-namespace Aiur
-
-namespace Bytecode
-
-abbrev FunIdx := Nat
-abbrev ValIdx := Nat
-abbrev SelIdx := Nat
-
-inductive Op
-  | const : G → Op
-  | add : ValIdx → ValIdx → Op
-  | sub : ValIdx → ValIdx → Op
-  | mul : ValIdx → ValIdx → Op
-  | call : FunIdx → Array ValIdx → (outputSize : Nat) → Op
-  | store : Array ValIdx → Op
-  | load : (size : Nat) → ValIdx → Op
-  deriving Repr
-
-mutual
-  inductive Ctrl where
-    | match : ValIdx → Array (G × Block) → Option Block → Ctrl
-    | return : SelIdx → Array ValIdx → Ctrl
-    deriving Inhabited, Repr
-
-  structure Block where
-    ops : Array Op
-    ctrl : Ctrl
-    minSelIncluded: SelIdx
-    maxSelExcluded: SelIdx
-    deriving Inhabited, Repr
-end
-
-/-- The circuit layout of a function -/
-structure FunctionLayout where
-  inputSize : Nat
-  outputSize : Nat
-  /-- Bit values that identify which path the computation took.
-    Exactly one selector must be set. -/
-  selectors : Nat
-  /-- Represent registers that hold temporary values and can be shared by
-    different circuit paths, since they never overlap. -/
-  auxiliaries : Nat
-  /-- Lookups can be shared across calls, stores, loads and returns from
-    different paths. -/
-  lookups : Nat
-  deriving Inhabited, Repr
-
-structure Function where
-  body : Block
-  layout: FunctionLayout
-  deriving Inhabited, Repr
-
-structure Toplevel where
-  functions : Array Function
-  memorySizes : Array Nat
-  deriving Repr
-
-end Bytecode
-
-end Aiur
diff --git a/Ix/Aiur2/Check.lean b/Ix/Aiur2/Check.lean
deleted file mode 100644
index d9b09f56..00000000
--- a/Ix/Aiur2/Check.lean
+++ /dev/null
@@ -1,368 +0,0 @@
-import Ix.Aiur2.Term
-import Std.Data.HashSet
-
-namespace Aiur
-
-inductive CheckError
-  | duplicatedDefinition : Global → CheckError
-  | undefinedGlobal : Global → CheckError
-  | unboundVariable : Global → CheckError
-  | notAConstructor : Global → CheckError
-  | notAValue : Global → CheckError
-  | notAFunction : Global → CheckError
-  | notAGadget : Global → CheckError
-  | cannotApply : Global → CheckError
-  | notADataType : Global → CheckError
-  | typeMismatch : Typ → Typ → CheckError
-  | illegalReturn : CheckError
-  | nonNumeric : Typ → CheckError
-  | notAField : Typ → CheckError
-  | wrongNumArgs : Global → Nat → Nat → CheckError
-  | notATuple : Typ → CheckError
-  | indexOoB : Nat → CheckError
-  | negativeRange : Nat → Nat → CheckError
-  | rangeOoB : Nat → Nat → CheckError
-  | incompatiblePattern : Pattern → Typ → CheckError
-  | differentBindings : List (Local × Typ) → List (Local × Typ) → CheckError
-  | emptyMatch
-  | branchMismatch : Typ → Typ → CheckError
-  | notAPointer : Typ → CheckError
-  | duplicatedBind : Pattern → CheckError
-  deriving Repr
-
-instance : ToString CheckError where
-  toString e := repr e |>.pretty
-
-/--
-Constructs a map of declarations from a toplevel, ensuring that there are no duplicate names
-for functions and datatypes.
--/
-def Toplevel.mkDecls (toplevel : Toplevel) : Except CheckError Decls := do
-  let map ← toplevel.functions.foldlM (init := default)
-    fun acc function => addDecl acc Function.name .function function
-  toplevel.dataTypes.foldlM (init := map) addDataType
-where
-  ensureUnique name (map : IndexMap Global _) := do
-    if map.containsKey name then throw $ .duplicatedDefinition name
-  addDecl {α : Type} map (nameFn : α → Global) (wrapper : α → Declaration) (inner : α) := do
-    ensureUnique (nameFn inner) map
-    pure $ map.insert (nameFn inner) (wrapper inner)
-  addDataType map dataType := do
-    let dataTypeName := dataType.name
-    ensureUnique dataTypeName map
-    let map' := map.insert dataTypeName (.dataType dataType)
-    dataType.constructors.foldlM (init := map') fun acc (constructor : Constructor) =>
-      addDecl acc (dataTypeName.pushNamespace ∘ Constructor.nameHead) (.constructor dataType) constructor
-
-structure CheckContext where
-  decls : Decls
-  varTypes : Std.HashMap Local Typ
-  returnType : Typ
-
-abbrev CheckM := ReaderT CheckContext (Except CheckError)
-
-/-- Retrieves the type of a global reference. -/
-def refLookup (global : Global) : CheckM Typ := do
-  let ctx ← read
-  match ctx.decls.getByKey global with
-  | some (.function function) =>
-    pure $ .function (function.inputs.map Prod.snd) function.output
-  | some (.constructor dataType constructor) =>
-    let args := constructor.argTypes
-    unless args.isEmpty do (throw $ .wrongNumArgs global args.length 0)
-    pure $ .dataType $ dataType.name
-  | some _ => throw $ .notAValue global
-  | none => throw $ .unboundVariable global
-
-/-- Extend context with locally bound variables. -/
-def bindIdents (bindings : List (Local × Typ)) (ctx : CheckContext) : CheckContext :=
-  { ctx with varTypes := ctx.varTypes.insertMany bindings }
-
-mutual
-partial def inferTerm : Term → CheckM TypedTerm
-  | .var x => do
-    -- Retrieves and returns the variable type from the context.
-    let ctx ← read
-    match ctx.varTypes[x]? with
-    | some t => pure $ .mk (.evaluates t) (.var x)
-    | none =>
-      let Local.str localName := x | unreachable!
-      let typ := .evaluates (← refLookup (Global.init localName))
-      pure $ .mk typ (.var x)
-  | .ref x => do
-    let typ := .evaluates (← refLookup x)
-    pure $ .mk typ (.ref x)
-  | .ret term => do
-    -- Ensures that the type of the returned term matches the expected return type.
-    -- The term is not allowed to have a (nested) return.
-    -- Returning the type of the term is not necessary because it's already in the context.
-    let ctx ← read
-    let inner ← checkNoEscape term ctx.returnType
-    pure $ .mk .escapes inner
-  | .data data => do
-    let (typ, inner) ← inferData data
-    pure $ .mk (.evaluates typ) inner
-  | .let pat expr body => do
-    -- Returns the type of the body, inferred in the context extended with the bound variable type.
-    -- The bound variable is ensured not to escape.
-    let (exprTyp, exprInner) ← inferNoEscape expr
-    let expr' := .mk (.evaluates exprTyp) exprInner
-    let bindings ← checkPattern pat exprTyp
-    let body' ← withReader (bindIdents bindings) (inferTerm body)
-    pure $ .mk body'.typ (.let pat expr' body')
-  | .match term branches => inferMatch term branches
-  | .app func@(⟨.str .anonymous unqualifiedFunc⟩) args => do
-    -- Ensures the function exists in the context and that the arguments, which aren't allowed to
-    -- escape, match the function's input types. Returns the function's output type.
-    let ctx ← read
-    match ctx.varTypes[Local.str unqualifiedFunc]? with
-    | some (.function inputs output) => do
-      let args ← checkArgsAndInputs func args inputs
-      pure $ .mk (.evaluates output) (.app func args)
-    | some _ => throw $ .notAFunction func
-    | none => match ctx.decls.getByKey func with
-      | some (.function function) => do
-        let args ← checkArgsAndInputs func args (function.inputs.map Prod.snd)
-        pure $ .mk (.evaluates function.output) (.app func args)
-      | some (.constructor dataType constr) => do
-        let args ← checkArgsAndInputs func args constr.argTypes
-        pure $ .mk (.evaluates (.dataType dataType.name)) (.app func args)
-      | _ => throw $ .cannotApply func
-  | .app func args => do
-    -- Only checks global map if it is not unqualified
-    let ctx ← read
-    match ctx.decls.getByKey func with
-    | some (.function function) =>
-      let args ← checkArgsAndInputs func args (function.inputs.map Prod.snd)
-      pure $ .mk (.evaluates function.output) (.app func args)
-    | some (.constructor dataType constr) =>
-      let args ← checkArgsAndInputs func args constr.argTypes
-      pure $ .mk (.evaluates (.dataType dataType.name)) (.app func args)
-    | _ => throw $ .cannotApply func
-  | .add a b => do
-    let (ctxTyp, a, b) ← checkArith a b
-    pure $ .mk ctxTyp (.add a b)
-  | .sub a b => do
-    let (ctxTyp, a, b) ← checkArith a b
-    pure $ .mk ctxTyp (.sub a b)
-  | .mul a b => do
-    let (ctxTyp, a, b) ← checkArith a b
-    pure $ .mk ctxTyp (.mul a b)
-  | .get tup i => do
-    let (typs, tupInner) ← inferTuple tup
-    if i < typs.size then
-      let typ := typs[i]!
-      let tup := .mk (.evaluates (.tuple typs)) tupInner
-      pure $ .mk (.evaluates typ) (.get tup i)
-    else
-      throw $ .indexOoB i
-  | .slice tup i j =>
-    -- Retrieves the types of elements in a tuple by a range (checked to be non-negative) and
-    -- returns them encoded in a `Typ.tuple`. Errors if the index is out of bounds.
-    if j < i then throw $ .negativeRange i j else do
-    let (typs, tupInner) ← inferTuple tup
-    if i < typs.size then
-      let slice := typs.drop i |>.take (j - i)
-      let tup := .mk (.evaluates (.tuple typs)) tupInner
-      pure $ .mk (.evaluates (.tuple slice)) (.slice tup i j)
-    else
-      throw $ .rangeOoB i j
-  | .store term => do
-    -- Infers the type of the term and returns it, wrapped by a pointer type.
-    -- The term is not allowed to early return.
-    let (typ, inner) ← inferNoEscape term
-    let store := .store (.mk (.evaluates typ) inner)
-    pure $ .mk (.evaluates (.pointer typ)) store
-  | .load term => do
-    -- Ensures that the the type of the term is a pointer type and returns the unwrapped type.
-    -- The term is not allowed to early return.
-    let (typ, inner) ← inferNoEscape term
-    match typ with
-    | .pointer innerTyp =>
-      let load := .load (.mk (.evaluates typ) inner)
-      pure $ .mk (.evaluates innerTyp) load
-    | _ => throw $ .notAPointer typ
-  | .ptrVal term => do
-    -- Infers the type of the term, which must be a pointer, but returns `.u64`, as in a cast.
-    -- The term is not allowed to early return.
-    let (typ, inner) ← inferNoEscape term
-    match typ with
-    | .pointer _ =>
-      let asU64 := .ptrVal (.mk (.evaluates typ) inner)
-      pure $ .mk (.evaluates .field) asU64
-    | _ => throw $ .notAPointer typ
-  | .ann typ term => do
-    let inner ← checkNoEscape term typ
-    pure $ .mk (.evaluates typ) inner
-where
-  /--
-  Ensures that there are as many arguments and as expected types and that
-  the types of the arguments are precisely those expected.
-  -/
-  checkArgsAndInputs func args inputs : CheckM (List TypedTerm) := do
-    let lenArgs := args.length
-    let lenInputs := inputs.length
-    unless lenArgs == lenInputs do throw $ .wrongNumArgs func lenArgs lenInputs
-    let pass := fun (arg, input) => do
-      let inner ← checkNoEscape arg input
-      pure $ .mk (.evaluates input) inner
-    args.zip inputs |>.mapM pass
-  checkArith a b := do
-    let (typ, aInner) ← inferNoEscape a
-    unless (typ == .field) do throw $ .notAField typ
-    let bInner ← checkNoEscape b typ
-    let ctxTyp := .evaluates typ
-    let a := .mk ctxTyp aInner
-    let b := .mk ctxTyp bInner
-    pure (ctxTyp, a, b)
-
-partial def checkNoEscape (term : Term) (typ : Typ) : CheckM TypedTermInner := do
-  let (typ', inner) ← inferNoEscape term
-  unless typ == typ' do throw $ .typeMismatch typ typ'
-  pure inner
-
-partial def inferNoEscape (term : Term) : CheckM (Typ × TypedTermInner) := do
-  let typedTerm ← inferTerm term
-  match typedTerm.typ with
-  | .escapes => throw .illegalReturn
-  | .evaluates type => pure (type, typedTerm.inner)
-
-partial def inferData : Data → CheckM (Typ × TypedTermInner)
-  | .field g => pure (.field, .data (.field g))
-  | .tuple terms => do
-    let typsAndInners ← terms.mapM inferNoEscape
-    let typs := typsAndInners.map Prod.fst
-    let terms := typsAndInners.map fun (typ, inner) => TypedTerm.mk (.evaluates typ) inner
-    pure (.tuple typs, .data (.tuple terms))
-
-/-- Infers the type of a 'match' expression and ensures its patterns and branches are valid. -/
-partial def inferMatch (term : Term) (branches : List (Pattern × Term)) : CheckM TypedTerm := do
-  if branches.isEmpty then throw .emptyMatch
-  let (termTyp, termInner) ← inferNoEscape term
-  let term := .mk (.evaluates termTyp) termInner
-  let init := ([], .escapes)
-  let (branches, typ) ← branches.foldrM (init := init) (checkBranch termTyp)
-  pure $ .mk typ (.match term branches)
-where
-  checkBranch patTyp branchData acc := do
-    let (pat, branch) := branchData
-    let (typedBranches, currentTyp) := acc
-    let bindings ← checkPattern pat patTyp
-    withReader (bindIdents bindings) (match currentTyp with
-      | .escapes => do
-        let typedBranch ← inferTerm branch
-        pure (typedBranches.cons (pat, typedBranch), typedBranch.typ)
-      | .evaluates matchTyp => do
-        -- Some branch didn't escape, so if this branch doesn't escape it must have the same type
-        -- as the previous non-escaping branch.
-        let typedBranch ← inferTerm branch
-        let typedBranches := typedBranches.cons (pat, typedBranch)
-        match typedBranch.typ with
-        | .escapes => pure (typedBranches, currentTyp)
-        | .evaluates branchTyp =>
-          -- This branch doesn't escape so its type must match the type of the previous non-escaping branch.
-          unless (matchTyp == branchTyp) do throw $ .branchMismatch matchTyp branchTyp
-          pure (typedBranches, currentTyp))
-
-/-- Checks that a pattern matches a given type and collects its bindings. -/
-partial def checkPattern (pat : Pattern) (typ : Typ) : CheckM $ List (Local × Typ) := do
-  let binds ← aux pat typ
-  let locals := binds.map Prod.fst
-  unless (locals == locals.eraseDups) do throw $ .duplicatedBind pat
-  pure binds
-where
-  aux pat typ := match (pat, typ) with
-    | (.var var, _) => pure [(var, typ)]
-    | (.wildcard, _)
-    | (.field _, .field) => pure []
-    | (.tuple pats, .tuple typs) => do
-      unless pats.size == typs.size do throw $ .incompatiblePattern pat typ
-      pats.zip typs |>.foldlM (init := []) fun acc (pat, typ) => acc.append <$> aux pat typ
-    | (.ref funcName [], typ@(.function ..)) => do
-      let ctx ← read
-      let some (.function function) := ctx.decls.getByKey funcName | throw $ .incompatiblePattern pat typ
-      let typ' := .function (function.inputs.map Prod.snd) function.output
-      unless typ == typ' do throw $ .typeMismatch typ typ'
-      pure []
-    | (.ref constrRef pats, .dataType dataTypeRef) => do
-      let ctx ← read
-      let some (.dataType dataType) := ctx.decls.getByKey dataTypeRef | unreachable!
-      let some (.constructor dataType' constr) := ctx.decls.getByKey constrRef | throw $ .notAConstructor constrRef
-      unless dataType == dataType' do throw $ .incompatiblePattern pat typ
-      let typs := constr.argTypes
-      let lenPats := pats.length
-      let lenTyps := typs.length
-      unless lenPats == lenTyps do throw $ .wrongNumArgs constrRef lenPats lenTyps
-      pats.zip typs |>.foldlM (init := []) fun acc (pat, typ) => acc.append <$> aux pat typ
-    | (.or pat pat', _) => do
-      let bind ← aux pat typ
-      let bind' ← aux pat' typ
-      if bind != bind' then throw $ .differentBindings bind bind' else pure bind
-    | _ => throw $ .incompatiblePattern pat typ
-
--- partial def inferNumber (term : Term) : CheckM (Typ × TypedTermInner) := do
---   let (typ, inner) ← inferNoEscape term
---   match typ with
---   | .primitive .u1
---   | .primitive .u8
---   | .primitive .u16
---   | .primitive .u32
---   | .primitive .u64 => pure (typ, inner)
---   | _ => throw $ .nonNumeric typ
-
-partial def inferTuple (term : Term) : CheckM (Array Typ × TypedTermInner) := do
-  let (typ, inner) ← inferNoEscape term
-  match typ with
-  | .tuple typs => pure (typs, inner)
-  | _ => throw $ .notATuple typ
-end
-
-def getFunctionContext (function : Function) (decls : Decls) : CheckContext :=
-  {
-    decls,
-    varTypes := .ofList function.inputs
-    returnType := function.output
-  }
-
-/--
-Ensures that all declarations are wellformed by checking that every datatype reference
-points to an actual datatype in the toplevel.
-
-Note: it's assumed that all constructor declarations are properly extracted from the
-original datatypes.
--/
-partial def wellFormedDecls (decls : Decls) : Except CheckError Unit := do
-  let mut visited := default
-  for (_, decl) in decls.pairs do
-    match EStateM.run (wellFormedDecl decl) visited with
-    | .error e _ => throw e
-    | .ok () visited' => visited := visited'
-where
-  wellFormedDecl : Declaration → EStateM CheckError (Std.HashSet Global) Unit
-    | .dataType dataType => do
-      let map ← get
-      if !map.contains dataType.name then
-        set $ map.insert dataType.name
-        dataType.constructors.flatMap (·.argTypes) |>.forM wellFormedType
-    | .function function => do
-      wellFormedType function.output
-      function.inputs.forM fun (_, typ) => wellFormedType typ
-    -- No need to check constructors because they come from datatype declarations.
-    | .constructor .. => pure ()
-  wellFormedType : Typ → EStateM CheckError (Std.HashSet Global) Unit
-    | .tuple typs => typs.forM wellFormedType
-    | .pointer pointerTyp => wellFormedType pointerTyp
-    | .dataType dataTypeRef => match decls.getByKey dataTypeRef with
-      | some (.dataType _) => pure ()
-      | some _ => throw $ .notADataType dataTypeRef
-      | none => throw $ .undefinedGlobal dataTypeRef
-    | _ => pure ()
-
-/-- Checks a function to ensure its body's type matches its declared output type. -/
-def checkFunction (function : Function) : CheckM TypedFunction := do
-  let body ← inferTerm function.body
-  if let .evaluates typ := body.typ then
-    unless typ == function.output do throw $ .typeMismatch typ function.output
-  pure ⟨function.name, function.inputs, function.output, body⟩
-
-end Aiur
diff --git a/Ix/Aiur2/Match.lean b/Ix/Aiur2/Match.lean
deleted file mode 100644
index 2370374f..00000000
--- a/Ix/Aiur2/Match.lean
+++ /dev/null
@@ -1,218 +0,0 @@
-import Ix.Aiur2.Term
-import Ix.SmallMap
-
-namespace Aiur
-
-abbrev TermId := Nat
-abbrev UniqTerm := TermId × Term
-
-inductive SPattern
-  | field : G → SPattern
-  | ref : Global → Array Local → SPattern
-  | tuple : Array Local → SPattern
-  deriving BEq, Hashable, Inhabited
-
-structure Clause where
-  pat : SPattern
-  guards : Array (Pattern × UniqTerm)
-  body : UniqTerm
-  deriving Inhabited
-
-structure ExtTerm where
-  renames : Array (Local × Term)
-  value : Term
-  deriving Inhabited
-
-structure Row where
-  clauses : Array Clause
-  body : ExtTerm
-  uniqId : TermId
-  deriving Inhabited
-
-structure Diagnostics where
-  missing : Bool
-  reachable : List Term
-
-structure Compiler where
-  uniqId : TermId
-  decls : Decls
-  diagnostics : Diagnostics
-
-abbrev CompilerM := StateM Compiler
-
-def setId (id : TermId) : CompilerM Unit :=
-  modify fun stt => { stt with uniqId := id }
-
-def newId : CompilerM TermId := do
-  let varId ← Compiler.uniqId <$> get
-  modify fun stt => { stt with uniqId := stt.uniqId + 1 }
-  pure varId
-
-def dnfProd (branches: List $ Pattern × UniqTerm) (body : ExtTerm) : CompilerM (Array Row) := do
-  let initId ← Compiler.uniqId <$> get
-  let rec aux := fun renames clauses branches body => match branches with
-    | [] => do
-      let id ← Compiler.uniqId <$> get
-      let row := ⟨clauses, { body with renames := body.renames ++ renames }, id⟩
-      setId initId
-      pure #[row]
-    | (.or patL patR, term) :: rest => do
-      let rowsL ← aux renames clauses ((patL, term) :: rest) body
-      let rowsR ← aux renames clauses ((patR, term) :: rest) body
-      pure $ rowsL ++ rowsR
-    | (.wildcard, _) :: rest => aux renames clauses rest body
-    | (.var var, (_, term)) :: rest => aux (renames.push (var, term)) clauses rest body
-    | (.field g, term) :: rest => aux renames (clauses.push ⟨.field g, #[], term⟩) rest body
-    | (.tuple args, term) :: rest => do
-      let (vars, guards) ← flattenArgs args
-      let clause := ⟨.tuple vars, guards, term⟩
-      aux renames (clauses.push clause) rest body
-    | (.ref global args, term) :: rest => do
-      let (vars, guards) ← flattenArgs args.toArray
-      let clause := ⟨.ref global vars, guards, term⟩
-      aux renames (clauses.push clause) rest body
-  aux Array.empty Array.empty branches body
-where
-  flattenArgs args := do
-    let varIds ← args.mapM fun _ => newId
-    let guards := args.zip varIds |>.map fun (arg, id) => (arg, (id, .var (.idx id)))
-    pure (varIds.map .idx, guards)
-
-inductive Decision
-  | success : ExtTerm → Decision
-  | failure
-  | switch : Local → List (SPattern × Decision) → Decision → Decision
-  | let : Local → Term → Decision → Decision
-  deriving Inhabited
-
-def modifyDiagnostics (f : Diagnostics → Diagnostics) : CompilerM Unit :=
-  modify fun stt => { stt with diagnostics := f stt.diagnostics }
-
-def patTypeLength (decls : Decls) : SPattern → Nat
-  | .field _ => gSize.toNat
-  | .tuple _ => 1
-  | .ref global _ => typeLookup global |>.constructors.length
-where
-  typeLookup (global : Global) :=
-    match global.popNamespace with
-    | some (_, enum) => match decls.getByKey enum with
-      | some (.dataType typ) => typ
-      | _ => unreachable!
-    | none => unreachable!
-
-def extractSPatterns (rows : Array Row) (term : UniqTerm) : SmallMap SPattern (Array Row) :=
-  rows.foldl (init := default) processRow
-where
-  processRow map row := row.clauses.foldl (init := map) processClause
-  processClause map clause :=
-    if term.fst == clause.body.fst then map.insert clause.pat #[] else map
-
-def removeFirstInstance (find : α → Bool) (vec : Array α) : Option (α × Array α) :=
-  match h : vec.findIdx? find with
-  | none => none
-  | some i =>
-    let filtered := vec.extract 0 i ++ vec.extract (i + 1) vec.size
-    have := Array.findIdx?_eq_some_iff_findIdx_eq.mp h |>.left
-    some (vec[i], filtered)
-
-def rowRemoveClause (row : Row) (term : UniqTerm) : Option (Clause × Row) :=
-  let id := term.fst
-  match removeFirstInstance (·.body.fst == id) row.clauses with
-  | some (deletedClause, restClauses) => some (deletedClause, { row with clauses := restClauses })
-  | none => none
-
-def switch (cases : List (SPattern × Decision)) (fallback : Decision) : UniqTerm → Decision
-  | (_, .var var) => .switch var cases fallback
-  | (id, term) => let var := .idx id; .let var term (.switch var cases fallback)
-
-mutual
-
-partial def compileSwitch (rows : Array Row) (term : UniqTerm) : CompilerM Decision := do
-  let stt ← get
-  let numCases := patTypeLength stt.decls rows[0]!.clauses[0]!.pat
-  let spatMap := extractSPatterns rows term
-  let size := spatMap.size
-  assert! size <= numCases
-  if size == numCases then
-    let (rowMap, _) ← rows.foldlM (init := (spatMap, #[])) processRow
-    let cases ← rowMap.toList.mapM fun (pat, rows) => Prod.mk pat <$> compileRows rows
-    setId stt.uniqId
-    pure $ switch cases .failure term
-  else
-    let (rowMap, fallbackRows) ← rows.foldlM (init := (spatMap, #[])) processRow
-    let cases ← rowMap.toList.mapM fun (pat, rows) => Prod.mk pat <$> compileRows rows
-    let fallback ← compileRows fallbackRows
-    setId stt.uniqId
-    pure $ switch cases fallback term
-where
-  processRow pair row :=
-    let (rowMap, fallbackRows) := pair
-    match rowRemoveClause row term with
-    | some (clause, row') => do
-      setId row.uniqId
-      let newRows ← dnfProd clause.guards.toList row'.body
-      let newRows := newRows.map (fun r => { r with clauses := r.clauses ++ row'.clauses })
-      let updatedMap := rowMap.update clause.pat (· ++ newRows)
-      pure (updatedMap, fallbackRows)
-    | none => pure (rowMap.map (·.push row), fallbackRows.push row)
-
-partial def compileRows (rows : Array Row) : CompilerM Decision :=
-  match rows[0]? with
-  | some row => match row.clauses[0]? with
-    | some clause => compileSwitch rows clause.body
-    | none => do
-      modifyDiagnostics fun d => { d with reachable := row.body.value :: d.reachable }
-      pure $ .success row.body
-  | none => do
-    modifyDiagnostics fun d => { d with missing := true }
-    pure .failure
-
-end
-
-def compile (term : Term) (rules : List (Pattern × Term)) : CompilerM (Decision × Diagnostics) := do
-  let id ← newId
-  let rows ← rules.foldlM (init := #[]) fun acc rule => do
-    let newRows ← fromRule id rule
-    pure $ acc ++ newRows
-  let tree ← compileRows rows
-  let diagnostics ← Compiler.diagnostics <$> get
-  pure (tree, diagnostics)
-where
-  fromRule id rule :=
-    let (pat, bod) := rule
-    dnfProd [(pat, (id, term))] ⟨#[], bod⟩
-
-def runWithNewCompiler (typs : Decls) (f : CompilerM α) : α :=
-  StateT.run' f ⟨0, typs, ⟨false, []⟩⟩
-
-def runMatchCompiler (typs : Decls) (term : Term) (rules : List (Pattern × Term)) :
-    Decision × Diagnostics :=
-  runWithNewCompiler typs (compile term rules)
-
-def spatternToPattern : SPattern → Pattern
-  | .field g => .field g
-  | .ref global vars => .ref global (vars.map .var).toList
-  | .tuple vars => .tuple (vars.map .var)
-
-mutual
-
-partial def branchesToTerm (branches : List (SPattern × Decision)) (dec : Decision) :
-    List (Pattern × Term) :=
-  let toTerm := fun (spat, tree) =>
-    decisionToTerm tree >>= fun term => some (spatternToPattern spat, term)
-  match decisionToTerm dec with
-  | some defTerm => branches.filterMap toTerm ++ [(Pattern.wildcard, defTerm)]
-  | none => branches.filterMap toTerm
-
-partial def decisionToTerm : Decision → Option Term
-  | .success ⟨renames, value⟩ =>
-    some $ renames.foldr (init := value) fun (x, y) acc => .let (.var x) y acc
-  | .switch var branches dec => some $ .match (.var var) (branchesToTerm branches dec)
-  | .let var term body => do
-    let body' ← decisionToTerm body
-    some $ .let (.var var) term body'
-  | .failure => none
-
-end
-
-end Aiur
diff --git a/Ix/Aiur2/Meta.lean b/Ix/Aiur2/Meta.lean
deleted file mode 100644
index 0e457f47..00000000
--- a/Ix/Aiur2/Meta.lean
+++ /dev/null
@@ -1,235 +0,0 @@
-import Lean
-import Ix.Aiur2.Term
-
-namespace Aiur
-
-open Lean Elab Meta
-
-abbrev ElabStxCat name := TSyntax name → TermElabM Expr
-
-declare_syntax_cat                             pattern
-syntax ("." noWs)? ident                     : pattern
-syntax "_"                                   : pattern
-syntax ident "(" pattern (", " pattern)* ")" : pattern
-syntax num                                   : pattern
-syntax "(" pattern (", " pattern)* ")"       : pattern
-syntax pattern "|" pattern                   : pattern
-
-def elabListCore (head : α) (tail : Array α) (elabFn : α → TermElabM Expr)
-    (listEltType : Expr) (isArray := false) : TermElabM Expr := do
-  let mut elaborated := Array.mkEmpty (tail.size + 1)
-  elaborated := elaborated.push $ ← elabFn head
-  for elt in tail do
-    elaborated := elaborated.push $ ← elabFn elt
-  if isArray
-  then mkArrayLit listEltType elaborated.toList
-  else mkListLit listEltType elaborated.toList
-
-def elabList (head : α) (tail : Array α) (elabFn : α → TermElabM Expr)
-    (listEltTypeName : Name) (isArray := false) : TermElabM Expr :=
-  elabListCore head tail elabFn (mkConst listEltTypeName) isArray
-
-def elabEmptyList (listEltTypeName : Name) : TermElabM Expr :=
-  mkListLit (mkConst listEltTypeName) []
-
-def elabG (n : TSyntax `num) : TermElabM Expr :=
-  mkAppM ``G.ofNat #[mkNatLit n.getNat]
-
-partial def elabPattern : ElabStxCat `pattern
-  | `(pattern| $v:ident($p:pattern $[, $ps:pattern]*)) => do
-    let g ← mkAppM ``Global.mk #[toExpr v.getId]
-    mkAppM ``Pattern.ref #[g, ← elabList p ps elabPattern ``Pattern]
-  | `(pattern| .$i:ident) => do
-    let g ← mkAppM ``Global.mk #[toExpr i.getId]
-    mkAppM ``Pattern.ref #[g, ← elabEmptyList ``Pattern]
-  | `(pattern| $i:ident) => match i.getId with
-    | .str .anonymous name => do
-      mkAppM ``Pattern.var #[← mkAppM ``Local.str #[toExpr name]]
-    | name@(.str _ _) => do
-      let g ← mkAppM ``Global.mk #[toExpr name]
-      mkAppM ``Pattern.ref #[g, ← elabEmptyList ``Pattern]
-    | _ => throw $ .error i "Illegal pattern name"
-  | `(pattern| _) => pure $ mkConst ``Pattern.wildcard
-  | `(pattern| $n:num) => do mkAppM ``Pattern.field #[← elabG n]
-  | `(pattern| ($p:pattern $[, $ps:pattern]*)) => do
-    mkAppM ``Pattern.tuple #[← elabList p ps elabPattern ``Pattern true]
-  | `(pattern| $p₁:pattern | $p₂:pattern) => do
-    mkAppM ``Pattern.or #[← elabPattern p₁, ← elabPattern p₂]
-  | stx => throw $ .error stx "Invalid syntax for pattern"
-
-declare_syntax_cat                               typ
-syntax "G"                                     : typ
-syntax "(" typ (", " typ)* ")"                 : typ
-syntax "&" typ                                 : typ
-syntax ("." noWs)? ident                       : typ
-syntax "fn" "(" ")" " -> " typ                 : typ
-syntax "fn" "(" typ (", " typ)* ")" " -> " typ : typ
-
-partial def elabTyp : ElabStxCat `typ
-  | `(typ| G) => pure $ mkConst ``Typ.field
-  | `(typ| ($t:typ $[, $ts:typ]*)) => do
-    mkAppM ``Typ.tuple #[← elabList t ts elabTyp ``Typ true]
-  | `(typ| &$t:typ) => do
-    mkAppM ``Typ.pointer #[← elabTyp t]
-  | `(typ| $[.]?$i:ident) => do
-    let g ← mkAppM ``Global.mk #[toExpr i.getId]
-    mkAppM ``Typ.dataType #[g]
-  | `(typ| fn() -> $t:typ) => do
-    mkAppM ``Typ.function #[← elabEmptyList ``Typ, ← elabTyp t]
-  | `(typ| fn($t$[, $ts:typ]*) -> $t':typ) => do
-    mkAppM ``Typ.function #[← elabList t ts elabTyp ``Typ, ← elabTyp t']
-  | stx => throw $ .error stx "Invalid syntax for type"
-
-declare_syntax_cat                                          trm
-syntax ("." noWs)? ident                                  : trm
-syntax num                                                : trm
-syntax "(" trm (", " trm)* ")"                            : trm
-syntax "return " trm                                      : trm
-syntax "let " pattern " = " trm "; " trm                  : trm
-syntax "match " trm " { " (pattern " => " trm ", ")+ " }" : trm
-syntax ("." noWs)? ident "(" ")"                          : trm
-syntax ("." noWs)? ident "(" trm (", " trm)* ")"          : trm
-syntax "add" "(" trm ", " trm ")"                         : trm
-syntax "sub" "(" trm ", " trm ")"                         : trm
-syntax "mul" "(" trm ", " trm ")"                         : trm
-syntax "get" "(" trm ", " num ")"                         : trm
-syntax "slice" "(" trm ", " num ", " num ")"              : trm
-syntax "store" "(" trm ")"                                : trm
-syntax "load" "(" trm ")"                                 : trm
-syntax "ptr_val" "(" trm ")"                              : trm
-syntax trm ": " typ                                       : trm
-
-partial def elabTrm : ElabStxCat `trm
-  | `(trm| .$i:ident) => do
-    mkAppM ``Term.ref #[← mkAppM ``Global.mk #[toExpr i.getId]]
-  | `(trm| $i:ident) => match i.getId with
-    | .str .anonymous name => do
-      mkAppM ``Term.var #[← mkAppM ``Local.str #[toExpr name]]
-    | name@(.str _ _) => do
-      mkAppM ``Term.ref #[← mkAppM ``Global.mk #[toExpr name]]
-    | _ => throw $ .error i "Illegal name"
-  | `(trm| $n:num) => do
-    let data ← mkAppM ``Data.field #[← elabG n]
-    mkAppM ``Term.data #[data]
-  | `(trm| ($t:trm $[, $ts:trm]*)) => do
-    let data ← mkAppM ``Data.tuple #[← elabList t ts elabTrm ``Term true]
-    mkAppM ``Term.data #[data]
-  | `(trm| return $t:trm) => do
-    mkAppM ``Term.ret #[← elabTrm t]
-  | `(trm| let $p:pattern = $t:trm; $t':trm) => do
-    mkAppM ``Term.let #[← elabPattern p, ← elabTrm t, ← elabTrm t']
-  | `(trm| match $t:trm {$[$ps:pattern => $ts:trm,]*}) => do
-    let mut prods := Array.mkEmpty (ps.size + 1)
-    for (p, t) in ps.zip ts do
-      prods := prods.push $ ← mkAppM ``Prod.mk #[← elabPattern p, ← elabTrm t]
-    let prodType ← mkAppM ``Prod #[mkConst ``Pattern, mkConst ``Term]
-    mkAppM ``Term.match #[← elabTrm t, ← mkListLit prodType prods.toList]
-  | `(trm| $[.]?$f:ident ()) => do
-    let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Term.app #[g, ← elabEmptyList ``Term]
-  | `(trm| $[.]?$f:ident ($a:trm $[, $as:trm]*)) => do
-    let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Term.app #[g, ← elabList a as elabTrm ``Term]
-  | `(trm| add($a:trm, $b:trm)) => do
-    mkAppM ``Term.add #[← elabTrm a, ← elabTrm b]
-  | `(trm| sub($a:trm, $b:trm)) => do
-    mkAppM ``Term.sub #[← elabTrm a, ← elabTrm b]
-  | `(trm| mul($a:trm, $b:trm)) => do
-    mkAppM ``Term.mul #[← elabTrm a, ← elabTrm b]
-  | `(trm| get($a:trm, $i:num)) => do
-    mkAppM ``Term.get #[← elabTrm a, toExpr i.getNat]
-  | `(trm| slice($a:trm, $i:num, $j:num)) => do
-    mkAppM ``Term.slice #[← elabTrm a, toExpr i.getNat, toExpr j.getNat]
-  | `(trm| store($a:trm)) => do
-    mkAppM ``Term.store #[← elabTrm a]
-  | `(trm| load($a:trm)) => do
-    mkAppM ``Term.load #[← elabTrm a]
-  | `(trm| ptr_val($a:trm)) => do
-    mkAppM ``Term.ptrVal #[← elabTrm a]
-  | `(trm| $v:trm : $t:typ) => do
-    mkAppM ``Term.ann #[← elabTyp t, ← elabTrm v]
-  | stx => throw $ .error stx "Invalid syntax for term"
-
-declare_syntax_cat                     constructor
-syntax ident                         : constructor
-syntax ident "(" typ (", " typ)* ")" : constructor
-
-def elabConstructor : ElabStxCat `constructor
-  | `(constructor| $i:ident) => match i.getId with
-    | .str .anonymous name => do
-      mkAppM ``Constructor.mk #[toExpr name, ← elabEmptyList ``Typ]
-    | _ => throw $ .error i "Illegal constructor name"
-  | `(constructor| $i:ident($t:typ$[, $ts:typ]*)) => match i.getId with
-    | .str .anonymous name => do
-      mkAppM ``Constructor.mk #[toExpr name, ← elabList t ts elabTyp ``Typ]
-    | _ => throw $ .error i "Illegal constructor name"
-  | stx => throw $ .error stx "Invalid syntax for constructor"
-
-declare_syntax_cat                                             data_type
-syntax "enum " ident                                         : data_type
-syntax "enum " ident "{" constructor (", " constructor)* "}" : data_type
-
-def elabDataType : ElabStxCat `data_type
-  | `(data_type| enum $n:ident) => do
-    let g ← mkAppM ``Global.mk #[toExpr n.getId]
-    mkAppM ``DataType.mk #[g, ← elabEmptyList ``Constructor]
-  | `(data_type| enum $n:ident {$c:constructor $[, $cs:constructor]*}) => do
-    let g ← mkAppM ``Global.mk #[toExpr n.getId]
-    mkAppM ``DataType.mk #[g, ← elabList c cs elabConstructor ``Constructor]
-  | stx => throw $ .error stx "Invalid syntax for data type"
-
-declare_syntax_cat      bind
-syntax ident ": " typ : bind
-
-def elabBind : ElabStxCat `bind
-  | `(bind| $i:ident: $t:typ) => match i.getId with
-    | .str .anonymous name => do
-      mkAppM ``Prod.mk #[← mkAppM ``Local.str #[toExpr name], ← elabTyp t]
-    | _ => throw $ .error i "Illegal variable name"
-  | stx => throw $ .error stx "Invalid syntax for binding"
-
-declare_syntax_cat                                                    function
-syntax "fn " ident "(" ")" " -> " typ "{" trm "}"                   : function
-syntax "fn " ident "(" bind (", " bind)* ")" " -> " typ "{" trm "}" : function
-
-def elabFunction : ElabStxCat `function
-  | `(function| fn $i:ident() -> $ty:typ {$t:trm}) => do
-    let g ← mkAppM ``Global.mk #[toExpr i.getId]
-    let bindType ← mkAppM ``Prod #[mkConst ``Local, mkConst ``Typ]
-    mkAppM ``Function.mk #[g, ← mkListLit bindType [], ← elabTyp ty, ← elabTrm t]
-  | `(function| fn $i:ident($b:bind $[, $bs:bind]*) -> $ty:typ {$t:trm}) => do
-    let g ← mkAppM ``Global.mk #[toExpr i.getId]
-    let bindType ← mkAppM ``Prod #[mkConst ``Local, mkConst ``Typ]
-    mkAppM ``Function.mk
-      #[g, ← elabListCore b bs elabBind bindType, ← elabTyp ty, ← elabTrm t]
-  | stx => throw $ .error stx "Invalid syntax for function"
-
-declare_syntax_cat declaration
-syntax function  : declaration
-syntax data_type : declaration
-
-def accElabDeclarations (declarations : (Array Expr × Array Expr))
-    (stx : TSyntax `declaration) : TermElabM (Array Expr × Array Expr) :=
-  let (dataTypes, functions) := declarations
-  match stx with
-  | `(declaration| $f:function) => do
-    pure (dataTypes, functions.push $ ← elabFunction f)
-  | `(declaration| $d:data_type) => do
-    pure (dataTypes.push $ ← elabDataType d, functions)
-  | stx => throw $ .error stx "Invalid syntax for declaration"
-
-declare_syntax_cat    toplevel
-syntax declaration* : toplevel
-
-def elabToplevel : ElabStxCat `toplevel
-  | `(toplevel| $[$ds:declaration]*) => do
-    let (dataTypes, functions) ← ds.foldlM (init := default) accElabDeclarations
-    mkAppM ``Toplevel.mk #[
-      ← mkListLit (mkConst ``DataType) dataTypes.toList,
-      ← mkListLit (mkConst ``Function) functions.toList,
-    ]
-  | stx => throw $ .error stx "Invalid syntax for toplevel"
-
-elab "⟦" t:toplevel "⟧" : term => elabToplevel t
-
-end Aiur
diff --git a/Ix/Aiur2/Simple.lean b/Ix/Aiur2/Simple.lean
deleted file mode 100644
index e165ae68..00000000
--- a/Ix/Aiur2/Simple.lean
+++ /dev/null
@@ -1,46 +0,0 @@
-import Ix.Aiur2.Match
-import Ix.Aiur2.Check
-
-namespace Aiur
-
-/-- This temporary variable can only be used when it does not shadow any other internal. -/
-private abbrev tmpVar := Local.idx 0
-
-partial def simplifyTerm (decls : Decls) : Term → Term
-  | .let var@(.var _) val body => .let var (recr val) (recr body)
-  -- NOTE: This would not be safe in case Aiur allows side-effects.
-  -- A sequencing operation would be needed.
-  | .let .wildcard _ body => recr body
-  | .let pat val body =>
-    let mtch := .match (.var tmpVar) [(pat, body)]
-    .let (.var tmpVar) (recr val) (recr mtch)
-  | .match term branches =>
-    let (tree, _diag) := runMatchCompiler decls term branches
-    match decisionToTerm tree with
-    | some term => term
-    | none => unreachable!
-  | .ret r => .ret (recr r)
-  | .app global args => .app global (args.map recr)
-  | .data (.tuple args) => .data (.tuple (args.map recr))
-  | t => t
-where
-  recr := simplifyTerm decls
-
-def Toplevel.checkAndSimplify (toplevel : Toplevel) : Except CheckError TypedDecls := do
-  let decls ← toplevel.mkDecls
-  wellFormedDecls decls
-  -- The first check happens on the original terms.
-  toplevel.functions.forM fun function => do
-    let _ ← (checkFunction function) (getFunctionContext function decls)
-  let decls := decls.map fun decl => match decl with
-    | .function f => .function { f with body := simplifyTerm decls f.body }
-    | _ => decl
-  decls.foldlM (init := default) fun typedDecls (name, decl) => match decl with
-    | .constructor d c => pure $ typedDecls.insert name (.constructor d c)
-    | .dataType d => pure $ typedDecls.insert name (.dataType d)
-    | .function f => do
-      -- The second check happens on the simplified terms.
-      let f ← (checkFunction f) (getFunctionContext f decls)
-      pure $ typedDecls.insert name (.function f)
-
-end Aiur
diff --git a/Ix/Aiur2/Term.lean b/Ix/Aiur2/Term.lean
deleted file mode 100644
index 42e83c75..00000000
--- a/Ix/Aiur2/Term.lean
+++ /dev/null
@@ -1,204 +0,0 @@
-import Std.Data.HashSet.Basic
-import Ix.Aiur2.Goldilocks
-import Ix.IndexMap
-
-namespace Aiur
-
-inductive Local
-  | str : String → Local
-  | idx : Nat → Local
-  deriving Repr, BEq, Hashable
-
-structure Global where
-  toName : Lean.Name
-  deriving Repr, BEq, Inhabited
-
-instance : EquivBEq Global where
-  symm {_ _} h := by rw [BEq.beq] at h ⊢; exact BEq.symm h
-  trans {_ _ _} h₁ h₂ := by rw [BEq.beq] at h₁ h₂ ⊢; exact BEq.trans h₁ h₂
-  refl {_} := by rw [BEq.beq]; apply BEq.refl
-
-instance : Hashable Global where
-  hash a := hash a.toName
-
-instance : LawfulHashable Global where
-  hash_eq a b h := LawfulHashable.hash_eq a.toName b.toName h
-
-instance : ToString Global where
-  toString g := g.toName.toString
-
-def Global.init (limb : String) : Global :=
-  ⟨.mkSimple limb⟩
-
-def Global.pushNamespace (global : Global) (limb : String) : Global :=
-  ⟨global.toName.mkStr limb⟩
-
-def Global.popNamespace (global : Global) : Option (String × Global) :=
-  match global.toName with
-  | .str tail head => some (head, ⟨tail⟩)
-  | _ => none
-
-inductive Pattern
-  | var : Local → Pattern
-  | wildcard : Pattern
-  | ref : Global → List Pattern → Pattern
-  | field : G → Pattern
-  | tuple : Array Pattern → Pattern
-  | or : Pattern → Pattern → Pattern
-  deriving Repr, BEq, Hashable, Inhabited
-
-inductive Typ where
-  | field
-  | tuple : Array Typ → Typ
-  | pointer : Typ → Typ
-  | dataType : Global → Typ
-  | function : List Typ → Typ → Typ
-  deriving Repr, BEq, Hashable, Inhabited
-
-mutual
-
-inductive Term
-  | var : Local → Term
-  | ref : Global → Term
-  | data : Data → Term
-  | ret : Term → Term
-  | let : Pattern → Term → Term → Term
-  | match : Term → List (Pattern × Term) → Term
-  | app : Global → List Term → Term
-  | add : Term → Term → Term
-  | sub : Term → Term → Term
-  | mul : Term → Term → Term
-  | get : Term → Nat → Term
-  | slice : Term → Nat → Nat → Term
-  | store : Term → Term
-  | load : Term → Term
-  | ptrVal : Term → Term
-  | ann : Typ → Term → Term
-  deriving Repr, BEq, Hashable, Inhabited
-
-inductive Data
-  | field : G → Data
-  | tuple : Array Term → Data
-  deriving Repr
-
-end
-
-inductive ContextualType
-  | evaluates : Typ → ContextualType
-  | escapes : ContextualType
-  deriving Repr, BEq, Inhabited
-
-def ContextualType.unwrap : ContextualType → Typ
-| .escapes => panic! "term should not escape"
-| .evaluates typ => typ
-
-def ContextualType.unwrapOr : ContextualType → Typ → Typ
-| .escapes => fun typ => typ
-| .evaluates typ => fun _ => typ
-
-mutual
-inductive TypedTermInner
-  | var : Local → TypedTermInner
-  | ref : Global → TypedTermInner
-  | data : TypedData → TypedTermInner
-  | ret : TypedTerm → TypedTermInner
-  | let : Pattern → TypedTerm → TypedTerm → TypedTermInner
-  | match : TypedTerm → List (Pattern × TypedTerm) → TypedTermInner
-  | app : Global → List TypedTerm → TypedTermInner
-  | add : TypedTerm → TypedTerm → TypedTermInner
-  | sub : TypedTerm → TypedTerm → TypedTermInner
-  | mul : TypedTerm → TypedTerm → TypedTermInner
-  | get : TypedTerm → Nat → TypedTermInner
-  | slice : TypedTerm → Nat → Nat → TypedTermInner
-  | store : TypedTerm → TypedTermInner
-  | load : TypedTerm → TypedTermInner
-  | ptrVal : TypedTerm → TypedTermInner
-  deriving Repr, Inhabited
-
-structure TypedTerm where
-  typ : ContextualType
-  inner : TypedTermInner
-  deriving Repr, Inhabited
-
-inductive TypedData
-  | field : G → TypedData
-  | tuple : Array TypedTerm → TypedData
-  deriving Repr
-
-end
-
-structure Constructor where
-  nameHead : String
-  argTypes : List Typ
-  deriving Repr, BEq, Inhabited
-
-structure DataType where
-  name : Global
-  constructors : List Constructor
-  deriving Repr, BEq, Inhabited
-
-structure Function where
-  name : Global
-  inputs : List (Local × Typ)
-  output : Typ
-  body : Term
-  deriving Repr
-
-structure Toplevel where
-  dataTypes : List DataType
-  functions : List Function
-  deriving Repr
-
-def Toplevel.getFuncIdx (toplevel : Toplevel) (funcName : Lean.Name) : Option Nat := do
-  toplevel.functions.findIdx? fun function => function.name.toName == funcName
-
-inductive Declaration
-  | function : Function → Declaration
-  | dataType : DataType → Declaration
-  | constructor : DataType → Constructor → Declaration
-  deriving Repr, Inhabited
-
-abbrev Decls := IndexMap Global Declaration
-
-structure TypedFunction where
-  name : Global
-  inputs : List (Local × Typ)
-  output : Typ
-  body : TypedTerm
-  deriving Repr
-
-inductive TypedDeclaration
-  | function : TypedFunction → TypedDeclaration
-  | dataType : DataType → TypedDeclaration
-  | constructor : DataType → Constructor → TypedDeclaration
-  deriving Repr, Inhabited
-
-abbrev TypedDecls := IndexMap Global TypedDeclaration
-
-mutual
-
-open Std (HashSet)
-
-partial def Typ.size (decls : TypedDecls) (visited : HashSet Global := {}) : Typ → Nat
-  | Typ.field .. => 1
-  | Typ.pointer .. => 1
-  | Typ.function .. => 1
-  | Typ.tuple ts => ts.foldl (init := 0) (fun acc t => acc + t.size decls visited)
-  | Typ.dataType g => match decls.getByKey g with
-    | some (.dataType data) => data.size decls visited
-    | _ => panic! "impossible case"
-
-partial def Constructor.size (decls : TypedDecls) (visited : HashSet Global := {}) (c : Constructor) : Nat :=
-  c.argTypes.foldl (λ acc t => acc + t.size decls visited) 0
-
-partial def DataType.size (dt : DataType) (decls : TypedDecls) (visited : HashSet Global := {}) : Nat :=
-  if visited.contains dt.name then
-    panic! s!"cycle detected at datatype `{dt.name}`"
-  else
-    let visited := visited.insert dt.name
-    let ctorSizes := dt.constructors.map (Constructor.size decls visited)
-    let maxFields := ctorSizes.foldl max 0
-    maxFields + 1
-end
-
-end Aiur
diff --git a/Ix/Archon/ArithExpr.lean b/Ix/Archon/ArithExpr.lean
deleted file mode 100644
index 318ba4c2..00000000
--- a/Ix/Archon/ArithExpr.lean
+++ /dev/null
@@ -1,62 +0,0 @@
-import Ix.Archon.OracleIdx
-import Ix.Unsigned
-
-namespace Archon
-
-/-- Arithmetic expression type for BinaryField128b -/
-inductive ArithExpr
-  | const : UInt128 → ArithExpr
-  | var : USize → ArithExpr
-  | oracle : OracleIdx → ArithExpr
-  | add : ArithExpr → ArithExpr → ArithExpr
-  | mul : ArithExpr → ArithExpr → ArithExpr
-  | pow : ArithExpr → UInt64 → ArithExpr
-  deriving Inhabited, Ord
-
-instance : Add ArithExpr := ⟨.add⟩
-instance : Sub ArithExpr := ⟨.add⟩
-instance : Mul ArithExpr := ⟨.mul⟩
-instance : HPow ArithExpr UInt64 ArithExpr where
-  hPow x e := .pow x e
-
-instance : Zero ArithExpr := ⟨.const 0⟩
-
-instance : Coe OracleIdx ArithExpr := ⟨.oracle⟩
-
-namespace ArithExpr
-
-@[inline] def zero : ArithExpr := Zero.zero
-@[inline] def one : ArithExpr := .const 1
-
-def toString : ArithExpr → String
-  | const c => s!"Const({c})"
-  | var v => s!"Var({v})"
-  | oracle o => s!"Oracle({o.toUSize})"
-  | add x y => s!"Add({x.toString}, {y.toString})"
-  | mul x y => s!"Mul({x.toString}, {y.toString})"
-  | pow x e => s!"Pow({x.toString}, {e})"
-
-instance : ToString ArithExpr := ⟨toString⟩
-
-def toBytes : @& ArithExpr → ByteArray
-  | const u128 => ⟨#[0]⟩ ++ u128.toLEBytes
-  | var v => ⟨#[1]⟩ ++ v.toLEBytes
-  | oracle o => ⟨#[2]⟩ ++ o.toUSize.toLEBytes
-  | add x y =>
-    let xBytes := x.toBytes
-    ⟨#[3, xBytes.size.toUInt8]⟩ ++ xBytes ++ y.toBytes
-  | mul x y =>
-    let xBytes := x.toBytes
-    ⟨#[4, xBytes.size.toUInt8]⟩ ++ xBytes ++ y.toBytes
-  | pow x e => ⟨#[5]⟩ ++ x.toBytes ++ e.toLEBytes
-
-/--
-Function meant for testing that tells whether the Lean→Rust mapping of ArithExpr
-results on the same expression as deserializing the provided bytes.
--/
-@[extern "rs_arith_expr_is_equivalent_to_bytes"]
-opaque isEquivalentToBytes : @& ArithExpr → @& ByteArray → Bool
-
-end ArithExpr
-
-end Archon
diff --git a/Ix/Archon/Circuit.lean b/Ix/Archon/Circuit.lean
deleted file mode 100644
index e9f36369..00000000
--- a/Ix/Archon/Circuit.lean
+++ /dev/null
@@ -1,99 +0,0 @@
-import Blake3
-import Ix.Archon.ArithExpr
-import Ix.Archon.OracleIdx
-import Ix.Archon.RelativeHeight
-import Ix.Archon.OracleOrConst
-import Ix.Archon.Transparent
-import Ix.Archon.Witness
-import Ix.Binius.Common
-
-namespace Archon
-
-private opaque GenericNonempty : NonemptyType
-def CircuitModule : Type := GenericNonempty.type
-instance : Nonempty CircuitModule := GenericNonempty.property
-
-inductive ShiftVariant
-  | circularLeft | logicalLeft | logicalRight
-
-namespace CircuitModule
-
-@[never_extract, extern "c_rs_circuit_module_new"]
-opaque new : USize → CircuitModule
-
-abbrev selector : OracleIdx := ⟨0⟩
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_freeze_oracles"]
-opaque freezeOracles : CircuitModule → CircuitModule
-
-@[extern "c_rs_circuit_module_init_witness_module"]
-opaque initWitnessModule : @& CircuitModule → WitnessModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_flush"]
-opaque flush : CircuitModule → Binius.FlushDirection → Binius.ChannelId →
-  (selector : OracleIdx) → @& Array OracleOrConst → (multiplicity : UInt64) → CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_assert_zero"]
-opaque assertZero : CircuitModule → @& String → @& Array OracleIdx →
-  @& ArithExpr → CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_assert_not_zero"]
-opaque assertNotZero : CircuitModule → OracleIdx → CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_assert_exp"]
-opaque assertExp : CircuitModule → (expBits : @& Array OracleIdx) →
-  (result : OracleIdx) → (base : @& OracleOrConst) → CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_add_committed"]
-opaque addCommitted : CircuitModule → @& String → TowerField → @& RelativeHeight →
-  OracleIdx × CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_add_transparent"]
-opaque addTransparent : CircuitModule → @& String → @& Transparent → @& RelativeHeight →
-  OracleIdx × CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_add_linear_combination"]
-opaque addLinearCombination : CircuitModule → @& String → (offset : @& UInt128) →
-  (inner : @& Array (OracleIdx × UInt128)) → @& RelativeHeight → OracleIdx × CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_add_packed"]
-opaque addPacked : CircuitModule → @& String → OracleIdx →
-  (logDegree : USize) → OracleIdx × CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_add_shifted"]
-opaque addShifted : CircuitModule → @& String → OracleIdx → (shiftOffset : UInt32) →
-  (blockBits : USize) → @& ShiftVariant → OracleIdx × CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_add_projected"]
-opaque addProjected : CircuitModule → @& String → OracleIdx → (selection : UInt64) →
-  (chunkSize : USize) → OracleIdx × CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_push_namespace"]
-opaque pushNamespace : CircuitModule → @& String → CircuitModule
-
-/-- **Invalidates** the input `CircuitModule` -/
-@[never_extract, extern "c_rs_circuit_module_pop_namespace"]
-opaque popNamespace : CircuitModule → CircuitModule
-
-@[extern "c_rs_circuit_module_canonical_bytes"]
-opaque canonicalBytes : @& CircuitModule → ByteArray
-
-end CircuitModule
-
-def version (modules : Array CircuitModule) : Blake3.Blake3Hash :=
-  let bytes := modules.foldl (fun acc mod => acc ++ mod.canonicalBytes) default
-  Blake3.hash bytes
-
-end Archon
diff --git a/Ix/Archon/ModuleMode.lean b/Ix/Archon/ModuleMode.lean
deleted file mode 100644
index 00e49909..00000000
--- a/Ix/Archon/ModuleMode.lean
+++ /dev/null
@@ -1,31 +0,0 @@
-import Ix.Unsigned
-
-namespace Archon
-
-inductive ModuleMode
-  | inactive
-  | active (logHeight : UInt8) (depth : UInt64)
-  deriving Inhabited, Repr
-
-namespace ModuleMode
-
-def toString : ModuleMode → String
-  | inactive => "Inactive"
-  | active logHeight depth => s!"Active({logHeight}, {depth})"
-
-instance : ToString ModuleMode := ⟨toString⟩
-
-def toBytes : @& ModuleMode → ByteArray
-  | inactive => ⟨#[0]⟩
-  | active logHeight depth => ⟨#[1, logHeight]⟩ ++ depth.toLEBytes
-
-/--
-Function meant for testing that tells whether the Lean→Rust mapping of ModuleMode
-results on the same expression as deserializing the provided bytes.
--/
-@[extern "rs_module_mode_is_equivalent_to_bytes"]
-opaque isEquivalentToBytes : @& ModuleMode → @& ByteArray → Bool
-
-end ModuleMode
-
-end Archon
diff --git a/Ix/Archon/OracleIdx.lean b/Ix/Archon/OracleIdx.lean
deleted file mode 100644
index f9853c7a..00000000
--- a/Ix/Archon/OracleIdx.lean
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace Archon
-
-structure OracleIdx where
-  toUSize : USize
-  deriving Inhabited, Ord
-
-end Archon
diff --git a/Ix/Archon/OracleOrConst.lean b/Ix/Archon/OracleOrConst.lean
deleted file mode 100644
index cd345266..00000000
--- a/Ix/Archon/OracleOrConst.lean
+++ /dev/null
@@ -1,33 +0,0 @@
-import Ix.Archon.OracleIdx
-import Ix.Archon.TowerField
-import Ix.Unsigned
-
-namespace Archon
-
-inductive OracleOrConst
-  | oracle : OracleIdx → OracleOrConst
-  | const : UInt128 → TowerField → OracleOrConst
-  deriving Inhabited
-
-namespace OracleOrConst
-
-def toString : OracleOrConst → String
-  | oracle o => s!"Oracle({o.toUSize})"
-  | const base tf => s!"Const({base}, {tf})"
-
-instance : ToString OracleOrConst := ⟨toString⟩
-
-def toBytes : @& OracleOrConst → ByteArray
-  | oracle o => ⟨#[0]⟩ ++ o.toUSize.toLEBytes
-  | const base tf => ⟨#[1]⟩ ++ base.toLEBytes |>.push tf.logDegree.toUInt8
-
-/--
-Function meant for testing that tells whether the Lean→Rust mapping of OracleOrConst
-results on the same expression as deserializing the provided bytes.
--/
-@[extern "rs_oracle_or_const_is_equivalent_to_bytes"]
-opaque isEquivalentToBytes : @& OracleOrConst → @& ByteArray → Bool
-
-end OracleOrConst
-
-end Archon
diff --git a/Ix/Archon/Protocol.lean b/Ix/Archon/Protocol.lean
deleted file mode 100644
index b4cc147a..00000000
--- a/Ix/Archon/Protocol.lean
+++ /dev/null
@@ -1,53 +0,0 @@
-import Ix.Archon.Circuit
-import Ix.Archon.Witness
-import Ix.Binius.Boundary
-
-namespace Archon
-
-open Binius
-
-private opaque GenericNonempty : NonemptyType
-def Proof : Type := GenericNonempty.type
-instance : Nonempty Proof := GenericNonempty.property
-
-@[never_extract, extern "c_rs_validate_witness"]
-opaque validateWitness : @& Array CircuitModule → @& Array Boundary → @& Witness →
-   Except String Unit
-
-/-- **Invalidates** the input `Witness` -/
-@[never_extract, extern "c_rs_prove"]
-opaque prove : @& Array CircuitModule → @& Array Boundary →
-  (logInvRate securityBits : USize) → Witness → Proof
-
-/-- **Invalidates** the input `Proof` -/
-@[never_extract, extern "c_rs_verify"]
-opaque verify : @& Array CircuitModule → @& Array Boundary →
-  (logInvRate securityBits : USize) → Proof → Except String Unit
-
-/--
-Serialize an Archon proof as a `ByteArray`.
-* The 2 first bytes form an `UInt16` that tells how many modules there are
-* Then, chunks of 8 bytes form `UInt64`s that tell the heights for each module
-* Finally, the rest of the bytes compose the Binius proof transcript
--/
-@[extern "c_rs_proof_to_bytes"]
-opaque Proof.toBytes : @& Proof → ByteArray
-
-@[extern "c_rs_proof_of_bytes"]
-private opaque Proof.ofBytes' : @& ByteArray → Proof
-
-def Proof.ofBytes (bytes : ByteArray) : Except String Proof :=
-  let size := bytes.size
-  if _ : 1 < size then -- 2 bytes are needed for the first `u16`
-    let b₀ := bytes[0]
-    let b₁ := bytes[1]
-    let numModules := b₀.toNat + 256 * b₁.toNat
-    let numHeightsBytes := numModules * 8 -- 8 bytes (an `u64`) for each module height
-    if size < 2 + numHeightsBytes then
-      .error "Not enough data to read modules heights"
-    else
-      .ok $ Proof.ofBytes' bytes
-  else
-    .error "Not enough data to read the number of modules"
-
-end Archon
diff --git a/Ix/Archon/RelativeHeight.lean b/Ix/Archon/RelativeHeight.lean
deleted file mode 100644
index 4d3efe07..00000000
--- a/Ix/Archon/RelativeHeight.lean
+++ /dev/null
@@ -1,32 +0,0 @@
-namespace Archon
-
-inductive RelativeHeight
-  | base
-  | div2 (n : UInt8)
-  | mul2 (n : UInt8)
-  deriving Inhabited
-
-namespace RelativeHeight
-
-def toString : RelativeHeight → String
-  | base => "Base"
-  | div2 n => s!"Div2({n})"
-  | mul2 n => s!"Mul2({n})"
-
-instance : ToString RelativeHeight := ⟨toString⟩
-
-def toBytes : @& RelativeHeight → ByteArray
-  | base => ⟨#[0]⟩
-  | div2 n => ⟨#[1, n]⟩
-  | mul2 n => ⟨#[2, n]⟩
-
-/--
-Function meant for testing that tells whether the Lean→Rust mapping of RelativeHeight
-results on the same expression as deserializing the provided bytes.
--/
-@[extern "rs_relative_height_is_equivalent_to_bytes"]
-opaque isEquivalentToBytes : @& RelativeHeight → @& ByteArray → Bool
-
-end RelativeHeight
-
-end Archon
diff --git a/Ix/Archon/TowerField.lean b/Ix/Archon/TowerField.lean
deleted file mode 100644
index 096a9c04..00000000
--- a/Ix/Archon/TowerField.lean
+++ /dev/null
@@ -1,30 +0,0 @@
-import Ix.Unsigned
-
-namespace Archon
-
-inductive TowerField
-  | b1 | b2 | b4 | b8 | b16 | b32 | b64 | b128
-  deriving Inhabited
-
-def TowerField.logDegree : TowerField → USize
-  | .b1 => 0
-  | .b2 => 1
-  | .b4 => 2
-  | .b8 => 3
-  | .b16 => 4
-  | .b32 => 5
-  | .b64 => 6
-  | .b128 => 7
-
-instance : ToString TowerField where
-  toString
-    | .b1 => "b1"
-    | .b2 => "b2"
-    | .b4 => "b4"
-    | .b8 => "b8"
-    | .b16 => "b16"
-    | .b32 => "b32"
-    | .b64 => "b64"
-    | .b128 => "b128"
-
-end Archon
diff --git a/Ix/Archon/Transparent.lean b/Ix/Archon/Transparent.lean
deleted file mode 100644
index 7343ef8e..00000000
--- a/Ix/Archon/Transparent.lean
+++ /dev/null
@@ -1,29 +0,0 @@
-import Ix.Unsigned
-
-namespace Archon
-
-inductive Transparent
-  | const : UInt128 → Transparent
-  | incremental
-  deriving Inhabited
-
-namespace Transparent
-
-def toString : Transparent → String
-  | const u128 => s!"Constant{u128}"
-  | incremental => "Incremental"
-
-def toBytes : @& Transparent → ByteArray
-  | const u128 => ⟨#[0]⟩ ++ u128.toLEBytes
-  | incremental => ⟨#[1]⟩
-
-/--
-Function meant for testing that tells whether the Lean→Rust mapping of Transparent
-results on the same expression as deserializing the provided bytes.
--/
-@[extern "rs_transparent_is_equivalent_to_bytes"]
-opaque isEquivalentToBytes : @& Transparent → @& ByteArray → Bool
-
-end Transparent
-
-end Archon
diff --git a/Ix/Archon/Witness.lean b/Ix/Archon/Witness.lean
deleted file mode 100644
index 6fd9e6fb..00000000
--- a/Ix/Archon/Witness.lean
+++ /dev/null
@@ -1,72 +0,0 @@
-import Ix.Archon.OracleIdx
-import Ix.Archon.ModuleMode
-import Ix.Archon.TowerField
-import Ix.Unsigned
-
-namespace Archon
-
-private opaque GenericNonempty : NonemptyType
-def WitnessModule : Type := GenericNonempty.type
-instance : Nonempty WitnessModule := GenericNonempty.property
-
-private opaque GenericNonempty' : NonemptyType
-def Witness : Type := GenericNonempty'.type
-instance : Nonempty Witness := GenericNonempty'.property
-
-structure EntryId where
-  toUSize : USize
-  deriving Inhabited
-
-namespace WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_add_entry"]
-opaque addEntry : WitnessModule → EntryId × WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_add_entry_with_capacity"]
-opaque addEntryWithCapacity : WitnessModule → (logBits : UInt8) → EntryId × WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_bind_oracle_to"]
-opaque bindOracleTo : WitnessModule → OracleIdx → EntryId → TowerField → WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_push_u8s_to"]
-opaque pushUInt8sTo : WitnessModule → @& Array UInt8 → EntryId → WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_push_u16s_to"]
-opaque pushUInt16sTo : WitnessModule → @& Array UInt16 → EntryId → WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_push_u32s_to"]
-opaque pushUInt32sTo : WitnessModule → @& Array UInt32 → EntryId → WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_push_u64s_to"]
-opaque pushUInt64sTo : WitnessModule → @& Array UInt64 → EntryId → WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_push_u128s_to"]
-opaque pushUInt128sTo : WitnessModule → @& Array UInt128 → EntryId → WitnessModule
-
-/-- **Invalidates** the input `WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_populate"]
-opaque populate : WitnessModule → @& ModuleMode → WitnessModule
-
-/-- **Invalidates** the elements of the input `Array WitnessModule` -/
-@[never_extract, extern "c_rs_witness_module_par_populate"]
-opaque parPopulate : @& Array WitnessModule → @& Array ModuleMode → Array WitnessModule
-
-/-- **Panics** if there's no entry bound to the oracle -/
-@[extern "c_rs_witness_module_get_data"]
-opaque getData : @& WitnessModule → OracleIdx → ByteArray
-
-end WitnessModule
-
-/-- **Invalidates** the elements of the input `Array WitnessModule` -/
-@[never_extract, extern "c_rs_compile_witness_modules"]
-opaque compileWitnessModules : Array WitnessModule → @& Array ModuleMode → Witness
-
-end Archon
diff --git a/Ix/Binius/Boundary.lean b/Ix/Binius/Boundary.lean
deleted file mode 100644
index dbbf5d93..00000000
--- a/Ix/Binius/Boundary.lean
+++ /dev/null
@@ -1,37 +0,0 @@
-import Ix.Binius.Common
-import Ix.Unsigned
-
-namespace Binius
-
-structure Boundary where
-  values : Array UInt128
-  channelId : ChannelId
-  direction : FlushDirection
-  multiplicity : UInt64
-
-namespace Boundary
-
-def toString (boundary : @& Boundary) : String :=
-  let values := boundary.values
-  let channelId := boundary.channelId.toUSize
-  s!"⟨{values}, {channelId}, {boundary.direction}, {boundary.multiplicity}⟩"
-
-def toBytes (boundary : @& Boundary) : ByteArray :=
-  let numValues := boundary.values.size
-  let valuesBytes := boundary.values.foldl (init := .mkEmpty (16 * numValues))
-    fun acc u128 => acc ++ u128.toLEBytes
-  let channelBytes := boundary.channelId.toUSize.toLEBytes
-  let directionByte := match boundary.direction with | .push => 0 | .pull => 1
-  numValues.toUSize.toLEBytes ++ valuesBytes ++ channelBytes ++
-    ⟨#[directionByte]⟩ ++ boundary.multiplicity.toLEBytes
-
-/--
-Function meant for testing that tells whether the Lean→Rust mapping of Boundary
-results on the same boundary as deserializing the provided bytes.
--/
-@[extern "rs_binius_boundary_is_equivalent_to_bytes"]
-opaque isEquivalentToBytes : @& Boundary → @& ByteArray → Bool
-
-end Boundary
-
-end Binius
diff --git a/Ix/Binius/Common.lean b/Ix/Binius/Common.lean
deleted file mode 100644
index acadb082..00000000
--- a/Ix/Binius/Common.lean
+++ /dev/null
@@ -1,48 +0,0 @@
-import Ix.Unsigned
-
-namespace Binius
-
-structure ChannelId where
-  toUSize : USize
-  deriving Inhabited
-
-structure ChannelAllocator where
-  nextId : USize
-
-def ChannelAllocator.init : ChannelAllocator := ⟨0⟩
-
-def ChannelAllocator.next : ChannelAllocator → ChannelId × ChannelAllocator
-  | ⟨nextId⟩ => (⟨nextId⟩, ⟨nextId + 1⟩)
-
-def ChannelAllocator.nextN (self : ChannelAllocator) (n : Nat) :
-    Array ChannelId × ChannelAllocator :=
-  n.fold (init := (#[], self)) fun _ _ (channels, channelAllocator) =>
-    let (channel, channelAllocator) := channelAllocator.next
-    (channels.push channel, channelAllocator)
-
-inductive FlushDirection
-  | push | pull
-
-instance : ToString FlushDirection where toString
-  | .push => "push"
-  | .pull => "pull"
-
-@[extern "c_rs_add_u128_in_binary_field"]
-opaque addUInt128InBinaryField : @& UInt128 → @& UInt128 → UInt128
-
-@[extern "c_rs_mul_u128_in_binary_field"]
-opaque mulUInt128InBinaryField : @& UInt128 → @& UInt128 → UInt128
-
-@[extern "rs_mul_u64_in_binary_field"]
-opaque mulUInt64InBinaryField : @& UInt64 → @& UInt64 → UInt64
-
-@[extern "rs_pow_u64_in_binary_field"]
-opaque powUInt64InBinaryField : (base : @& UInt64) → (exp : @& UInt64) → UInt64
-
-@[extern "c_rs_pow_u128_in_binary_field"]
-opaque powUInt128InBinaryField : (base : @& UInt128) → (exp : @& UInt64) → UInt128
-
-@[extern "rs_inv_u64_in_binary_field"]
-opaque invUInt64InBinaryField : @& UInt64 → UInt64
-
-end Binius
diff --git a/Ix/Iroh/Transfer.lean b/Ix/Iroh/Transfer.lean
index 3d1a6431..2748a8b9 100644
--- a/Ix/Iroh/Transfer.lean
+++ b/Ix/Iroh/Transfer.lean
@@ -1,8 +1,4 @@
-import Cli
-
-namespace Iroh
-
-namespace Transfer
+namespace Iroh.Transfer
 
 @[never_extract, extern "c_rs_iroh_send"]
 opaque sendBytes : @& ByteArray → IO Unit
@@ -10,5 +6,4 @@ opaque sendBytes : @& ByteArray → IO Unit
 @[never_extract, extern "c_rs_iroh_recv"]
 opaque recvBytes : (ticket : @& String) → (bufferCapacity : USize) → IO ByteArray
 
-end Transfer
-end Iroh
+end Iroh.Transfer
diff --git a/Ix/Unsigned.lean b/Ix/Unsigned.lean
index 3b8cd3f1..2fe1f70e 100644
--- a/Ix/Unsigned.lean
+++ b/Ix/Unsigned.lean
@@ -9,61 +9,3 @@ opaque UInt64.toLEBytes : UInt64 → ByteArray
 
 @[extern "c_usize_to_le_bytes"]
 opaque USize.toLEBytes : USize → ByteArray
-
-private opaque GenericNonempty : NonemptyType
-
-def UInt128 : Type := GenericNonempty.type
-
-instance : Nonempty UInt128 := GenericNonempty.property
-
-namespace UInt128
-
-abbrev size := 2^128
-
-@[extern "c_u128_of_lo_hi"]
-opaque ofLoHi : (lo : UInt64) → (hi : UInt64) → UInt128
-
-instance : Inhabited UInt128 where
-  default := ofLoHi 0 0
-
-def ofNatCore (n : Nat) (_ : n < size := by decide) : UInt128 :=
-  let lo := n % UInt64.size |>.toUInt64
-  let hi := n / UInt64.size |>.toUInt64
-  ofLoHi lo hi
-
-def ofNatWrap (n : Nat) : UInt128 :=
-  if h : n < size then ofNatCore n h
-  else ofNatCore (n % size) (Nat.mod_lt n (by decide))
-
-instance : OfNat UInt128 n := ⟨ofNatWrap n⟩
-
-@[extern "c_u128_to_lo_hi"]
-opaque toLoHi : @& UInt128 → UInt64 × UInt64
-
-@[extern "c_rs_exterior_mul_u64"]
-opaque exteriorMul : @& UInt64 → @& UInt64 → UInt128
-
-def toNat (u128 : @& UInt128) : Nat :=
-  let (lo, hi) := u128.toLoHi
-  lo.toNat + (hi.toNat * UInt64.size)
-
-instance : Repr UInt128 where
-  reprPrec x prec := reprPrec x.toNat prec
-
-instance : ToString UInt128 where
-  toString x := toString x.toNat
-
-@[extern "c_u128_cmp"]
-def cmpCore (a : @& UInt128) (b : @& UInt128) : Ordering :=
-  compare a.toNat b.toNat
-
-instance : Ord UInt128 where
-  compare := cmpCore
-
-instance : LT UInt128 where
-  lt a b := compare a b = .lt
-
-@[extern "c_u128_to_le_bytes"]
-opaque toLEBytes : @& UInt128 → ByteArray
-
-end UInt128
diff --git a/Main.lean b/Main.lean
index 2288ac76..f6081c99 100644
--- a/Main.lean
+++ b/Main.lean
@@ -1,7 +1,7 @@
 import Ix.Cli.ProveCmd
 import Ix.Cli.StoreCmd
-import Ix.Cli.SendCmd
-import Ix.Cli.RecvCmd
+-- import Ix.Cli.SendCmd
+-- import Ix.Cli.RecvCmd
 import Ix
 
 def VERSION : String :=
@@ -13,9 +13,9 @@ def ixCmd : Cli.Cmd := `[Cli|
 
   SUBCOMMANDS:
     proveCmd;
-    storeCmd;
-    sendCmd;
-    recvCmd
+    storeCmd
+    -- sendCmd;
+    -- recvCmd
 ]
 
 def main (args : List String) : IO UInt32 := do
diff --git a/Tests/Aiur.lean b/Tests/Aiur.lean
index db0aa031..c6885e6a 100644
--- a/Tests/Aiur.lean
+++ b/Tests/Aiur.lean
@@ -1,31 +1,29 @@
 import LSpec
-import Ix.Aiur.Bytecode
-import Ix.Aiur.Simple
 import Ix.Aiur.Meta
-import Ix.Aiur.Execute
-import Ix.Aiur.Witness
-import Ix.Archon.Protocol
+import Ix.Aiur.Simple
+import Ix.Aiur.Compile
+import Ix.Aiur.Protocol
 
-open LSpec Aiur
+open LSpec
 
 def toplevel := ⟦
-  fn id(n: u64) -> u64 {
+  fn id(n: G) -> G {
     n
   }
 
-  fn proj1(a: u64, _b: u64) -> u64 {
+  fn proj1(a: G, _b: G) -> G {
     a
   }
 
-  fn sum(x: u64, y: u64) -> u64 {
+  fn sum(x: G, y: G) -> G {
     add(x, y)
   }
 
-  fn prod(x: u64, y: u64) -> u64 {
+  fn prod(x: G, y: G) -> G {
     mul(x, y)
   }
 
-  fn store_and_load(x: u64) -> u64 {
+  fn store_and_load(x: G) -> G {
     load(store(x))
   }
 
@@ -34,147 +32,90 @@ def toplevel := ⟦
     Succ(&Nat)
   }
 
-  fn even(m: Nat) -> u1 {
+  fn even(m: Nat) -> G {
     match m {
-      Nat.Zero => 1u1,
+      Nat.Zero => 1,
       Nat.Succ(m) => odd(load(m)),
     }
   }
 
-  fn odd(m: Nat) -> u1 {
+  fn odd(m: Nat) -> G {
     match m {
-      Nat.Zero => 0u1,
+      Nat.Zero => 0,
       Nat.Succ(m) => even(load(m)),
     }
   }
 
-  fn is_0_even() -> u1 {
+  fn is_0_even() -> G {
     even(Nat.Zero)
   }
 
-  fn is_1_even() -> u1 {
+  fn is_1_even() -> G {
     even(Nat.Succ(store(Nat.Zero)))
   }
 
-  fn is_2_even() -> u1 {
+  fn is_2_even() -> G {
     even(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))
   }
 
-  fn is_3_even() -> u1 {
+  fn is_3_even() -> G {
     even(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))))
   }
 
-  fn is_4_even() -> u1 {
+  fn is_4_even() -> G {
     even(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))))))
   }
 
-  fn is_0_odd() -> u1 {
+  fn is_0_odd() -> G {
     odd(Nat.Zero)
   }
 
-  fn is_1_odd() -> u1 {
+  fn is_1_odd() -> G {
     odd(Nat.Succ(store(Nat.Zero)))
   }
 
-  fn is_2_odd() -> u1 {
+  fn is_2_odd() -> G {
     odd(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))
   }
 
-  fn is_3_odd() -> u1 {
+  fn is_3_odd() -> G {
     odd(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))))
   }
 
-  fn is_4_odd() -> u1 {
+  fn is_4_odd() -> G {
     odd(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))))))
   }
 
-  fn factorial(n: u64) -> u64 {
-    if n {
-      mul(n, factorial(sub(n, 1u64)))
-    } else {
-      1u64
+  fn factorial(n: G) -> G {
+    match n {
+      0 => 1,
+      _ => mul(n, factorial(sub(n, 1))),
     }
   }
 
-  fn fibonacci(n: u64) -> u64 {
-    if n {
-      let n_minus_1 = sub(n, 1u64);
-      if n_minus_1 {
-        let n_minus_2 = sub(n_minus_1, 1u64);
-        add(fibonacci(n_minus_1), fibonacci(n_minus_2))
-      } else {
-        1u64
-      }
-    } else {
-      1u64
+  fn fibonacci(n: G) -> G {
+    match n {
+      0 => 1,
+      _ =>
+        let n_minus_1 = sub(n, 1);
+        match n_minus_1 {
+          0 => 1,
+          _ =>
+            let n_minus_2 = sub(n_minus_1, 1);
+            add(fibonacci(n_minus_1), fibonacci(n_minus_2)),
+        },
     }
   }
 
-  fn call_bit_xor(a: u64, b: u64) -> u64 {
-    let c = ffi(bit_xor, a, b);
-    get(c, 0)
-  }
-
-  fn call_bit_xor2(a: u64, b: u64) -> u64 {
-    let (c) = ffi(bit_xor, a, b);
-    c
-  }
-
-  fn slice_and_get(as: (u64, u64, u64, u64)) -> u64 {
+  fn slice_and_get(as: (G, G, G, G)) -> G {
     get(slice(as, 1, 4), 2)
   }
 ⟧
 
-open Archon Binius
-
-def bitXor : Gadget :=
-  { name := `bit_xor
-    inputSize := 2
-    outputSize := 1
-    execute := fun inp => #[inp[0]! ^^^ inp[1]!]
-    synthesize
-    populate }
-where
-  synthesize channelId circuitModule :=
-    let circuitModule := circuitModule.pushNamespace "bit-xor"
-    let (xBits, circuitModule) := circuitModule.addCommitted "x-bits" .b1 (.mul2 6)
-    let (yBits, circuitModule) := circuitModule.addCommitted "y-bits" .b1 (.mul2 6)
-    let (multiplicity, circuitModule) := circuitModule.addCommitted "multiplicity" .b64 .base
-    let (zBits, circuitModule) := circuitModule.addLinearCombination "z-bits" 0
-      #[(xBits, 1), (yBits, 1)] (.mul2 6)
-    let (x, circuitModule) := circuitModule.addPacked "x-bits-packed" xBits 6
-    let (y, circuitModule) := circuitModule.addPacked "y-bits-packed" yBits 6
-    let (z, circuitModule) := circuitModule.addPacked "z-bits-packed" zBits 6
-    let args := #[x, y, z].map .oracle
-    let circuitModule := Gadget.provide circuitModule channelId multiplicity args
-    (circuitModule.popNamespace, #[xBits, yBits, multiplicity])
-  populate entries oracles witnessModule :=
-    if entries.isEmpty then (witnessModule, .inactive) else
-      let height := entries.size.nextPowerOfTwo.max 2
-      let logHeight := height.log2.toUInt8
-      let mode := .active logHeight entries.size.toUInt64
-      let xBits := oracles[0]!
-      let yBits := oracles[1]!
-      let multiplicity := oracles[2]!
-      let (xBitsEntry, witnessModule) := witnessModule.addEntryWithCapacity (logHeight + 6)
-      let (yBitsEntry, witnessModule) := witnessModule.addEntryWithCapacity (logHeight + 6)
-      let (multiplicityEntry, witnessModule) := witnessModule.addEntryWithCapacity logHeight
-      let witnessModule := witnessModule.bindOracleTo xBits xBitsEntry .b1
-      let witnessModule := witnessModule.bindOracleTo yBits yBitsEntry .b1
-      let witnessModule := witnessModule.bindOracleTo multiplicity multiplicityEntry .b64
-      let (xData, yData, mData) := entries.foldl (init := (#[], #[], #[]))
-        fun (xData, yData, mData) entry =>
-          let multiplicity := powUInt64InBinaryField MultiplicativeGenerator entry.multiplicity
-          (xData.push entry.input[0]!, yData.push entry.input[1]!, mData.push multiplicity)
-      let witnessModule := witnessModule.pushUInt64sTo xData xBitsEntry
-      let witnessModule := witnessModule.pushUInt64sTo yData yBitsEntry
-      let witnessModule := witnessModule.pushUInt64sTo mData multiplicityEntry
-      (witnessModule, mode)
-
 structure TestCase where
   functionName : Lean.Name
-  input : Array UInt64
-  expectedOutput : Array UInt64
+  input : Array Aiur.G
+  expectedOutput : Array Aiur.G
 
 def testCases : List TestCase := [
     ⟨`id, #[42], #[42]⟩,
@@ -196,38 +137,31 @@ def testCases : List TestCase := [
     ⟨`fibonacci, #[0], #[1]⟩,
     ⟨`fibonacci, #[1], #[1]⟩,
     ⟨`fibonacci, #[6], #[13]⟩,
-    ⟨`call_bit_xor, #[13, 7], #[10]⟩,
-    ⟨`call_bit_xor2, #[13, 7], #[10]⟩,
     ⟨`slice_and_get, #[1, 2, 3, 4], #[4]⟩,
   ]
 
+def friParameters : Aiur.FriParameters := {
+  logBlowup := 1
+  logFinalPolyLen := 0
+  numQueries := 100
+  proofOfWorkBits := 20
+}
+
 def aiurTest : TestSeq :=
-  let toplevel := toplevel.addGadget bitXor
-  withExceptOk "Check and simplification works" (checkAndSimplifyToplevel toplevel) fun decls =>
+  withExceptOk "Check and simplification works" toplevel.checkAndSimplify fun decls =>
     let bytecodeToplevel := decls.compile
-    let (aiurCircuits, funcChannels) := Circuit.synthesize bytecodeToplevel
-    let circuitModules := aiurCircuits.circuitModules
-    let runTestCase := fun (testCase : TestCase) =>
+    let aiurSystem := Aiur.AiurSystem.build bytecodeToplevel
+    let runTestCase := fun testCase =>
       let functionName := testCase.functionName
-      let funcIdx := toplevel.getFuncIdx functionName |>.get!
-      let record := bytecodeToplevel.execute funcIdx testCase.input
-      let output := record.getFuncResult funcIdx testCase.input |>.get!
-      let executionTest :=
-        test s!"Result of {functionName} with arguments {testCase.input} is correct"
-          (output == testCase.expectedOutput)
-      let traces := bytecodeToplevel.generateTraces record
-      let witness := Circuit.populateWitness aiurCircuits traces bytecodeToplevel.gadgets
-      let funcChannel := funcChannels[funcIdx]!
-      let boundaries := Circuit.mkBoundaries testCase.input output funcChannel
-      let witnessTest :=
-        withExceptOk s!"Witness for {functionName} with arguments {testCase.input} is accepted"
-          (Archon.validateWitness circuitModules boundaries witness) fun _ => .done
-      let (logInvRate, securityBits) := (1, 100)
-      let proof := Archon.prove circuitModules boundaries logInvRate securityBits witness
-      let proofTest :=
-        withExceptOk s!"Proof for {functionName} with arguments {testCase.input} verifies"
-          (Archon.verify circuitModules boundaries logInvRate securityBits proof) fun _ => .done
-      executionTest ++ witnessTest ++ proofTest
+      let funIdx := toplevel.getFuncIdx functionName |>.get!
+      let (claim, proof) := aiurSystem.prove friParameters funIdx testCase.input
+      let caseDescr := s!"{functionName} with arguments {testCase.input}"
+      let ioTest := test s!"Claim matches for {caseDescr}"
+        (claim == Aiur.buildClaim funIdx testCase.input testCase.expectedOutput)
+      let proof := .ofBytes proof.toBytes
+      let pvTest := withExceptOk s!"Prove/verify works for {caseDescr}"
+        (aiurSystem.verify friParameters claim proof) fun _ => .done
+      ioTest ++ pvTest
     testCases.foldl (init := .done) fun tSeq testCase =>
       tSeq ++ runTestCase testCase
 
diff --git a/Tests/Aiur2.lean b/Tests/Aiur2.lean
deleted file mode 100644
index 8d087ec8..00000000
--- a/Tests/Aiur2.lean
+++ /dev/null
@@ -1,168 +0,0 @@
-import LSpec
-import Ix.Aiur2.Meta
-import Ix.Aiur2.Simple
-import Ix.Aiur2.Compile
-import Ix.Aiur2.Protocol
-
-open LSpec
-
-def toplevel := ⟦
-  fn id(n: G) -> G {
-    n
-  }
-
-  fn proj1(a: G, _b: G) -> G {
-    a
-  }
-
-  fn sum(x: G, y: G) -> G {
-    add(x, y)
-  }
-
-  fn prod(x: G, y: G) -> G {
-    mul(x, y)
-  }
-
-  fn store_and_load(x: G) -> G {
-    load(store(x))
-  }
-
-  enum Nat {
-    Zero,
-    Succ(&Nat)
-  }
-
-  fn even(m: Nat) -> G {
-    match m {
-      Nat.Zero => 1,
-      Nat.Succ(m) => odd(load(m)),
-    }
-  }
-
-  fn odd(m: Nat) -> G {
-    match m {
-      Nat.Zero => 0,
-      Nat.Succ(m) => even(load(m)),
-    }
-  }
-
-  fn is_0_even() -> G {
-    even(Nat.Zero)
-  }
-
-  fn is_1_even() -> G {
-    even(Nat.Succ(store(Nat.Zero)))
-  }
-
-  fn is_2_even() -> G {
-    even(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))
-  }
-
-  fn is_3_even() -> G {
-    even(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))))
-  }
-
-  fn is_4_even() -> G {
-    even(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))))))
-  }
-
-  fn is_0_odd() -> G {
-    odd(Nat.Zero)
-  }
-
-  fn is_1_odd() -> G {
-    odd(Nat.Succ(store(Nat.Zero)))
-  }
-
-  fn is_2_odd() -> G {
-    odd(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))
-  }
-
-  fn is_3_odd() -> G {
-    odd(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))))
-  }
-
-  fn is_4_odd() -> G {
-    odd(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Succ(store(Nat.Zero)))))))))
-  }
-
-  fn factorial(n: G) -> G {
-    match n {
-      0 => 1,
-      _ => mul(n, factorial(sub(n, 1))),
-    }
-  }
-
-  fn fibonacci(n: G) -> G {
-    match n {
-      0 => 1,
-      _ =>
-        let n_minus_1 = sub(n, 1);
-        match n_minus_1 {
-          0 => 1,
-          _ =>
-            let n_minus_2 = sub(n_minus_1, 1);
-            add(fibonacci(n_minus_1), fibonacci(n_minus_2)),
-        },
-    }
-  }
-
-  fn slice_and_get(as: (G, G, G, G)) -> G {
-    get(slice(as, 1, 4), 2)
-  }
-⟧
-
-structure TestCase where
-  functionName : Lean.Name
-  input : Array Aiur.G
-  expectedOutput : Array Aiur.G
-
-def testCases : List TestCase := [
-    ⟨`id, #[42], #[42]⟩,
-    ⟨`proj1, #[42, 64], #[42]⟩,
-    ⟨`sum, #[3, 5], #[8]⟩,
-    ⟨`prod, #[3, 5], #[15]⟩,
-    ⟨`store_and_load, #[42], #[42]⟩,
-    ⟨`is_0_even, #[], #[1]⟩,
-    ⟨`is_1_even, #[], #[0]⟩,
-    ⟨`is_2_even, #[], #[1]⟩,
-    ⟨`is_3_even, #[], #[0]⟩,
-    ⟨`is_4_even, #[], #[1]⟩,
-    ⟨`is_0_odd, #[], #[0]⟩,
-    ⟨`is_1_odd, #[], #[1]⟩,
-    ⟨`is_2_odd, #[], #[0]⟩,
-    ⟨`is_3_odd, #[], #[1]⟩,
-    ⟨`is_4_odd, #[], #[0]⟩,
-    ⟨`factorial, #[5], #[120]⟩,
-    ⟨`fibonacci, #[0], #[1]⟩,
-    ⟨`fibonacci, #[1], #[1]⟩,
-    ⟨`fibonacci, #[6], #[13]⟩,
-    ⟨`slice_and_get, #[1, 2, 3, 4], #[4]⟩,
-  ]
-
-def friParameters : Aiur.FriParameters := {
-  logBlowup := 1
-  logFinalPolyLen := 0
-  numQueries := 100
-  proofOfWorkBits := 20
-}
-
-def aiurTest : TestSeq :=
-  withExceptOk "Check and simplification works" toplevel.checkAndSimplify fun decls =>
-    let bytecodeToplevel := decls.compile
-    let aiurSystem := Aiur.AiurSystem.build bytecodeToplevel
-    let runTestCase := fun testCase =>
-      let functionName := testCase.functionName
-      let funIdx := toplevel.getFuncIdx functionName |>.get!
-      let (claim, proof) := aiurSystem.prove friParameters funIdx testCase.input
-      let caseDescr := s!"{functionName} with arguments {testCase.input}"
-      let ioTest := test s!"Claim matches for {caseDescr}"
-        (claim == Aiur.buildClaim funIdx testCase.input testCase.expectedOutput)
-      let proof := .ofBytes proof.toBytes
-      let pvTest := withExceptOk s!"Prove/verify works for {caseDescr}"
-        (aiurSystem.verify friParameters claim proof) fun _ => .done
-      ioTest ++ pvTest
-    testCases.foldl (init := .done) fun tSeq testCase =>
-      tSeq ++ runTestCase testCase
-
-def Tests.Aiur.suite := [aiurTest]
diff --git a/Tests/Archon.lean b/Tests/Archon.lean
deleted file mode 100644
index e6647da4..00000000
--- a/Tests/Archon.lean
+++ /dev/null
@@ -1,188 +0,0 @@
-import LSpec
-import Ix.Archon.Circuit
-import Ix.Archon.Protocol
-import Ix.ByteArray
-
-open LSpec Archon
-
-def populateAndValidate (circuitModule : CircuitModule)
-    (witnessModule : WitnessModule) (depth : UInt64) msg :=
-  let logHeight := depth.toNat.nextPowerOfTwo.log2.toUInt8
-  let mode := .active logHeight depth
-  let witnessModule := witnessModule.populate mode
-  let witness := compileWitnessModules #[witnessModule] #[mode]
-  withExceptOk msg (validateWitness #[circuitModule] #[] witness) fun _ => .done
-
-def transparent : TestSeq :=
-  let circuitModule := CircuitModule.new 0
-  let (_, circuitModule) := circuitModule.addTransparent "constant" (.const 300) .base
-  let (_, circuitModule) := circuitModule.addTransparent "incremental" .incremental .base
-  let circuitModule := circuitModule.freezeOracles
-  let witnessModule := circuitModule.initWitnessModule
-  populateAndValidate circuitModule witnessModule 91 "Archon transparents work"
-
-def linearCombination : TestSeq := Id.run do
-  let circuitModule := CircuitModule.new 0
-  let (b1, circuitModule) := circuitModule.addCommitted "b1" .b1 .base
-  let (b2, circuitModule) := circuitModule.addCommitted "b2" .b2 .base
-  let (b4, circuitModule) := circuitModule.addCommitted "b4" .b4 .base
-  let (b8, circuitModule) := circuitModule.addCommitted "b8" .b8 .base
-  let (b16, circuitModule) := circuitModule.addCommitted "b16" .b16 .base
-  let (b32, circuitModule) := circuitModule.addCommitted "b32" .b32 .base
-  let (b64, circuitModule) := circuitModule.addCommitted "b64" .b64 .base
-  let (b128, circuitModule) := circuitModule.addCommitted "b128" .b128 .base
-
-  let (_, circuitModule) := circuitModule.addLinearCombination "lcb128" 3
-    #[(b1, 3), (b2, 4), (b4, 5), (b8, 6), (b16, 7), (b32, 8), (b64, 9), (b128, 10)]
-    .base
-  let (_, circuitModule) := circuitModule.addLinearCombination "lcb64" 907898
-    #[(b1, 500), (b2, 2000), (b4, 5), (b8, 4), (b16, 7), (b32, 8), (b64, 9879)]
-    .base
-
-  let circuitModule := circuitModule.freezeOracles
-  let mut witnessModule := circuitModule.initWitnessModule
-
-  let oracles := [b1, b2, b4, b8, b16, b32, b64, b128].mergeSort
-    fun a b => (a.toUSize.toNat ^ 7) % 3 < (b.toUSize.toNat ^ 7) % 3
-  for (oracleId, i) in oracles.zipIdx do
-    let (entryId, newWitnessModule) := witnessModule.addEntry
-    witnessModule := newWitnessModule
-    for j in [0 : 1 <<< i ] do
-      let u128 := UInt128.ofNatWrap (j * j + 17)
-      witnessModule := witnessModule.pushUInt128sTo #[u128] entryId
-    match i with
-    | 0 => witnessModule := witnessModule.bindOracleTo oracleId entryId .b1
-    | 1 => witnessModule := witnessModule.bindOracleTo oracleId entryId .b2
-    | 2 => witnessModule := witnessModule.bindOracleTo oracleId entryId .b4
-    | 3 => witnessModule := witnessModule.bindOracleTo oracleId entryId .b8
-    | 4 => witnessModule := witnessModule.bindOracleTo oracleId entryId .b16
-    | 5 => witnessModule := witnessModule.bindOracleTo oracleId entryId .b32
-    | 6 => witnessModule := witnessModule.bindOracleTo oracleId entryId .b64
-    | 7 => witnessModule := witnessModule.bindOracleTo oracleId entryId .b128
-    | _ => unreachable!
-
-  populateAndValidate circuitModule witnessModule 128 "Archon linear combination works"
-
-def packed : TestSeq :=
-  let circuitModule := CircuitModule.new 0
-  let (x, circuitModule) := circuitModule.addCommitted "x" .b1 .base
-  let (_, circuitModule) := circuitModule.addPacked "packed" x 2
-  let circuitModule := circuitModule.freezeOracles
-  let witnessModule := circuitModule.initWitnessModule
-  let (entryId, witnessModule) := witnessModule.addEntryWithCapacity 7
-  let witnessModule := witnessModule.pushUInt128sTo #[2347928368726] entryId
-  let witnessModule := witnessModule.bindOracleTo x entryId .b1
-  populateAndValidate circuitModule witnessModule 128 "Archon packed works"
-
-def shifted : TestSeq :=
-  let circuitModule := CircuitModule.new 0
-  let (x, circuitModule) := circuitModule.addCommitted "x" .b1 .base
-  let (_, circuitModule) := circuitModule.addShifted "shifted" x 2 4 .logicalLeft
-  let circuitModule := circuitModule.freezeOracles
-  let witnessModule := circuitModule.initWitnessModule
-  let (entryId, witnessModule) := witnessModule.addEntryWithCapacity 7
-  let witnessModule := witnessModule.pushUInt128sTo #[2347928368726] entryId
-  let witnessModule := witnessModule.bindOracleTo x entryId .b1
-  populateAndValidate circuitModule witnessModule 128 "Archon shifted works"
-
-def pushData : TestSeq :=
-  let circuitModule := CircuitModule.new 0
-  let (u8s, circuitModule) := circuitModule.addCommitted "u8s" .b1 .base
-  let (u16s, circuitModule) := circuitModule.addCommitted "u16s" .b1 .base
-  let (u32s, circuitModule) := circuitModule.addCommitted "u32s" .b1 .base
-  let (u64s, circuitModule) := circuitModule.addCommitted "u64s" .b1 .base
-  let (u128s, circuitModule) := circuitModule.addCommitted "u128s" .b1 .base
-  let circuitModule := circuitModule.assertZero "u8s xor u16s" #[] $ .add (.oracle u8s) (.oracle u16s)
-  let circuitModule := circuitModule.assertZero "u16s xor u32s" #[] $ .add (.oracle u16s) (.oracle u32s)
-  let circuitModule := circuitModule.assertZero "u32s xor u64s" #[] $ .add (.oracle u32s) (.oracle u64s)
-  let circuitModule := circuitModule.assertZero "u64s xor u128s" #[] $ .add (.oracle u64s) (.oracle u128s)
-  let circuitModule := circuitModule.freezeOracles
-  let witnessModule := circuitModule.initWitnessModule
-  let (u8sEntry, witnessModule) := witnessModule.addEntryWithCapacity 7
-  let (u16sEntry, witnessModule) := witnessModule.addEntryWithCapacity 7
-  let (u32sEntry, witnessModule) := witnessModule.addEntryWithCapacity 7
-  let (u64sEntry, witnessModule) := witnessModule.addEntryWithCapacity 7
-  let (u128sEntry, witnessModule) := witnessModule.addEntryWithCapacity 7
-  let witnessModule := witnessModule.pushUInt8sTo (.mkArray 16 0) u8sEntry
-  let witnessModule := witnessModule.pushUInt16sTo (.mkArray 8 0) u16sEntry
-  let witnessModule := witnessModule.pushUInt32sTo #[0, 0, 0, 0] u32sEntry
-  let witnessModule := witnessModule.pushUInt64sTo #[0, 0] u64sEntry
-  let witnessModule := witnessModule.pushUInt128sTo #[0] u128sEntry
-  let witnessModule := witnessModule.bindOracleTo u8s u8sEntry .b1
-  let witnessModule := witnessModule.bindOracleTo u16s u16sEntry .b1
-  let witnessModule := witnessModule.bindOracleTo u32s u32sEntry .b1
-  let witnessModule := witnessModule.bindOracleTo u64s u64sEntry .b1
-  let witnessModule := witnessModule.bindOracleTo u128s u128sEntry .b1
-  populateAndValidate circuitModule witnessModule 128 "Archon witness data pushes work"
-
-def proveAndVerify : TestSeq :=
-  let circuitModule := CircuitModule.new 0
-  let (x, circuitModule) := circuitModule.addCommitted "x" .b1 .base
-  let (y, circuitModule) := circuitModule.addCommitted "y" .b1 .base
-  let circuitModule := circuitModule.assertZero "x xor y" #[] $ .add (.oracle x) (.oracle y)
-  let circuitModule := circuitModule.freezeOracles
-  let witnessModule := circuitModule.initWitnessModule
-  let (entryId, witnessModule) := witnessModule.addEntryWithCapacity 7
-  let witnessModule := witnessModule.pushUInt128sTo #[(.ofNatCore $ UInt128.size - 1)] entryId
-  let witnessModule := witnessModule.bindOracleTo x entryId .b1
-  let witnessModule := witnessModule.bindOracleTo y entryId .b1
-  let mode := .active 7 128
-  let witnessModule := witnessModule.populate mode
-  let witness := compileWitnessModules #[witnessModule] #[mode]
-  let proof := prove #[circuitModule] #[] 1 100 witness
-  let proofBytes := proof.toBytes
-  withExceptOk "Archon proof serde works" (Proof.ofBytes proofBytes) fun proof =>
-    withExceptOk "Archon prove and verify work"
-      (verify #[circuitModule] #[] 1 100 proof) fun _ => .done
-
-def parPopulate : TestSeq :=
-  let c₁ := CircuitModule.new 0
-  let c₂ := CircuitModule.new 1
-  let (o₁, c₁) := c₁.addCommitted "x" .b128 .base
-  let (o₂, c₂) := c₂.addCommitted "y" .b128 .base
-  let c₁ := c₁.freezeOracles
-  let c₂ := c₂.freezeOracles
-  let w₁ := c₁.initWitnessModule
-  let w₂ := c₂.initWitnessModule
-  let (e₁, w₁) := w₁.addEntry
-  let (e₂, w₂) := w₂.addEntry
-  let w₁ := w₁.pushUInt8sTo #[0] e₁
-  let w₂ := w₂.pushUInt8sTo #[0] e₂
-  let w₁ := w₁.bindOracleTo o₁ e₁ .b128
-  let w₂ := w₂.bindOracleTo o₂ e₂ .b128
-  let mode := .active 0 1
-  let modes := #[mode, mode]
-  let ws := WitnessModule.parPopulate #[w₁, w₂] modes
-  let w := compileWitnessModules ws modes
-  withExceptOk "Parallel population works" (validateWitness #[c₁, c₂] #[] w) fun _ => .done
-
-def getData : TestSeq :=
-  let c := CircuitModule.new 0
-  let (o, c) := c.addCommitted "o" .b8 .base
-  let w := c.freezeOracles.initWitnessModule
-  let (e, w) := w.addEntry
-  let w := w.pushUInt128sTo #[0] e
-    |>.pushUInt8sTo #[0] e
-    |>.bindOracleTo o e .b8
-  test "getData works" (w.getData o == ⟨⟨List.replicate 17 0⟩⟩)
-
-def versionCircuitModules : TestSeq :=
-  let c₁ := CircuitModule.new 0
-  let (_, c₁) := c₁.addCommitted "a" .b1 .base
-  let c₂ := CircuitModule.new 0
-  let (_, c₂) := c₂.addCommitted "b" .b1 .base
-  let v₁ := version #[c₁]
-  let v₂ := version #[c₂]
-  test "Circuit module versioning is name-irrelevant" (v₁.val == v₂.val)
-
-def Tests.Archon.suite := [
-    transparent,
-    linearCombination,
-    packed,
-    shifted,
-    pushData,
-    proveAndVerify,
-    parPopulate,
-    getData,
-    versionCircuitModules,
-  ]
diff --git a/Tests/Blake3.lean b/Tests/Blake3.lean
deleted file mode 100644
index daeebcb3..00000000
--- a/Tests/Blake3.lean
+++ /dev/null
@@ -1,747 +0,0 @@
-import LSpec
-import Ix.Archon.Circuit
-import Ix.Archon.Protocol
-
-namespace Utilities
-
-def randArray (rng : StdGen) (length : Nat) : Array UInt32 :=
-  let rec randArrayInner (rng : StdGen) (length : Nat) (array: Array UInt32) : Array UInt32 :=
-    match length with
-    | 0 => array
-    | length' + 1 =>
-      let (g₁, g₂) := RandomGen.split rng
-      let (next, _) := RandomGen.next g₁
-      randArrayInner g₂ length' (array.push next.toUInt32)
-  randArrayInner rng length Array.empty
-
-def transpose (initial : Array (Array UInt32)) (rowLen : Nat) : Array (Array UInt32) :=
-  let rec transposeInner (initial : Array (Array UInt32)) (tmp : Array (Array UInt32)) (rowLen: Nat): Array (Array UInt32) :=
-    match rowLen with
-    | 0 => tmp.reverse
-    | idx + 1 =>
-      let col := Array.ofFn (n := initial.size) fun i => initial[i]![idx]!
-      transposeInner initial (tmp.push col) idx
-  transposeInner initial Array.empty rowLen
-
-def arrayEq (a b : Array UInt32) : Bool :=
-      if a.size != b.size then
-        false
-      else
-        let rec loop (i : Nat) : Bool :=
-          if i < a.size then
-            if a[i]! != b[i]! then false else loop (i + 1)
-          else
-            true
-        loop 0
-
-def byteArrayToUInt32Array (b : ByteArray) : Array UInt32 :=
-  let len := b.size / 4
-  Array.ofFn (n := len) (fun i =>
-    let base := i.toNat * 4
-    let b0 := b.get! base
-    let b1 := b.get! (base + 1)
-    let b2 := b.get! (base + 2)
-    let b3 := b.get! (base + 3)
-    UInt32.ofNat (b0.toNat ||| (b1.toNat <<< 8) ||| (b2.toNat <<< 16) ||| (b3.toNat <<< 24))
-  )
-
-end Utilities
-
-namespace TraceGenerator
-
-structure Traces where
-  transitionTraces : Array (Array UInt32)
-  cvTraces : Array UInt32
-  state08Traces : Array UInt32
-  state816Traces : Array UInt32
-  stateXorTraces : Array UInt32
-  cvXorTraces : Array UInt32
-  aInTraces : Array UInt32
-  bInTraces : Array UInt32
-  cInTraces : Array UInt32
-  dInTraces : Array UInt32
-  mxInTraces : Array UInt32
-  myInTraces : Array UInt32
-  a0TmpTraces : Array UInt32
-  a0Traces : Array UInt32
-  b0Traces : Array UInt32
-  c0Traces : Array UInt32
-  d0Traces : Array UInt32
-  a1TmpTraces : Array UInt32
-  a1Traces : Array UInt32
-  b1Traces : Array UInt32
-  c1Traces : Array UInt32
-  d1Traces : Array UInt32
-  coutTraces : Array (Array UInt32)
-
-structure TransitionOutput where
-  aIn : UInt32
-  bIn : UInt32
-  cIn : UInt32
-  dIn : UInt32
-  mxIn : UInt32
-  myIn : UInt32
-  a0Tmp : UInt32
-  a0 : UInt32
-  b0 : UInt32
-  c0 : UInt32
-  d0 : UInt32
-  a1Tmp : UInt32
-  a1 : UInt32
-  b1 : UInt32
-  c1 : UInt32
-  d1 : UInt32
-  couts : Array UInt32
-
-structure CompressionOutput where
-  transition : Array (Array UInt32)
-  state08 : Array UInt32
-  state816 : Array UInt32
-  stateXor : Array UInt32
-  cvXor : Array UInt32
-  aIn : Array UInt32
-  bIn : Array UInt32
-  cIn : Array UInt32
-  dIn : Array UInt32
-  mxIn : Array UInt32
-  myIn : Array UInt32
-  a0Tmp : Array UInt32
-  a0 : Array UInt32
-  b0 : Array UInt32
-  c0 : Array UInt32
-  d0 : Array UInt32
-  a1Tmp : Array UInt32
-  a1 : Array UInt32
-  b1 : Array UInt32
-  c1 : Array UInt32
-  d1 : Array UInt32
-  couts : Array (Array UInt32)
-
-
-def IV : Vector UInt32 8 := #v[0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19]
-def MSG_PERMUTATION : Vector (Fin 16) 16  := #v[2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8]
-def A : Vector (Fin 32) 8 := #v[0, 1, 2, 3, 0, 1, 2, 3]
-def B : Vector (Fin 32) 8 := #v[4, 5, 6, 7, 5, 6, 7, 4]
-def C : Vector (Fin 32) 8 := #v[8, 9, 10, 11, 10, 11, 8, 9]
-def D : Vector (Fin 32) 8 := #v[12, 13, 14, 15, 15, 12, 13, 14]
-def MX : Vector (Fin 32) 8 := #v[16, 18, 20, 22, 24, 26, 28, 30]
-def MY : Vector (Fin 32) 8 := #v[17, 19, 21, 23, 25, 27, 29, 31]
-
-def AdditionOperationsNumber : Nat := 6
-
-def permute (state: Array UInt32) : Array UInt32 :=
-  let left := state.extract 0 16
-  let right := state.extract 16 32
-  let permuted := right.mapIdx (fun i _ =>
-      let idx := 16 + MSG_PERMUTATION[i]!.toNat
-      state[idx]!
-  )
-
-  left ++ permuted
-
-def transition (state: Array UInt32) (j : Fin 8) : TransitionOutput × Array UInt32 :=
-  let add (a : UInt32) (b : UInt32) : UInt32 × UInt32 × UInt32 :=
-    let zout := a.add b
-    let carry : UInt32 := if zout < a then 1 else 0
-    let cin := (a.toBitVec.xor b.toBitVec).xor zout.toBitVec
-    let cout := (carry <<< 31) ||| (cin.toNat.toUInt32 >>> 1)
-    (cin.toNat.toUInt32, cout, zout)
-
-  let cins : Array UInt32 := #[]
-  let couts : Array UInt32 := #[]
-
-  let aIn := state[(A[j])]!
-  let bIn := state[(B[j])]!
-  let cIn := state[(C[j])]!
-  let dIn := state[(D[j])]!
-  let mxIn := state[(MX[j])]!
-  let myIn := state[(MY[j])]!
-
-  let (cin, cout, a0Tmp) := add aIn bIn
-  let cins := cins.push cin
-  let couts := couts.push cout
-
-  let (cin, cout, a0) := add a0Tmp mxIn
-  let cins := cins.push cin
-  let couts := couts.push cout
-
-  let d0 := UInt32.ofBitVec ((dIn.xor a0).toBitVec.rotateRight 16)
-
-  let (cin, cout, c0) := add cIn d0
-  let cins := cins.push cin
-  let couts := couts.push cout
-
-  let b0 := UInt32.ofBitVec ((bIn.xor c0).toBitVec.rotateRight 12)
-
-  let (cin, cout, a1Tmp) := add a0 b0
-  let cins := cins.push cin
-  let couts := couts.push cout
-
-  let (cin, cout, a1) := add a1Tmp myIn
-  let cins := cins.push cin
-  let couts := couts.push cout
-
-  let d1 := UInt32.ofBitVec ((d0.xor a1).toBitVec.rotateRight 8)
-
-  let (cin, cout, c1) := add c0 d1
-  let cins := cins.push cin
-  let couts := couts.push cout
-
-  let b1 := UInt32.ofBitVec ((b0.xor c1).toBitVec.rotateRight 7)
-
-  let state := state.modify (A[j]).toNat fun _ => a1
-  let state := state.modify (B[j]).toNat fun _ => b1
-  let state := state.modify (C[j]).toNat fun _ => c1
-  let state := state.modify (D[j]).toNat fun _ => d1
-
-  (
-    { aIn, bIn, cIn, dIn, mxIn, myIn, a0Tmp, a0, b0, c0, d0, a1Tmp, a1, b1, c1, d1, couts },
-    state
-  )
-
-def roundNoPermute (state : Array UInt32) : Array TransitionOutput × Array (Array UInt32) × Array UInt32 :=
-  let indices := List.range 8
-  aux #[] #[] state indices
-where aux outputs transitions state indices := match indices with
-  | [] => (outputs, transitions, state)
-  | i :: is =>
-    let (tOutput, newState) := transition state (Fin.ofNat' 8 i)
-    aux (outputs.push tOutput) (transitions.push newState) newState is
-
-def round (state: Array UInt32) : Array TransitionOutput × Array (Array UInt32) × Array UInt32 :=
-  let (outputs, transition, state) := roundNoPermute state
-  (outputs, transition, (permute state))
-
-def compress (cv : Array UInt32) (blockWords : Array UInt32) (counter : UInt64) (blockLen flags : UInt32) : CompressionOutput × Array UInt32 :=
-  let counterLow := UInt32.ofBitVec (counter.toBitVec.truncate 32)
-  let counterHigh := UInt32.ofBitVec ((counter.shiftRight 32).toBitVec.truncate 32)
-
-  let state := cv ++ (IV.extract 0 4).toArray ++ #[counterLow, counterHigh, blockLen, flags] ++ blockWords
-
-  -- every compression includes 7 rounds (where last round doesn't include permutation)
-  let rec runRounds (outputs: Array TransitionOutput) (transitions : Array (Array UInt32)) (state : Array UInt32) (indices : List Nat) :
-      Array TransitionOutput × Array (Array UInt32) × Array UInt32 :=
-    match indices with
-    | [] => (outputs, transitions, state)
-    | i :: is =>
-      let (roundOutputs, roundTransitions, newState) :=
-        if i == 6 then roundNoPermute state else round state
-      runRounds (outputs.append roundOutputs) (transitions.append roundTransitions) newState is
-
-  let (outputs, transitions, state) := runRounds #[] #[state] state (List.range 7)
-
-  let state08 := state.extract 0 8
-  let state816 := state.extract 8 16
-
-  let temp := (state08.zipWith (Xor.xor) state816)
-  let stateXor := temp
-  let state := temp.append (state.extract 8 32)
-  let temp := (state.extract 8 16).zipWith (Xor.xor) cv
-  let cvXor := temp
-  let state := state.extract 0 8 ++ temp ++ state.extract 16 32
-  let transitions := transitions.push state
-
-  -- pad state transitions with 6 32-zero arrays for correct transposing
-  let zeroes32 := Array.ofFn (n := 32) (fun _ => (0 : UInt32))
-  let transitions := transitions.append (Array.ofFn (n := 6) (fun _ => zeroes32))
-
-  -- pad temp variables for correct witness population
-  let zeroes8 := Array.ofFn (n := 8) (fun _ => (0 : UInt32))
-  let aIns := outputs.map (fun o => o.aIn) ++ zeroes8
-  let bIns := outputs.map (fun o => o.bIn) ++ zeroes8
-  let cIns := outputs.map (fun o => o.cIn) ++ zeroes8
-  let dIns := outputs.map (fun o => o.dIn) ++ zeroes8
-  let mxIns := outputs.map (fun o => o.mxIn) ++ zeroes8
-  let myIns := outputs.map (fun o => o.myIn) ++ zeroes8
-
-  let a0Tmp := outputs.map (fun o => o.a0Tmp) ++ zeroes8
-  let a0 := outputs.map (fun o => o.a0) ++ zeroes8
-  let b0 := outputs.map (fun o => o.b0) ++ zeroes8
-  let c0 := outputs.map (fun o => o.c0) ++ zeroes8
-  let d0 := outputs.map (fun o => o.d0) ++ zeroes8
-  let a1Tmp := outputs.map (fun o => o.a1Tmp) ++ zeroes8
-  let a1 := outputs.map (fun o => o.a1) ++ zeroes8
-  let b1 := outputs.map (fun o => o.b1) ++ zeroes8
-  let c1 := outputs.map (fun o => o.c1) ++ zeroes8
-  let d1 := outputs.map (fun o => o.d1) ++ zeroes8
-
-  -- pad couts with 8 zero arrays (each of unpadded cout array size) for correct transposing
-  let couts := outputs.map (fun o => o.couts)
-  let zeroesCoutsSize := Array.ofFn (n := couts.size) (fun _ => (0 : UInt32))
-  let couts := couts.append (Array.ofFn (n := 8) (fun _ => zeroesCoutsSize))
-
-  let out : CompressionOutput := {
-    transition := (Utilities.transpose transitions 32),
-    state08,
-    state816,
-    stateXor,
-    cvXor,
-    aIn := aIns,
-    bIn := bIns,
-    cIn := cIns,
-    dIn := dIns,
-    mxIn := mxIns,
-    myIn := myIns,
-    a0Tmp,
-    a0,
-    b0,
-    c0,
-    d0,
-    a1Tmp,
-    a1,
-    b1,
-    c1,
-    d1,
-    couts := Utilities.transpose couts AdditionOperationsNumber,
-  }
-
-  ( out, (state.extract 0 16))
-
-abbrev ExpectedStates := Array (Array UInt32)
-
-def mkTraces (rng : StdGen) (length : Nat) : Traces × ExpectedStates :=
-  let rec generateTracesInner (rng : StdGen) (length : Nat) (traces :  Traces) (array : ExpectedStates) : Traces × ExpectedStates :=
-    match length with
-    | 0 => (traces, array)
-    | length' + 1 =>
-
-      let compressionInputGen : StateM StdGen (Array UInt32 × Array UInt32 × UInt64 × UInt32 × UInt32) := do
-        let (g₁, g₂) := RandomGen.split (← get)
-        let cv := Utilities.randArray g₁ 8
-        set g₂
-
-        let (g₁, g₂) := RandomGen.split (← get)
-        let block := Utilities.randArray g₁ 16
-        set g₂
-
-        let (counter, g₂) := RandomGen.next (← get)
-        set g₂
-
-        let (blockLen, g₂) := RandomGen.next (← get)
-        set g₂
-
-        let (flags, _) := RandomGen.next (← get)
-        pure (cv, block, counter.toUInt64, blockLen.toUInt32, flags.toUInt32)
-
-      let (g₁, g₂) := RandomGen.split rng
-      let (cv, block, counter, blockLen, flags) := compressionInputGen g₁ |>.1
-
-      let (compressionOut, expected) := compress cv block counter blockLen flags
-
-      -- Now, on each recursion call, we extend 'Traces' inner arrays via concatenating new trace data from a given compression to them
-      let transitions := traces.transitionTraces
-      let transition := compressionOut.transition
-      let transitions' := if transitions.isEmpty then transition else (transitions.zip transition).map (fun (a, b) => a ++ b)
-
-      let cvTraces := traces.cvTraces
-      let cvTraces' := if cvTraces.isEmpty then cv else cvTraces ++ cv
-
-      let state08Traces := traces.state08Traces
-      let state08Trace := compressionOut.state08
-      let state08Traces' := if state08Traces.isEmpty then state08Trace else state08Traces ++ state08Trace
-
-      let state816Traces := traces.state816Traces
-      let state816Trace := compressionOut.state816
-      let state816Traces' := if state816Traces.isEmpty then state816Trace else state816Traces ++ state816Trace
-
-      let stateXorTraces := traces.stateXorTraces
-      let stateXorTrace := compressionOut.stateXor
-      let stateXorTraces' := if stateXorTraces.isEmpty then stateXorTrace else stateXorTraces ++ stateXorTrace
-
-      let cvXorTraces := traces.cvXorTraces
-      let cvXorTrace := compressionOut.cvXor
-      let cvXorTraces' := if cvXorTraces.isEmpty then cvXorTrace else cvXorTraces ++ cvXorTrace
-
-      let aInTraces := traces.aInTraces
-      let aInTrace := compressionOut.aIn
-      let aInTraces' := if aInTraces.isEmpty then aInTrace else aInTraces ++ aInTrace
-
-      let bInTraces := traces.bInTraces
-      let bInTrace := compressionOut.bIn
-      let bInTraces' := if bInTraces.isEmpty then bInTrace else bInTraces ++ bInTrace
-
-      let cInTraces := traces.cInTraces
-      let cInTrace := compressionOut.cIn
-      let cInTraces' := if cInTraces.isEmpty then cInTrace else cInTraces ++ cInTrace
-
-      let dInTraces := traces.dInTraces
-      let dInTrace := compressionOut.dIn
-      let dInTraces' := if dInTraces.isEmpty then dInTrace else dInTraces ++ dInTrace
-
-      let mxInTraces := traces.mxInTraces
-      let mxInTrace := compressionOut.mxIn
-      let mxInTraces' := if mxInTraces.isEmpty then mxInTrace else mxInTraces ++ mxInTrace
-
-      let myInTraces := traces.myInTraces
-      let myInTrace := compressionOut.myIn
-      let myInTraces' := if myInTraces.isEmpty then myInTrace else myInTraces ++ myInTrace
-
-      let a0TmpTraces := traces.a0TmpTraces
-      let a0TmpTrace := compressionOut.a0Tmp
-      let a0TmpTraces' := if a0TmpTraces.isEmpty then a0TmpTrace else a0TmpTraces ++ a0TmpTrace
-
-      let a0Traces := traces.a0Traces
-      let a0Trace := compressionOut.a0
-      let a0Traces' := if a0Traces.isEmpty then a0Trace else a0Traces ++ a0Trace
-
-      let b0Traces := traces.b0Traces
-      let b0Trace := compressionOut.b0
-      let b0Traces' := if b0Traces.isEmpty then b0Trace else b0Traces ++ b0Trace
-
-      let c0Traces := traces.c0Traces
-      let c0Trace := compressionOut.c0
-      let c0Traces' := if c0Traces.isEmpty then c0Trace else c0Traces ++ c0Trace
-
-      let d0Traces := traces.d0Traces
-      let d0Trace := compressionOut.d0
-      let d0Traces' := if d0Traces.isEmpty then d0Trace else d0Traces ++ d0Trace
-
-      let a1TmpTraces := traces.a1TmpTraces
-      let a1TmpTrace := compressionOut.a1Tmp
-      let a1TmpTraces' := if a1TmpTraces.isEmpty then a1TmpTrace else a1TmpTraces ++ a1TmpTrace
-
-      let a1Traces := traces.a1Traces
-      let a1Trace := compressionOut.a1
-      let a1Traces' := if a1Traces.isEmpty then a1Trace else a1Traces ++ a1Trace
-
-      let b1Traces := traces.b1Traces
-      let b1Trace := compressionOut.b1
-      let b1Traces' := if b1Traces.isEmpty then b1Trace else b1Traces ++ b1Trace
-
-      let c1Traces := traces.c1Traces
-      let c1Trace := compressionOut.c1
-      let c1Traces' := if c1Traces.isEmpty then c1Trace else c1Traces ++ c1Trace
-
-      let d1Traces := traces.d1Traces
-      let d1Trace := compressionOut.d1
-      let d1Traces' := if d1Traces.isEmpty then d1Trace else d1Traces ++ d1Trace
-
-      let coutTraces := traces.coutTraces
-      let coutTrace := compressionOut.couts
-      let coutTraces' := if coutTraces.isEmpty then coutTrace else (coutTraces.zip coutTrace).map (fun (a, b) => a ++ b)
-
-      let traces' := { traces with
-        transitionTraces := transitions',
-        cvTraces := cvTraces',
-        state08Traces := state08Traces',
-        state816Traces := state816Traces'
-        stateXorTraces := stateXorTraces'
-        cvXorTraces := cvXorTraces'
-        aInTraces := aInTraces'
-        bInTraces := bInTraces'
-        cInTraces := cInTraces'
-        dInTraces := dInTraces'
-        mxInTraces := mxInTraces'
-        myInTraces := myInTraces'
-        a0TmpTraces := a0TmpTraces'
-        a0Traces := a0Traces'
-        b0Traces := b0Traces'
-        c0Traces := c0Traces'
-        d0Traces := d0Traces'
-        a1TmpTraces := a1TmpTraces'
-        a1Traces := a1Traces'
-        b1Traces := b1Traces'
-        c1Traces := c1Traces'
-        d1Traces := d1Traces'
-        coutTraces := coutTraces'
-      }
-
-      generateTracesInner g₂ length' traces' (array.push expected)
-
-  let emptyTraces : Traces := {
-    transitionTraces := Array.empty,
-    cvTraces := Array.empty,
-    state08Traces := Array.empty,
-    state816Traces := Array.empty,
-    stateXorTraces := Array.empty,
-    cvXorTraces := Array.empty,
-    aInTraces := Array.empty,
-    bInTraces := Array.empty,
-    cInTraces := Array.empty,
-    dInTraces := Array.empty,
-    mxInTraces := Array.empty,
-    myInTraces := Array.empty,
-    a0TmpTraces := Array.empty,
-    a0Traces := Array.empty,
-    b0Traces := Array.empty,
-    c0Traces := Array.empty,
-    d0Traces := Array.empty,
-    a1TmpTraces := Array.empty,
-    a1Traces := Array.empty,
-    b1Traces := Array.empty,
-    c1Traces := Array.empty,
-    d1Traces := Array.empty,
-    coutTraces := Array.empty,
-  }
-
-  generateTracesInner rng length emptyTraces Array.empty
-
-end TraceGenerator
-
-open TraceGenerator
-open LSpec
-open Archon
-
-def StateSize : Nat := 32
-def LogU32Bits : USize := 5
-def TestLogCompressionsNum : Nat := 5
-def OutHeight : Nat := 8
-def SingleCompressionNVars : Nat := 6
-def SingleCompressionHeight : Nat := 2 ^ SingleCompressionNVars
-def ProjectedSelectorInput : UInt64 := 0
-def ProjectedSelectorOutput : UInt64 := 57
-
-def testCompression : TestSeq :=
-  let cv : Array UInt32 := #[0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]
-  let blockWords : Array UInt32 := #[0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000, 0xaa000000]
-  let counter : UInt64 := 0xbbbbbbbbcccccccc
-  let blockLen : UInt32 := 0xeeeeeeee
-  let flags : UInt32 := 0xdddddddd
-  let expected : Array UInt32 := #[0x8980fe15, 0x55898ce0, 0x8cf4fbde, 0x5e8537e9, 0x3d2e54f, 0x7e46753f, 0x5d151bb8, 0x2559b733, 0x24560929, 0x6625b1bf, 0xaaccc80e, 0xc5d4287a, 0x2848c46b, 0x94f666c, 0x3adaaeb3, 0x12011250]
-
-  let (_, actual) := compress cv blockWords counter blockLen flags
-
-  test "Blake3 compression is OK" (expected == actual)
-
-
-/-- this test is intended to check that state transition is correctly mapped into traces:
-* every state transition takes 64 elements
-* every state transition ends with 6 zeroes
--/
-def testTraceGenerating : TestSeq :=
-    let (traces, _expected) := mkTraces (mkStdGen 0) 1
-
-    let lenExpected := traces.transitionTraces.all (fun a => a.size == 64)
-    let endExpected := traces.transitionTraces.all (fun a => if a.size < 6 then false else
-      let tail := a.extract (a.size - 6) a.size
-      tail.all (fun x => x == 0)
-    )
-
-    test "Trace generating is OK" (lenExpected && endExpected)
-
-def testArchonStateTransitionModule : TestSeq := Id.run do
-    let mkColumns (circuitModule: CircuitModule) (length : Nat) (f : TowerField) (name: String) : CircuitModule × Array OracleIdx × Array OracleIdx × Array OracleIdx :=
-      let rec mkColumnsInner
-        (circuitModule: CircuitModule)
-        (length : Nat)
-        (f : TowerField)
-        (name: String)
-        (committed : Array OracleIdx)
-        (input : Array OracleIdx)
-        (output : Array OracleIdx) : CircuitModule × Array OracleIdx × Array OracleIdx × Array OracleIdx :=
-          match length with
-          | 0 => (circuitModule, committed, input, output)
-          | length' + 1 =>
-            let (committed', circuitModule):= circuitModule.addCommitted (String.append name (toString length)) f .base
-            let (input', circuitModule) := circuitModule.addProjected (String.append (String.append name (toString length)) "input") committed' ProjectedSelectorInput SingleCompressionHeight.toUSize
-            let (output', circuitModule) := circuitModule.addProjected (String.append (String.append name (toString length)) "output") committed' ProjectedSelectorOutput SingleCompressionHeight.toUSize
-            mkColumnsInner circuitModule length' f (String.append name (toString length')) (committed.push committed') (input.push input') (output.push output')
-
-      mkColumnsInner circuitModule length f name Array.empty Array.empty Array.empty
-
-    -- TODO: Assert that traces and states should have same size
-    let writeTraces (witnessModule : WitnessModule) (traces : Array (Array UInt32)) (states : Array OracleIdx) (f: TowerField) : WitnessModule :=
-      let rec writeTracesInner (witnessModule : WitnessModule) (traces : List (Array UInt32)) (states : List OracleIdx) (f: TowerField) : WitnessModule :=
-        match traces, states with
-        | [], _ => witnessModule
-        | _, [] => witnessModule
-        | t :: traces', s :: states' =>
-          let (entryId, witnessModule) := witnessModule.addEntry
-          let witnessModule := witnessModule.pushUInt32sTo t entryId
-          let witnessModule := witnessModule.bindOracleTo s entryId f
-          writeTracesInner witnessModule traces' states' f
-
-      writeTracesInner witnessModule traces.toList states.toList f
-
-
-    let tracesNum := 2 ^ TestLogCompressionsNum
-    let (traces, expected) := mkTraces (mkStdGen 0) tracesNum
-
-    let logHeight := Nat.log2 (tracesNum * SingleCompressionHeight) |>.toUInt8
-    let mode := .active logHeight 0
-
-    let circuitModule := CircuitModule.new 0
-    let (circuitModule, state, _, output) := mkColumns circuitModule StateSize .b32 "stateTransition"
-    let circuitModule := circuitModule.freezeOracles
-    let witnessModule := circuitModule.initWitnessModule
-    let witnessModule := writeTraces witnessModule traces.transitionTraces state .b32
-    let witnessModule := witnessModule.populate mode
-
-    -- get data as ByteArray of every actually computed cv and convert it to Array UInt32 for comparison
-    let actual := (Array.ofFn (n := 16) fun i => witnessModule.getData output[i]!).map (fun bytes => Utilities.byteArrayToUInt32Array bytes)
-    let expected := Utilities.transpose expected 16
-
-    let witness := compileWitnessModules #[witnessModule] #[mode]
-    withExceptOk "[Archon] state transition module testing is OK" (validateWitness #[circuitModule] #[] witness) fun _ =>
-      test "output is expected" ((actual.zip expected).all (fun (a, b) => Utilities.arrayEq a b))
-
-def testArchonCVOutputModule : TestSeq := Id.run do
-  let tracesNum := 2 ^ TestLogCompressionsNum
-  let (traces, expected) := mkTraces (mkStdGen 0) tracesNum
-
-  let logHeight := Nat.log2 (tracesNum * OutHeight) |>.toUInt8
-  let mode := .active logHeight 0
-
-  let circuitModule := CircuitModule.new 0
-
-  let (cv, circuitModule):= circuitModule.addCommitted "cv" .b32 .base
-  let (state08, circuitModule):= circuitModule.addCommitted "state08" .b32 .base
-  let (state816, circuitModule):= circuitModule.addCommitted "state816" .b32 .base
-  let (state08xor816, circuitModule) := circuitModule.addLinearCombination "state08 xor state816" 0 #[(state08, 1), (state816, 1)] .base
-  let (state816xorCv, circuitModule) := circuitModule.addLinearCombination "state816 xor cv" 0 #[(cv, 1), (state816, 1)] .base
-
-  let circuitModule := circuitModule.freezeOracles
-  let witnessModule := circuitModule.initWitnessModule
-  let (cvEntry, witnessModule) := witnessModule.addEntry
-  let (state08Entry, witnessModule) := witnessModule.addEntry
-  let (state816Entry, witnessModule) := witnessModule.addEntry
-
-  let witnessModule := witnessModule.pushUInt32sTo traces.cvTraces cvEntry
-  let witnessModule := witnessModule.pushUInt32sTo traces.state08Traces state08Entry
-  let witnessModule := witnessModule.pushUInt32sTo traces.state816Traces state816Entry
-
-  let witnessModule := witnessModule.bindOracleTo cv cvEntry .b32
-  let witnessModule := witnessModule.bindOracleTo state08 state08Entry .b32
-  let witnessModule := witnessModule.bindOracleTo state816 state816Entry .b32
-
-  let witnessModule := witnessModule.populate mode
-
-  let a := Utilities.byteArrayToUInt32Array (witnessModule.getData state08xor816)
-  let b := Utilities.byteArrayToUInt32Array (witnessModule.getData state816xorCv)
-
-  let a := Array.ofFn (n := 16) (fun i => a.extract (8 * i) (8 * i + 8))
-  let b := Array.ofFn (n := 16) (fun i => b.extract (8 * i) (8 * i + 8))
-  let actual := (a.zip b).map (fun (a, b) => a ++ b)
-
-  let witness := compileWitnessModules #[witnessModule] #[mode]
-  withExceptOk "[Archon] cv output module testing is OK" (validateWitness #[circuitModule] #[] witness) fun _ =>
-    test "output is expected" ((actual.zip expected).all (fun (a, b) => Utilities.arrayEq a b))
-
-def testArchonAdditionXorRotateModule : TestSeq := Id.run do
-  let sumAssertZero (circuitModule : CircuitModule) (indices : List Nat) (name : String) (xins : Array OracleIdx) (yins : Array OracleIdx) (cins : Array OracleIdx) (zouts : Array OracleIdx) : CircuitModule :=
-    let rec sumAssertZeroInner (circuitModule : CircuitModule) (indices : List Nat) (name : String) (xins : Array OracleIdx) (yins : Array OracleIdx) (cins : Array OracleIdx) (zouts : Array OracleIdx) : CircuitModule :=
-      match indices with
-      | [] => circuitModule
-      | i :: indices' =>
-        let circuitModule' := circuitModule.assertZero (String.append name s!"{i}") #[xins[i]!, yins[i]!, cins[i]!, zouts[i]!] (ArithExpr.oracle xins[i]! + ArithExpr.oracle yins[i]! + ArithExpr.oracle cins[i]! + ArithExpr.oracle zouts[i]!)
-        sumAssertZeroInner circuitModule' indices' name xins yins cins zouts
-
-    sumAssertZeroInner circuitModule indices name xins yins cins zouts
-
-  let carryAssertZero (circuitModule : CircuitModule) (indices : List Nat) (name : String) (xins : Array OracleIdx) (yins : Array OracleIdx) (cins : Array OracleIdx) (couts : Array OracleIdx) : CircuitModule :=
-    let rec carryAssertZeroInner (circuitModule : CircuitModule) (indices : List Nat) (name : String) (xins : Array OracleIdx) (yins : Array OracleIdx) (cins : Array OracleIdx) (couts : Array OracleIdx) : CircuitModule :=
-      match indices with
-      | [] => circuitModule
-      | i :: indices' =>
-        let circuitModule' := circuitModule.assertZero (String.append name s!"{i}") #[xins[i]!, yins[i]!, cins[i]!, couts[i]!] ((ArithExpr.oracle xins[i]! + ArithExpr.oracle cins[i]!) * (ArithExpr.oracle yins[i]! + ArithExpr.oracle cins[i]!) + ArithExpr.oracle cins[i]! + ArithExpr.oracle couts[i]!)
-        carryAssertZeroInner circuitModule' indices' name xins yins cins couts
-
-    carryAssertZeroInner circuitModule indices name xins yins cins couts
-
-  let mkColumns (circuitModule: CircuitModule) (length : Nat) (f : TowerField) (name: String) : CircuitModule × Array OracleIdx × Array OracleIdx :=
-        let rec mkColumnsInner
-          (circuitModule: CircuitModule)
-          (length : Nat)
-          (f : TowerField)
-          (name: String)
-          (couts : Array OracleIdx)
-          (cins : Array OracleIdx) : CircuitModule × Array OracleIdx × Array OracleIdx :=
-            match length with
-            | 0 => (circuitModule, couts, cins)
-            | length' + 1 =>
-              let (cout, circuitModule):= circuitModule.addCommitted (String.append (String.append name (toString length)) "cin") f .base
-              let (cin, circuitModule) := circuitModule.addShifted (String.append (String.append name (toString length)) "cin") cout 1 5 ShiftVariant.logicalLeft
-
-              mkColumnsInner circuitModule length' f (String.append name (toString length')) (couts.push cout) (cins.push cin)
-
-        mkColumnsInner circuitModule length f name Array.empty Array.empty
-
-  let tracesNum := 2 ^ TestLogCompressionsNum
-  let (traces, _expected) := mkTraces (mkStdGen 0) tracesNum
-
-  let logHeight := Nat.log2 (tracesNum * SingleCompressionHeight) |>.toUInt8
-  let mode := .active (logHeight + 5) 0
-
-  let circuitModule := CircuitModule.new 0
-  let (aIn, circuitModule) := circuitModule.addCommitted "aIn" .b1 .base
-  let (bIn, circuitModule) := circuitModule.addCommitted "bIn" .b1 .base
-  let (cIn, circuitModule) := circuitModule.addCommitted "cIn" .b1 .base
-  let (dIn, circuitModule) := circuitModule.addCommitted "dIn" .b1 .base
-  let (mxIn, circuitModule) := circuitModule.addCommitted "mxIn" .b1 .base
-  let (myIn, circuitModule) := circuitModule.addCommitted "myIn" .b1 .base
-
-  let (a0, circuitModule) := circuitModule.addCommitted "a0" .b1 .base
-  let (a0Tmp, circuitModule) := circuitModule.addCommitted "a0Tmp" .b1 .base
-  let (c0, circuitModule) := circuitModule.addCommitted "c0" .b1 .base
-  let (a1, circuitModule) := circuitModule.addCommitted "a1" .b1 .base
-  let (a1Tmp, circuitModule) := circuitModule.addCommitted "a1Tmp" .b1 .base
-  let (c1, circuitModule) := circuitModule.addCommitted "c1" .b1 .base
-
-  let (bInXorC0, circuitModule) := circuitModule.addLinearCombination "bInXorC0" 0 #[(bIn, 1), (c0, 1)] .base
-  let (dInXorA0, circuitModule) := circuitModule.addLinearCombination "dInXorA0" 0 #[(dIn, 1), (a0, 1)] .base
-
-  let (b0, circuitModule) := circuitModule.addShifted "b0" bInXorC0 (32 - 12) LogU32Bits ShiftVariant.circularLeft
-  let (d0, circuitModule) := circuitModule.addShifted "d0" dInXorA0 (32 - 16) LogU32Bits ShiftVariant.circularLeft
-
-  let (d0XorA1, circuitModule) := circuitModule.addLinearCombination "d0XorA1" 0 #[(d0, 1), (a1, 1)] .base
-  let (b0XorC1, circuitModule) := circuitModule.addLinearCombination "b0XorC1" 0 #[(b0, 1), (c1, 1)] .base
-
-  let (d1, circuitModule) := circuitModule.addShifted "d1" d0XorA1 (32 - 8) LogU32Bits ShiftVariant.circularLeft
-  let (_, circuitModule) := circuitModule.addShifted "b1" b0XorC1 (32 - 7) LogU32Bits ShiftVariant.circularLeft
-
-  let (circuitModule, couts, cins) := mkColumns circuitModule AdditionOperationsNumber .b1 "additionCinCout"
-
-  let xins := #[aIn, a0Tmp, cIn, a0, a1Tmp, c0]
-  let yins := #[bIn, mxIn, d0, b0, myIn, d1]
-  let zouts := #[a0Tmp, a0, c0, a1Tmp, a1, c1]
-
-  let circuitModule := sumAssertZero circuitModule (List.range 6) "sum" xins yins cins zouts
-  let circuitModule := carryAssertZero circuitModule (List.range 6) "carry" xins yins cins couts
-
-  let circuitModule := circuitModule.freezeOracles
-
-  let mut witnessModule := circuitModule.initWitnessModule
-
-  let xinTraces := #[traces.aInTraces, traces.a0TmpTraces, traces.cInTraces, traces.a0Traces, traces.a1TmpTraces, traces.c0Traces]
-  let yinTraces := #[traces.bInTraces, traces.mxInTraces, traces.d0Traces, traces.b0Traces, traces.myInTraces, traces.d1Traces]
-  let zoutTraces := #[traces.a0TmpTraces, traces.a0Traces, traces.c0Traces, traces.a1TmpTraces, traces.a1Traces, traces.c1Traces]
-
-  for xy in [0:AdditionOperationsNumber] do
-    let (coutEntry, witnessModule') := witnessModule.addEntry
-    witnessModule := witnessModule'
-    let (xinEntry, witnessModule') := witnessModule.addEntry
-    witnessModule := witnessModule'
-    let (yinEntry, witnessModule') := witnessModule.addEntry
-    witnessModule := witnessModule'
-    let (zoutEntry, witnessModule') := witnessModule.addEntry
-    witnessModule := witnessModule'
-
-    witnessModule := witnessModule.pushUInt32sTo xinTraces[xy]! xinEntry
-    witnessModule := witnessModule.pushUInt32sTo yinTraces[xy]! yinEntry
-    witnessModule := witnessModule.pushUInt32sTo traces.coutTraces[xy]! coutEntry
-    witnessModule := witnessModule.pushUInt32sTo zoutTraces[xy]! zoutEntry
-
-    witnessModule := witnessModule.bindOracleTo xins[xy]! xinEntry .b1
-    witnessModule := witnessModule.bindOracleTo yins[xy]! yinEntry .b1
-    witnessModule := witnessModule.bindOracleTo couts[xy]! coutEntry .b1
-    witnessModule := witnessModule.bindOracleTo zouts[xy]! zoutEntry .b1
-
-  -- not to forget about dIn
-  let (dInEntry, witnessModule') := witnessModule.addEntry
-  witnessModule := witnessModule'
-  witnessModule := witnessModule.pushUInt32sTo traces.dInTraces dInEntry
-  witnessModule := witnessModule.bindOracleTo dIn dInEntry .b1
-
-  witnessModule := witnessModule.populate mode
-
-  let witness := compileWitnessModules #[witnessModule] #[mode]
-  withExceptOk "[Archon] addition/xor/rotate module testing is OK" (validateWitness #[circuitModule] #[] witness) fun _ => .done
-
-def Tests.Blake3.suite : List LSpec.TestSeq :=
-[
-  testCompression,
-  testTraceGenerating,
-  testArchonStateTransitionModule,
-  testArchonCVOutputModule,
-  testArchonAdditionXorRotateModule,
-]
diff --git a/Tests/Common.lean b/Tests/Common.lean
index 972e1236..3321641e 100644
--- a/Tests/Common.lean
+++ b/Tests/Common.lean
@@ -15,9 +15,6 @@ def genUInt64 : Gen UInt64 :=
 def genUSize : Gen USize :=
   .ofNat <$> choose Nat 0 (2^System.Platform.numBits - 1)
 
-def genUInt128 : Gen UInt128 :=
-  .ofLoHi <$> genUInt64 <*> genUInt64
-
 def frequency' (default: Gen α) (xs: List (Nat × Gen α)) : Gen α := do
   let n ← choose Nat 0 total
   pick n xs
diff --git a/Tests/FFIConsistency.lean b/Tests/FFIConsistency.lean
index 8ebba997..d7909ed7 100644
--- a/Tests/FFIConsistency.lean
+++ b/Tests/FFIConsistency.lean
@@ -1,16 +1,8 @@
 import LSpec
 import Tests.Common
-import Ix.Binius.Boundary
-import Ix.Archon.ArithExpr
-import Ix.Archon.OracleOrConst
-import Ix.Archon.ModuleMode
-import Ix.Archon.RelativeHeight
-import Ix.Archon.Transparent
 
 open LSpec SlimCheck Gen
 
-open Archon Binius
-
 /- Array UInt32 -/
 
 def genArrayUInt32 : Gen $ Array UInt32 := do
@@ -31,134 +23,9 @@ instance : Shrinkable (Array UInt32) where
 
 instance : SampleableExt (Array UInt32) := SampleableExt.mkSelfContained genArrayUInt32
 
-/- Boundary -/
-
-def genBoundary : Gen Boundary := do
-  let numValues ← choose Nat 0 128
-  let mut values := Array.mkEmpty numValues
-  for _ in [:numValues] do
-    values := values.push $ ← genUInt128
-  let direction := if ← chooseAny Bool then .pull else .push
-  pure ⟨values, ⟨← genUSize⟩, direction, ← genUInt64⟩
-
-instance : Shrinkable Boundary where
-  shrink _ := []
-
-instance : Repr Boundary where
-  reprPrec boundary _ := boundary.toString
-
-instance : SampleableExt Boundary := SampleableExt.mkSelfContained genBoundary
-
-/- ArithExpr -/
-
-def genArithExpr : Gen ArithExpr := getSize >>= go
-  where
-    go : Nat → Gen ArithExpr
-    | 0 => return .const 0
-    | Nat.succ n =>
-      frequency [
-        (30, .const <$> genUInt128),
-        (30, .var <$> genUSize),
-        (30, .oracle <$> OracleIdx.mk <$> genUSize),
-        (25, .add <$> go n <*> go n),
-        (25, .mul <$> go n <*> go n),
-        (40, .pow <$> go n <*> genUInt64)
-      ]
-
-instance : Shrinkable ArithExpr where
-  shrink _ := []
-
-instance : Repr ArithExpr where
-  reprPrec expr _ := expr.toString
-
-instance : SampleableExt ArithExpr := SampleableExt.mkSelfContained genArithExpr
-
-/- ModuleMode -/
-
-def genModuleMode : Gen ModuleMode :=
-  frequency [
-      (5, pure .inactive),
-      (15, .active <$> genUInt8 <*> genUInt64),
-    ]
-
-instance : Shrinkable ModuleMode where
-  shrink _ := []
-
-instance : Repr ModuleMode where
-  reprPrec mode _ := mode.toString
-
-instance : SampleableExt ModuleMode := SampleableExt.mkSelfContained genModuleMode
-
-/- OracleOrConst -/
-
-def genOracleIdx : Gen OracleIdx :=
-  OracleIdx.mk <$> genUSize
-
-def genTowerField : Gen TowerField :=
-  elements #[.b1, .b2, .b4, .b8, .b16, .b32, .b64, .b128]
-
-def genOracleOrConst : Gen OracleOrConst :=
-  frequency [
-      (5, .oracle <$> genOracleIdx),
-      (10, .const <$> genUInt128 <*> genTowerField),
-    ]
-
-instance : Shrinkable OracleOrConst where
-  shrink _ := []
-
-instance : Repr OracleOrConst where
-  reprPrec oc _ := oc.toString
-
-instance : SampleableExt OracleOrConst := SampleableExt.mkSelfContained genOracleOrConst
-
-/- RelativeHeight -/
-
-def genRelativeHeight : Gen RelativeHeight :=
-  frequency [
-      (5, pure .base),
-      (15, .div2 <$> genUInt8),
-      (15, .mul2 <$> genUInt8),
-    ]
-
-instance : Shrinkable RelativeHeight where
-  shrink _ := []
-
-instance : Repr RelativeHeight where
-  reprPrec relativeHeight _ := relativeHeight.toString
-
-instance : SampleableExt RelativeHeight := SampleableExt.mkSelfContained genRelativeHeight
-
-/- Transparent -/
-
-def genTransparent : Gen Transparent :=
-  frequency [
-      (10, .const <$> genUInt128),
-      (10, pure .incremental),
-    ]
-
-instance : Shrinkable Transparent where
-  shrink _ := []
-
-instance : Repr Transparent where
-  reprPrec transparent _ := transparent.toString
-
-instance : SampleableExt Transparent := SampleableExt.mkSelfContained genTransparent
-
 /- Suite -/
 
 def Tests.FFIConsistency.suite := [
     check "Boxed UInt32s are unboxed correctly in Rust"
       (∀ arr : Array UInt32, boxedUInt32sAreEquivalentToBytes arr (arrayUInt32sToBytes arr)),
-    check "ArithExpr Lean->Rust mapping matches the deserialized bytes"
-      (∀ expr : ArithExpr, expr.isEquivalentToBytes expr.toBytes),
-    check "Boundary Lean->Rust mapping matches the deserialized bytes"
-      (∀ boundary : Boundary, boundary.isEquivalentToBytes boundary.toBytes),
-    check "ModuleMode Lean->Rust mapping matches the deserialized bytes"
-      (∀ moduleMode : ModuleMode, moduleMode.isEquivalentToBytes moduleMode.toBytes),
-    check "OracleOrConst Lean->Rust mapping matches the deserialized bytes"
-      (∀ oc : OracleOrConst, oc.isEquivalentToBytes oc.toBytes),
-    check "RelativeHeight Lean->Rust mapping matches the deserialized bytes"
-      (∀ relativeHeight : RelativeHeight, relativeHeight.isEquivalentToBytes relativeHeight.toBytes),
-    check "Transparent Lean->Rust mapping matches the deserialized bytes"
-      (∀ transparent : Transparent, transparent.isEquivalentToBytes transparent.toBytes),
   ]
diff --git a/Tests/Main.lean b/Tests/Main.lean
index a939bc9b..4fc48802 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -1,13 +1,10 @@
-import Tests.Aiur2
-import Tests.Archon
+import Tests.Aiur
 import Tests.FFIConsistency
 import Tests.ByteArray
-import Tests.Unsigned
 import Tests.Ix
 import Tests.Ix.Compile
 import Tests.Keccak
 import Tests.Cli
-import Tests.Blake3
 
 def main (args: List String) : IO UInt32 := do
   if args.contains "compile"
@@ -17,11 +14,8 @@ def main (args: List String) : IO UInt32 := do
   else
     LSpec.lspecIO (.ofList [
       ("aiur", Tests.Aiur.suite),
-      ("archon", Tests.Archon.suite),
       ("ffi-consistency", Tests.FFIConsistency.suite),
       ("byte-array", Tests.ByteArray.suite),
-      ("unsigned", Tests.Unsigned.suite),
       ("ix", Tests.Ix.suite),
       ("keccak", Tests.Keccak.suite),
-      ("blake3", Tests.Blake3.suite),
     ]) args
diff --git a/Tests/Unsigned.lean b/Tests/Unsigned.lean
deleted file mode 100644
index 7d8a730a..00000000
--- a/Tests/Unsigned.lean
+++ /dev/null
@@ -1,21 +0,0 @@
-import Tests.Common
-
-open LSpec SlimCheck Gen
-
-namespace Tests.Unsigned
-
-scoped instance (priority := high) : SampleableExt Nat :=
-  SampleableExt.mkSelfContained $ choose Nat 0 (UInt128.size - 1)
-
-instance : Shrinkable UInt128 where
-  shrink x := Shrinkable.shrink x.toNat |>.map UInt128.ofNatWrap
-
-instance : SampleableExt UInt128 :=
-  SampleableExt.mkSelfContained genUInt128
-
-def suite := [
-    check "UInt128 to/from Nat roundtrips" (∀ n : Nat, (UInt128.ofNatWrap n).toNat = n),
-    check "UInt128 cmp matches Nat cmp" (∀ a b : UInt128, compare a b = compare a.toNat b.toNat),
-  ]
-
-end Tests.Unsigned
diff --git a/c/archon.c b/c/archon.c
deleted file mode 100644
index 5f500071..00000000
--- a/c/archon.c
+++ /dev/null
@@ -1,563 +0,0 @@
-#include "lean/lean.h"
-#include "linear.h"
-#include "rust.h"
-
-/* --- WitnessModule --- */
-
-extern lean_obj_res c_rs_witness_module_add_entry(lean_obj_arg l_witness) {
-    linear_object *linear = validated_linear(l_witness);
-    size_t entry_id = rs_witness_module_add_entry(get_object_ref(linear));
-    linear_object *new_linear = linear_bump(linear);
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_usize(entry_id));
-    lean_ctor_set(tuple, 1, alloc_lean_linear_object(new_linear));
-    return tuple;
-}
-
-extern lean_obj_res c_rs_witness_module_add_entry_with_capacity(
-    lean_obj_arg l_witness,
-    uint8_t log_bits
-) {
-    linear_object *linear = validated_linear(l_witness);
-    size_t entry_id = rs_witness_module_add_entry_with_capacity(
-        get_object_ref(linear),
-        log_bits
-    );
-    linear_object *new_linear = linear_bump(linear);
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_usize(entry_id));
-    lean_ctor_set(tuple, 1, alloc_lean_linear_object(new_linear));
-    return tuple;
-}
-
-extern lean_obj_res c_rs_witness_module_bind_oracle_to(
-    lean_obj_arg l_witness,
-    size_t oracle_idx,
-    size_t entry_id,
-    uint8_t tower_level
-) {
-    linear_object *linear = validated_linear(l_witness);
-    rs_witness_module_bind_oracle_to(
-        get_object_ref(linear),
-        oracle_idx,
-        entry_id,
-        tower_level
-    );
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-static inline lean_obj_res c_rs_witness_module_push_data_to(
-    lean_obj_arg l_witness,
-    b_lean_obj_arg data,
-    size_t entry_id,
-    void (*rs_fn)(void*, b_lean_obj_arg, size_t)
-) {
-    linear_object *linear = validated_linear(l_witness);
-    rs_fn(get_object_ref(linear), data, entry_id);
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_witness_module_push_u8s_to(
-    lean_obj_arg l_witness,
-    b_lean_obj_arg u8s,
-    size_t entry_id
-) {
-    return c_rs_witness_module_push_data_to(
-        l_witness,
-        u8s,
-        entry_id,
-        rs_witness_module_push_u8s_to
-    );
-}
-
-extern lean_obj_res c_rs_witness_module_push_u16s_to(
-    lean_obj_arg l_witness,
-    b_lean_obj_arg u16s,
-    size_t entry_id
-) {
-    return c_rs_witness_module_push_data_to(
-        l_witness,
-        u16s,
-        entry_id,
-        rs_witness_module_push_u16s_to
-    );
-}
-
-extern lean_obj_res c_rs_witness_module_push_u32s_to(
-    lean_obj_arg l_witness,
-    b_lean_obj_arg u32s,
-    size_t entry_id
-) {
-    return c_rs_witness_module_push_data_to(
-        l_witness,
-        u32s,
-        entry_id,
-        rs_witness_module_push_u32s_to
-    );
-}
-
-extern lean_obj_res c_rs_witness_module_push_u64s_to(
-    lean_obj_arg l_witness,
-    b_lean_obj_arg u64s,
-    size_t entry_id
-) {
-    return c_rs_witness_module_push_data_to(
-        l_witness,
-        u64s,
-        entry_id,
-        rs_witness_module_push_u64s_to
-    );
-}
-
-extern lean_obj_res c_rs_witness_module_push_u128s_to(
-    lean_obj_arg l_witness,
-    b_lean_obj_arg u128s,
-    size_t entry_id
-) {
-    return c_rs_witness_module_push_data_to(
-        l_witness,
-        u128s,
-        entry_id,
-        rs_witness_module_push_u128s_to
-    );
-}
-
-extern lean_obj_res c_rs_witness_module_populate(
-    lean_obj_arg l_witness,
-    b_lean_obj_arg mode
-) {
-    linear_object *linear = validated_linear(l_witness);
-    rs_witness_module_populate(get_object_ref(linear), mode);
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_witness_module_par_populate(
-    lean_obj_arg l_witnesses,
-    b_lean_obj_arg modes
-) {
-    size_t size = lean_array_size(l_witnesses);
-    lean_object **witnesses_cptrs = lean_array_cptr(l_witnesses);
-    void *witnesses_ptrs[size];
-    lean_object *new_l_witnesses = lean_alloc_array(size, size);
-    lean_object **new_witnesses_cptrs = lean_array_cptr(new_l_witnesses);
-    for (size_t i = 0; i < size; i++) {
-        linear_object *linear = validated_linear(witnesses_cptrs[i]);
-        witnesses_ptrs[i] = get_object_ref(linear);
-        new_witnesses_cptrs[i] = alloc_lean_linear_object(linear_bump(linear));
-    }
-    rs_witness_module_par_populate(witnesses_ptrs, modes);
-    return new_l_witnesses;
-}
-
-extern lean_obj_res c_rs_witness_module_get_data(
-    b_lean_obj_arg l_witness,
-    size_t oracle_idx
-) {
-    linear_object *linear = validated_linear(l_witness);
-    lean_object *witness_module = get_object_ref(linear);
-    size_t size = rs_witness_module_get_data_num_bytes(witness_module, oracle_idx);
-    lean_object *byte_array = lean_alloc_sarray(1, size, size);
-    rs_witness_module_get_data(witness_module, oracle_idx, byte_array);
-    return byte_array;
-}
-
-extern lean_obj_res c_rs_compile_witness_modules(
-    lean_obj_arg l_witnesses,
-    b_lean_obj_arg modes
-) {
-    size_t size = lean_array_size(l_witnesses);
-    lean_object **witnesses_cptrs = lean_array_cptr(l_witnesses);
-    void *witnesses_ptrs[size];
-    for (size_t i = 0; i < size; i++) {
-        linear_object *linear = validated_linear(witnesses_cptrs[i]);
-        witnesses_ptrs[i] = get_object_ref(linear);
-        ditch_linear(linear);
-    }
-    void *witness = rs_compile_witness_modules(witnesses_ptrs, modes);
-    linear_object *new_linear = linear_object_init(
-        witness,
-        &rs_witness_free
-    );
-    return alloc_lean_linear_object(new_linear);
-}
-
-/* --- CircuitModule --- */
-
-extern lean_obj_res c_rs_circuit_module_new(size_t module_id) {
-    linear_object *linear = linear_object_init(
-        rs_circuit_module_new(module_id),
-        &rs_circuit_module_free
-    );
-    return alloc_lean_linear_object(linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_freeze_oracles(lean_obj_arg l_circuit) {
-    linear_object *linear = validated_linear(l_circuit);
-    rs_circuit_module_freeze_oracles(get_object_ref(linear));
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_init_witness_module(b_lean_obj_arg l_circuit) {
-    linear_object *linear = validated_linear(l_circuit);
-    void *witness_module = rs_circuit_module_init_witness_module(get_object_ref(linear));
-    linear_object *new_linear = linear_object_init(
-        witness_module,
-        &rs_witness_module_free
-    );
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_flush(
-    lean_obj_arg l_circuit,
-    bool direction_pull,
-    size_t channel_id,
-    size_t selector,
-    b_lean_obj_arg values,
-    uint64_t multiplicity
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    rs_circuit_module_flush(
-        get_object_ref(linear),
-        direction_pull,
-        channel_id,
-        selector,
-        values,
-        multiplicity
-    );
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_assert_zero(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg name,
-    b_lean_obj_arg oracle_idxs,
-    b_lean_obj_arg composition
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    char const *chars = lean_string_cstr(name);
-    rs_circuit_module_assert_zero(
-        get_object_ref(linear),
-        chars,
-        oracle_idxs,
-        composition
-    );
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_assert_not_zero(
-    lean_obj_arg l_circuit,
-    size_t oracle_idx
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    rs_circuit_module_assert_not_zero(get_object_ref(linear), oracle_idx);
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_assert_exp(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg exp_bits,
-    size_t result,
-    b_lean_obj_arg base
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    rs_circuit_module_assert_exp(
-        get_object_ref(linear),
-        exp_bits,
-        result,
-        base
-    );
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_add_committed(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg name,
-    uint8_t tower_level,
-    b_lean_obj_arg relative_height
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    char const *chars = lean_string_cstr(name);
-    size_t oracle_idx = rs_circuit_module_add_committed(
-        get_object_ref(linear),
-        chars,
-        tower_level,
-        relative_height
-    );
-    linear_object *new_linear = linear_bump(linear);
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_usize(oracle_idx));
-    lean_ctor_set(tuple, 1, alloc_lean_linear_object(new_linear));
-    return tuple;
-}
-
-extern lean_obj_res c_rs_circuit_module_add_transparent(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg name,
-    b_lean_obj_arg transparent,
-    b_lean_obj_arg relative_height
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    char const *chars = lean_string_cstr(name);
-    size_t oracle_idx = rs_circuit_module_add_transparent(
-        get_object_ref(linear),
-        chars,
-        transparent,
-        relative_height
-    );
-    linear_object *new_linear = linear_bump(linear);
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_usize(oracle_idx));
-    lean_ctor_set(tuple, 1, alloc_lean_linear_object(new_linear));
-    return tuple;
-}
-
-extern lean_obj_res c_rs_circuit_module_add_linear_combination(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg name,
-    b_lean_obj_arg offset,
-    b_lean_obj_arg inner,
-    b_lean_obj_arg relative_height
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    char const *chars = lean_string_cstr(name);
-    size_t oracle_idx = rs_circuit_module_add_linear_combination(
-        get_object_ref(linear),
-        chars,
-        lean_get_external_data(offset),
-        inner,
-        relative_height
-    );
-    linear_object *new_linear = linear_bump(linear);
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_usize(oracle_idx));
-    lean_ctor_set(tuple, 1, alloc_lean_linear_object(new_linear));
-    return tuple;
-}
-
-extern lean_obj_res c_rs_circuit_module_add_packed(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg name,
-    size_t inner,
-    size_t log_degree
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    char const *chars = lean_string_cstr(name);
-    size_t oracle_idx = rs_circuit_module_add_packed(
-        get_object_ref(linear),
-        chars,
-        inner,
-        log_degree
-    );
-    linear_object *new_linear = linear_bump(linear);
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_usize(oracle_idx));
-    lean_ctor_set(tuple, 1, alloc_lean_linear_object(new_linear));
-    return tuple;
-}
-
-extern lean_obj_res c_rs_circuit_module_add_shifted(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg name,
-    size_t inner,
-    uint32_t shift_offset,
-    size_t block_bits,
-    uint8_t shift_variant
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    char const *chars = lean_string_cstr(name);
-    size_t oracle_idx = rs_circuit_module_add_shifted(
-        get_object_ref(linear),
-        chars,
-        inner,
-        shift_offset,
-        block_bits,
-        shift_variant
-    );
-    linear_object *new_linear = linear_bump(linear);
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_usize(oracle_idx));
-    lean_ctor_set(tuple, 1, alloc_lean_linear_object(new_linear));
-    return tuple;
-}
-
-extern lean_obj_res c_rs_circuit_module_add_projected(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg name,
-    size_t inner,
-    uint64_t selection,
-    size_t chunk_size
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    char const *chars = lean_string_cstr(name);
-    size_t oracle_idx = rs_circuit_module_add_projected(
-        get_object_ref(linear),
-        chars,
-        inner,
-        selection,
-        chunk_size
-    );
-    linear_object *new_linear = linear_bump(linear);
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_usize(oracle_idx));
-    lean_ctor_set(tuple, 1, alloc_lean_linear_object(new_linear));
-    return tuple;
-}
-
-extern lean_obj_res c_rs_circuit_module_push_namespace(
-    lean_obj_arg l_circuit,
-    b_lean_obj_arg name
-) {
-    linear_object *linear = validated_linear(l_circuit);
-    char const *chars = lean_string_cstr(name);
-    rs_circuit_module_push_namespace(get_object_ref(linear), chars);
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_pop_namespace(lean_obj_arg l_circuit) {
-    linear_object *linear = validated_linear(l_circuit);
-    rs_circuit_module_pop_namespace(get_object_ref(linear));
-    linear_object *new_linear = linear_bump(linear);
-    return alloc_lean_linear_object(new_linear);
-}
-
-extern lean_obj_res c_rs_circuit_module_canonical_bytes(b_lean_obj_arg l_circuit) {
-    linear_object *linear = validated_linear(l_circuit);
-    void *circuit = get_object_ref(linear);
-    size_t size = rs_circuit_module_canonical_bytes_size(circuit);
-    lean_object *byte_array = lean_alloc_sarray(1, size, size);
-    rs_circuit_module_canonical_bytes(circuit, size, lean_sarray_cptr(byte_array));
-    return byte_array;
-}
-
-/* --- Protocol --- */
-
-extern lean_obj_res c_rs_validate_witness(
-    b_lean_obj_arg l_circuit_modules,
-    b_lean_obj_arg boundaries,
-    b_lean_obj_arg l_witness
-) {
-    linear_object *witness_linear = validated_linear(l_witness);
-
-    size_t num_modules = lean_array_size(l_circuit_modules);
-    lean_object **modules_cptrs = lean_array_cptr(l_circuit_modules);
-    void *modules_ptrs[num_modules];
-    for (size_t i = 0; i < num_modules; i++) {
-        linear_object *linear = validated_linear(modules_cptrs[i]);
-        modules_ptrs[i] = get_object_ref(linear);
-    }
-
-    c_result *result = rs_validate_witness(
-        num_modules,
-        modules_ptrs,
-        boundaries,
-        get_object_ref(witness_linear)
-    );
-
-    lean_object *except;
-    if (result->is_ok) {
-        except = lean_alloc_ctor(1, 1, 0);
-        lean_ctor_set(except, 0, lean_box(0));
-    } else {
-        except = lean_alloc_ctor(0, 1, 0);
-        lean_ctor_set(except, 0, lean_mk_string(result->data));
-    }
-    rs__c_result_unit_string_free(result);
-
-    return except;
-}
-
-extern lean_obj_res c_rs_prove(
-    b_lean_obj_arg l_circuit_modules,
-    b_lean_obj_arg boundaries,
-    size_t log_inv_rate,
-    size_t security_bits,
-    lean_obj_arg l_witness
-) {
-    linear_object *witness_linear = validated_linear(l_witness);
-
-    size_t num_modules = lean_array_size(l_circuit_modules);
-    lean_object **modules_cptrs = lean_array_cptr(l_circuit_modules);
-    void *modules_ptrs[num_modules];
-    for (size_t i = 0; i < num_modules; i++) {
-        linear_object *linear = validated_linear(modules_cptrs[i]);
-        modules_ptrs[i] = get_object_ref(linear);
-    }
-
-    void *proof = rs_prove(
-        num_modules,
-        modules_ptrs,
-        boundaries,
-        log_inv_rate,
-        security_bits,
-        get_object_ref(witness_linear)
-    );
-    ditch_linear(witness_linear);
-
-    linear_object *proof_linear = linear_object_init(proof, &rs_proof_free);
-    return alloc_lean_linear_object(proof_linear);
-}
-
-extern lean_obj_res c_rs_verify(
-    b_lean_obj_arg l_circuit_modules,
-    b_lean_obj_arg boundaries,
-    size_t log_inv_rate,
-    size_t security_bits,
-    lean_obj_arg l_proof
-) {
-    linear_object *proof_linear = validated_linear(l_proof);
-
-    size_t num_modules = lean_array_size(l_circuit_modules);
-    lean_object **modules_cptrs = lean_array_cptr(l_circuit_modules);
-    void *modules_ptrs[num_modules];
-    for (size_t i = 0; i < num_modules; i++) {
-        linear_object *linear = validated_linear(modules_cptrs[i]);
-        modules_ptrs[i] = get_object_ref(linear);
-    }
-
-    c_result *result = rs_verify(
-        num_modules,
-        modules_ptrs,
-        boundaries,
-        log_inv_rate,
-        security_bits,
-        get_object_ref(proof_linear)
-    );
-
-    ditch_linear(proof_linear);
-
-    lean_object *except;
-    if (result->is_ok) {
-        except = lean_alloc_ctor(1, 1, 0);
-        lean_ctor_set(except, 0, lean_box(0));
-    } else {
-        except = lean_alloc_ctor(0, 1, 0);
-        lean_ctor_set(except, 0, lean_mk_string(result->data));
-    }
-    rs__c_result_unit_string_free(result);
-
-    return except;
-}
-
-extern lean_obj_res c_rs_proof_to_bytes(b_lean_obj_arg l_proof) {
-    linear_object *proof_linear = validated_linear(l_proof);
-    void *proof = get_object_ref(proof_linear);
-    size_t proof_size = rs_proof_size(proof);
-    lean_object *byte_array = lean_alloc_sarray(1, proof_size, proof_size);
-    rs_proof_to_bytes(proof, proof_size, lean_sarray_cptr(byte_array));
-    return byte_array;
-}
-
-extern lean_obj_res c_rs_proof_of_bytes(b_lean_obj_arg byte_array) {
-    void *proof = rs_proof_of_bytes(byte_array);
-    linear_object *proof_linear = linear_object_init(proof, &rs_proof_free);
-    return alloc_lean_linear_object(proof_linear);
-}
diff --git a/c/iroh.c b/c/iroh.c
index 5711921d..d167a086 100644
--- a/c/iroh.c
+++ b/c/iroh.c
@@ -1,36 +1,35 @@
-#include "lean/lean.h"
-#include "linear.h"
-#include "rust.h"
+// #include "lean/lean.h"
+// #include "rust.h"
 
-extern lean_obj_res c_rs_iroh_send(b_lean_obj_arg bytes) {
-    c_result *result = rs_iroh_send(bytes);
-    lean_object *io_result;
-    if (result->is_ok) {
-        io_result = lean_io_result_mk_ok(lean_box(0));
-    }
-    else {
-        io_result = lean_mk_io_user_error(lean_mk_string(result->data));
-    }
-    rs__c_result_unit_string_free(result);
+// extern lean_obj_res c_rs_iroh_send(b_lean_obj_arg bytes) {
+//     c_result *result = rs_iroh_send(bytes);
+//     lean_object *io_result;
+//     if (result->is_ok) {
+//         io_result = lean_io_result_mk_ok(lean_box(0));
+//     }
+//     else {
+//         io_result = lean_mk_io_user_error(lean_mk_string(result->data));
+//     }
+//     rs__c_result_unit_string_free(result);
 
-    return io_result;
-}
+//     return io_result;
+// }
 
-extern lean_obj_res c_rs_iroh_recv(b_lean_obj_arg ticket, size_t buffer_capacity) {
-    char const *ticket_str = lean_string_cstr(ticket);
-    // Buffer is allocated optimistically, but if the download fails it must be freed explicitly
-    lean_object *buffer = lean_alloc_sarray(1, 0, buffer_capacity);
-    c_result *result = rs_iroh_recv(ticket_str, buffer, buffer_capacity);
+// extern lean_obj_res c_rs_iroh_recv(b_lean_obj_arg ticket, size_t buffer_capacity) {
+//     char const *ticket_str = lean_string_cstr(ticket);
+//     // Buffer is allocated optimistically, but if the download fails it must be freed explicitly
+//     lean_object *buffer = lean_alloc_sarray(1, 0, buffer_capacity);
+//     c_result *result = rs_iroh_recv(ticket_str, buffer, buffer_capacity);
 
-    lean_object *io_result;
-    if (result->is_ok) {
-        io_result = lean_io_result_mk_ok(buffer);
-    }
-    else {
-        io_result = lean_mk_io_user_error(lean_mk_string(result->data));
-        free(buffer);
-    }
-    rs__c_result_unit_string_free(result);
+//     lean_object *io_result;
+//     if (result->is_ok) {
+//         io_result = lean_io_result_mk_ok(buffer);
+//     }
+//     else {
+//         io_result = lean_mk_io_user_error(lean_mk_string(result->data));
+//         free(buffer);
+//     }
+//     rs__c_result_unit_string_free(result);
 
-    return io_result;
-}
+//     return io_result;
+// }
diff --git a/c/rust.h b/c/rust.h
index 10c3b384..7d3f7c1e 100644
--- a/c/rust.h
+++ b/c/rust.h
@@ -7,6 +7,8 @@ typedef struct {
     void *data;
 } c_result;
 
+/* --- Aiur -- */
+
 typedef struct {
     size_t size;
     void *bytes_vec;
@@ -35,62 +37,6 @@ void rs_set_aiur_claim_args(lean_obj_arg, void*);
 
 c_result *rs_aiur_system_verify(void*, b_lean_obj_arg, b_lean_obj_arg, void*);
 
-/* --- WitnessModule --- */
-
-void rs_witness_module_free(void*);
-size_t rs_witness_module_add_entry(void*);
-size_t rs_witness_module_add_entry_with_capacity(void*, uint8_t);
-void rs_witness_module_bind_oracle_to(void*, size_t, size_t, uint8_t);
-void rs_witness_module_push_u8s_to(void*, b_lean_obj_arg, size_t);
-void rs_witness_module_push_u16s_to(void*, b_lean_obj_arg, size_t);
-void rs_witness_module_push_u32s_to(void*, b_lean_obj_arg, size_t);
-void rs_witness_module_push_u64s_to(void*, b_lean_obj_arg, size_t);
-void rs_witness_module_push_u128s_to(void*, b_lean_obj_arg, size_t);
-void rs_witness_module_populate(void*, b_lean_obj_arg);
-void rs_witness_module_par_populate(void**, b_lean_obj_arg);
-size_t rs_witness_module_get_data_num_bytes(void*, size_t);
-void rs_witness_module_get_data(void*, size_t, lean_obj_arg);
-void *rs_compile_witness_modules(void**, b_lean_obj_arg);
-
-void rs_witness_free(void*);
-
-/* --- CircuitModule --- */
-
-void *rs_circuit_module_new(size_t);
-void rs_circuit_module_free(void*);
-void rs_circuit_module_freeze_oracles(void*);
-void *rs_circuit_module_init_witness_module(void*);
-void rs_circuit_module_flush(void*, bool, size_t, size_t, b_lean_obj_arg, uint64_t);
-void rs_circuit_module_assert_zero(
-    void*, char const*, b_lean_obj_arg, b_lean_obj_arg
-);
-void rs_circuit_module_assert_not_zero(void*, size_t);
-void rs_circuit_module_assert_exp(void*, b_lean_obj_arg, size_t, b_lean_obj_arg);
-size_t rs_circuit_module_add_committed(void*, char const *, uint8_t, b_lean_obj_arg);
-size_t rs_circuit_module_add_transparent(void*, char const *, b_lean_obj_arg, b_lean_obj_arg);
-size_t rs_circuit_module_add_linear_combination(
-    void*, char const *, b_lean_obj_arg, b_lean_obj_arg, b_lean_obj_arg
-);
-size_t rs_circuit_module_add_packed(void*, char const *, size_t, size_t);
-size_t rs_circuit_module_add_shifted(
-    void*, char const *, size_t, uint32_t, size_t, uint8_t
-);
-size_t rs_circuit_module_add_projected(void*, char const *, size_t, uint64_t, size_t);
-void rs_circuit_module_push_namespace(void*, char const *);
-void rs_circuit_module_pop_namespace(void*);
-size_t rs_circuit_module_canonical_bytes_size(void*);
-void rs_circuit_module_canonical_bytes(void*, size_t, uint8_t*);
-
-/* --- Archon protocol --- */
-
-c_result *rs_validate_witness(size_t, void**, b_lean_obj_arg, void*);
-void rs_proof_free(void*);
-void *rs_prove(size_t, void**, b_lean_obj_arg, size_t, size_t, void*);
-c_result *rs_verify(size_t, void**, b_lean_obj_arg, size_t, size_t, void*);
-size_t rs_proof_size(void*);
-void rs_proof_to_bytes(void*, size_t, uint8_t*);
-void *rs_proof_of_bytes(b_lean_obj_arg);
-
 /* --- Iroh --- */
 
 c_result *rs_iroh_send(b_lean_obj_arg);
@@ -104,10 +50,3 @@ void *rs_keccak256_hasher_init(void);
 void rs_keccak256_hasher_free(void*);
 void *rs_keccak256_hasher_update(void*, void*);
 void *rs_keccak256_hasher_finalize(void*, void*);
-
-/* --- u128 --- */
-
-uint8_t *rs_add_u128_in_binary_field(uint8_t*, uint8_t*);
-uint8_t *rs_mul_u128_in_binary_field(uint8_t*, uint8_t*);
-uint8_t *rs_pow_u128_in_binary_field(uint8_t*, uint64_t);
-uint8_t *rs_exterior_mul_u64(uint64_t, uint64_t);
diff --git a/c/unsigned.c b/c/unsigned.c
index 475d85c9..e1493bd7 100644
--- a/c/unsigned.c
+++ b/c/unsigned.c
@@ -1,5 +1,4 @@
 #include "lean/lean.h"
-#include "common.h"
 #include "rust.h"
 
 #define memcpy __builtin_memcpy // Avoids including `string.h`
@@ -25,105 +24,3 @@ extern lean_obj_res c_u64_to_le_bytes(uint64_t u64) {
 extern lean_obj_res c_usize_to_le_bytes(size_t usize) {
     return mk_byte_array(sizeof(size_t), (uint8_t*)&usize);
 }
-
-/* --- UInt128 --- */
-
-static lean_external_class *g_u128_class = NULL;
-
-static lean_external_class *get_u128_class() {
-    if (g_u128_class == NULL) {
-        g_u128_class = lean_register_external_class(
-            &free,
-            &noop_foreach
-        );
-    }
-    return g_u128_class;
-}
-
-extern lean_obj_res c_u128_of_lo_hi(uint64_t lo, uint64_t hi) {
-    uint8_t *bytes = (uint8_t*)malloc(2 * sizeof(uint64_t));
-    memcpy(bytes, (uint8_t*)&lo, sizeof(uint64_t));
-    memcpy(bytes + sizeof(uint64_t), (uint8_t*)&hi, sizeof(uint64_t));
-    return lean_alloc_external(get_u128_class(), bytes);
-}
-
-extern lean_obj_res c_u128_to_lo_hi(b_lean_obj_arg u128) {
-    uint8_t *bytes = lean_get_external_data(u128);
-    uint64_t lo, hi;
-    memcpy(&lo, bytes, sizeof(uint64_t));
-    memcpy(&hi, bytes + sizeof(uint64_t), sizeof(uint64_t));
-    lean_obj_res tuple = lean_alloc_ctor(0, 2, 0);
-    lean_ctor_set(tuple, 0, lean_box_uint64(lo));
-    lean_ctor_set(tuple, 1, lean_box_uint64(hi));
-    return tuple;
-}
-
-extern uint8_t c_u128_cmp(b_lean_obj_arg a, b_lean_obj_arg b) {
-    uint8_t *a_bytes = lean_get_external_data(a);
-    uint8_t *b_bytes = lean_get_external_data(b);
-
-    uint64_t a_hi, b_hi;
-    memcpy(&a_hi, a_bytes + sizeof(uint64_t), sizeof(uint64_t));
-    memcpy(&b_hi, b_bytes + sizeof(uint64_t), sizeof(uint64_t));
-    if (a_hi < b_hi) {
-        return 0; // lt
-    } else if (a_hi > b_hi) {
-        return 2; // gt
-    } else {
-        uint64_t a_lo, b_lo;
-        memcpy(&a_lo, a_bytes, sizeof(uint64_t));
-        memcpy(&b_lo, b_bytes, sizeof(uint64_t));
-        if (a_lo < b_lo) {
-            return 0; // lt
-        } else if (a_lo > b_lo) {
-            return 2; // gt
-        } else {
-            return 1; // eq
-        }
-    }
-}
-
-extern lean_obj_res c_u128_to_le_bytes(b_lean_obj_arg u128) {
-    return mk_byte_array(2 * sizeof(uint64_t), lean_get_external_data(u128));
-}
-
-extern lean_obj_res c_rs_add_u128_in_binary_field(
-    b_lean_obj_arg a,
-    b_lean_obj_arg b
-) {
-    uint8_t *bytes = rs_add_u128_in_binary_field(
-        lean_get_external_data(a),
-        lean_get_external_data(b)
-    );
-    return lean_alloc_external(get_u128_class(), bytes);
-}
-
-extern lean_obj_res c_rs_mul_u128_in_binary_field(
-    b_lean_obj_arg a,
-    b_lean_obj_arg b
-) {
-    uint8_t *bytes = rs_mul_u128_in_binary_field(
-        lean_get_external_data(a),
-        lean_get_external_data(b)
-    );
-    return lean_alloc_external(get_u128_class(), bytes);
-}
-
-extern lean_obj_res c_rs_exterior_mul_u64(
-    uint64_t a,
-    uint64_t b
-) {
-    uint8_t *bytes = rs_exterior_mul_u64(a, b);
-    return lean_alloc_external(get_u128_class(), bytes);
-}
-
-extern lean_obj_res c_rs_pow_u128_in_binary_field(
-    b_lean_obj_arg a,
-    uint64_t b
-) {
-    uint8_t *bytes = rs_pow_u128_in_binary_field(
-        lean_get_external_data(a),
-        b
-    );
-    return lean_alloc_external(get_u128_class(), bytes);
-}
diff --git a/ix.nix b/ix.nix
index c7f30039..95c30d9b 100644
--- a/ix.nix
+++ b/ix.nix
@@ -3,7 +3,7 @@ let
   # Pins the Rust toolchain
   rustToolchain = fenix.packages.${system}.fromToolchainFile {
     file = ./rust-toolchain.toml;
-    sha256 = "sha256-pyALh2dsNqnioKUs2BY07gOU96ZNB7D4esEmcxym//4=";
+    sha256 = "sha256-Qxt8XAuaUR2OMdKbN4u8dBJOhSHxS+uS06Wl9+flVEk=";
   };
 
   # Rust package
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 10df8ffe..d61a2533 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,5 +1,4 @@
-# TODO: Add periodic Rust toolchain upgrade workflow in CI
 [toolchain]
 # The default profile includes rustc, rust-std, cargo, rust-docs, rustfmt and clippy.
 profile = "default"
-channel = "nightly-2025-05-08"
+channel = "1.88"
diff --git a/src/aiur/arithmetic.rs b/src/aiur/arithmetic.rs
deleted file mode 100644
index 97fbfdd5..00000000
--- a/src/aiur/arithmetic.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-use std::array::from_fn;
-
-use binius_circuits::{
-    arithmetic::mul::mul,
-    builder::{ConstraintSystemBuilder, witness},
-};
-use binius_core::{
-    constraint_system::channel::{ChannelId, OracleOrConst},
-    oracle::{OracleId, ShiftVariant},
-};
-use binius_field::{
-    Field,
-    packed::set_packed_slice,
-    underlier::{U1, WithUnderlier},
-};
-use binius_macros::arith_expr;
-use binius_maybe_rayon::prelude::*;
-
-use crate::aiur::layout::{B1, B64};
-
-use super::{
-    constraints::Expr,
-    execute::QueryRecord,
-    layout::{B1_LEVEL, B64_LEVEL, B128},
-};
-
-struct AddCols {
-    xin: OracleId,
-    yin: OracleId,
-    cin: OracleId,
-    zout: OracleId,
-    cout: OracleId,
-    packed_xin: OracleId,
-    packed_yin: OracleId,
-    packed_zout: OracleId,
-    projected_cout: OracleId,
-}
-
-pub struct AddTrace {
-    xin: Vec<u64>,
-    yin: Vec<u64>,
-    pub height: usize,
-}
-
-impl AddTrace {
-    pub fn generate_trace(record: &QueryRecord) -> Self {
-        let height = record.add_queries.len();
-        let mut trace = AddTrace {
-            xin: Vec::with_capacity(height),
-            yin: Vec::with_capacity(height),
-            height,
-        };
-        for (xin, yin) in record.add_queries.iter() {
-            trace.xin.push(*xin);
-            trace.yin.push(*yin);
-        }
-        trace
-    }
-}
-
-impl AddCols {
-    fn new(builder: &mut ConstraintSystemBuilder<'_>, log_n: usize) -> Self {
-        let xin = builder.add_committed("xin", log_n + B64_LEVEL, B1_LEVEL);
-        let yin = builder.add_committed("yin", log_n + B64_LEVEL, B1_LEVEL);
-        let zout = builder.add_committed("zout", log_n + B64_LEVEL, B1_LEVEL);
-        let cout = builder.add_committed("cout", log_n + B64_LEVEL, B1_LEVEL);
-        let cin = builder
-            .add_shifted("cin", cout, 1, B64_LEVEL, ShiftVariant::LogicalLeft)
-            .unwrap();
-        let packed_xin = builder.add_packed("packed_xin", xin, B64_LEVEL).unwrap();
-        let packed_yin = builder.add_packed("packed_yin", yin, B64_LEVEL).unwrap();
-        let packed_zout = builder.add_packed("packed_zout", zout, B64_LEVEL).unwrap();
-        let args = [B128::ONE; B64_LEVEL].to_vec();
-        let projected_cout = builder
-            .add_projected("projected_cout", cout, args, 0)
-            .unwrap();
-        AddCols {
-            xin,
-            yin,
-            cin,
-            zout,
-            cout,
-            packed_xin,
-            packed_yin,
-            packed_zout,
-            projected_cout,
-        }
-    }
-
-    fn populate(&self, witness: &mut witness::Builder<'_>, trace: &AddTrace, count: usize) {
-        witness.new_column::<B1>(self.xin).as_mut_slice::<u64>()[..count]
-            .copy_from_slice(&trace.xin);
-        witness.new_column::<B1>(self.yin).as_mut_slice::<u64>()[..count]
-            .copy_from_slice(&trace.yin);
-        (
-            witness.get::<B1>(self.xin).unwrap().as_slice::<u64>(),
-            witness.get::<B1>(self.yin).unwrap().as_slice::<u64>(),
-            witness.new_column::<B1>(self.zout).as_mut_slice::<u64>(),
-            witness.new_column::<B1>(self.cout).as_mut_slice::<u64>(),
-            witness.new_column::<B1>(self.cin).as_mut_slice::<u64>(),
-        )
-            .into_par_iter()
-            .for_each(|(xin, yin, zout, cout, cin)| {
-                let carry;
-                (*zout, carry) = (*xin).overflowing_add(*yin);
-                *cin = (*xin) ^ (*yin) ^ (*zout);
-                *cout = ((carry as u64) << 63) | (*cin >> 1);
-            });
-        let packed_xin_witness = witness.get::<B1>(self.xin).unwrap();
-        let packed_yin_witness = witness.get::<B1>(self.yin).unwrap();
-        let packed_zout_witness = witness.get::<B1>(self.zout).unwrap();
-        witness
-            .set(self.packed_xin, packed_xin_witness.repacked::<B64>())
-            .unwrap();
-        witness
-            .set(self.packed_yin, packed_yin_witness.repacked::<B64>())
-            .unwrap();
-        witness
-            .set(self.packed_zout, packed_zout_witness.repacked::<B64>())
-            .unwrap();
-        let cout_witness = witness.get::<B1>(self.cout).unwrap().as_slice::<u64>();
-        let mut projected_cout_witness = witness.new_column::<B1>(self.projected_cout);
-        let projected_cout_witness = projected_cout_witness.packed();
-        for (i, word) in cout_witness.iter().enumerate() {
-            let bit = (word >> 63) as u8;
-            set_packed_slice(projected_cout_witness, i, B1::from_underlier(U1::new(bit)));
-        }
-    }
-}
-
-fn constrain_add(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    add_channel_id: ChannelId,
-    cols: &AddCols,
-    count: usize,
-) {
-    builder.assert_zero(
-        "sum",
-        [cols.xin, cols.yin, cols.cin, cols.zout],
-        arith_expr!([xin, yin, cin, zout] = xin + yin + cin - zout).convert_field(),
-    );
-
-    builder.assert_zero(
-        "carry",
-        [cols.xin, cols.yin, cols.cin, cols.cout],
-        arith_expr!([xin, yin, cin, cout] = (xin + cin) * (yin + cin) + cin - cout).convert_field(),
-    );
-    let args = [
-        cols.packed_xin,
-        cols.packed_yin,
-        cols.packed_zout,
-        cols.projected_cout,
-    ]
-    .map(OracleOrConst::Oracle);
-    builder.receive(add_channel_id, count, args).unwrap();
-}
-
-pub fn prover_synthesize_add(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    add_channel_id: ChannelId,
-    trace: &AddTrace,
-) {
-    let log_n = trace.height.next_power_of_two().ilog2() as usize;
-    let count = trace.height;
-    let cols = AddCols::new(builder, log_n);
-    cols.populate(builder.witness().unwrap(), trace, count);
-    constrain_add(builder, add_channel_id, &cols, count);
-}
-
-pub fn verifier_synthesize_add(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    add_channel_id: ChannelId,
-    count: u64,
-) {
-    let log_n = count.next_power_of_two().ilog2() as usize;
-    let cols = AddCols::new(builder, log_n);
-    constrain_add(builder, add_channel_id, &cols, count.try_into().expect(""));
-}
-
-struct MulCols {
-    xin: OracleId,
-    yin: OracleId,
-    xin_bits: [OracleId; 64],
-    yin_bits: [OracleId; 64],
-    zout: OracleId,
-}
-
-impl MulCols {
-    fn new(builder: &mut ConstraintSystemBuilder<'_>, log_n: usize) -> Self {
-        let xin = builder.add_committed("xin", log_n, B64_LEVEL);
-        let yin = builder.add_committed("yin", log_n, B64_LEVEL);
-        let zout = builder.add_committed("zout", log_n, B64_LEVEL);
-        let xin_bits = from_fn(|i| builder.add_committed(format!("xin_bits{i}"), log_n, B1_LEVEL));
-        let yin_bits = from_fn(|i| builder.add_committed(format!("yin_bits{i}"), log_n, B1_LEVEL));
-        Self {
-            xin,
-            yin,
-            zout,
-            xin_bits,
-            yin_bits,
-        }
-    }
-
-    fn populate(&self, witness: &mut witness::Builder<'_>, trace: &MulTrace, count: usize) {
-        witness.new_column::<B64>(self.xin).as_mut_slice::<u64>()[..count]
-            .copy_from_slice(&trace.xin);
-        witness.new_column::<B64>(self.yin).as_mut_slice::<u64>()[..count]
-            .copy_from_slice(&trace.yin);
-        let xin_slice = witness.get::<B64>(self.xin).unwrap().as_slice::<u64>();
-        let yin_slice = witness.get::<B64>(self.yin).unwrap().as_slice::<u64>();
-        let mut zout_witness = witness.new_column::<B64>(self.zout);
-        (xin_slice, yin_slice, zout_witness.as_mut_slice::<u64>())
-            .into_par_iter()
-            .for_each(|(xin, yin, zout)| {
-                *zout = xin.wrapping_mul(*yin);
-            });
-        for i in 0..64 {
-            let mut xin_bit = witness.new_column::<B1>(self.xin_bits[i]);
-            let xin_bit = xin_bit.packed();
-            for (j, xin) in xin_slice.iter().enumerate() {
-                let bit = ((xin >> i) & 1) as u8;
-                set_packed_slice(xin_bit, j, U1::new(bit).into())
-            }
-            let mut yin_bit = witness.new_column::<B1>(self.yin_bits[i]);
-            let yin_bit = yin_bit.packed();
-            for (j, yin) in yin_slice.iter().enumerate() {
-                let bit = ((yin >> i) & 1) as u8;
-                set_packed_slice(yin_bit, j, U1::new(bit).into())
-            }
-        }
-    }
-}
-
-pub struct MulTrace {
-    xin: Vec<u64>,
-    yin: Vec<u64>,
-    pub height: usize,
-}
-
-impl MulTrace {
-    pub fn generate_trace(record: &QueryRecord) -> Self {
-        let height = record.mul_queries.len();
-        let mut trace = MulTrace {
-            xin: Vec::with_capacity(height),
-            yin: Vec::with_capacity(height),
-            height,
-        };
-        for (xin, yin) in record.mul_queries.iter() {
-            trace.xin.push(*xin);
-            trace.yin.push(*yin);
-        }
-        trace
-    }
-}
-
-pub fn prover_synthesize_mul(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    mul_channel_id: ChannelId,
-    trace: &MulTrace,
-) {
-    let log_n = trace.height.next_power_of_two().ilog2() as usize;
-    let cols = MulCols::new(builder, log_n);
-    let count = trace.height;
-    cols.populate(builder.witness().unwrap(), trace, count);
-    constrain_mul(builder, mul_channel_id, &cols, count);
-}
-
-pub fn verifier_synthesize_mul(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    mul_channel_id: ChannelId,
-    count: u64,
-) {
-    let log_n = count.next_power_of_two().ilog2() as usize;
-    let cols = MulCols::new(builder, log_n);
-    let count = count.try_into().expect("");
-    constrain_mul(builder, mul_channel_id, &cols, count);
-}
-
-fn constrain_mul(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    mul_channel_id: ChannelId,
-    cols: &MulCols,
-    count: usize,
-) {
-    bit_decomposition(builder, &cols.xin_bits, cols.xin);
-    bit_decomposition(builder, &cols.yin_bits, cols.yin);
-    let zout_bits = mul::<B128>(
-        builder,
-        "u64_mul",
-        cols.xin_bits.to_vec(),
-        cols.yin_bits.to_vec(),
-    )
-    .unwrap();
-    let zout_bits = (&zout_bits[0..64]).try_into().unwrap();
-    bit_decomposition(builder, zout_bits, cols.zout);
-    let args = [cols.xin, cols.yin, cols.zout].map(OracleOrConst::Oracle);
-    builder.receive(mul_channel_id, count, args).unwrap();
-}
-
-fn bit_decomposition(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    bits: &[OracleId; 64],
-    word: OracleId,
-) {
-    let mut expr: Expr = Expr::Var(word);
-    let mut coeff = 1;
-    for bit in bits.iter() {
-        expr = expr - Expr::Const(coeff.into()) * Expr::Var(*bit);
-        coeff = coeff.wrapping_shl(1);
-    }
-    let (oracles, arith) = expr.to_arith_expr();
-    builder.assert_zero("bit decomposition", oracles, arith.into());
-}
diff --git a/src/aiur2/bytecode.rs b/src/aiur/bytecode.rs
similarity index 100%
rename from src/aiur2/bytecode.rs
rename to src/aiur/bytecode.rs
diff --git a/src/aiur/constraints.rs b/src/aiur/constraints.rs
index 8b457c49..8d9384b9 100644
--- a/src/aiur/constraints.rs
+++ b/src/aiur/constraints.rs
@@ -1,409 +1,325 @@
-use std::ops::{Add, AddAssign, Mul, Sub};
-
-use binius_circuits::builder::ConstraintSystemBuilder;
-use binius_core::oracle::OracleId;
-use binius_field::{Field, underlier::WithUnderlier};
+use multi_stark::{
+    builder::symbolic::SymbolicExpression, lookup::Lookup, p3_field::PrimeCharacteristicRing,
+};
+use std::ops::Range;
 
 use super::{
-    ir::{Block, Ctrl, FuncIdx, Function, Op, Prim, SelIdx, ValIdx},
-    layout::{B1_LEVEL, B8_LEVEL, B64, B64_LEVEL, Layout},
+    G,
+    bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel},
+    trace::Channel,
 };
 
-#[derive(Clone, Debug)]
-pub enum Expr {
-    Const(B64),
-    Var(OracleId),
-    Add(Box<Expr>, Box<Expr>),
-    Mul(Box<Expr>, Box<Expr>),
-    Pow(Box<Expr>, u64),
-}
-
-impl Mul for Expr {
-    type Output = Self;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        match (self, rhs) {
-            (Expr::Const(B64::ONE), b) => b,
-            (a, Expr::Const(B64::ONE)) => a,
-            (Expr::Const(a), Expr::Const(b)) => Expr::Const(a * b),
-            (a, b) => Self::Mul(a.into(), b.into()),
-        }
-    }
-}
-
-impl AddAssign for Expr {
-    fn add_assign(&mut self, rhs: Expr) {
-        *self = self.clone() + rhs;
-    }
+#[macro_export]
+macro_rules! sym_var {
+    ($a:expr) => {{
+        use multi_stark::builder::symbolic::*;
+        let entry = Entry::Main { offset: 0 };
+        SymbolicExpression::Variable(SymbolicVariable::new(entry, $a))
+    }};
 }
 
-impl Add for Expr {
-    type Output = Self;
+type Expr = SymbolicExpression<G>;
+type Degree = u8;
 
-    fn add(self, rhs: Expr) -> Self {
-        match (self, rhs) {
-            (Expr::Const(B64::ZERO), b) => b,
-            (a, Expr::Const(B64::ZERO)) => a,
-            (Expr::Const(a), Expr::Const(b)) => Expr::Const(a + b),
-            (a, b) => Self::Add(a.into(), b.into()),
-        }
-    }
-}
-
-impl Sub for Expr {
-    type Output = Self;
-
-    // Subtraction is the same thing as addition in Binius
-    #[allow(clippy::suspicious_arithmetic_impl)]
-    fn sub(self, rhs: Expr) -> Self {
-        self + rhs
-    }
-}
-
-impl Expr {
-    fn zero() -> Self {
-        Self::Const(B64::ZERO)
-    }
-
-    fn one() -> Self {
-        Self::Const(B64::ONE)
-    }
-}
-
-#[derive(Clone)]
+/// Holds data for a function circuit.
 pub struct Constraints {
-    pub shared_constraints: Vec<Expr>,
-    pub unique_constraints: Vec<Expr>,
-    pub sends: Vec<(Channel, Expr, Vec<Expr>)>,
-    pub requires: Vec<(Channel, Expr, OracleId, Vec<Expr>)>,
-    pub topmost_selector: Expr,
-    pub io: Vec<OracleId>,
-    pub multiplicity: OracleId,
+    pub zeros: Vec<Expr>,
+    pub selectors: Range<usize>,
+    pub width: usize,
 }
 
-#[derive(Clone)]
-pub enum Channel {
-    Add,
-    Mul,
-    Fun(FuncIdx),
-    Mem(u32),
-}
-
-impl Constraints {
-    pub fn new(function: &Function, layout: &Layout, columns: &Columns) -> Self {
-        let shared_constraints = vec![Expr::zero(); layout.shared_constraints as usize];
-        let unique_constraints = vec![];
-        let sends = vec![];
-        let requires = vec![];
-        let topmost_selector = block_selector(&function.body, columns);
-        let mut io = columns.inputs.clone();
-        io.extend(columns.outputs.iter().cloned());
-        let multiplicity = columns.multiplicity;
-        Self {
-            shared_constraints,
-            unique_constraints,
-            sends,
-            requires,
-            topmost_selector,
-            io,
-            multiplicity,
-        }
-    }
-
-    fn push_unique(&mut self, expr: Expr) {
-        self.unique_constraints.push(expr);
-    }
-
-    fn send(&mut self, channel: Channel, sel: Expr, args: Vec<Expr>) {
-        self.sends.push((channel, sel, args));
-    }
-
-    fn require(&mut self, channel: Channel, sel: Expr, prev_idx: OracleId, args: Vec<Expr>) {
-        self.requires.push((channel, sel, prev_idx, args));
-    }
+struct ConstraintState {
+    function_index: G,
+    layout: FunctionLayout,
+    column: usize,
+    lookup: usize,
+    lookups: Vec<Lookup<Expr>>,
+    map: Vec<(Expr, Degree)>,
+    constraints: Constraints,
 }
 
-#[derive(Clone, Default)]
-struct ConstraintState {
-    constraint_index: usize,
-    u1_auxiliary_index: usize,
-    u8_auxiliary_index: usize,
-    u64_auxiliary_index: usize,
-    var_map: Vec<Expr>,
+struct SharedState {
+    column: usize,
+    lookup: usize,
+    map_len: usize,
 }
 
 impl ConstraintState {
-    fn save(&self) -> Self {
-        self.clone()
-    }
-
-    fn restore(&mut self, state: Self) {
-        *self = state;
+    fn selector_index(&self, sel: usize) -> usize {
+        sel + self.layout.input_size
     }
 
-    fn push_var(&mut self, expr: Expr) {
-        self.var_map.push(expr);
+    fn next_lookup(&mut self) -> &mut Lookup<Expr> {
+        let lookup = &mut self.lookups[self.lookup];
+        self.lookup += 1;
+        lookup
     }
 
-    fn get_var(&self, idx: ValIdx) -> &Expr {
-        &self.var_map[idx.to_usize()]
+    fn next_auxiliary(&mut self) -> Expr {
+        self.column += 1;
+        sym_var!(self.column - 1)
     }
 
-    #[allow(dead_code)]
-    fn get_vars(&self, idx: ValIdx, offset: usize) -> &[Expr] {
-        let idx = idx.to_usize();
-        &self.var_map[idx..idx + offset]
-    }
-
-    fn bind_u1_column(&mut self, columns: &Columns) -> OracleId {
-        let col = self.next_u1_column(columns);
-        self.var_map.push(Expr::Var(col));
-        col
-    }
-
-    #[allow(dead_code)]
-    fn bind_u8_column(&mut self, columns: &Columns) -> OracleId {
-        let col = self.next_u8_column(columns);
-        self.var_map.push(Expr::Var(col));
-        col
-    }
-
-    fn bind_u64_column(&mut self, columns: &Columns) -> OracleId {
-        let col = self.next_u64_column(columns);
-        self.var_map.push(Expr::Var(col));
-        col
-    }
-
-    fn next_u1_column(&mut self, columns: &Columns) -> OracleId {
-        let col = columns.u1_auxiliaries[self.u1_auxiliary_index];
-        self.u1_auxiliary_index += 1;
-        col
-    }
-
-    #[allow(dead_code)]
-    fn next_u8_column(&mut self, columns: &Columns) -> OracleId {
-        let col = columns.u8_auxiliaries[self.u8_auxiliary_index];
-        self.u8_auxiliary_index += 1;
-        col
+    fn save(&mut self) -> SharedState {
+        SharedState {
+            column: self.column,
+            lookup: self.lookup,
+            map_len: self.map.len(),
+        }
     }
 
-    fn next_u64_column(&mut self, columns: &Columns) -> OracleId {
-        let col = columns.u64_auxiliaries[self.u64_auxiliary_index];
-        self.u64_auxiliary_index += 1;
-        col
+    #[allow(clippy::needless_pass_by_value)]
+    fn restore(&mut self, init: SharedState) {
+        self.column = init.column;
+        self.lookup = init.lookup;
+        self.map.truncate(init.map_len);
     }
+}
 
-    fn add_shared_constraint(&mut self, constraints: &mut Constraints, expr: Expr) {
-        constraints.shared_constraints[self.constraint_index] += expr;
-        self.constraint_index += 1;
+impl Toplevel {
+    pub fn build_constraints(&self, function_index: usize) -> (Constraints, Vec<Lookup<Expr>>) {
+        let function = &self.functions[function_index];
+        let empty_lookup = Lookup {
+            multiplicity: Expr::Constant(G::ZERO),
+            args: vec![],
+        };
+        let constraints = Constraints {
+            zeros: vec![],
+            selectors: 0..0,
+            width: function.layout.width(),
+        };
+        let mut state = ConstraintState {
+            function_index: G::from_usize(function_index),
+            layout: function.layout,
+            column: 0,
+            lookup: 0,
+            map: vec![],
+            lookups: vec![empty_lookup; function.layout.lookups],
+            constraints,
+        };
+        function.build_constraints(&mut state, self);
+        (state.constraints, state.lookups)
     }
 }
 
-#[derive(Clone, Default)]
-pub struct Columns {
-    pub inputs: Vec<OracleId>,
-    pub outputs: Vec<OracleId>,
-    pub u1_auxiliaries: Vec<OracleId>,
-    pub u8_auxiliaries: Vec<OracleId>,
-    pub u64_auxiliaries: Vec<OracleId>,
-    pub multiplicity: OracleId,
-    pub selectors: Vec<OracleId>,
+impl Function {
+    fn build_constraints(&self, state: &mut ConstraintState, toplevel: &Toplevel) {
+        // 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((sym_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 = sym_var!(state.column);
+        state.column += 1;
+        // the return lookup occupies the first lookup slot
+        state.lookups[0].multiplicity = -multiplicity.clone();
+        state.lookup += 1;
+        // the multiplicity can only be set if one and only one selector is set
+        let sel = self.body.get_block_selector(state);
+        state
+            .constraints
+            .zeros
+            .push(multiplicity * (Expr::from(G::ONE) - sel.clone()));
+        self.body.collect_constraints(sel, state, toplevel);
+    }
 }
 
-impl Columns {
-    pub fn get_selector(&self, idx: SelIdx) -> OracleId {
-        self.selectors[idx.to_usize()]
+impl Block {
+    fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState, toplevel: &Toplevel) {
+        self.ops
+            .iter()
+            .for_each(|op| op.collect_constraints(&sel, state));
+        self.ctrl.collect_constraints(sel, state, toplevel);
     }
 
-    pub fn from_layout(
-        builder: &mut ConstraintSystemBuilder<'_>,
-        layout: &Layout,
-        log_n: u8,
-    ) -> Self {
-        let log_n = log_n as usize;
-        let inputs = (0..layout.inputs)
-            .map(|i| builder.add_committed(format!("input{i}"), log_n, B64_LEVEL))
-            .collect();
-        let outputs = (0..layout.outputs)
-            .map(|i| builder.add_committed(format!("outputs{i}"), log_n, B64_LEVEL))
-            .collect();
-        let u1_auxiliaries = (0..layout.u1_auxiliaries)
-            .map(|i| builder.add_committed(format!("u1_auxiliaries{i}"), log_n, B1_LEVEL))
-            .collect();
-        let u8_auxiliaries = (0..layout.u8_auxiliaries)
-            .map(|i| builder.add_committed(format!("u8_auxiliaries{i}"), log_n, B8_LEVEL))
-            .collect();
-        let u64_auxiliaries = (0..layout.u64_auxiliaries)
-            .map(|i| builder.add_committed(format!("u64_auxiliary{i}"), log_n, B64_LEVEL))
-            .collect();
-        let multiplicity = builder.add_committed("multiplicity", log_n, B64_LEVEL);
-        let selectors = (0..layout.selectors)
-            .map(|i| builder.add_committed(format!("selectors{i}"), log_n, B1_LEVEL))
-            .collect();
-        Self {
-            inputs,
-            outputs,
-            u1_auxiliaries,
-            u8_auxiliaries,
-            u64_auxiliaries,
-            multiplicity,
-            selectors,
-        }
+    fn get_block_selector(&self, state: &mut ConstraintState) -> Expr {
+        (self.min_sel_included..self.max_sel_excluded)
+            .map(|i| sym_var!(state.selector_index(i)))
+            .fold(Expr::Constant(G::ZERO), |var, acc| var + acc)
     }
 }
 
-pub fn build_func_constraints(
-    function: &Function,
-    layout: &Layout,
-    columns: &Columns,
-) -> Constraints {
-    let mut state = ConstraintState::default();
-    columns
-        .inputs
-        .iter()
-        .for_each(|input| state.var_map.push(Expr::Var(*input)));
-    let mut constraints = Constraints::new(function, layout, columns);
-    collect_block_constraints(&function.body, &mut state, columns, &mut constraints);
-    constraints
-}
-
-fn collect_block_constraints(
-    block: &Block,
-    state: &mut ConstraintState,
-    columns: &Columns,
-    constraints: &mut Constraints,
-) {
-    let sel = block_selector(block, columns);
-    block
-        .ops
-        .iter()
-        .for_each(|op| collect_op_constraints(op, state, columns, constraints, &sel));
-    match block.ctrl.as_ref() {
-        Ctrl::If(b, t, f) => {
-            let b = state.get_var(*b).clone();
-            let saved = state.save();
-            let t_sel = block_selector(t, columns);
-            let d = Expr::Var(state.next_u64_column(columns));
-            constraints.push_unique(t_sel * (b.clone() * d - Expr::one()));
-            collect_block_constraints(t, state, columns, constraints);
-            state.restore(saved);
-            let f_sel = block_selector(f, columns);
-            constraints.push_unique(f_sel * b);
-            collect_block_constraints(f, state, columns, constraints);
-        }
-        Ctrl::Return(id, rs) => {
-            let sel_col = columns.get_selector(*id);
-            for (r, o) in rs.iter().zip(columns.outputs.iter()) {
-                let r = state.get_var(*r).clone();
-                let o = Expr::Var(*o);
-                let sel = Expr::Var(sel_col);
-                state.add_shared_constraint(constraints, sel * (r - o));
+impl Ctrl {
+    #[allow(clippy::needless_pass_by_value)]
+    fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState, toplevel: &Toplevel) {
+        match self {
+            Ctrl::Return(_, values) => {
+                // channel and function index
+                let mut vector = vec![
+                    sel.clone() * Channel::Function.to_field(),
+                    sel.clone() * state.function_index,
+                ];
+                // input
+                vector.extend(
+                    (0..state.layout.input_size).map(|arg| sel.clone() * state.map[arg].0.clone()),
+                );
+                // output
+                vector.extend(
+                    values
+                        .iter()
+                        .map(|arg| sel.clone() * state.map[*arg].0.clone()),
+                );
+                let mut values_iter = vector.into_iter();
+                let lookup = &mut state.lookups[0];
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                // multiplicity is already set
+            }
+            Ctrl::Match(var, cases, def) => {
+                let (var, _) = state.map[*var].clone();
+                for (&value, branch) in cases.iter() {
+                    let init = state.save();
+                    let branch_sel = branch.get_block_selector(state);
+                    state
+                        .constraints
+                        .zeros
+                        .push(branch_sel.clone() * (var.clone() - Expr::from(value)));
+                    branch.collect_constraints(branch_sel, state, toplevel);
+                    state.restore(init);
+                }
+                def.iter().for_each(|branch| {
+                    let init = state.save();
+                    let branch_sel = branch.get_block_selector(state);
+                    for &value in cases.keys() {
+                        let inverse = state.next_auxiliary();
+                        state.constraints.zeros.push(
+                            branch_sel.clone()
+                                * ((var.clone() - Expr::from(value)) * inverse
+                                    - Expr::from(G::ONE)),
+                        );
+                    }
+                    branch.collect_constraints(branch_sel, state, toplevel);
+                    state.restore(init);
+                })
             }
         }
     }
 }
 
-fn collect_op_constraints(
-    op: &Op,
-    state: &mut ConstraintState,
-    columns: &Columns,
-    constraints: &mut Constraints,
-    sel: &Expr,
-) {
-    match op {
-        Op::Prim(Prim::Bool(a)) => {
-            let a = B64::from_underlier(*a as u64);
-            state.push_var(Expr::Const(a));
-        }
-        Op::Prim(Prim::U64(a)) => {
-            let a = B64::from_underlier(*a);
-            state.push_var(Expr::Const(a));
-        }
-        Op::Add(a, b) => {
-            let a = state.get_var(*a).clone();
-            let b = state.get_var(*b).clone();
-            // 8 bytes of result
-            let c = Expr::Var(state.bind_u64_column(columns));
-            // 1 byte of carry, which is not bound
-            let carry = Expr::Var(state.next_u1_column(columns));
-            let args = [a, b, c, carry];
-            constraints.send(Channel::Add, sel.clone(), args.to_vec());
-        }
-        Op::Sub(c, b) => {
-            // `c - b = a` is equivalent to `a + b = c`.
-            let a = Expr::Var(state.bind_u64_column(columns));
-            let b = state.get_var(*b).clone();
-            let c = state.get_var(*c).clone();
-            let carry = Expr::Var(state.next_u1_column(columns));
-            let args = [a, b, c, carry];
-            constraints.send(Channel::Add, sel.clone(), args.to_vec());
-        }
-        Op::Lt(c, b) => {
-            // `c < b` is equivalent to `c - b` underflowing, which is
-            // equivalent to the addition in `a + b = c` overflowing
-            // Note that the result of the subtraction is not bound
-            let a = Expr::Var(state.next_u64_column(columns));
-            let b = state.get_var(*b).clone();
-            let c = state.get_var(*c).clone();
-            // The carry is bound
-            let carry = Expr::Var(state.bind_u1_column(columns));
-            let args = [a, b, c, carry];
-            constraints.send(Channel::Add, sel.clone(), args.to_vec());
-        }
-        Op::Mul(a, b) => {
-            let a = state.get_var(*a).clone();
-            let b = state.get_var(*b).clone();
-            // 8 bytes of result
-            let c = Expr::Var(state.bind_u64_column(columns));
-            let args = [a, b, c];
-            constraints.send(Channel::Mul, sel.clone(), args.to_vec());
-        }
-        Op::Xor(a, b) => {
-            let a = state.get_var(*a).clone();
-            let b = state.get_var(*b).clone();
-            state.push_var(a + b);
-        }
-        Op::And(a, b) => {
-            let a = state.get_var(*a).clone();
-            let b = state.get_var(*b).clone();
-            let c = Expr::Var(state.bind_u1_column(columns));
-            state.push_var(c.clone());
-            state.add_shared_constraint(constraints, sel.clone() * (c - a * b));
-        }
-        Op::Store(values) => {
-            let len = values
-                .len()
-                .try_into()
-                .expect("Error: too many arguments to store");
-            let mut args = [Expr::Var(state.bind_u64_column(columns))].to_vec();
-            args.extend(values.iter().map(|value| state.get_var(*value).clone()));
-            let require = state.next_u64_column(columns);
-            constraints.require(Channel::Mem(len), sel.clone(), require, args);
-        }
-        Op::Load(len, ptr) => {
-            let mut args = [state.get_var(*ptr).clone()].to_vec();
-            let values = (0..*len).map(|_| Expr::Var(state.bind_u64_column(columns)));
-            args.extend(values);
-            let require = state.next_u64_column(columns);
-            constraints.require(Channel::Mem(*len), sel.clone(), require, args);
-        }
-        Op::Call(f, args, out_size) => {
-            let mut args = args
-                .iter()
-                .map(|a| state.get_var(*a).clone())
-                .collect::<Vec<_>>();
-            let out = (0..*out_size).map(|_| Expr::Var(state.bind_u64_column(columns)));
-            args.extend(out);
-            let require = state.next_u64_column(columns);
-            constraints.require(Channel::Fun(*f), sel.clone(), require, args);
+impl Op {
+    fn collect_constraints(&self, sel: &Expr, state: &mut ConstraintState) {
+        match self {
+            Op::Const(f) => state.map.push(((*f).into(), 0)),
+            Op::Add(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg.max(b_deg);
+                state.map.push((a.clone() + b.clone(), *deg));
+            }
+            Op::Sub(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg.max(b_deg);
+                state.map.push((a.clone() - b.clone(), *deg));
+            }
+            Op::Mul(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg + b_deg;
+                let mul = a.clone() * b.clone();
+                if deg < 2 {
+                    state.map.push((mul, deg));
+                } else {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    state.constraints.zeros.push(sel.clone() * (col - mul));
+                }
+            }
+            Op::Call(function_index, inputs, output_size) => {
+                // channel and function index
+                let mut vector = vec![
+                    sel.clone() * Channel::Function.to_field(),
+                    sel.clone() * G::from_usize(*function_index),
+                ];
+                // input
+                vector.extend(
+                    inputs
+                        .iter()
+                        .map(|arg| sel.clone() * state.map[*arg].0.clone()),
+                );
+                // output
+                let output = (0..*output_size).map(|_| {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    col
+                });
+                vector.extend(output);
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
+            Op::Store(values) => {
+                let size = values.len();
+                // channel, function index and pointer
+                let ptr = state.next_auxiliary();
+                state.map.push((ptr.clone(), 1));
+                let mut vector = vec![
+                    sel.clone() * Channel::Memory.to_field(),
+                    sel.clone() * G::from_usize(size),
+                    sel.clone() * ptr.clone(),
+                ];
+                // stored values
+                vector.extend(
+                    values
+                        .iter()
+                        .map(|value| sel.clone() * state.map[*value].0.clone()),
+                );
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
+            Op::Load(size, ptr) => {
+                // channel, size and pointer
+                let mut vector = vec![
+                    sel.clone() * Channel::Memory.to_field(),
+                    sel.clone() * G::from_usize(*size),
+                    sel.clone() * state.map[*ptr].0.clone(),
+                ];
+                // loaded values
+                let values = (0..*size).map(|_| {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    col
+                });
+                vector.extend(values);
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
         }
     }
 }
-
-fn block_selector(block: &Block, columns: &Columns) -> Expr {
-    block
-        .return_idents
-        .iter()
-        .map(|id| Expr::Var(columns.get_selector(*id)))
-        .fold(Expr::zero(), |var, acc| acc + var)
-}
diff --git a/src/aiur/execute.rs b/src/aiur/execute.rs
index ab797f3f..7c3ab38a 100644
--- a/src/aiur/execute.rs
+++ b/src/aiur/execute.rs
@@ -1,71 +1,47 @@
-use indexmap::IndexMap;
-use rustc_hash::FxBuildHasher;
+use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
 
-pub type FxIndexMap<K, V> = IndexMap<K, V, FxBuildHasher>;
+use super::{
+    G,
+    bytecode::{Ctrl, FunIdx, Function, FxIndexMap, Op, Toplevel},
+};
 
-use super::ir::{Ctrl, FuncIdx, Op, Prim, Toplevel, ValIdx};
-
-/// `QueryResult` is an output of the particular function. The `TopLevel` may contain multiply
-/// functions, and for each one executed, it generates one `QueryResult` objects that contains
-/// output for a given function
-#[derive(PartialEq, Eq, Debug)]
 pub struct QueryResult {
-    pub result: Vec<u64>,
-    pub multiplicity: u64,
+    pub(crate) output: Vec<G>,
+    pub(crate) multiplicity: G,
 }
 
-/// `QueryRecord` is a collection of `QueryResult` objects that can be referenced by the input tuple
-/// used while invoking `TopLevel` execution algorithm
-#[derive(Debug)]
+pub type QueryMap = FxIndexMap<Vec<G>, QueryResult>;
+
 pub struct QueryRecord {
-    pub func_queries: Vec<FxIndexMap<Vec<u64>, QueryResult>>,
-    pub mem_queries: Vec<(u32, FxIndexMap<Vec<u64>, QueryResult>)>,
-    pub add_queries: Vec<(u64, u64)>,
-    pub mul_queries: Vec<(u64, u64)>,
+    pub(crate) function_queries: Vec<QueryMap>,
+    pub(crate) memory_queries: FxIndexMap<usize, QueryMap>,
 }
 
 impl QueryRecord {
-    pub fn new(toplevel: &Toplevel) -> Self {
-        let func_len = toplevel.functions.len();
-        let func_queries = (0..func_len).map(|_| Default::default()).collect();
-        let mem_queries = toplevel
-            .mem_widths
+    fn new(toplevel: &Toplevel) -> Self {
+        let function_queries = toplevel
+            .functions
             .iter()
-            .map(|width| (*width, Default::default()))
+            .map(|_| QueryMap::default())
             .collect();
-        let add_queries = Vec::new();
-        let mul_queries = Vec::new();
-        QueryRecord {
-            func_queries,
-            mem_queries,
-            add_queries,
-            mul_queries,
+        let memory_queries = toplevel
+            .memory_sizes
+            .iter()
+            .map(|width| (*width, QueryMap::default()))
+            .collect();
+        Self {
+            function_queries,
+            memory_queries,
         }
     }
+}
 
-    pub fn get_func_map(&self, func_idx: FuncIdx) -> &FxIndexMap<Vec<u64>, QueryResult> {
-        &self.func_queries[func_idx.to_usize()]
-    }
-
-    pub fn get_from_u64(&self, func_idx: FuncIdx, input: &[u64]) -> Option<&QueryResult> {
-        self.func_queries[func_idx.to_usize()].get(input)
-    }
-
-    pub fn get(&self, func_idx: FuncIdx, input: &[u64]) -> Option<&QueryResult> {
-        self.func_queries[func_idx.to_usize()].get(input)
-    }
-
-    pub fn get_mut(&mut self, func_idx: FuncIdx, input: &[u64]) -> Option<&mut QueryResult> {
-        self.func_queries[func_idx.to_usize()].get_mut(input)
-    }
-
-    pub fn insert(
-        &mut self,
-        func_idx: FuncIdx,
-        input: Vec<u64>,
-        output: QueryResult,
-    ) -> Option<QueryResult> {
-        self.func_queries[func_idx.to_usize()].insert(input, output)
+impl Toplevel {
+    pub fn execute(&self, fun_idx: FunIdx, args: Vec<G>) -> (QueryRecord, Vec<G>) {
+        let mut record = QueryRecord::new(self);
+        let function = &self.functions[fun_idx];
+        let output = function.execute(fun_idx, args, self, &mut record);
+        (record, output)
     }
 }
 
@@ -75,346 +51,134 @@ enum ExecEntry<'a> {
 }
 
 struct CallerState {
-    func_idx: FuncIdx,
-    map: Vec<u64>,
+    fun_idx: FunIdx,
+    map: Vec<G>,
 }
 
-impl Toplevel {
-    /// Implementation of the execution algorithm
-    ///
-    /// 1) The values from the input are the very first values in the inner stack of the execution
-    ///    algorithm
-    /// 2) You can write additional input values (for example if you need some constants) into the
-    ///    stack while implementing particular block of the program
-    pub fn execute(&self, mut func_idx: FuncIdx, input: Vec<u64>) -> QueryRecord {
-        let func = &self.functions[func_idx.to_usize()];
-        assert_eq!(input.len(), func.input_size as usize);
-
-        let mut record = QueryRecord::new(self);
+impl Function {
+    fn execute(
+        &self,
+        mut fun_idx: FunIdx,
+        mut map: Vec<G>,
+        toplevel: &Toplevel,
+        record: &mut QueryRecord,
+    ) -> Vec<G> {
         let mut exec_entries_stack = vec![];
         let mut callers_states_stack = vec![];
-        let mut map = input;
-
-        macro_rules! stack_block_exec_entries {
+        macro_rules! push_block_exec_entries {
             ($block:expr) => {
                 exec_entries_stack.push(ExecEntry::Ctrl(&$block.ctrl));
                 exec_entries_stack.extend($block.ops.iter().rev().map(ExecEntry::Op));
             };
         }
-
-        stack_block_exec_entries!(&func.body);
-
+        push_block_exec_entries!(&self.body);
         while let Some(exec_entry) = exec_entries_stack.pop() {
             match exec_entry {
-                ExecEntry::Op(Op::Prim(Prim::Bool(x))) => map.push(*x as u64),
-                ExecEntry::Op(Op::Prim(Prim::U64(x))) => map.push(*x),
+                ExecEntry::Op(Op::Const(c)) => map.push(*c),
                 ExecEntry::Op(Op::Add(a, b)) => {
-                    let a = map[a.to_usize()];
-                    let b = map[b.to_usize()];
-                    let c = a.wrapping_add(b);
-                    map.push(c);
-                    record.add_queries.push((a, b));
-                }
-                ExecEntry::Op(Op::Sub(c, b)) => {
-                    let c = map[c.to_usize()];
-                    let b = map[b.to_usize()];
-                    let a = c.wrapping_sub(b);
-                    map.push(a);
-                    record.add_queries.push((a, b));
+                    let a = map[*a];
+                    let b = map[*b];
+                    map.push(a + b);
                 }
-                ExecEntry::Op(Op::Lt(c, b)) => {
-                    let c = map[c.to_usize()];
-                    let b = map[b.to_usize()];
-                    let (a, underflow) = c.overflowing_sub(b);
-                    map.push(underflow as u64);
-                    record.add_queries.push((a, b));
+                ExecEntry::Op(Op::Sub(a, b)) => {
+                    let a = map[*a];
+                    let b = map[*b];
+                    map.push(a - b);
                 }
                 ExecEntry::Op(Op::Mul(a, b)) => {
-                    let a = map[a.to_usize()];
-                    let b = map[b.to_usize()];
-                    let c = a.wrapping_mul(b);
-                    map.push(c);
-                    record.mul_queries.push((a, b));
+                    let a = map[*a];
+                    let b = map[*b];
+                    map.push(a * b);
                 }
-                ExecEntry::Op(Op::And(a, b)) => {
-                    let a = map[a.to_usize()];
-                    let b = map[b.to_usize()];
-                    let c = a & b;
-                    map.push(c);
-                }
-                ExecEntry::Op(Op::Xor(a, b)) => {
-                    let a = map[a.to_usize()];
-                    let b = map[b.to_usize()];
-                    let c = a ^ b;
-                    map.push(c);
+                ExecEntry::Op(Op::Call(callee_idx, args, _)) => {
+                    let args = args.iter().map(|i| map[*i]).collect();
+                    if let Some(result) = record.function_queries[*callee_idx].get_mut(&args) {
+                        result.multiplicity += G::ONE;
+                        map.extend(result.output.clone());
+                    } else {
+                        let saved_map = std::mem::replace(&mut map, args);
+                        // Save the current caller state.
+                        callers_states_stack.push(CallerState {
+                            fun_idx,
+                            map: saved_map,
+                        });
+                        // Prepare outer variables to go into the new func scope.
+                        fun_idx = *callee_idx;
+                        let function = &toplevel.functions[fun_idx];
+                        push_block_exec_entries!(&function.body);
+                    }
                 }
                 ExecEntry::Op(Op::Store(values)) => {
-                    let len = values
-                        .len()
-                        .try_into()
-                        .expect("Error: too many arguments to store");
-                    let mem_map = load_mem_map_mut(&mut record.mem_queries, len);
-                    let values = values
-                        .iter()
-                        .map(|value| map[value.to_usize()])
-                        .collect::<Vec<_>>();
-                    if let Some(query_result) = mem_map.get_mut(&values) {
-                        query_result.multiplicity += 1;
-                        map.extend(&query_result.result);
+                    let values = values.iter().map(|v| map[*v]).collect::<Vec<_>>();
+                    let size = values.len();
+                    let memory_queries = record
+                        .memory_queries
+                        .get_mut(&size)
+                        .expect("Invalid memory size");
+                    if let Some(result) = memory_queries.get_mut(&values) {
+                        result.multiplicity += G::ONE;
+                        map.extend(&result.output);
                     } else {
-                        let ptr = mem_map.len() as u64;
-                        let query_result = QueryResult {
-                            result: vec![ptr],
-                            multiplicity: 1,
+                        let ptr = G::from_usize(memory_queries.len());
+                        let result = QueryResult {
+                            output: vec![ptr],
+                            multiplicity: G::ONE,
                         };
-                        map.extend(&query_result.result);
-                        mem_map.insert(values, query_result);
+                        memory_queries.insert(values, result);
+                        map.push(ptr);
                     }
                 }
-                ExecEntry::Op(Op::Load(len, ptr)) => {
-                    let ptr = map[ptr.to_usize()]
-                        .try_into()
-                        .expect("Value too big for current architecture");
-                    let mem_map = load_mem_map_mut(&mut record.mem_queries, *len);
-                    let (values, query_result) = mem_map
-                        .get_index_mut(ptr)
-                        .unwrap_or_else(|| panic!("Unbound {len}-wide pointer {ptr}"));
-                    query_result.multiplicity += 1;
-                    map.extend(values);
+                ExecEntry::Op(Op::Load(size, ptr)) => {
+                    let memory_queries = record
+                        .memory_queries
+                        .get_mut(size)
+                        .expect("Invalid memory size");
+                    let ptr = &map[*ptr];
+                    let ptr_u64 = ptr.as_canonical_u64();
+                    let ptr_usize = usize::try_from(ptr_u64).expect("Pointer is too big");
+                    let (args, result) = memory_queries
+                        .get_index_mut(ptr_usize)
+                        .expect("Unbound pointer");
+                    result.multiplicity += G::ONE;
+                    map.extend(args);
                 }
-                ExecEntry::Op(Op::Call(called_func_idx, args, _)) => {
-                    let args = args
-                        .iter()
-                        .map(|ValIdx(v)| map[*v as usize])
-                        .collect::<Vec<_>>();
-                    if let Some(query_result) = record.get_mut(*called_func_idx, &args) {
-                        query_result.multiplicity += 1;
-                        map.extend(query_result.result.clone());
+                ExecEntry::Ctrl(Ctrl::Match(val_idx, cases, default)) => {
+                    let val = &map[*val_idx];
+                    if let Some(block) = cases.get(val) {
+                        push_block_exec_entries!(block);
                     } else {
-                        let input_len = args.len();
-                        // `map_buffer` will become the map for the called function
-                        let mut map_buffer = args;
-                        // Swap so we can save the old map in `map_buffer` and move on
-                        // with `map` already set.
-                        std::mem::swap(&mut map_buffer, &mut map);
-                        callers_states_stack.push(CallerState {
-                            func_idx,
-                            map: map_buffer,
-                        });
-                        // Prepare outer variables to go into the new func scope.
-                        func_idx = *called_func_idx;
-                        let func = &self.functions[func_idx.to_usize()];
-                        assert_eq!(input_len, func.input_size as usize);
-                        stack_block_exec_entries!(&func.body);
+                        let default = default.as_ref().expect("No match");
+                        push_block_exec_entries!(default);
                     }
                 }
-                ExecEntry::Ctrl(Ctrl::Return(_, out)) => {
-                    let out = out
-                        .iter()
-                        .map(|ValIdx(v)| map[*v as usize])
-                        .collect::<Vec<_>>();
-
-                    // Register the result for the current function index.
-                    let query_result = QueryResult {
-                        result: out.clone(),
-                        multiplicity: 1,
+                ExecEntry::Ctrl(Ctrl::Return(_, output)) => {
+                    // Register the query.
+                    let input_size = toplevel.functions[fun_idx].layout.input_size;
+                    let args = map[..input_size].to_vec();
+                    let output = output.iter().map(|i| map[*i]).collect::<Vec<_>>();
+                    let result = QueryResult {
+                        output: output.clone(),
+                        multiplicity: G::ONE,
                     };
-                    let num_inp = self.functions[func_idx.to_usize()].input_size as usize;
-                    let args = map[..num_inp].to_vec();
-                    record.insert(func_idx, args, query_result);
-
-                    // Recover the state of the caller
+                    record.function_queries[fun_idx].insert(args, result);
                     if let Some(CallerState {
-                        func_idx: caller_func_idx,
+                        fun_idx: caller_idx,
                         map: caller_map,
                     }) = callers_states_stack.pop()
                     {
-                        func_idx = caller_func_idx;
+                        // Recover the state of the caller.
+                        fun_idx = caller_idx;
                         map = caller_map;
-                        map.extend(out);
+                        map.extend(output);
                     } else {
-                        // No outer caller... about to exit!
+                        // No outer caller. About to exit.
                         assert!(exec_entries_stack.is_empty());
-                        assert!(callers_states_stack.is_empty());
+                        map = output;
                         break;
                     }
                 }
-                ExecEntry::Ctrl(Ctrl::If(v, tt, ff)) => {
-                    let cond = map[v.to_usize()];
-                    if cond != 0 {
-                        stack_block_exec_entries!(tt);
-                    } else {
-                        stack_block_exec_entries!(ff);
-                    }
-                }
             }
         }
-        record
-    }
-}
-
-fn load_mem_map_mut(
-    mem_queries: &mut [(u32, FxIndexMap<Vec<u64>, QueryResult>)],
-    len: u32,
-) -> &mut FxIndexMap<Vec<u64>, QueryResult> {
-    mem_queries
-        .iter_mut()
-        .find(|(k, _)| *k == len)
-        .map(|(_, v)| v)
-        .unwrap()
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use crate::{
-        aiur::{
-            execute::QueryResult,
-            frontend::expr::toplevel_from_funcs,
-            ir::{FuncIdx, Toplevel},
-        },
-        func,
-    };
-
-    pub(crate) fn factorial_toplevel() -> Toplevel {
-        let func = func!(
-        fn factorial(n): [1] {
-            let one = 1;
-            if n {
-                let pred = sub(n, one);
-                let m = call(factorial, pred);
-                let res = mul(n, m);
-                return res
-            }
-            return one
-        });
-        toplevel_from_funcs(&[func])
-    }
-
-    fn square_toplevel() -> Toplevel {
-        let func = func!(
-        fn square(n): [1] {
-            let m = mul(n, n);
-            return m
-        });
-        toplevel_from_funcs(&[func])
-    }
-
-    fn cube_toplevel() -> Toplevel {
-        let func = func!(
-        fn cube(n): [1] {
-            let tmp = mul(n, n);
-            let m = mul(tmp, n);
-            return m
-        });
-        toplevel_from_funcs(&[func])
-    }
-
-    fn double_toplevel() -> Toplevel {
-        let func = func!(
-        fn double(n): [1] {
-            let two = 2;
-            let m = mul(two, n);
-            return m
-        });
-        toplevel_from_funcs(&[func])
-    }
-
-    fn addition_toplevel() -> Toplevel {
-        let func = func!(
-        fn addition(n): [1] {
-            let m = add(n, n);
-            return m
-        });
-        toplevel_from_funcs(&[func])
-    }
-
-    #[test]
-    fn test_addition() {
-        // Regular computation
-        let val_in = 100u64;
-        let val_out = val_in + val_in;
-
-        // Euir-rs program
-        let func_idx = FuncIdx(0);
-        let input = [val_in];
-        let toplevel = addition_toplevel();
-
-        let result = toplevel.execute(func_idx, input.to_vec());
-        let out = result.get(func_idx, &input).unwrap();
-        assert_eq!(out.result.len(), 1);
-        assert_eq!(&out.result, &[val_out]);
-    }
-
-    #[test]
-    fn test_double() {
-        // Regular computation
-        let val_in = 50u64;
-        let val_out = val_in * 2;
-
-        // Euir-rs program
-        let toplevel = double_toplevel();
-
-        let func_idx = FuncIdx(0);
-        let input = [val_in];
-        let result = toplevel.execute(func_idx, input.to_vec());
-        let out = result
-            .get(func_idx, &input)
-            .expect("requested item is unavailable");
-        assert_eq!(out.result.len(), 1);
-        assert_eq!(&out.result, &[val_out]);
-    }
-
-    #[test]
-    fn test_cube() {
-        // Regular program
-        let val_in = 3u64;
-        let val_out = val_in * val_in * val_in;
-
-        // Aiur-rs program
-        let top_level = cube_toplevel();
-
-        let func_idx = FuncIdx(0);
-        let input = [val_in];
-        let record = top_level.execute(func_idx, input.to_vec());
-        let out = record
-            .get(func_idx, &input)
-            .expect("output of Lair / Aiur program is unavailable");
-
-        assert_eq!(out.result.len(), 1);
-        assert_eq!(&out.result, &[val_out]);
-    }
-
-    #[test]
-    fn test_square() {
-        // Regular computation
-        let val_in = 6u64;
-        let val_out = val_in * val_in;
-
-        // Aiur-rs program
-        let top_level = square_toplevel();
-
-        let func_idx = FuncIdx(0);
-        let input = [val_in];
-        let record = top_level.execute(func_idx, input.to_vec());
-
-        let out = record.get(func_idx, &input).expect("no out available");
-
-        assert_eq!(out.result.len(), 1);
-        assert_eq!(&out.result, &[val_out]);
-    }
-
-    #[test]
-    fn test_factorial() {
-        let toplevel = factorial_toplevel();
-
-        let record = toplevel.execute(FuncIdx(0), vec![5u64]);
-        let pairs: [(u64, u64); 6] = [(0, 1), (1, 1), (2, 2), (3, 6), (4, 24), (5, 120)];
-        for (i, o) in pairs {
-            let query_result = QueryResult {
-                result: vec![o],
-                multiplicity: 1,
-            };
-            assert_eq!(record.get(FuncIdx(0), &[i]), Some(&query_result));
-        }
+        map
     }
 }
diff --git a/src/aiur/frontend/expr.rs b/src/aiur/frontend/expr.rs
deleted file mode 100644
index 1c381ef4..00000000
--- a/src/aiur/frontend/expr.rs
+++ /dev/null
@@ -1,604 +0,0 @@
-//! Aiur's frontend, which uses named references for variables and functions.
-
-use std::fmt::Debug;
-
-use rustc_hash::FxHashMap;
-
-use crate::aiur::{
-    execute::FxIndexMap,
-    ir::{Block, Ctrl, FuncIdx, Function, Name, Op, Prim, SelIdx, Toplevel, ValIdx},
-    layout::func_layout,
-};
-
-/// The type for variable references
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
-pub struct Var {
-    pub name: Ident,
-    pub size: u32,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
-pub enum Ident {
-    User(&'static str),
-    Internal(usize),
-}
-
-impl Var {
-    pub fn atom(name: &'static str) -> Self {
-        Self {
-            name: Ident::User(name),
-            size: 1,
-        }
-    }
-}
-
-impl std::fmt::Display for Var {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.size == 1 {
-            write!(f, "{}", self.name)
-        } else {
-            write!(f, "{}: [{}]", self.name, self.size)
-        }
-    }
-}
-
-impl std::fmt::Display for Ident {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Ident::User(n) => write!(f, "{n}"),
-            Ident::Internal(n) => write!(f, "${n}"),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct VarVec(Vec<Var>);
-
-impl VarVec {
-    #[inline]
-    pub fn total_size(&self) -> u32 {
-        self.0.iter().map(|var| var.size).sum()
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[Var] {
-        &self.0
-    }
-
-    #[inline]
-    pub fn iter(&self) -> core::slice::Iter<'_, Var> {
-        self.as_slice().iter()
-    }
-
-    fn var_list_str(&self) -> String {
-        self.iter()
-            .map(|v| format!("{v}"))
-            .collect::<Vec<_>>()
-            .join(", ")
-    }
-}
-
-impl std::fmt::Display for VarVec {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let s = self.var_list_str();
-        if self.as_slice().len() == 1 {
-            write!(f, "{s}")
-        } else {
-            write!(f, "({s})")
-        }
-    }
-}
-
-impl<const N: usize> From<[Var; N]> for VarVec {
-    fn from(value: [Var; N]) -> Self {
-        Self(value.into())
-    }
-}
-
-impl From<Vec<Var>> for VarVec {
-    fn from(value: Vec<Var>) -> Self {
-        Self(value)
-    }
-}
-
-/// Interface for basic Aiur operations
-#[allow(clippy::type_complexity)]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum OpE {
-    Prim(Var, u64),
-    Add(Var, Var, Var),
-    Sub(Var, Var, Var),
-    Lt(Var, Var, Var),
-    Mul(Var, Var, Var),
-    Store(Var, VarVec),
-    Load(VarVec, Var),
-    Call(VarVec, Name, VarVec),
-}
-
-/// A "code block" containing a sequence of operators and a control node to be
-/// executed afterwards
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct BlockE {
-    pub ops: Vec<OpE>,
-    pub ctrl: CtrlE,
-}
-
-impl BlockE {
-    #[inline]
-    pub fn no_op(ctrl: CtrlE) -> Self {
-        Self {
-            ops: [].into(),
-            ctrl,
-        }
-    }
-}
-
-/// Encodes the logical flow of a Aiur program
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum CtrlE {
-    If(Var, Box<BlockE>, Box<BlockE>),
-    Return(VarVec),
-}
-
-impl CtrlE {
-    #[inline]
-    pub fn return_vars<const N: usize>(vars: [Var; N]) -> Self {
-        Self::Return(vars.into())
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum CaseType {
-    Constrained,
-    Unconstrained,
-}
-
-/// Represents the cases for `CtrlE::Match`, containing the branches for successful
-/// matches and an optional default case in case there's no match. Each code path
-/// is encoded as its own block
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct CasesE<K, B> {
-    pub branches: Vec<(K, B)>,
-    pub default: Option<Box<B>>,
-}
-
-impl<K, B> CasesE<K, B> {
-    #[inline]
-    pub fn no_default(branches: Vec<(K, B)>) -> Self {
-        Self {
-            branches,
-            default: None,
-        }
-    }
-}
-
-/// Abstraction for a Aiur function, which has a name, the input variables, the
-/// size (arity) of the output and, of course, its body (encoded as a block).
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct FunctionE {
-    pub name: Name,
-    pub invertible: bool,
-    pub partial: bool,
-    pub input_params: VarVec,
-    pub output_size: u32,
-    pub body: BlockE,
-}
-
-impl OpE {
-    pub fn pretty(&self) -> String {
-        match self {
-            OpE::Prim(x, c) => {
-                format!("let {x} = {c:?};")
-            }
-            OpE::Add(x, y, z) => {
-                format!("let {x} = add({y}, {z});")
-            }
-            OpE::Sub(x, y, z) => {
-                format!("let {x} = sub({y}, {z});")
-            }
-            OpE::Lt(x, y, z) => {
-                format!("let {x} = lt({y}, {z});")
-            }
-            OpE::Mul(x, y, z) => {
-                format!("let {x} = mul({y}, {z});")
-            }
-            OpE::Call(xs, n, ys) => {
-                format!("let {xs} = call({n}, {});", ys.var_list_str())
-            }
-            OpE::Store(x, ys) => {
-                format!("let {x} = store({});", ys.var_list_str())
-            }
-            OpE::Load(xs, y) => {
-                format!("let {xs} = load({y});")
-            }
-        }
-    }
-}
-
-pub(crate) struct FuncInfo {
-    input_size: u32,
-    output_size: u32,
-    partial: bool,
-}
-
-pub fn toplevel_from_funcs(func_exprs: &[FunctionE]) -> Toplevel {
-    let info_map = func_exprs
-        .iter()
-        .map(|func| {
-            let func_info = FuncInfo {
-                input_size: func.input_params.total_size(),
-                output_size: func.output_size,
-                partial: func.partial,
-            };
-            (func.name, func_info)
-        })
-        .collect();
-    let functions: Vec<_> = func_exprs
-        .iter()
-        .map(|func| {
-            func.check(&info_map);
-            func.compile(&info_map)
-        })
-        .collect();
-    let mut mem_sizes = Vec::new();
-    let layouts = functions
-        .iter()
-        .map(|f| func_layout(f, &mut mem_sizes))
-        .collect();
-    Toplevel {
-        functions,
-        layouts,
-        mem_widths: mem_sizes,
-    }
-}
-
-/// A map from `Var` its block identifier. Variables in this map are always bound
-type BindMap = FxHashMap<Var, usize>;
-
-/// A map that tells whether a `Var`, from a certain block, has been used or not
-type UsedMap = FxHashMap<(Var, usize), bool>;
-
-/// A map from `Var` to its compiled indices
-type LinkMap = FxHashMap<Var, Vec<ValIdx>>;
-
-impl Var {
-    fn check_unused_var(&self, used: bool) {
-        let Ident::User(name) = self.name else {
-            unreachable!()
-        };
-        let ch = name.chars().next().expect("Empty var name");
-        assert!(
-            used || ch == '_',
-            "Variable {self} not used. If intended, please prefix it with \"_\""
-        );
-    }
-}
-
-#[inline]
-/// Binds a new variable. If a variable of the same name, in the same block, is shadowed,
-/// then it ensures the variable has been used at least once or starts with '_'
-fn bind_var(var: &Var, ctx: &mut CheckCtx<'_>) {
-    ctx.bind_map.insert(*var, ctx.block_ident);
-    if let Some(used) = ctx.used_map.insert((*var, ctx.block_ident), false) {
-        var.check_unused_var(used)
-    }
-}
-
-#[inline]
-/// Marks a variable as used
-fn use_var(var: &Var, ctx: &mut CheckCtx<'_>) {
-    let block_idx = ctx
-        .bind_map
-        .get(var)
-        .unwrap_or_else(|| panic!("Variable {var} is unbound."));
-    let used = ctx
-        .used_map
-        .get_mut(&(*var, *block_idx))
-        .expect("Data should have been inserted when binding");
-    *used = true;
-}
-
-#[inline]
-/// Links a variable name to a list of fresh indices
-fn link_new(var: &Var, ctx: &mut LinkCtx<'_>) {
-    let idxs = (0..var.size).map(|_| ctx.new_var()).collect();
-    link(var, idxs, ctx);
-}
-
-#[inline]
-/// Links a variable name to a given list of indices
-fn link(var: &Var, idxs: Vec<ValIdx>, ctx: &mut LinkCtx<'_>) {
-    ctx.link_map.insert(*var, idxs);
-}
-
-#[inline]
-/// Retrieves the indices of a given variable
-fn get_var<'a>(var: &Var, ctx: &'a mut LinkCtx<'_>) -> &'a [ValIdx] {
-    ctx.link_map
-        .get(var)
-        .unwrap_or_else(|| panic!("Variable {var} is unbound."))
-}
-
-/// Context struct of `check`
-struct CheckCtx<'a> {
-    block_ident: usize,
-    return_size: u32,
-    partial: bool,
-    bind_map: BindMap,
-    used_map: UsedMap,
-    info_map: &'a FxIndexMap<Name, FuncInfo>,
-}
-
-/// Context struct of `compile`
-struct LinkCtx<'a> {
-    var_index: ValIdx,
-    return_ident: SelIdx,
-    return_idents: Vec<SelIdx>,
-    link_map: LinkMap,
-    info_map: &'a FxIndexMap<Name, FuncInfo>,
-}
-
-impl CheckCtx<'_> {
-    fn save_state(&mut self) -> BindMap {
-        self.bind_map.clone()
-    }
-
-    fn restore_state(&mut self, bind_map: BindMap) {
-        self.bind_map = bind_map;
-    }
-}
-
-impl LinkCtx<'_> {
-    fn save_state(&mut self) -> (ValIdx, LinkMap) {
-        (self.var_index, self.link_map.clone())
-    }
-
-    fn restore_state(&mut self, (index, link_map): (ValIdx, LinkMap)) {
-        self.var_index = index;
-        self.link_map = link_map;
-    }
-
-    fn new_var(&mut self) -> ValIdx {
-        let var = self.var_index;
-        self.var_index.0 += 1;
-        var
-    }
-}
-
-impl FunctionE {
-    /// Checks that a Aiur function is well formed
-    fn check(&self, info_map: &FxIndexMap<Name, FuncInfo>) {
-        let ctx = &mut CheckCtx {
-            block_ident: 0,
-            return_size: self.output_size,
-            partial: self.partial,
-            bind_map: FxHashMap::default(),
-            used_map: FxHashMap::default(),
-            info_map,
-        };
-        self.input_params.iter().for_each(|var| {
-            bind_var(var, ctx);
-        });
-        self.body.check(ctx);
-        for ((var, _), used) in ctx.used_map.iter() {
-            var.check_unused_var(*used)
-        }
-    }
-
-    /// Compile a Aiur function into bytecode
-    fn compile(&self, info_map: &FxIndexMap<Name, FuncInfo>) -> Function {
-        let ctx = &mut LinkCtx {
-            var_index: ValIdx(0),
-            return_ident: SelIdx(0),
-            return_idents: vec![],
-            link_map: FxHashMap::default(),
-            info_map,
-        };
-        self.input_params.iter().for_each(|var| {
-            link_new(var, ctx);
-        });
-        let body = self.body.compile(ctx);
-        let input_size = self.input_params.total_size();
-        let output_size = self.output_size;
-        Function {
-            name: self.name,
-            body,
-            input_size,
-            output_size,
-        }
-    }
-}
-
-impl BlockE {
-    fn check(&self, ctx: &mut CheckCtx<'_>) {
-        self.ops.iter().for_each(|op| op.check(ctx));
-        self.ctrl.check(ctx);
-    }
-
-    fn compile(&self, ctx: &mut LinkCtx<'_>) -> Block {
-        let mut ops = vec![];
-        self.ops.iter().for_each(|op| op.compile(&mut ops, ctx));
-        let saved_return_idents = std::mem::take(&mut ctx.return_idents);
-        let ctrl = self.ctrl.compile(ctx).into();
-        let block_return_idents = std::mem::take(&mut ctx.return_idents);
-        // sanity check
-        assert!(
-            !block_return_idents.is_empty(),
-            "A block must have at least one return ident"
-        );
-        ctx.return_idents = saved_return_idents;
-        ctx.return_idents.extend(&block_return_idents);
-        Block {
-            ops,
-            ctrl,
-            return_idents: block_return_idents,
-        }
-    }
-}
-
-impl CtrlE {
-    fn check(&self, ctx: &mut CheckCtx<'_>) {
-        match &self {
-            CtrlE::Return(return_vars) => {
-                let total_size = return_vars.total_size();
-                assert_eq!(
-                    total_size, ctx.return_size,
-                    "Return size {} different from expected size of return {}",
-                    total_size, ctx.return_size
-                );
-                return_vars.iter().for_each(|arg| use_var(arg, ctx));
-            }
-            CtrlE::If(b, true_block, false_block) => {
-                use_var(b, ctx);
-
-                let state = ctx.save_state();
-                ctx.block_ident += 1;
-                true_block.check(ctx);
-                ctx.restore_state(state);
-
-                let state = ctx.save_state();
-                ctx.block_ident += 1;
-                false_block.check(ctx);
-                ctx.restore_state(state);
-            }
-        }
-    }
-
-    fn compile(&self, ctx: &mut LinkCtx<'_>) -> Ctrl {
-        match &self {
-            CtrlE::Return(return_vars) => {
-                let return_vec = return_vars
-                    .iter()
-                    .flat_map(|arg| get_var(arg, ctx).to_vec())
-                    .collect();
-                let ctrl = Ctrl::Return(ctx.return_ident, return_vec);
-                ctx.return_idents.push(ctx.return_ident);
-                ctx.return_ident.0 += 1;
-                ctrl
-            }
-            CtrlE::If(b, t, f) => {
-                let b = get_var(b, ctx)[0];
-                let state = ctx.save_state();
-                let t = t.compile(ctx);
-                ctx.restore_state(state);
-                let state = ctx.save_state();
-                let f = f.compile(ctx);
-                ctx.restore_state(state);
-                Ctrl::If(b, t, f)
-            }
-        }
-    }
-}
-
-impl OpE {
-    fn check(&self, ctx: &mut CheckCtx<'_>) {
-        match self {
-            OpE::Prim(tgt, _) => {
-                assert_eq!(tgt.size, 1, "Var mismatch on `{}`", self.pretty());
-                bind_var(tgt, ctx);
-            }
-            OpE::Add(tgt, a, b)
-            | OpE::Sub(tgt, a, b)
-            | OpE::Lt(tgt, a, b)
-            | OpE::Mul(tgt, a, b) => {
-                assert_eq!(a.size, 1, "Var mismatch on `{}`", self.pretty());
-                assert_eq!(b.size, 1, "Var mismatch on `{}`", self.pretty());
-                assert_eq!(tgt.size, 1, "Var mismatch on `{}`", self.pretty());
-                use_var(a, ctx);
-                use_var(b, ctx);
-                bind_var(tgt, ctx);
-            }
-            OpE::Call(out, name, inp) => {
-                let info = ctx
-                    .info_map
-                    .get(name)
-                    .unwrap_or_else(|| panic!("Unknown function {name}"));
-                let FuncInfo {
-                    input_size,
-                    output_size,
-                    partial,
-                } = *info;
-                if partial {
-                    assert!(ctx.partial);
-                }
-                assert_eq!(
-                    inp.total_size(),
-                    input_size,
-                    "Input mismatch on `{}`",
-                    self.pretty()
-                );
-                assert_eq!(
-                    out.total_size(),
-                    output_size,
-                    "Output mismatch on `{}`",
-                    self.pretty()
-                );
-                inp.iter().for_each(|a| use_var(a, ctx));
-                out.iter().for_each(|t| bind_var(t, ctx));
-            }
-            OpE::Store(ptr, vals) => {
-                assert_eq!(ptr.size, 1, "Var mismatch on `{}`", self.pretty());
-                vals.iter().for_each(|a| use_var(a, ctx));
-                bind_var(ptr, ctx);
-            }
-            OpE::Load(vals, ptr) => {
-                assert_eq!(ptr.size, 1, "Var mismatch on `{}`", self.pretty());
-                use_var(ptr, ctx);
-                vals.iter().for_each(|val| bind_var(val, ctx));
-            }
-        }
-    }
-
-    fn compile(&self, ops: &mut Vec<Op>, ctx: &mut LinkCtx<'_>) {
-        match self {
-            OpE::Prim(tgt, f) => {
-                ops.push(Op::Prim(Prim::U64(*f)));
-                link_new(tgt, ctx);
-            }
-            OpE::Add(tgt, a, b) => {
-                let a = get_var(a, ctx)[0];
-                let b = get_var(b, ctx)[0];
-                ops.push(Op::Add(a, b));
-                link_new(tgt, ctx);
-            }
-            OpE::Sub(tgt, a, b) => {
-                let a = get_var(a, ctx)[0];
-                let b = get_var(b, ctx)[0];
-                ops.push(Op::Sub(a, b));
-                link_new(tgt, ctx);
-            }
-            OpE::Lt(tgt, a, b) => {
-                let a = get_var(a, ctx)[0];
-                let b = get_var(b, ctx)[0];
-                ops.push(Op::Lt(a, b));
-                link_new(tgt, ctx);
-            }
-            OpE::Mul(tgt, a, b) => {
-                let a = get_var(a, ctx)[0];
-                let b = get_var(b, ctx)[0];
-                ops.push(Op::Mul(a, b));
-                link_new(tgt, ctx);
-            }
-            OpE::Call(out, name, inp) => {
-                let (idx, _, info) = ctx
-                    .info_map
-                    .get_full(name)
-                    .unwrap_or_else(|| panic!("Unknown function {name}"));
-                let name_idx = FuncIdx(idx.try_into().expect("Too many functions"));
-                let inp = inp.iter().flat_map(|a| get_var(a, ctx).to_vec()).collect();
-                ops.push(Op::Call(name_idx, inp, info.output_size));
-                out.iter().for_each(|t| link_new(t, ctx));
-            }
-            OpE::Store(ptr, vals) => {
-                let vals = vals.iter().flat_map(|a| get_var(a, ctx).to_vec()).collect();
-                ops.push(Op::Store(vals));
-                link_new(ptr, ctx);
-            }
-            OpE::Load(vals, ptr) => {
-                let ptr = get_var(ptr, ctx)[0];
-                ops.push(Op::Load(vals.total_size(), ptr));
-                vals.iter().for_each(|val| link_new(val, ctx));
-            }
-        }
-    }
-}
diff --git a/src/aiur/frontend/macros.rs b/src/aiur/frontend/macros.rs
deleted file mode 100644
index 1f59d3ad..00000000
--- a/src/aiur/frontend/macros.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-#[macro_export]
-macro_rules! func {
-    (fn $name:ident($( $in:ident $(: [$in_size:expr])? ),*): [$size:expr] $aiur:tt) => {{
-        $(let $in = $crate::var!($in $(, $in_size)?);)*
-        $crate::aiur::frontend::expr::FunctionE {
-            name: stringify!($name),
-            invertible: false,
-            partial: false,
-            input_params: [$($crate::var!($in $(, $in_size)?)),*].into(),
-            output_size: $size,
-            body: $crate::block_init!($aiur),
-        }
-    }};
-    (partial fn $name:ident($( $in:ident $(: [$in_size:expr])? ),*): [$size:expr] $aiur:tt) => {{
-        $(let $in = $crate::var!($in $(, $in_size)?);)*
-        $crate::aiur::frontend::expr::FunctionE {
-            name: stringify!($name),
-            invertible: false,
-            partial: true,
-            input_params: [$($crate::var!($in $(, $in_size)?)),*].into(),
-            output_size: $size,
-            body: $crate::block_init!($aiur),
-        }
-    }};
-    (invertible fn $name:ident($( $in:ident $(: [$in_size:expr])? ),*): [$size:expr] $aiur:tt) => {{
-        $(let $in = $crate::var!($in $(, $in_size)?);)*
-        $crate::aiur::frontend::expr::FunctionE {
-            name: stringify!($name),
-            invertible: true,
-            partial: false,
-            input_params: [$($crate::var!($in $(, $in_size)?)),*].into(),
-            output_size: $size,
-            body: $crate::block_init!($aiur),
-        }
-    }};
-    (invertible partial fn $name:ident($( $in:ident $(: [$in_size:expr])? ),*): [$size:expr] $aiur:tt) => {{
-        $(let $in = $crate::var!($in $(, $in_size)?);)*
-        $crate::aiur::frontend::expr::FunctionE {
-            name: stringify!($name),
-            invertible: true,
-            partial: true,
-            input_params: [$($crate::var!($in $(, $in_size)?)),*].into(),
-            output_size: $size,
-            body: $crate::block_init!($aiur),
-        }
-    }};
-}
-
-#[macro_export]
-macro_rules! var {
-    ($variable:ident) => {{
-        let name = $crate::aiur::frontend::expr::Ident::User(stringify!($variable));
-        $crate::aiur::frontend::expr::Var { name, size: 1 }
-    }};
-    ($variable:ident, $size:expr) => {{
-        let name = $crate::aiur::frontend::expr::Ident::User(stringify!($variable));
-        $crate::aiur::frontend::expr::Var { name, size: $size }
-    }};
-}
-
-#[macro_export]
-macro_rules! block_init {
-    ({ #[unconstrained] $($body:tt)+ }) => {{
-        #[allow(unused_mut)]
-        let mut ops = vec![];
-        $crate::block!({ $($body)+ }, ops)
-    }};
-    ({ $($body:tt)+ }) => {{
-        #[allow(unused_mut)]
-        let mut ops = vec![];
-        $crate::block!({ $($body)+ }, ops)
-    }}
-}
-
-#[macro_export]
-macro_rules! block {
-    // Operations
-    ({ let $tgt:ident = $a:literal; $($tail:tt)+ }, $ops:expr) => {{
-        $ops.push($crate::aiur::frontend::expr::OpE::Prim($crate::var!($tgt), $a));
-        let $tgt = $crate::var!($tgt);
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let $tgt:ident = add($a:ident, $b:ident); $($tail:tt)+ }, $ops:expr) => {{
-        let tgt_size = $a.size;
-        $ops.push($crate::aiur::frontend::expr::OpE::Add($crate::var!($tgt, tgt_size), $a, $b));
-        let $tgt = $crate::var!($tgt, tgt_size);
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let $tgt:ident = sub($a:ident, $b:ident); $($tail:tt)+ }, $ops:expr) => {{
-        let tgt_size = $a.size;
-        $ops.push($crate::aiur::frontend::expr::OpE::Sub($crate::var!($tgt, tgt_size), $a, $b));
-        let $tgt = $crate::var!($tgt, tgt_size);
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let $tgt:ident = lt($a:ident, $b:ident); $($tail:tt)+ }, $ops:expr) => {{
-        let tgt_size = $a.size;
-        $ops.push($crate::aiur::frontend::expr::OpE::Lt($crate::var!($tgt, tgt_size), $a, $b));
-        let $tgt = $crate::var!($tgt, tgt_size);
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let $tgt:ident = mul($a:ident, $b:ident); $($tail:tt)+ }, $ops:expr) => {{
-        let tgt_size = $a.size;
-        $ops.push($crate::aiur::frontend::expr::OpE::Mul($crate::var!($tgt, tgt_size), $a, $b));
-        let $tgt = $crate::var!($tgt, tgt_size);
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let $tgt:ident = store($($arg:ident),*); $($tail:tt)+ }, $ops:expr) => {{
-        let inp = [$($arg),*].into();
-        $ops.push($crate::aiur::frontend::expr::OpE::Store($crate::var!($tgt), inp));
-        let $tgt = $crate::var!($tgt);
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let $tgt:ident $(: [$size:expr])? = load($arg:ident); $($tail:tt)+ }, $ops:expr) => {{
-        let out = [$crate::var!($tgt $(, $size)?)].into();
-        $ops.push($crate::aiur::frontend::expr::OpE::Load(out, $arg));
-        let $tgt = $crate::var!($tgt $(, $size)?);
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let ($($tgt:ident $(: [$size:expr])?),*) = load($arg:ident); $($tail:tt)+ }, $ops:expr) => {{
-        let out = [$($crate::var!($tgt $(, $size)?)),*].into();
-        $ops.push($crate::aiur::frontend::expr::OpE::Load(out, $arg));
-        $(let $tgt = $crate::var!($tgt $(, $size)?);)*
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let ($($tgt:ident $(: [$size:expr])?),*) = call($name:ident, $($arg:ident),*); $($tail:tt)+ }, $ops:expr) => {{
-        let func = stringify!($name);
-        let out = [$($crate::var!($tgt $(, $size)?)),*].into();
-        let inp = [$($arg),*].into();
-        $ops.push($crate::aiur::frontend::expr::OpE::Call(out, func, inp));
-        $(let $tgt = $crate::var!($tgt $(, $size)?);)*
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let $tgt:ident $(: [$size:expr])? = call($name:ident, $($arg:ident),*); $($tail:tt)+ }, $ops:expr) => {{
-        let func = stringify!($name);
-        let out = [$crate::var!($tgt $(, $size)?)].into();
-        let inp = [$($arg),*].into();
-        $ops.push($crate::aiur::frontend::expr::OpE::Call(out, func, inp));
-        let $tgt = $crate::var!($tgt $(, $size)?);
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    ({ let ($($tgt:ident $(: [$size:expr])?),*) = extern_call($name:ident, $($arg:ident),*); $($tail:tt)+ }, $ops:expr) => {{
-        let func = stringify!($name);
-        let out = [$($crate::var!($tgt $(, $size)?)),*].into();
-        let inp = [$($arg),*].into();
-        $ops.push($crate::aiur::frontend::expr::OpE::ExternCall(out, func, inp));
-        $(let $tgt = $crate::var!($tgt $(, $size)?);)*
-        $crate::block!({ $($tail)* }, $ops)
-    }};
-    // Control statements
-    ({ return ($($src:ident),*) }, $ops:expr) => {{
-        let ops = $ops.into();
-        let ctrl = $crate::aiur::frontend::expr::CtrlE::Return([$($src),*].into());
-        $crate::aiur::frontend::expr::BlockE { ops, ctrl }
-    }};
-    ({ return $src:ident }, $ops:expr) => {{
-        let ops = $ops.into();
-        let ctrl = $crate::aiur::frontend::expr::CtrlE::Return([$src].into());
-        $crate::aiur::frontend::expr::BlockE { ops, ctrl }
-    }};
-    ({ if $x:ident { $($true_block:tt)+ } $($false_block:tt)+ }, $ops:expr) => {{
-        let ops = $ops.into();
-        let true_block = Box::new($crate::block_init!({ $($true_block)+ }));
-        let false_block = Box::new($crate::block_init!({ $($false_block)+ }));
-        let ctrl = $crate::aiur::frontend::expr::CtrlE::If($x, true_block, false_block);
-        $crate::aiur::frontend::expr::BlockE { ops, ctrl }
-    }};
-    ({ if !$x:ident { $($true_block:tt)+ } $($false_block:tt)+ }, $ops:expr) => {{
-        let ops = $ops.into();
-        let true_block = Box::new($crate::block_init!({ $($true_block)+ }));
-        let false_block = Box::new($crate::block_init!({ $($false_block)+ }));
-        let ctrl = $crate::aiur::frontend::expr::CtrlE::If($x, false_block, true_block);
-        $crate::aiur::frontend::expr::BlockE { ops, ctrl }
-    }};
-}
-
-#[macro_export]
-macro_rules! constrained {
-    ({ #[unconstrained] $($body:tt)+ }) => {
-        $crate::aiur::frontend::expr::CaseType::Unconstrained
-    };
-    ({ $($body:tt)+ }) => {
-        $crate::aiur::frontend::expr::CaseType::Constrained
-    };
-}
diff --git a/src/aiur/frontend/mod.rs b/src/aiur/frontend/mod.rs
deleted file mode 100644
index beba92f6..00000000
--- a/src/aiur/frontend/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub mod expr;
-pub mod macros;
diff --git a/src/aiur/gadgets/binius.rs b/src/aiur/gadgets/binius.rs
deleted file mode 100644
index f562b774..00000000
--- a/src/aiur/gadgets/binius.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use binius_circuits::builder::witness::Builder;
-use binius_core::constraint_system::ConstraintSystem;
-use binius_field::BinaryField128b;
-use bumpalo::Bump;
-use std::{cell::RefCell, rc::Rc};
-
-#[inline]
-pub fn witness_builder<'a>(
-    allocator: &'a Bump,
-    cs: &ConstraintSystem<BinaryField128b>,
-) -> Builder<'a> {
-    // The following clone is cheap because `MultilinearOracleSet` is a wrapper
-    // around a `Vec<Arc<_>>`.
-    Builder::new(allocator, Rc::new(RefCell::new(cs.oracles.clone())))
-}
diff --git a/src/aiur/gadgets/mod.rs b/src/aiur/gadgets/mod.rs
deleted file mode 100644
index 56cba4e4..00000000
--- a/src/aiur/gadgets/mod.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-pub mod binius;
-pub mod uint_add;
-pub mod uint_sub;
-
-use anyhow::Result;
-use binius_circuits::builder::{ConstraintSystemBuilder, witness::Builder};
-use binius_core::oracle::OracleId;
-
-/// Trait for Aiur-compatible gadgets
-pub trait Gadget {
-    /// Type for the set of input oracles, usually associated with committed columns
-    type InputOracles;
-    /// Type for the set of virtual columns, returned by the constraining algorithm
-    type VirtualOracles;
-    /// Type for arbitrary configurations that a gadget may receive
-    type Config;
-    /// Creates the constraints for the gadget. New columns, if needed, should be
-    /// transparent and returned. The constraints should be relaxed where `enabled`
-    /// is zero.
-    fn constrain(
-        builder: &mut ConstraintSystemBuilder<'_>,
-        name: impl ToString,
-        input: Self::InputOracles,
-        enabled: OracleId,
-        config: Self::Config,
-    ) -> Result<Self::VirtualOracles>;
-    /// Populates the columns with witness data that satisfy the constraints.
-    fn generate_witness(
-        builder: &mut Builder<'_>,
-        input: Self::InputOracles,
-        vrtual: Self::VirtualOracles,
-        config: Self::Config,
-    ) -> Result<()>;
-}
-
-pub enum UIntType {
-    U8,
-    U16,
-    U32,
-    U64,
-}
-
-impl UIntType {
-    const fn n_vars(&self) -> usize {
-        match self {
-            Self::U8 => 3,
-            Self::U16 => 4,
-            Self::U32 => 5,
-            Self::U64 => 6,
-        }
-    }
-}
diff --git a/src/aiur/gadgets/uint_add.rs b/src/aiur/gadgets/uint_add.rs
deleted file mode 100644
index 343576ad..00000000
--- a/src/aiur/gadgets/uint_add.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-use anyhow::Result;
-use binius_circuits::builder::{ConstraintSystemBuilder, witness::Builder};
-use binius_core::oracle::{OracleId, ShiftVariant};
-use binius_field::BinaryField1b as B1;
-use binius_macros::arith_expr;
-use rayon::prelude::*;
-
-use super::{Gadget, UIntType};
-
-/// Gadget for overflowing addition over unsigned integers
-pub struct UIntAdd;
-
-#[derive(Clone, Copy)]
-pub struct UIntAddInput {
-    pub xin: OracleId,
-    pub yin: OracleId,
-    pub zout: OracleId,
-    pub cout: OracleId,
-}
-
-pub struct UIntAddVirtual {
-    pub cin: OracleId,
-}
-
-impl Gadget for UIntAdd {
-    type InputOracles = UIntAddInput;
-    type VirtualOracles = UIntAddVirtual;
-    type Config = UIntType;
-
-    fn constrain(
-        builder: &mut ConstraintSystemBuilder<'_>,
-        name: impl ToString,
-        input: UIntAddInput,
-        enabled: OracleId,
-        config: UIntType,
-    ) -> Result<UIntAddVirtual> {
-        builder.push_namespace(name);
-        let UIntAddInput {
-            xin,
-            yin,
-            zout,
-            cout,
-        } = input;
-        let n_vars = config.n_vars();
-        let cin = builder.add_shifted("cin", cout, 1, n_vars, ShiftVariant::LogicalLeft)?;
-
-        builder.assert_zero(
-            "sum",
-            [xin, yin, cin, zout, enabled],
-            arith_expr!([xin, yin, cin, zout, enabled] = enabled * (xin + yin + cin - zout))
-                .convert_field(),
-        );
-
-        builder.assert_zero(
-            "carry",
-            [xin, yin, cin, cout, enabled],
-            arith_expr!(
-                [xin, yin, cin, cout, enabled] = enabled * ((xin + cin) * (yin + cin) + cin - cout)
-            )
-            .convert_field(),
-        );
-
-        builder.pop_namespace();
-        Ok(UIntAddVirtual { cin })
-    }
-
-    /// Populates new columns for `zout`, `cout` and `cin` based on the values
-    /// from `xin` and `yin`.
-    fn generate_witness(
-        builder: &mut Builder<'_>,
-        input: UIntAddInput,
-        vrtual: UIntAddVirtual,
-        config: UIntType,
-    ) -> Result<()> {
-        let UIntAddInput {
-            xin,
-            yin,
-            zout,
-            cout,
-        } = input;
-        let UIntAddVirtual { cin } = vrtual;
-        macro_rules! witgen {
-            ($t:ty, $lsbits:expr) => {
-                (
-                    builder.get::<B1>(xin)?.as_slice::<$t>(),
-                    builder.get::<B1>(yin)?.as_slice::<$t>(),
-                    builder.new_column::<B1>(zout).as_mut_slice::<$t>(),
-                    builder.new_column::<B1>(cout).as_mut_slice::<$t>(),
-                    builder.new_column::<B1>(cin).as_mut_slice::<$t>(),
-                )
-                    .into_par_iter()
-                    .for_each(|(xin, yin, zout, cout, cin)| {
-                        let carry;
-                        (*zout, carry) = xin.overflowing_add(*yin);
-                        *cin = xin ^ yin ^ *zout;
-                        *cout = ((carry as $t) << $lsbits) | (*cin >> 1);
-                    })
-            };
-        }
-        match config {
-            UIntType::U8 => witgen!(u8, 7),
-            UIntType::U16 => witgen!(u16, 15),
-            UIntType::U32 => witgen!(u32, 31),
-            UIntType::U64 => witgen!(u64, 63),
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use binius_circuits::builder::{ConstraintSystemBuilder, witness::Builder};
-    use binius_core::constraint_system::validate::validate_witness;
-    use binius_field::{BinaryField1b as B1, TowerField, underlier::SmallU};
-    use bumpalo::Bump;
-    use proptest::{collection::vec, prelude::*};
-
-    use crate::aiur::gadgets::{
-        Gadget,
-        binius::witness_builder,
-        uint_add::{UIntAdd, UIntAddInput, UIntType},
-    };
-    const LEN: usize = 16;
-
-    macro_rules! auto_test {
-        ($fn:ident, $cfg:expr, $t:ty) => {
-            #[test]
-            fn $fn() {
-                const N_VARS: usize = $cfg.n_vars() + LEN.ilog2() as usize;
-
-                proptest!(|(
-                    vec1 in vec(any::<$t>(), LEN),
-                    vec2 in vec(any::<$t>(), LEN),
-                )| {
-                    let mut csb = ConstraintSystemBuilder::new();
-                    let xin = csb.add_committed("xin", N_VARS, B1::TOWER_LEVEL);
-                    let yin = csb.add_committed("yin", N_VARS, B1::TOWER_LEVEL);
-                    let cout = csb.add_committed("cout", N_VARS, B1::TOWER_LEVEL);
-                    let zout = csb.add_committed("zout", N_VARS, B1::TOWER_LEVEL);
-                    let enabled = csb.add_committed("enabled", N_VARS, B1::TOWER_LEVEL);
-
-                    let input = UIntAddInput {xin, yin, zout, cout};
-                    let transparent = UIntAdd::constrain(&mut csb, "add", input, enabled, $cfg).unwrap();
-
-                    let cs = csb.build().unwrap();
-
-                    let allocator = Bump::new();
-                    let mut wb: Builder<'_> = witness_builder(&allocator, &cs);
-
-                    wb.new_column::<B1>(xin).as_mut_slice().copy_from_slice(&vec1);
-                    wb.new_column::<B1>(yin).as_mut_slice().copy_from_slice(&vec2);
-                    wb.new_column_with_default(enabled, B1::new(SmallU::new(1)));
-
-                    UIntAdd::generate_witness(&mut wb, input, transparent, $cfg).unwrap();
-
-                    let res = vec1.into_iter().zip(vec2).map(|(a, b)| a.overflowing_add(b).0).collect::<Vec<_>>();
-                    prop_assert_eq!(wb.get::<B1>(zout).unwrap().as_slice::<$t>(), &res);
-
-                    let w = wb.build().unwrap();
-
-                    prop_assert!(validate_witness(&cs, &[], &w).is_ok());
-                });
-            }
-        };
-    }
-
-    auto_test!(test_add_u8, UIntType::U8, u8);
-    auto_test!(test_add_u16, UIntType::U16, u16);
-    auto_test!(test_add_u32, UIntType::U32, u32);
-    auto_test!(test_add_u64, UIntType::U64, u64);
-}
diff --git a/src/aiur/gadgets/uint_sub.rs b/src/aiur/gadgets/uint_sub.rs
deleted file mode 100644
index 16aec51b..00000000
--- a/src/aiur/gadgets/uint_sub.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-use anyhow::Result;
-use binius_circuits::builder::{ConstraintSystemBuilder, witness::Builder};
-use binius_core::oracle::OracleId;
-use binius_field::BinaryField1b as B1;
-use rayon::prelude::*;
-
-use super::{
-    Gadget, UIntType,
-    uint_add::{UIntAdd, UIntAddInput, UIntAddVirtual},
-};
-
-/// Gadget for underflowing subtraction over unsigned integers
-pub struct UIntSub;
-
-#[derive(Clone, Copy)]
-pub struct UIntSubInput {
-    zin: OracleId,
-    yin: OracleId,
-    cout: OracleId,
-    xout: OracleId,
-}
-
-pub struct UIntSubVirtual {
-    cin: OracleId,
-}
-
-impl Gadget for UIntSub {
-    type InputOracles = UIntSubInput;
-    type VirtualOracles = UIntSubVirtual;
-    type Config = UIntType;
-
-    fn constrain(
-        builder: &mut ConstraintSystemBuilder<'_>,
-        name: impl ToString,
-        input: UIntSubInput,
-        enabled: OracleId,
-        config: UIntType,
-    ) -> Result<UIntSubVirtual> {
-        builder.push_namespace(name);
-        let UIntSubInput {
-            zin,
-            yin,
-            cout,
-            xout,
-        } = input;
-        let add_input = UIntAddInput {
-            xin: xout,
-            yin,
-            cout,
-            zout: zin,
-        };
-        let UIntAddVirtual { cin } =
-            UIntAdd::constrain(builder, "add", add_input, enabled, config)?;
-        builder.pop_namespace();
-        Ok(UIntSubVirtual { cin })
-    }
-
-    /// Populates new columns for `xout`, `cout` and `cin` based on the values
-    /// from `zin` and `yin`.
-    fn generate_witness(
-        builder: &mut Builder<'_>,
-        input: UIntSubInput,
-        vrtual: UIntSubVirtual,
-        config: UIntType,
-    ) -> Result<()> {
-        let UIntSubInput {
-            zin,
-            yin,
-            cout,
-            xout,
-        } = input;
-        let UIntSubVirtual { cin } = vrtual;
-        macro_rules! witgen {
-            ($t:ty, $lsbits:expr) => {
-                (
-                    builder.get::<B1>(zin)?.as_slice::<$t>(),
-                    builder.get::<B1>(yin)?.as_slice::<$t>(),
-                    builder.new_column::<B1>(xout).as_mut_slice::<$t>(),
-                    builder.new_column::<B1>(cout).as_mut_slice::<$t>(),
-                    builder.new_column::<B1>(cin).as_mut_slice::<$t>(),
-                )
-                    .into_par_iter()
-                    .for_each(|(zout, yin, xin, cout, cin)| {
-                        let carry;
-                        (*xin, carry) = (*zout).overflowing_sub(*yin);
-                        *cin = (*xin) ^ (*yin) ^ (*zout);
-                        *cout = ((carry as $t) << $lsbits) | (*cin >> 1);
-                    })
-            };
-        }
-        match config {
-            UIntType::U8 => witgen!(u8, 7),
-            UIntType::U16 => witgen!(u16, 15),
-            UIntType::U32 => witgen!(u32, 31),
-            UIntType::U64 => witgen!(u64, 63),
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use binius_circuits::builder::{ConstraintSystemBuilder, witness::Builder};
-    use binius_core::constraint_system::validate::validate_witness;
-    use binius_field::{BinaryField1b as B1, TowerField, underlier::SmallU};
-    use bumpalo::Bump;
-    use proptest::{collection::vec, prelude::*};
-
-    use crate::aiur::gadgets::{
-        Gadget, UIntType,
-        binius::witness_builder,
-        uint_sub::{UIntSub, UIntSubInput},
-    };
-    const LEN: usize = 16;
-
-    macro_rules! auto_test {
-        ($fn:ident, $cfg:expr, $t:ty) => {
-            #[test]
-            fn $fn() {
-                const N_VARS: usize = $cfg.n_vars() + LEN.ilog2() as usize;
-
-                proptest!(|(
-                    vec1 in vec(any::<$t>(), LEN),
-                    vec2 in vec(any::<$t>(), LEN),
-                )| {
-                    let mut csb = ConstraintSystemBuilder::new();
-                    let zin = csb.add_committed("zin", N_VARS, B1::TOWER_LEVEL);
-                    let yin = csb.add_committed("yin", N_VARS, B1::TOWER_LEVEL);
-                    let cout = csb.add_committed("cout", N_VARS, B1::TOWER_LEVEL);
-                    let xout = csb.add_committed("xout", N_VARS, B1::TOWER_LEVEL);
-                    let enabled = csb.add_committed("enabled", N_VARS, B1::TOWER_LEVEL);
-
-                    let input = UIntSubInput {zin, yin, cout, xout};
-                    let transparent = UIntSub::constrain(&mut csb, "sub", input, enabled, $cfg).unwrap();
-
-                    let cs = csb.build().unwrap();
-
-                    let allocator = Bump::new();
-                    let mut wb: Builder<'_> = witness_builder(&allocator, &cs);
-
-                    wb.new_column::<B1>(zin).as_mut_slice().copy_from_slice(&vec1);
-                    wb.new_column::<B1>(yin).as_mut_slice().copy_from_slice(&vec2);
-                    wb.new_column_with_default(enabled, B1::new(SmallU::new(1)));
-
-                    UIntSub::generate_witness(&mut wb, input, transparent, $cfg).unwrap();
-
-                    let res = vec1.into_iter().zip(vec2).map(|(a, b)| a.overflowing_sub(b).0).collect::<Vec<_>>();
-                    prop_assert_eq!(wb.get::<B1>(xout).unwrap().as_slice::<$t>(), &res);
-
-                    let w = wb.build().unwrap();
-
-                    prop_assert!(validate_witness(&cs, &[], &w).is_ok());
-                });
-            }
-        };
-    }
-
-    auto_test!(test_sub_u8, UIntType::U8, u8);
-    auto_test!(test_sub_u16, UIntType::U16, u16);
-    auto_test!(test_sub_u32, UIntType::U32, u32);
-    auto_test!(test_sub_u64, UIntType::U64, u64);
-}
diff --git a/src/aiur/ir.rs b/src/aiur/ir.rs
deleted file mode 100644
index 0987c7e6..00000000
--- a/src/aiur/ir.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use super::layout::Layout;
-
-/// The `TopLevel` is an abstraction that allows executing arbitrary Aiur-rs program.
-/// Roughly it works as following: user instantiates the `TopLevel` object using one or
-/// more functions (of type `Function`) that express one or more finite computations.
-/// The `TopLevel` implementation defines an execution algorithm which takes a tuple
-/// (`FuncIdx`, `Vec<Value>`) as input and returns `QueryRecord` as output. The input
-/// provides information about what exact function to invoke (`FuncIdx`) as well as what
-/// data (`Vec<Value>`) to use for this function. The output (`QueryRecord`) contains
-/// result of the provided function execution over provided data.
-///
-pub struct Toplevel {
-    pub functions: Vec<Function>,
-    pub layouts: Vec<Layout>,
-    pub mem_widths: Vec<u32>,
-}
-
-pub type Name = &'static str;
-
-impl Toplevel {
-    pub fn get_function(&self, f: FuncIdx) -> &Function {
-        &self.functions[f.to_usize()]
-    }
-}
-
-/// `Function` is an abstraction that expresses some finite computation
-pub struct Function {
-    pub name: Name,
-    pub input_size: u32,
-    pub output_size: u32,
-    pub body: Block,
-}
-
-/// `Prim` defines primitive data types currently supported by Aiur-rs language
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum Prim {
-    U64(u64),
-    Bool(bool),
-}
-
-/// `ValIdx` is a pointer to a particular value stored in the inner stack of the
-/// `TopLevel` execution algorithm
-#[derive(Clone, Copy, Debug)]
-pub struct ValIdx(pub u32);
-
-impl ValIdx {
-    pub fn to_usize(self) -> usize {
-        self.0 as usize
-    }
-}
-
-/// `FuncIdx` is a pointer to a function that needs to be executed by a `TopLevel` execution
-/// algorithm
-#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
-pub struct FuncIdx(pub u32);
-
-impl FuncIdx {
-    pub fn to_usize(self) -> usize {
-        self.0 as usize
-    }
-}
-
-/// `Op` enumerates operations currently supported by Aiur-rs
-pub enum Op {
-    Prim(Prim),
-    Add(ValIdx, ValIdx),
-    Sub(ValIdx, ValIdx),
-    Mul(ValIdx, ValIdx),
-    Xor(ValIdx, ValIdx),
-    And(ValIdx, ValIdx),
-    Lt(ValIdx, ValIdx),
-    Store(Vec<ValIdx>),
-    Load(u32, ValIdx),
-    /// A call operation takes 3 elements, function index, arguments, and output size
-    Call(FuncIdx, Vec<ValIdx>, u32),
-}
-
-/// `SelIdx` serves as a selector of the particular code branch that is executed and
-/// requires constraining for the proving system
-#[derive(Clone, Copy, Debug)]
-pub struct SelIdx(pub u32);
-
-impl SelIdx {
-    pub fn to_usize(self) -> usize {
-        self.0 as usize
-    }
-}
-
-/// `Ctrl` expresses the control flows of the program
-pub enum Ctrl {
-    If(ValIdx, Block, Block),
-    Return(SelIdx, Vec<ValIdx>),
-}
-
-/// `Block` serves as a body of the user-defined Aiur program / computation. May reference inner
-/// blocks via `Ctrl`
-pub struct Block {
-    pub ops: Vec<Op>,
-    pub ctrl: Box<Ctrl>,
-    pub return_idents: Vec<SelIdx>,
-}
diff --git a/src/aiur/layout.rs b/src/aiur/layout.rs
deleted file mode 100644
index 0411293f..00000000
--- a/src/aiur/layout.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-use binius_field::{
-    BinaryField1b, BinaryField8b, BinaryField32b, BinaryField64b, BinaryField128b, TowerField,
-    arch::OptimalUnderlier,
-};
-
-use super::ir::{Block, Ctrl, Function, Op};
-
-pub type B1 = BinaryField1b;
-pub type B8 = BinaryField8b;
-pub type B32 = BinaryField32b;
-pub type B64 = BinaryField64b;
-pub type B128 = BinaryField128b;
-pub type U = OptimalUnderlier;
-
-pub const B1_LEVEL: usize = B1::TOWER_LEVEL;
-pub const B8_LEVEL: usize = B8::TOWER_LEVEL;
-pub const B32_LEVEL: usize = B32::TOWER_LEVEL;
-pub const B64_LEVEL: usize = B64::TOWER_LEVEL;
-
-/// The circuit layout of a function.
-/// The `auxiliaries` represent registers that hold temporary values
-/// and can be shared by different circuit paths, since they never
-/// overlap.
-/// The `selectors` are bit values that identify which path the computation
-/// took. Exactly one selector must be set.
-/// The `shared_constraints` are constraint slots that can be shared in
-/// different paths of the circuit.
-#[derive(Clone, Default, Debug)]
-pub struct Layout {
-    pub inputs: u32,
-    pub outputs: u32,
-    pub u1_auxiliaries: u32,
-    pub u8_auxiliaries: u32,
-    pub u64_auxiliaries: u32,
-    pub selectors: u32,
-    pub shared_constraints: u32,
-}
-
-#[derive(Clone, Default)]
-struct LayoutBranchState {
-    u1_auxiliary_init: u32,
-    u1_auxiliary_max: u32,
-    u8_auxiliary_init: u32,
-    u8_auxiliary_max: u32,
-    u64_auxiliary_init: u32,
-    u64_auxiliary_max: u32,
-    shared_constraint_init: u32,
-    shared_constraint_max: u32,
-}
-
-impl Layout {
-    // `save` before the first branch
-    fn save(&self) -> LayoutBranchState {
-        // auxiliaries
-        let u1_auxiliary_init = self.u1_auxiliaries;
-        let u1_auxiliary_max = u1_auxiliary_init;
-        let u8_auxiliary_init = self.u8_auxiliaries;
-        let u8_auxiliary_max = u8_auxiliary_init;
-        let u64_auxiliary_init = self.u64_auxiliaries;
-        let u64_auxiliary_max = u64_auxiliary_init;
-        // shared constraints
-        let shared_constraint_init = self.shared_constraints;
-        let shared_constraint_max = shared_constraint_init;
-        LayoutBranchState {
-            u1_auxiliary_init,
-            u1_auxiliary_max,
-            u8_auxiliary_init,
-            u8_auxiliary_max,
-            u64_auxiliary_init,
-            u64_auxiliary_max,
-            shared_constraint_init,
-            shared_constraint_max,
-        }
-    }
-
-    // `restore` before new branches
-    fn restore(&mut self, state: &mut LayoutBranchState) {
-        // auxiliaries
-        state.u1_auxiliary_max = state.u1_auxiliary_max.max(self.u1_auxiliaries);
-        self.u1_auxiliaries = state.u1_auxiliary_init;
-        state.u8_auxiliary_max = state.u8_auxiliary_max.max(self.u8_auxiliaries);
-        self.u8_auxiliaries = state.u8_auxiliary_init;
-        state.u64_auxiliary_max = state.u64_auxiliary_max.max(self.u64_auxiliaries);
-        self.u64_auxiliaries = state.u64_auxiliary_init;
-        // shared constraints
-        state.shared_constraint_max = state.shared_constraint_max.max(self.shared_constraints);
-        self.shared_constraints = state.shared_constraint_init;
-    }
-
-    // `finish` at the end
-    fn finish(&mut self, state: &LayoutBranchState) {
-        self.u1_auxiliaries = state.u1_auxiliary_max;
-        self.u8_auxiliaries = state.u8_auxiliary_max;
-        self.u64_auxiliaries = state.u64_auxiliary_max;
-        self.shared_constraints = state.shared_constraint_max;
-    }
-}
-
-pub fn func_layout(func: &Function, mem_widths: &mut Vec<u32>) -> Layout {
-    let mut layout = Layout {
-        inputs: func.input_size,
-        outputs: func.output_size,
-        ..Default::default()
-    };
-    block_layout(&func.body, &mut layout, mem_widths);
-    layout
-}
-
-pub fn block_layout(block: &Block, layout: &mut Layout, mem_widths: &mut Vec<u32>) {
-    let op_layout = |op| op_layout(op, layout, mem_widths);
-    block.ops.iter().for_each(op_layout);
-    match block.ctrl.as_ref() {
-        Ctrl::If(_, t, f) => {
-            let mut state = layout.save();
-            // This auxiliary is for proving inequality
-            layout.u64_auxiliaries += 1;
-            block_layout(t, layout, mem_widths);
-            layout.restore(&mut state);
-            block_layout(f, layout, mem_widths);
-            layout.finish(&state);
-        }
-        Ctrl::Return(_, rs) => {
-            // One selector per return
-            layout.selectors += 1;
-            // Each output must equal its respective return variable,
-            // thus one constraint per return variable
-            layout.shared_constraints +=
-                u32::try_from(rs.len()).expect("Failed to convert usize to u32");
-        }
-    }
-}
-
-pub fn op_layout(op: &Op, layout: &mut Layout, mem_widths: &mut Vec<u32>) {
-    match op {
-        Op::Prim(..) | Op::Xor(..) => {}
-        Op::And(..) => {
-            // `And` is achieved by multiplication. Since we do not want
-            // expressions of order greater than 1, we create a new auxiliary
-            // and constrain it to be equal to the product of the two expressions
-            layout.shared_constraints += 1;
-            layout.u1_auxiliaries += 1;
-        }
-        Op::Add(..) | Op::Lt(..) | Op::Sub(..) => {
-            // uses the addition gadget which outputs 8 bytes of sum
-            // plus 1 byte of carry
-            layout.u64_auxiliaries += 1;
-            layout.u1_auxiliaries += 1;
-        }
-        Op::Mul(..) => {
-            // uses the multiplication gadget which outputs 8 bytes
-            layout.u64_auxiliaries += 1;
-        }
-        Op::Store(values) => {
-            let len = values
-                .len()
-                .try_into()
-                .expect("Number of arguments exceeds 256.");
-            if !mem_widths.contains(&len) {
-                mem_widths.push(len)
-            }
-            // outputs a pointer and a require hint
-            layout.u64_auxiliaries += 2;
-        }
-        Op::Load(len, _) => {
-            if !mem_widths.contains(len) {
-                mem_widths.push(*len)
-            }
-            // outputs the loaded values and a require hint
-            layout.u64_auxiliaries += *len + 1;
-        }
-        Op::Call(_, _, out_size) => {
-            layout.u64_auxiliaries += out_size + 1;
-        }
-    }
-}
diff --git a/src/aiur/memory.rs b/src/aiur/memory.rs
index f73738cc..3f02111e 100644
--- a/src/aiur/memory.rs
+++ b/src/aiur/memory.rs
@@ -1,117 +1,124 @@
-use binius_circuits::builder::{ConstraintSystemBuilder, witness};
-use binius_core::{constraint_system::channel::ChannelId, oracle::OracleId};
-use binius_field::Field;
-
-use crate::aiur::{layout::B64, trace::load_mem_map, transparent::Address};
+use multi_stark::{
+    builder::symbolic::SymbolicExpression,
+    lookup::Lookup,
+    p3_air::{Air, AirBuilder, BaseAir},
+    p3_field::PrimeCharacteristicRing,
+    p3_matrix::{Matrix, dense::RowMajorMatrix},
+};
+use rayon::{
+    iter::{
+        IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator,
+        ParallelIterator,
+    },
+    slice::ParallelSliceMut,
+};
 
-use super::{
-    execute::QueryRecord,
-    layout::B64_LEVEL,
-    synthesis::{VirtualMap, provide},
-    trace::MULT_GEN,
+use crate::{
+    aiur::{G, execute::QueryRecord, trace::Channel},
+    sym_var,
 };
 
-struct MemCols {
-    address: OracleId,
-    values: Vec<OracleId>,
-    multiplicity: OracleId,
+pub struct Memory {
+    width: usize,
 }
 
-pub struct MemTrace {
-    pub values: Vec<Vec<u64>>,
-    pub multiplicity: Vec<B64>,
-    pub height: usize,
-}
+impl Memory {
+    pub(super) fn lookup(multiplicity: G, size: G, ptr: G, values: &[G]) -> Lookup<G> {
+        let mut args = vec![Channel::Memory.to_field(), size, ptr];
+        args.extend(values);
+        Lookup { multiplicity, args }
+    }
 
-impl MemTrace {
-    pub fn generate_trace(width: u32, record: &QueryRecord) -> Self {
-        let mem_map = load_mem_map(&record.mem_queries, width);
-        let height = mem_map.len();
-        let mut trace = MemTrace {
-            values: vec![Vec::with_capacity(height); width as usize],
-            multiplicity: Vec::with_capacity(height),
-            height,
-        };
-        for (args, result) in mem_map.iter() {
-            for (i, arg) in args.iter().enumerate() {
-                trace.values[i].push(*arg);
-            }
-            trace.multiplicity.push(MULT_GEN.pow([result.multiplicity]));
-        }
-        trace
+    fn width(size: usize) -> usize {
+        // Multiplicity, selector, pointer and values.
+        3 + size
     }
-}
 
-impl MemCols {
-    fn new(builder: &mut ConstraintSystemBuilder<'_>, log_n: usize, width: usize) -> Self {
-        let address = builder.add_transparent("", Address::new(log_n)).unwrap();
-        let values: Vec<_> = (0..width)
-            .map(|i| builder.add_committed(format!("value-{i}"), log_n, B64_LEVEL))
-            .collect();
-        let multiplicity = builder.add_committed("multiplicity", log_n, B64_LEVEL);
-        MemCols {
-            address,
-            values,
-            multiplicity,
+    pub fn build(size: usize) -> (Self, Lookup<SymbolicExpression<G>>) {
+        let multiplicity = -sym_var!(0);
+        let selector = sym_var!(1);
+        let pointer = sym_var!(2);
+        let mut args = Vec::with_capacity(3 + size);
+        args.push(selector.clone() * Channel::Memory.to_field());
+        args.push(selector.clone() * G::from_usize(size));
+        args.push(selector.clone() * pointer);
+        for val_idx in 0..size {
+            args.push(selector.clone() * sym_var!(3 + val_idx));
         }
+        let width = Self::width(size);
+        (Self { width }, Lookup { multiplicity, args })
     }
 
-    fn populate(&self, witness: &mut witness::Builder<'_>, trace: &MemTrace) {
-        let count = trace.height;
-        Address::populate(self.address, witness);
-        for (id, values) in self.values.iter().zip(trace.values.iter()) {
-            witness.new_column::<B64>(*id).as_mut_slice::<u64>()[..count].copy_from_slice(values);
-        }
-        {
-            witness
-                .new_column::<B64>(self.multiplicity)
-                .as_mut_slice::<B64>()[..count]
-                .copy_from_slice(&trace.multiplicity);
-        }
+    pub fn generate_trace(
+        size: usize,
+        record: &QueryRecord,
+    ) -> (RowMajorMatrix<G>, Vec<Vec<Lookup<G>>>) {
+        let queries = record.memory_queries.get(&size).expect("Invalid size");
+        let width = Self::width(size);
+        let height_no_padding = queries.len();
+        let height = height_no_padding.next_power_of_two();
+
+        let mut rows = vec![G::ZERO; height * width];
+        let rows_no_padding = &mut rows[0..height_no_padding * width];
+
+        let empty_lookup = Lookup {
+            multiplicity: G::ZERO,
+            args: vec![],
+        };
+        let mut lookups = vec![vec![empty_lookup]; height];
+        let lookups_no_padding = &mut lookups[0..height_no_padding];
+
+        rows_no_padding
+            .par_chunks_mut(width)
+            .zip(queries.par_iter())
+            .zip(lookups_no_padding.par_iter_mut())
+            .enumerate()
+            .for_each(|(i, ((row, (values, result)), row_lookups))| {
+                row[0] = result.multiplicity;
+                row[1] = G::ONE;
+                row[2] = G::from_usize(i);
+                row[3..].copy_from_slice(values);
+
+                row_lookups[0] = Self::lookup(-row[0], G::from_usize(size), row[2], &row[3..]);
+            });
+
+        let trace = RowMajorMatrix::new(rows, width);
+        (trace, lookups)
     }
 }
 
-pub fn prover_synthesize_mem(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    mem_channel_id: ChannelId,
-    trace: &MemTrace,
-) -> u8 {
-    let log_n = trace.height.next_power_of_two().ilog2() as usize;
-    let width = trace.values.len();
-    let count = trace.height.try_into().expect("");
-    let cols = MemCols::new(builder, log_n, width);
-    cols.populate(builder.witness().unwrap(), trace);
-    let mut virt_map = VirtualMap::default();
-    let mut args = [cols.address].to_vec();
-    args.extend(cols.values);
-    provide(
-        builder,
-        mem_channel_id,
-        cols.multiplicity,
-        args,
-        count,
-        &mut virt_map,
-    );
-    log_n.try_into().expect("Trace too large")
+impl BaseAir<G> for Memory {
+    fn width(&self) -> usize {
+        self.width
+    }
 }
 
-pub fn verifier_synthesize_mem(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    mem_channel_id: ChannelId,
-    width: u32,
-    count: u64,
-) {
-    let log_n = count.next_power_of_two().ilog2() as usize;
-    let cols = MemCols::new(builder, log_n, width as usize);
-    let mut virt_map = VirtualMap::default();
-    let mut args = cols.values;
-    args.push(cols.address);
-    provide(
-        builder,
-        mem_channel_id,
-        cols.multiplicity,
-        args,
-        count,
-        &mut virt_map,
-    );
+impl<AB> Air<AB> for Memory
+where
+    AB: AirBuilder<F = G>,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local: &[AB::Var] = &main.row_slice(0).unwrap();
+        let next: &[AB::Var] = &main.row_slice(1).unwrap();
+
+        let (is_real, ptr) = (local[1].clone(), local[2].clone());
+        let (is_real_next, ptr_next) = (next[1].clone(), next[2].clone());
+
+        builder.assert_bool(is_real.clone());
+
+        // Whether the next row is real.
+        let is_real_transition = is_real_next * builder.is_transition();
+
+        // If the next row is real, the current row is real.
+        builder.when(is_real_transition.clone()).assert_one(is_real);
+
+        // Is this necessary?
+        // builder.when_first_row().when(is_real).assert_zero(ptr);
+
+        // Pointer increases by one
+        builder
+            .when(is_real_transition)
+            .assert_eq(ptr + AB::Expr::ONE, ptr_next);
+    }
 }
diff --git a/src/aiur/mod.rs b/src/aiur/mod.rs
index 6d52ebfd..ec2e5cd2 100644
--- a/src/aiur/mod.rs
+++ b/src/aiur/mod.rs
@@ -1,11 +1,8 @@
-pub mod arithmetic;
+pub mod bytecode;
 pub mod constraints;
 pub mod execute;
-pub mod frontend;
-pub mod gadgets;
-pub mod ir;
-pub mod layout;
 pub mod memory;
 pub mod synthesis;
 pub mod trace;
-pub mod transparent;
+
+pub type G = multi_stark::p3_goldilocks::Goldilocks;
diff --git a/src/aiur/synthesis.rs b/src/aiur/synthesis.rs
index 4e865b0a..fb395357 100644
--- a/src/aiur/synthesis.rs
+++ b/src/aiur/synthesis.rs
@@ -1,795 +1,133 @@
-#![allow(clippy::cast_possible_truncation)]
-
-use binius_circuits::builder::ConstraintSystemBuilder;
-use binius_core::{
-    constraint_system::channel::{ChannelId, FlushDirection, OracleOrConst},
-    oracle::OracleId,
-    transparent::{constant::Constant, step_down::StepDown},
-};
-use binius_field::{
-    Field,
-    packed::{get_packed_slice, set_packed_slice},
-    underlier::WithUnderlier,
+use multi_stark::{
+    lookup::LookupAir,
+    p3_air::{Air, AirBuilder, BaseAir},
+    p3_field::PrimeCharacteristicRing,
+    p3_matrix::Matrix,
+    prover::Proof,
+    system::{Circuit, System, SystemWitness},
+    types::{FriParameters, PcsError, new_stark_config},
+    verifier::VerificationError,
 };
-use binius_math::ArithExpr;
-use binius_maybe_rayon::prelude::*;
 
-use super::{
-    arithmetic::{
-        AddTrace, MulTrace, prover_synthesize_add, prover_synthesize_mul, verifier_synthesize_add,
-        verifier_synthesize_mul,
-    },
-    constraints::{Channel, Columns, Constraints, Expr, build_func_constraints},
-    execute::{FxIndexMap, QueryRecord},
-    ir::Toplevel,
-    layout::{B1, B8, B32, B64, B128},
-    memory::{MemTrace, prover_synthesize_mem, verifier_synthesize_mem},
-    trace::{MULT_GEN, Trace},
-    transparent::{Fields, Virtual},
+use crate::aiur::{
+    G,
+    bytecode::{FunIdx, Toplevel},
+    constraints::Constraints,
+    memory::Memory,
+    trace::Channel,
 };
 
-#[derive(Clone)]
-pub struct AiurChannelIds {
-    pub fun: ChannelId,
-    pub add: ChannelId,
-    pub mul: ChannelId,
-    pub mem: Vec<(u32, ChannelId)>,
-}
-
-impl AiurChannelIds {
-    pub fn get_mem_channel(&self, width: u32) -> ChannelId {
-        *self.mem.iter().find(|(k, _)| *k == width).map_or_else(
-            || panic!("Internal error: no memory map of width {width}"),
-            |(_, v)| v,
-        )
-    }
-
-    pub fn get_mem_pos(&self, width: u32) -> usize {
-        self.mem
-            .iter()
-            .position(|(k, _)| *k == width)
-            .unwrap_or_else(|| panic!("Internal error: no memory map of width {width}"))
-    }
+pub struct AiurSystem {
+    toplevel: Toplevel,
+    system: System<AiurCircuit>,
 }
 
-pub struct AiurCount {
-    pub fun: Vec<u64>,
-    pub mem: Vec<u64>,
-    pub add: u64,
-    pub mul: u64,
+enum AiurCircuit {
+    Function(Constraints),
+    Memory(Memory),
 }
 
-#[derive(Default)]
-pub struct VirtualMap {
-    pub map: FxIndexMap<Virtual, OracleId>,
-}
-
-impl VirtualMap {
-    fn sum_b1(
-        &mut self,
-        builder: &mut ConstraintSystemBuilder<'_>,
-        oracles: Vec<OracleId>,
-        offset: B64,
-        log_n: usize,
-    ) -> OracleId {
-        let virt = Virtual::Sum {
-            oracles,
-            offset,
-            log_n,
-        };
-        let id = self.map.entry(virt).or_insert_with_key(|virt| {
-            let Virtual::Sum { oracles, .. } = virt else {
-                unreachable!()
-            };
-            let lc = oracles.iter().map(|oracle| (*oracle, B128::ONE));
-            let id = builder
-                .add_linear_combination_with_offset("linear combination", log_n, offset.into(), lc)
-                .unwrap();
-            if let Some(witness) = builder.witness() {
-                let slices = oracles
-                    .iter()
-                    .map(|oracle| witness.get::<B1>(*oracle).unwrap().packed())
-                    .collect::<Vec<_>>();
-                let mut bits = witness.new_column::<B1>(id);
-                let bits = bits.packed();
-                (0..(1 << log_n)).for_each(|i| {
-                    let mut res = offset
-                        .try_into()
-                        .expect("Internal error: The offset is not a bit");
-                    for slice in slices.iter() {
-                        res += get_packed_slice(slice, i);
-                    }
-                    set_packed_slice(bits, i, res);
-                });
-            }
-            id
-        });
-        *id
-    }
-
-    fn sum_b64(
-        &mut self,
-        builder: &mut ConstraintSystemBuilder<'_>,
-        oracles: Vec<OracleId>,
-        offset: B64,
-        log_n: usize,
-    ) -> OracleId {
-        let virt = Virtual::Sum {
-            oracles,
-            offset,
-            log_n,
-        };
-        let id = self.map.entry(virt).or_insert_with_key(|virt| {
-            let Virtual::Sum { oracles, .. } = virt else {
-                unreachable!()
-            };
-            let lc = oracles.iter().map(|oracle| (*oracle, B128::ONE));
-            let id = builder
-                .add_linear_combination_with_offset("linear combination", log_n, offset.into(), lc)
-                .unwrap();
-            if let Some(witness) = builder.witness() {
-                let slices = oracles
-                    .iter()
-                    .map(|oracle| witness.get::<B64>(*oracle).unwrap().as_slice::<B64>())
-                    .collect::<Vec<_>>();
-                witness
-                    .new_column::<B64>(id)
-                    .as_mut_slice::<B64>()
-                    .into_par_iter()
-                    .enumerate()
-                    .for_each(|(i, w)| {
-                        let mut res = offset;
-                        for slice in slices.iter() {
-                            res += slice[i];
-                        }
-                        *w = res;
-                    });
-            }
-            id
-        });
-        *id
-    }
-
-    fn constant(
-        &mut self,
-        builder: &mut ConstraintSystemBuilder<'_>,
-        constant: Fields,
-        log_n: usize,
-    ) -> OracleId {
-        let virt = Virtual::Constant { constant, log_n };
-        macro_rules! constant {
-            ($f:ident) => {{
-                let id = builder
-                    .add_transparent("constant", Constant::new(log_n, $f))
-                    .unwrap();
-                if let Some(witness) = builder.witness() {
-                    witness.new_column_with_default(id, $f);
-                }
-                id
-            }};
+impl BaseAir<G> for AiurCircuit {
+    fn width(&self) -> usize {
+        // Even though the inner types might have `width` attributes, we dispatch
+        // to their trait implementations for correctness.
+        match self {
+            Self::Function(constraints) => constraints.width(),
+            Self::Memory(memory) => memory.width(),
         }
-        let id = self.map.entry(virt).or_insert_with(|| match constant {
-            Fields::B1(f) => constant!(f),
-            Fields::B8(f) => constant!(f),
-            Fields::B32(f) => constant!(f),
-            Fields::B64(f) => constant!(f),
-        });
-        *id
-    }
-
-    #[allow(dead_code)]
-    fn step_down(
-        &mut self,
-        builder: &mut ConstraintSystemBuilder<'_>,
-        log_n: usize,
-        index: usize,
-    ) -> OracleId {
-        let virt = Virtual::StepDown { index, log_n };
-        let id = self.map.entry(virt).or_insert_with(|| {
-            let step_down = StepDown::new(log_n, index).unwrap();
-            let id = builder
-                .add_transparent("step_down", step_down.clone())
-                .unwrap();
-            if let Some(witness) = builder.witness() {
-                step_down.populate(witness.new_column::<B1>(id).packed());
-            }
-            id
-        });
-        *id
-    }
-}
-
-impl AiurChannelIds {
-    pub fn initialize_channels(
-        builder: &mut ConstraintSystemBuilder<'_>,
-        mem_widths: &[u32],
-    ) -> Self {
-        let fun = builder.add_channel();
-        let add = builder.add_channel();
-        let mul = builder.add_channel();
-        let mem = mem_widths
-            .iter()
-            .map(|width| (*width, builder.add_channel()))
-            .collect();
-        AiurChannelIds { fun, add, mul, mem }
     }
 }
 
-impl Expr {
-    fn to_sum_b1(
-        &self,
-        builder: &mut ConstraintSystemBuilder<'_>,
-        virt_map: &mut VirtualMap,
-        log_n: u8,
-    ) -> OracleId {
-        if let Expr::Const(x) = self {
-            let bit = (*x).try_into().expect("Constant not a bit");
-            return virt_map.constant(builder, Fields::B1(bit), log_n as usize);
-        }
-        let mut sum = vec![];
-        let mut offset = B64::ZERO;
-        self.accumulate_sum(&mut sum, &mut offset).unwrap();
-        if sum.len() == 1 && offset == B64::ZERO {
-            return sum[0];
-        }
-        virt_map.sum_b1(builder, sum, offset, log_n as usize)
-    }
-
-    fn to_sum_b64(
-        &self,
-        builder: &mut ConstraintSystemBuilder<'_>,
-        virt_map: &mut VirtualMap,
-        log_n: u8,
-    ) -> OracleId {
-        if let Expr::Const(x) = self {
-            return virt_map.constant(builder, Fields::B64(*x), log_n as usize);
-        }
-        let mut sum = vec![];
-        let mut offset = B64::ZERO;
-        self.accumulate_sum(&mut sum, &mut offset).unwrap();
-        if sum.len() == 1 && offset == B64::ZERO {
-            return sum[0];
-        }
-        virt_map.sum_b64(builder, sum, offset, log_n as usize)
-    }
-
-    fn accumulate_sum(&self, sum: &mut Vec<OracleId>, offset: &mut B64) -> Option<()> {
-        match self {
-            Self::Const(k) => *offset += *k,
-            Self::Var(x) => sum.push(*x),
-            Self::Add(a, b) => {
-                a.accumulate_sum(sum, offset);
-                b.accumulate_sum(sum, offset);
-            }
-            _ => return None,
-        };
-        Some(())
-    }
-
-    pub fn to_arith_expr(&self) -> (Vec<OracleId>, ArithExpr<B128>) {
-        let mut map = FxIndexMap::default();
-        let arith = self.to_arith_expr_aux(&mut map);
-        let oracles = map.keys().copied().collect();
-        (oracles, arith)
-    }
-
-    fn to_arith_expr_aux(&self, map: &mut FxIndexMap<OracleId, usize>) -> ArithExpr<B128> {
+impl<AB> Air<AB> for AiurCircuit
+where
+    AB: AirBuilder<F = G>,
+{
+    fn eval(&self, builder: &mut AB) {
         match self {
-            Expr::Const(f) => ArithExpr::Const((*f).into()),
-            Expr::Var(id) => {
-                let len = map.len();
-                let index = map.entry(*id).or_insert(len);
-                ArithExpr::Var(*index)
-            }
-            Expr::Add(a, b) => {
-                let a = a.to_arith_expr_aux(map).into();
-                let b = b.to_arith_expr_aux(map).into();
-                ArithExpr::Add(a, b)
-            }
-            Expr::Mul(a, b) => {
-                let a = a.to_arith_expr_aux(map).into();
-                let b = b.to_arith_expr_aux(map).into();
-                ArithExpr::Mul(a, b)
-            }
-            Expr::Pow(a, n) => {
-                let a = a.to_arith_expr_aux(map).into();
-                ArithExpr::Pow(a, *n)
-            }
+            Self::Function(constraints) => constraints.eval(builder),
+            Self::Memory(memory) => memory.eval(builder),
         }
     }
 }
 
-impl Columns {
-    fn populate(&mut self, builder: &mut ConstraintSystemBuilder<'_>, trace: &Trace) {
-        let witness = builder.witness().unwrap();
-        for (id, values) in self.inputs.iter().zip(trace.inputs.iter()) {
-            let count = values.len();
-            witness.new_column::<B64>(*id).as_mut_slice::<u64>()[..count].copy_from_slice(values);
-        }
-        for (id, values) in self.outputs.iter().zip(trace.outputs.iter()) {
-            let count = values.len();
-            witness.new_column::<B64>(*id).as_mut_slice::<u64>()[..count].copy_from_slice(values);
-        }
-        for (id, values) in self.u1_auxiliaries.iter().zip(trace.u1_auxiliaries.iter()) {
-            let mut bits = witness.new_column::<B1>(*id);
-            let bits = bits.packed();
-            values.iter().enumerate().for_each(|(i, value)| {
-                set_packed_slice(bits, i, B1::from_underlier(*value));
-            });
-        }
-        for (id, values) in self.u8_auxiliaries.iter().zip(trace.u8_auxiliaries.iter()) {
-            let count = values.len();
-            witness.new_column::<B8>(*id).as_mut_slice::<u8>()[..count].copy_from_slice(values);
-        }
-        for (id, values) in self
-            .u64_auxiliaries
-            .iter()
-            .zip(trace.u64_auxiliaries.iter())
-        {
-            let count = values.len();
-            witness.new_column::<B64>(*id).as_mut_slice::<u64>()[..count].copy_from_slice(values);
-        }
-        {
-            let count = trace.multiplicity.len();
-            witness
-                .new_column::<B64>(self.multiplicity)
-                .as_mut_slice::<u64>()[..count]
-                .copy_from_slice(&trace.multiplicity);
-        }
-        for (id, values) in self.selectors.iter().zip(trace.selectors.iter()) {
-            let mut bits = witness.new_column::<B1>(*id);
-            let bits = bits.packed();
-            values.iter().enumerate().for_each(|(i, value)| {
-                set_packed_slice(bits, i, B1::from_underlier(*value));
-            });
-        }
+impl BaseAir<G> for Constraints {
+    fn width(&self) -> usize {
+        self.width
     }
 }
 
-impl Toplevel {
-    pub fn prover_synthesize(
-        &self,
-        builder: &mut ConstraintSystemBuilder<'_>,
-        record: &QueryRecord,
-    ) -> (AiurCount, AiurChannelIds) {
-        let traces = self.generate_trace(record);
-        let mut aiur_count = AiurCount {
-            fun: Vec::with_capacity(self.functions.len()),
-            mem: Vec::with_capacity(self.mem_widths.len()),
-            add: record.add_queries.len() as u64,
-            mul: record.mul_queries.len() as u64,
-        };
-        let channel_ids = AiurChannelIds::initialize_channels(builder, &self.mem_widths);
-        for (func_idx, function) in self.functions.iter().enumerate() {
-            let trace = &traces[func_idx];
-            let layout = &self.layouts[func_idx];
-            let mut virt_map = VirtualMap::default();
-            let count = trace.num_queries;
-            aiur_count.fun.push(count);
-            let log_n = count.next_power_of_two().ilog2() as u8;
-            let mut columns = Columns::from_layout(builder, layout, log_n);
-            columns.populate(builder, trace);
-            let constraints = build_func_constraints(function, layout, &columns);
-            synthesize_constraints(
-                builder,
-                func_idx as u32,
-                &channel_ids,
-                count,
-                constraints,
-                &mut virt_map,
-            );
-        }
-        for &width in self.mem_widths.iter() {
-            let mem_channel = channel_ids.get_mem_channel(width);
-            let trace = MemTrace::generate_trace(width, record);
-            let count = trace.height;
-            aiur_count.mem.push(count.try_into().unwrap());
-            if count != 0 {
-                prover_synthesize_mem(builder, mem_channel, &trace);
-            }
-        }
-        {
-            let add_channel = channel_ids.add;
-            let trace = AddTrace::generate_trace(record);
-            if trace.height != 0 {
-                prover_synthesize_add(builder, add_channel, &trace);
-            }
-        }
-        {
-            let mul_channel = channel_ids.mul;
-            let trace = MulTrace::generate_trace(record);
-            if trace.height != 0 {
-                prover_synthesize_mul(builder, mul_channel, &trace);
-            }
-        }
-        (aiur_count, channel_ids)
-    }
-
-    pub fn verifier_synthesize(
-        &self,
-        builder: &mut ConstraintSystemBuilder<'_>,
-        count: &AiurCount,
-    ) -> AiurChannelIds {
-        let channel_ids = AiurChannelIds::initialize_channels(builder, &self.mem_widths);
-        for (func_idx, function) in self.functions.iter().enumerate() {
-            let count = count.fun[func_idx];
-            let layout = &self.layouts[func_idx];
-            let mut virt_map = VirtualMap::default();
-            let log_n = count.next_power_of_two().ilog2() as u8;
-            let columns = Columns::from_layout(builder, layout, log_n);
-            let constraints = build_func_constraints(function, layout, &columns);
-            synthesize_constraints(
-                builder,
-                func_idx as u32,
-                &channel_ids,
-                count,
-                constraints,
-                &mut virt_map,
-            );
-        }
-        for &width in self.mem_widths.iter() {
-            let mem_channel = channel_ids.get_mem_channel(width);
-            let idx = channel_ids.get_mem_pos(width);
-            let mem_counts = count.mem[idx];
-            if mem_counts != 0 {
-                verifier_synthesize_mem(builder, mem_channel, width, mem_counts);
-            }
+impl<AB> Air<AB> for Constraints
+where
+    AB: AirBuilder<F = G>,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let row = main.row_slice(0).unwrap();
+        for zero in self.zeros.iter() {
+            builder.assert_zero(zero.interpret(&row));
         }
-        {
-            let add_channel = channel_ids.add;
-            let add_counts = count.add;
-            if add_counts != 0 {
-                verifier_synthesize_add(builder, add_channel, add_counts);
-            }
+        for sel in self.selectors.clone() {
+            builder.assert_bool(row[sel].clone());
         }
-        {
-            let mul_channel = channel_ids.mul;
-            let mul_counts = count.mul;
-            if mul_counts != 0 {
-                verifier_synthesize_mul(builder, mul_channel, mul_counts);
-            }
-        }
-        channel_ids
-    }
-}
-
-fn synthesize_constraints(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    func_idx: u32,
-    channel_ids: &AiurChannelIds,
-    count: u64,
-    mut constraints: Constraints,
-    virt_map: &mut VirtualMap,
-) {
-    let log_n = count.next_power_of_two().ilog2() as u8;
-    {
-        // Topmost selector must be equal to the count step down
-        let step_down = virt_map.step_down(builder, log_n as usize, count as usize);
-        let (expr, oracles) = (constraints.topmost_selector - Expr::Var(step_down)).to_arith_expr();
-        builder.assert_zero("topmost", expr, oracles.into());
-    }
-    let constant = virt_map.constant(
-        builder,
-        Fields::B32(B32::from_underlier(func_idx)),
-        log_n as usize,
-    );
-    constraints.io.push(constant);
-    provide(
-        builder,
-        channel_ids.fun,
-        constraints.multiplicity,
-        constraints.io,
-        count,
-        virt_map,
-    );
-    for (i, expr) in constraints.unique_constraints.into_iter().enumerate() {
-        let ns = format!("unique constraint {i}");
-        let (expr, oracles) = expr.to_arith_expr();
-        builder.assert_zero(ns, expr, oracles.into());
-    }
-    for (i, expr) in constraints.shared_constraints.into_iter().enumerate() {
-        let ns = format!("shared constraint {i}");
-        let (expr, oracles) = expr.to_arith_expr();
-        builder.assert_zero(ns, expr, oracles.into());
-    }
-    for (channel, sel, args) in constraints.sends {
-        let sel = sel.to_sum_b1(builder, virt_map, log_n);
-        let oracles = args
-            .iter()
-            .map(|arg| OracleOrConst::Oracle(arg.to_sum_b64(builder, virt_map, log_n)))
-            .collect::<Vec<_>>();
-        match channel {
-            Channel::Add => builder
-                .flush_custom(FlushDirection::Push, channel_ids.add, vec![sel], oracles, 1)
-                .unwrap(),
-            Channel::Mul => builder
-                .flush_custom(FlushDirection::Push, channel_ids.mul, vec![sel], oracles, 1)
-                .unwrap(),
-            _ => (),
-        };
-    }
-    for (channel, sel, prev_index, args) in constraints.requires {
-        match channel {
-            Channel::Fun(func_idx) => {
-                let sel = sel.to_sum_b1(builder, virt_map, log_n);
-                let mut oracles = args
-                    .iter()
-                    .map(|arg| arg.to_sum_b64(builder, virt_map, log_n))
-                    .collect::<Vec<_>>();
-                let idx = virt_map.constant(
-                    builder,
-                    Fields::B32(B32::from_underlier(func_idx.0)),
-                    log_n as usize,
-                );
-                oracles.push(idx);
-                require(
-                    builder,
-                    channel_ids.fun,
-                    prev_index,
-                    oracles,
-                    sel,
-                    log_n.into(),
-                );
-            }
-            Channel::Mem(width) => {
-                let sel = sel.to_sum_b1(builder, virt_map, log_n);
-                let oracles = args
-                    .iter()
-                    .map(|arg| arg.to_sum_b64(builder, virt_map, log_n))
-                    .collect::<Vec<_>>();
-                let channel_id = channel_ids.get_mem_channel(width);
-                require(builder, channel_id, prev_index, oracles, sel, log_n.into());
-            }
-            _ => unreachable!(),
-        };
-    }
-}
-
-pub fn provide(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    channel_id: ChannelId,
-    multiplicity: OracleId,
-    mut receive_args: Vec<OracleId>,
-    count: u64,
-    virt_map: &mut VirtualMap,
-) {
-    let mut send_args = receive_args.clone();
-    let count = count as usize;
-    let log_n = count.next_power_of_two().ilog2() as usize;
-    let ones = virt_map.constant(builder, Fields::B64(B64::ONE), log_n);
-    if let Some(witness) = builder.witness() {
-        witness.new_column_with_default(ones, B64::ONE);
-    }
-    send_args.push(ones);
-    receive_args.push(multiplicity);
-    let send_args = send_args.into_iter().map(OracleOrConst::Oracle);
-    let receive_args = receive_args.into_iter().map(OracleOrConst::Oracle);
-    builder.send(channel_id, count, send_args).unwrap();
-    builder.receive(channel_id, count, receive_args).unwrap();
-}
-
-fn require(
-    builder: &mut ConstraintSystemBuilder<'_>,
-    channel_id: ChannelId,
-    prev_index: OracleId,
-    mut send_args: Vec<OracleId>,
-    sel: OracleId,
-    log_n: usize,
-) {
-    let mut receive_args = send_args.clone();
-    let index = builder
-        .add_linear_combination(
-            format!("index-{channel_id}"),
-            log_n,
-            [(prev_index, MULT_GEN.into())],
-        )
-        .unwrap();
-    if let Some(witness) = builder.witness() {
-        (
-            witness.get::<B64>(prev_index).unwrap().as_slice::<u64>(),
-            witness.new_column::<B64>(index).as_mut_slice::<u64>(),
-        )
-            .into_par_iter()
-            .for_each(|(prev, index)| {
-                *index = (B64::from_underlier(*prev) * MULT_GEN).to_underlier()
-            });
     }
-    receive_args.push(prev_index);
-    send_args.push(index);
-    let send_args = send_args.into_iter().map(OracleOrConst::Oracle);
-    let receive_args = receive_args.into_iter().map(OracleOrConst::Oracle);
-    builder
-        .flush_custom(FlushDirection::Pull, channel_id, vec![sel], receive_args, 1)
-        .unwrap();
-    builder
-        .flush_custom(FlushDirection::Push, channel_id, vec![sel], send_args, 1)
-        .unwrap();
 }
 
-#[cfg(test)]
-mod tests {
-    use binius_circuits::builder::{ConstraintSystemBuilder, types::U};
-    use binius_core::{
-        constraint_system::{
-            self,
-            channel::{Boundary, FlushDirection},
-            // validate::validate_witness,
-        },
-        fiat_shamir::HasherChallenger,
-    };
-    use binius_field::{Field, tower::CanonicalTowerFamily, underlier::WithUnderlier};
-    use binius_hal::make_portable_backend;
-    use binius_hash::groestl::Groestl256ByteCompression;
-    use groestl_crypto::Groestl256;
-
-    use crate::{
-        aiur::{
-            frontend::expr::toplevel_from_funcs,
-            ir::{FuncIdx, Toplevel},
-            layout::B128,
-            trace::MULT_GEN,
-        },
-        func,
-    };
-
-    fn prove_verify(toplevel: &Toplevel, index: u8, input: &[u64], output: &[u64]) {
-        let allocator = bumpalo::Bump::new();
-        let mut builder = ConstraintSystemBuilder::new_with_witness(&allocator);
-
-        let record = toplevel.execute(FuncIdx(index as u32), input.to_vec());
-        let (_counts, channel_ids) = toplevel.prover_synthesize(&mut builder, &record);
-
-        let witness = builder
-            .take_witness()
-            .expect("builder created with witness");
-        let constraint_system = builder.build().unwrap();
-
-        let backend = make_portable_backend();
-        const LOG_INV_RATE: usize = 1;
-        const SECURITY_BITS: usize = 100;
-
-        let f = |x: u64| B128::from_underlier(x.into());
-        let mut io = input.iter().copied().map(f).collect::<Vec<_>>();
-        io.extend(output.iter().copied().map(f));
-        io.push(f(index as u64));
-        let mut push_io = io.clone();
-        push_io.push(MULT_GEN.into());
-        let push_boundaries = Boundary {
-            values: push_io,
-            channel_id: channel_ids.fun,
-            direction: FlushDirection::Push,
-            multiplicity: 1,
-        };
-
-        let mut pull_io = io;
-        pull_io.push(B128::ONE);
-        let pull_boundaries = Boundary {
-            values: pull_io,
-            channel_id: channel_ids.fun,
-            direction: FlushDirection::Pull,
-            multiplicity: 1,
-        };
-
-        let boundaries = [pull_boundaries, push_boundaries];
-        // FIX: This is failing on Binius' `mul` gadget somehow
-        // validate_witness(&constraint_system, &boundaries, &witness).unwrap();
-
-        let proof = constraint_system::prove::<
-            U,
-            CanonicalTowerFamily,
-            Groestl256,
-            Groestl256ByteCompression,
-            HasherChallenger<Groestl256>,
-            _,
-        >(
-            &constraint_system,
-            LOG_INV_RATE,
-            SECURITY_BITS,
-            &boundaries,
-            witness,
-            &backend,
-        )
-        .unwrap();
-
-        constraint_system::verify::<
-            U,
-            CanonicalTowerFamily,
-            Groestl256,
-            Groestl256ByteCompression,
-            HasherChallenger<Groestl256>,
-        >(
-            &constraint_system,
-            LOG_INV_RATE,
-            SECURITY_BITS,
-            &boundaries,
-            proof,
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_fib() {
-        let func = func!(
-        fn fib(a): [1] {
-            let one = 1;
-            let gt2 = lt(one, a);
-            if gt2 {
-                let pred = sub(a, one);
-                let pred_pred = sub(pred, one);
-                let m = call(fib, pred);
-                let n = call(fib, pred_pred);
-                let res = add(m, n);
-                return res
-            }
-            return one
-        });
-        let toplevel = toplevel_from_funcs(&[func]);
-        let func_idx = 0;
-        let input = &[65];
-        let output = &[27777890035288];
-        prove_verify(&toplevel, func_idx, input, output);
-    }
-
-    #[test]
-    fn test_sum() {
-        let func = func!(
-        fn sum(n): [1] {
-            let one = 1;
-            if n {
-                let pred = sub(n, one);
-                let m = call(sum, pred);
-                let res = add(n, m);
-                return res
-            }
-            let zero = 0;
-            return zero
+impl AiurSystem {
+    pub fn build(toplevel: Toplevel) -> Self {
+        let function_circuits = (0..toplevel.functions.len()).map(|i| {
+            let (constraints, lookups) = toplevel.build_constraints(i);
+            let air = LookupAir::new(AiurCircuit::Function(constraints), lookups);
+            Circuit::from_air(air).unwrap()
         });
-        let toplevel = toplevel_from_funcs(&[func]);
-        let func_idx = 0;
-        let input = &[100];
-        let output = &[5050];
-        prove_verify(&toplevel, func_idx, input, output);
-    }
-
-    #[test]
-    fn test_factorial() {
-        let func = func!(
-        fn factorial(n): [1] {
-            let one = 1;
-            if n {
-                let pred = sub(n, one);
-                let m = call(factorial, pred);
-                let res = mul(n, m);
-                return res
-            }
-            return one
+        let memory_circuits = toplevel.memory_sizes.iter().map(|&width| {
+            let (memory, lookup) = Memory::build(width);
+            let air = LookupAir::new(AiurCircuit::Memory(memory), vec![lookup]);
+            Circuit::from_air(air).unwrap()
         });
-        let toplevel = toplevel_from_funcs(&[func]);
-        let func_idx = 0;
-        let input = &[100];
-        let output = &[0];
-        prove_verify(&toplevel, func_idx, input, output);
+        let system = System::new(function_circuits.chain(memory_circuits));
+        AiurSystem { system, toplevel }
     }
 
-    #[test]
-    fn test_load_store() {
-        let func = func!(
-        fn load_store(n): [1] {
-            let one = 1;
-            if !n {
-                let ptr = 50;
-                let x = load(ptr);
-                return x
-            }
-            let _ptr = store(n);
-            let pred = sub(n, one);
-            let m = call(load_store, pred);
-            return m
-        });
-        let toplevel = toplevel_from_funcs(&[func]);
-        let func_idx = 0;
-        let input = &[100];
-        let output = &[50];
-        prove_verify(&toplevel, func_idx, input, output);
+    pub fn prove(
+        &self,
+        fri_parameters: &FriParameters,
+        fun_idx: FunIdx,
+        input: &[G],
+    ) -> (Vec<G>, Proof) {
+        let (query_record, output) = self.toplevel.execute(fun_idx, input.to_vec());
+        let mut witness = SystemWitness {
+            traces: vec![],
+            lookups: vec![],
+        };
+        // TODO: parallelize
+        for function_index in 0..self.toplevel.functions.len() {
+            let (trace, lookups_per_function) =
+                self.toplevel.generate_trace(function_index, &query_record);
+            witness.traces.push(trace);
+            witness.lookups.push(lookups_per_function);
+        }
+        // TODO: parallelize
+        for width in &self.toplevel.memory_sizes {
+            let (trace, lookups) = Memory::generate_trace(*width, &query_record);
+            witness.traces.push(trace);
+            witness.lookups.push(lookups);
+        }
+        let mut claim = vec![Channel::Function.to_field(), G::from_usize(fun_idx)];
+        claim.extend(input);
+        claim.extend(output);
+        let config = new_stark_config(fri_parameters);
+        let proof = self.system.prove(&config, &claim, witness);
+        (claim, proof)
+    }
+
+    #[inline]
+    pub fn verify(
+        &self,
+        fri_parameters: &FriParameters,
+        claim: &[G],
+        proof: &Proof,
+    ) -> Result<(), VerificationError<PcsError>> {
+        let config = new_stark_config(fri_parameters);
+        self.system.verify(&config, claim, proof)
     }
 }
diff --git a/src/aiur/trace.rs b/src/aiur/trace.rs
index d991d830..ee92836f 100644
--- a/src/aiur/trace.rs
+++ b/src/aiur/trace.rs
@@ -1,310 +1,304 @@
-use binius_field::underlier::{U1, WithUnderlier};
-use binius_field::{BinaryField, Field};
+use multi_stark::{
+    lookup::Lookup,
+    p3_field::{Field, PrimeCharacteristicRing, PrimeField64},
+    p3_matrix::dense::RowMajorMatrix,
+};
+use rayon::{
+    iter::{IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator},
+    slice::ParallelSliceMut,
+};
 
-use super::execute::{FxIndexMap, QueryRecord, QueryResult};
-use super::ir::{Block, Ctrl, FuncIdx, Function, Op, Prim, SelIdx, Toplevel};
-use super::layout::{B64, Layout};
+use super::{
+    G,
+    bytecode::{Block, Ctrl, Function, Op, Toplevel},
+    execute::QueryRecord,
+    memory::Memory,
+};
 
-pub const MULT_GEN: B64 = B64::MULTIPLICATIVE_GENERATOR;
+pub enum Channel {
+    Function,
+    Memory,
+}
 
-#[derive(Clone, Default, Debug)]
-pub struct Trace {
-    pub num_queries: u64,
-    pub inputs: Vec<Vec<u64>>,
-    pub outputs: Vec<Vec<u64>>,
-    pub u1_auxiliaries: Vec<Vec<U1>>,
-    pub u8_auxiliaries: Vec<Vec<u8>>,
-    pub u64_auxiliaries: Vec<Vec<u64>>,
-    pub multiplicity: Vec<u64>,
-    pub selectors: Vec<Vec<U1>>,
+impl Channel {
+    pub fn to_field(&self) -> G {
+        match self {
+            Channel::Function => G::ZERO,
+            Channel::Memory => G::ONE,
+        }
+    }
 }
 
-#[derive(Clone, Copy, Default, Debug)]
 struct ColumnIndex {
-    u1_auxiliary: usize,
-    u8_auxiliary: usize,
-    u64_auxiliary: usize,
+    auxiliary: usize,
+    lookup: usize,
+}
+
+struct ColumnMutSlice<'a> {
+    inputs: &'a mut [G],
+    selectors: &'a mut [G],
+    auxiliaries: &'a mut [G],
+    lookups: &'a mut [Lookup<G>],
 }
 
-impl Trace {
-    fn blank_trace_with_io(
-        shape: &Layout,
-        num_queries: usize,
-        multiplicity: Vec<u64>,
-        inputs: Vec<Vec<u64>>,
-        outputs: Vec<Vec<u64>>,
-    ) -> Self {
-        let height = num_queries.next_power_of_two();
-        let blank_column = vec![U1::new(0); height];
-        let u1_auxiliaries = vec![blank_column.clone(); shape.u1_auxiliaries as usize];
-        let selectors = vec![blank_column; shape.selectors as usize];
-        let blank_column = vec![0; height];
-        let u8_auxiliaries = vec![blank_column; shape.u8_auxiliaries as usize];
-        let blank_column = vec![0; height];
-        let u64_auxiliaries = vec![blank_column; shape.u64_auxiliaries as usize];
+type Degree = u8;
+
+impl<'a> ColumnMutSlice<'a> {
+    fn from_slice(function: &Function, slice: &'a mut [G], lookups: &'a mut [Lookup<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());
         Self {
             inputs,
-            outputs,
-            u1_auxiliaries,
-            u8_auxiliaries,
-            u64_auxiliaries,
-            multiplicity,
             selectors,
-            num_queries: num_queries as u64,
+            auxiliaries,
+            lookups,
         }
     }
 
-    fn push_u1(&mut self, row: usize, col: &mut ColumnIndex, val: U1) {
-        self.u1_auxiliaries[col.u1_auxiliary][row] = val;
-        col.u1_auxiliary += 1;
-    }
-
-    #[allow(dead_code)]
-    fn push_u8(&mut self, row: usize, col: &mut ColumnIndex, val: u8) {
-        self.u8_auxiliaries[col.u8_auxiliary][row] = val;
-        col.u8_auxiliary += 1;
+    fn push_auxiliary(&mut self, index: &mut ColumnIndex, t: G) {
+        self.auxiliaries[index.auxiliary] = t;
+        index.auxiliary += 1;
     }
 
-    fn push_u64(&mut self, row: usize, col: &mut ColumnIndex, val: u64) {
-        self.u64_auxiliaries[col.u64_auxiliary][row] = val;
-        col.u64_auxiliary += 1;
-    }
-
-    fn set_selector(&mut self, row: usize, sel: SelIdx) {
-        self.selectors[sel.0 as usize][row] = U1::new(1);
+    fn push_lookup(&mut self, index: &mut ColumnIndex, t: Lookup<G>) {
+        self.lookups[index.lookup] = t;
+        index.lookup += 1;
     }
 }
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-enum Query {
-    Func(FuncIdx, Vec<u64>),
-    Mem(u32, Vec<u64>),
+#[derive(Clone, Copy)]
+struct TraceContext<'a> {
+    function_index: G,
+    multiplicity: G,
+    inputs: &'a [G],
+    output: &'a [G],
+    query_record: &'a QueryRecord,
 }
 
 impl Toplevel {
-    pub fn generate_trace(&self, record: &QueryRecord) -> Vec<Trace> {
-        let mut traces = Vec::with_capacity(self.functions.len());
-        let prev_counts = &mut FxIndexMap::default();
-        for (func_idx, func) in self.functions.iter().enumerate() {
-            let func_map = &record.func_queries[func_idx];
-            let layout = &self.layouts[func_idx];
-            let trace = generate_func_trace(func, func_map, layout, record, prev_counts);
-            traces.push(trace);
-        }
-        traces
+    pub fn generate_trace(
+        &self,
+        function_index: usize,
+        query_record: &QueryRecord,
+    ) -> (RowMajorMatrix<G>, Vec<Vec<Lookup<G>>>) {
+        let func = &self.functions[function_index];
+        let width = func.width();
+        let queries = &query_record.function_queries[function_index];
+        let height_no_padding = queries.len();
+        let height = height_no_padding.next_power_of_two();
+        let mut rows = vec![G::ZERO; height * width];
+        let rows_no_padding = &mut rows[0..height_no_padding * width];
+        let empty_lookup = Lookup {
+            multiplicity: G::ZERO,
+            args: vec![],
+        };
+        let mut lookups = vec![vec![empty_lookup; func.layout.lookups]; height];
+        let lookups_no_padding = &mut lookups[0..height_no_padding];
+        rows_no_padding
+            .par_chunks_mut(width)
+            .zip(lookups_no_padding.par_iter_mut())
+            .enumerate()
+            .for_each(|(i, (row, lookups))| {
+                let (inputs, result) = queries.get_index(i).unwrap();
+                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 context = TraceContext {
+                    function_index: G::from_usize(function_index),
+                    inputs,
+                    multiplicity: result.multiplicity,
+                    output: &result.output,
+                    query_record,
+                };
+                func.populate_row(index, slice, context);
+            });
+        let trace = RowMajorMatrix::new(rows, width);
+        (trace, lookups)
     }
 }
 
-fn generate_func_trace(
-    func: &Function,
-    func_map: &FxIndexMap<Vec<u64>, QueryResult>,
-    shape: &Layout,
-    record: &QueryRecord,
-    prev_counts: &mut FxIndexMap<Query, B64>,
-) -> Trace {
-    let num_queries = func_map.len();
-    let (multiplicity, inputs, outputs) = extract_io(func_map, shape);
-    let mut trace = Trace::blank_trace_with_io(shape, num_queries, multiplicity, inputs, outputs);
-    for row in 0..num_queries {
-        let mut col = ColumnIndex::default();
-        let mut map = trace.inputs.iter().map(|col| col[row]).collect::<Vec<_>>();
-        populate_block_trace(
-            &func.body,
-            &mut trace,
-            &mut map,
-            row,
-            &mut col,
-            record,
-            prev_counts,
+impl Function {
+    pub fn width(&self) -> usize {
+        self.layout.input_size + self.layout.auxiliaries + self.layout.selectors
+    }
+
+    fn populate_row(
+        &self,
+        index: &mut ColumnIndex,
+        slice: &mut ColumnMutSlice<'_>,
+        context: TraceContext<'_>,
+    ) {
+        debug_assert_eq!(
+            self.layout.input_size,
+            context.inputs.len(),
+            "Argument mismatch"
         );
+        // Variable to value map
+        let map = &mut context.inputs.iter().map(|arg| (*arg, 1)).collect();
+        // One column per input
+        context
+            .inputs
+            .iter()
+            .enumerate()
+            .for_each(|(i, arg)| slice.inputs[i] = *arg);
+        // Push the multiplicity
+        slice.push_auxiliary(index, context.multiplicity);
+        self.body.populate_row(map, index, slice, context);
+    }
+}
+
+impl Block {
+    fn populate_row(
+        &self,
+        map: &mut Vec<(G, Degree)>,
+        index: &mut ColumnIndex,
+        slice: &mut ColumnMutSlice<'_>,
+        context: TraceContext<'_>,
+    ) {
+        self.ops
+            .iter()
+            .for_each(|op| op.populate_row(map, index, slice, context));
+        self.ctrl.populate_row(map, index, slice, context);
     }
-    trace
 }
 
-fn populate_block_trace(
-    block: &Block,
-    trace: &mut Trace,
-    map: &mut Vec<u64>,
-    row: usize,
-    col: &mut ColumnIndex,
-    record: &QueryRecord,
-    prev_counts: &mut FxIndexMap<Query, B64>,
-) {
-    block
-        .ops
-        .iter()
-        .for_each(|op| populate_op_trace(op, trace, map, row, col, record, prev_counts));
-    match block.ctrl.as_ref() {
-        Ctrl::If(b, t, f) => {
-            let val = map[b.to_usize()];
-            if val != 0 {
-                let inv = B64::new(val).invert().unwrap().to_underlier();
-                trace.push_u64(row, col, inv);
-                populate_block_trace(t, trace, map, row, col, record, prev_counts);
-            } else {
-                populate_block_trace(f, trace, map, row, col, record, prev_counts);
+impl Ctrl {
+    fn populate_row(
+        &self,
+        map: &mut Vec<(G, Degree)>,
+        index: &mut ColumnIndex,
+        slice: &mut ColumnMutSlice<'_>,
+        context: TraceContext<'_>,
+    ) {
+        match self {
+            Ctrl::Return(sel, _) => {
+                slice.selectors[*sel] = G::ONE;
+                let lookup = function_lookup(
+                    -context.multiplicity,
+                    context.function_index,
+                    context.inputs,
+                    context.output,
+                );
+                slice.lookups[0] = lookup;
+            }
+            Ctrl::Match(var, cases, def) => {
+                let val = map[*var].0;
+                let branch = cases
+                    .get(&val)
+                    .or_else(|| {
+                        for &case in cases.keys() {
+                            // the witness shows that val is different from case
+                            let witness = (val - case).inverse();
+                            slice.push_auxiliary(index, witness);
+                        }
+                        def.as_deref()
+                    })
+                    .expect("No match");
+                branch.populate_row(map, index, slice, context);
             }
         }
-        Ctrl::Return(sel, _) => trace.set_selector(row, *sel),
     }
 }
 
-fn populate_op_trace(
-    op: &Op,
-    trace: &mut Trace,
-    map: &mut Vec<u64>,
-    row: usize,
-    col: &mut ColumnIndex,
-    record: &QueryRecord,
-    prev_counts: &mut FxIndexMap<Query, B64>,
-) {
-    match op {
-        Op::Prim(Prim::U64(a)) => {
-            map.push(*a);
-        }
-        Op::Prim(Prim::Bool(a)) => {
-            map.push(*a as u64);
-        }
-        Op::Xor(a, b) => {
-            let a = map[a.to_usize()];
-            let b = map[b.to_usize()];
-            map.push(a ^ b);
-        }
-        Op::And(a, b) => {
-            let a = map[a.to_usize()];
-            let b = map[b.to_usize()];
-            // NOTE: this operation only works when `a` and `b` are both bits
-            let c = a & b;
-            trace.push_u1(
-                row,
-                col,
-                U1::new(c.try_into().expect("Result exceed 1 bit")),
-            );
-            map.push(c);
-        }
-        Op::Add(a, b) => {
-            let a = map[a.to_usize()];
-            let b = map[b.to_usize()];
-            let (c, overflow) = a.overflowing_add(b);
-            trace.push_u64(row, col, c);
-            map.push(c);
-            trace.push_u1(row, col, U1::new(overflow as u8));
-        }
-        Op::Sub(c, b) => {
-            let c = map[c.to_usize()];
-            let b = map[b.to_usize()];
-            let (a, overflow) = c.overflowing_sub(b);
-            trace.push_u64(row, col, a);
-            map.push(a);
-            trace.push_u1(row, col, U1::new(overflow as u8));
-        }
-        Op::Lt(c, b) => {
-            let c = map[c.to_usize()];
-            let b = map[b.to_usize()];
-            let (a, overflow) = c.overflowing_sub(b);
-            trace.push_u64(row, col, a);
-            trace.push_u1(row, col, U1::new(overflow as u8));
-            map.push(overflow as u64);
-        }
-        Op::Mul(a, b) => {
-            let a = map[a.to_usize()];
-            let b = map[b.to_usize()];
-            let c = a.wrapping_mul(b);
-            trace.push_u64(row, col, c);
-            map.push(c);
-        }
-        Op::Store(values) => {
-            let len = values
-                .len()
-                .try_into()
-                .expect("Error: too many arguments to store");
-            let mem_map = load_mem_map(&record.mem_queries, len);
-            let values = values
-                .iter()
-                .map(|value| map[value.to_usize()])
-                .collect::<Vec<_>>();
-            let query_result = mem_map
-                .get(&values)
-                .unwrap_or_else(|| panic!("Value {values:?} not in memory"));
-            for value in query_result.result.iter() {
-                trace.push_u64(row, col, *value);
-                map.push(*value);
+impl Op {
+    fn populate_row(
+        &self,
+        map: &mut Vec<(G, Degree)>,
+        index: &mut ColumnIndex,
+        slice: &mut ColumnMutSlice<'_>,
+        context: TraceContext<'_>,
+    ) {
+        match self {
+            Op::Const(f) => map.push((*f, 0)),
+            Op::Add(a, b) => {
+                let (a, a_deg) = map[*a];
+                let (b, b_deg) = map[*b];
+                let deg = a_deg.max(b_deg);
+                map.push((a + b, deg));
             }
-            let count = prev_counts
-                .entry(Query::Mem(len, values.clone()))
-                .or_insert(B64::ONE);
-            trace.push_u64(row, col, count.to_underlier());
-            *count *= MULT_GEN;
-        }
-        Op::Load(len, ptr) => {
-            let ptr = map[ptr.to_usize()]
-                .try_into()
-                .expect("Value too big for current architecture");
-            let mem_map = load_mem_map(&record.mem_queries, *len);
-            let (values, _) = mem_map
-                .get_index(ptr)
-                .unwrap_or_else(|| panic!("Unbound {len}-wide pointer {ptr}"));
-            for value in values.iter() {
-                trace.push_u64(row, col, *value);
-                map.push(*value);
+            Op::Sub(a, b) => {
+                let (a, a_deg) = map[*a];
+                let (b, b_deg) = map[*b];
+                let deg = a_deg.max(b_deg);
+                map.push((a - b, deg));
             }
-            let count = prev_counts
-                .entry(Query::Mem(*len, values.clone()))
-                .or_insert(B64::ONE);
-            trace.push_u64(row, col, count.to_underlier());
-            *count *= MULT_GEN;
-        }
-        Op::Call(func_idx, args, _) => {
-            let args = args.iter().map(|a| map[a.to_usize()]).collect::<Vec<_>>();
-            let output = &record.get_from_u64(*func_idx, &args).unwrap().result;
-            for byte in output {
-                trace.push_u64(row, col, *byte);
-                map.push(*byte);
+            Op::Mul(a, b) => {
+                let (a, a_deg) = map[*a];
+                let (b, b_deg) = map[*b];
+                let deg = a_deg + b_deg;
+                let f = a * b;
+                if deg < 2 {
+                    map.push((f, deg));
+                } else {
+                    map.push((f, 1));
+                    slice.push_auxiliary(index, f);
+                }
+            }
+            Op::Call(function_index, inputs, _) => {
+                let inputs = inputs.iter().map(|a| map[*a].0).collect::<Vec<_>>();
+                let queries = &context.query_record.function_queries[*function_index];
+                let result = queries.get(&inputs).expect("Cannot find query result");
+                for f in result.output.iter() {
+                    map.push((*f, 1));
+                    slice.push_auxiliary(index, *f);
+                }
+                let lookup = function_lookup(
+                    G::ONE,
+                    G::from_usize(*function_index),
+                    &inputs,
+                    &result.output,
+                );
+                slice.push_lookup(index, lookup);
+            }
+            Op::Store(values) => {
+                let size = values.len();
+                let memory_queries = context
+                    .query_record
+                    .memory_queries
+                    .get(&size)
+                    .expect("Invalid memory size");
+                let values = values.iter().map(|a| map[*a].0).collect::<Vec<_>>();
+                let ptr = G::from_usize(
+                    memory_queries
+                        .get_index_of(&values)
+                        .expect("Unbound pointer"),
+                );
+                map.push((ptr, 1));
+                slice.push_auxiliary(index, ptr);
+                let lookup = Memory::lookup(G::ONE, G::from_usize(size), ptr, &values);
+                slice.push_lookup(index, lookup);
+            }
+            Op::Load(size, ptr) => {
+                let memory_queries = context
+                    .query_record
+                    .memory_queries
+                    .get(size)
+                    .expect("Invalid memory size");
+                let (ptr, _) = map[*ptr];
+                let ptr_u64 = ptr.as_canonical_u64();
+                let ptr_usize = usize::try_from(ptr_u64).expect("Pointer is too big");
+                let (values, _) = memory_queries
+                    .get_index(ptr_usize)
+                    .expect("Unbound pointer");
+                for f in values.iter() {
+                    map.push((*f, 1));
+                    slice.push_auxiliary(index, *f);
+                }
+                let lookup = Memory::lookup(G::ONE, G::from_usize(*size), ptr, values);
+                slice.push_lookup(index, lookup);
             }
-            let count = prev_counts
-                .entry(Query::Func(*func_idx, args))
-                .or_insert(B64::ONE);
-            trace.push_u64(row, col, count.to_underlier());
-            *count *= MULT_GEN;
         }
     }
 }
 
-fn extract_io(
-    func_map: &FxIndexMap<Vec<u64>, QueryResult>,
-    shape: &Layout,
-) -> (Vec<u64>, Vec<Vec<u64>>, Vec<Vec<u64>>) {
-    let height = func_map.len().next_power_of_two();
-    let blank_column = vec![0; height];
-    let mut inputs = vec![blank_column.clone(); shape.inputs as usize];
-    let mut outputs = vec![blank_column; shape.outputs as usize];
-    let mut multiplicity = vec![1; height];
-    func_map
-        .iter()
-        .enumerate()
-        .for_each(|(i, (input_bytes, result))| {
-            multiplicity[i] = MULT_GEN.pow([result.multiplicity]).to_underlier();
-            assert_eq!(input_bytes.len(), inputs.len());
-            input_bytes
-                .iter()
-                .zip(inputs.iter_mut())
-                .for_each(|(byte, inp)| inp[i] = *byte);
-            let output_bytes = &result.result;
-            assert_eq!(output_bytes.len(), outputs.len());
-            output_bytes
-                .iter()
-                .zip(outputs.iter_mut())
-                .for_each(|(byte, out)| out[i] = *byte);
-        });
-    (multiplicity, inputs, outputs)
-}
-
-pub(crate) fn load_mem_map(
-    mem_queries: &[(u32, FxIndexMap<Vec<u64>, QueryResult>)],
-    len: u32,
-) -> &FxIndexMap<Vec<u64>, QueryResult> {
-    mem_queries.iter().find(|(k, _)| *k == len).map_or_else(
-        || panic!("Internal error: no memory map of size {len}"),
-        |(_, v)| v,
-    )
+fn function_lookup(multiplicity: G, function_index: G, inputs: &[G], output: &[G]) -> Lookup<G> {
+    let mut args = vec![Channel::Function.to_field(), function_index];
+    args.extend(inputs);
+    args.extend(output);
+    Lookup { multiplicity, args }
 }
diff --git a/src/aiur/transparent.rs b/src/aiur/transparent.rs
deleted file mode 100644
index d310d7dc..00000000
--- a/src/aiur/transparent.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use binius_circuits::builder::witness;
-use binius_core::{
-    oracle::OracleId,
-    polynomial::{Error, MultivariatePoly},
-};
-use binius_field::{Field, TowerField, underlier::WithUnderlier};
-use binius_utils::bail;
-
-use super::layout::{B1, B8, B32, B64, B128};
-
-#[derive(PartialEq, Debug, Eq, Hash)]
-pub enum Virtual {
-    Constant {
-        constant: Fields,
-        log_n: usize,
-    },
-    Address {
-        log_n: usize,
-    },
-    StepDown {
-        index: usize,
-        log_n: usize,
-    },
-    Sum {
-        oracles: Vec<OracleId>,
-        offset: B64,
-        log_n: usize,
-    },
-}
-
-#[derive(PartialEq, Debug, Eq, Hash, Clone, Copy)]
-pub enum Fields {
-    B1(B1),
-    B8(B8),
-    B32(B32),
-    B64(B64),
-}
-
-#[derive(Debug, Clone)]
-pub struct Address {
-    n_vars: usize,
-}
-
-impl Address {
-    pub fn new(n_vars: usize) -> Self {
-        assert!(n_vars <= 64);
-        Address { n_vars }
-    }
-
-    pub fn populate(address: OracleId, witness: &mut witness::Builder<'_>) {
-        let mut slice = witness.new_column::<B128>(address);
-        for (i, val) in slice.as_mut_slice::<B128>().iter_mut().enumerate() {
-            *val = B128::from_underlier(i as u128);
-        }
-    }
-}
-
-impl MultivariatePoly<B128> for Address {
-    fn degree(&self) -> usize {
-        1
-    }
-
-    fn n_vars(&self) -> usize {
-        self.n_vars
-    }
-
-    fn evaluate(&self, query: &[B128]) -> Result<B128, Error> {
-        let n_vars = MultivariatePoly::n_vars(self);
-        if query.len() != n_vars {
-            bail!(Error::IncorrectQuerySize { expected: n_vars });
-        }
-        let mut result = B128::ZERO;
-        let mut coeff = 1;
-        for arg in query.iter() {
-            result += *arg * B128::from_underlier(coeff);
-            coeff <<= 1;
-        }
-
-        Ok(result)
-    }
-
-    fn binary_tower_level(&self) -> usize {
-        B64::TOWER_LEVEL
-    }
-}
diff --git a/src/aiur2/constraints.rs b/src/aiur2/constraints.rs
deleted file mode 100644
index 8d9384b9..00000000
--- a/src/aiur2/constraints.rs
+++ /dev/null
@@ -1,325 +0,0 @@
-use multi_stark::{
-    builder::symbolic::SymbolicExpression, lookup::Lookup, p3_field::PrimeCharacteristicRing,
-};
-use std::ops::Range;
-
-use super::{
-    G,
-    bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel},
-    trace::Channel,
-};
-
-#[macro_export]
-macro_rules! sym_var {
-    ($a:expr) => {{
-        use multi_stark::builder::symbolic::*;
-        let entry = Entry::Main { offset: 0 };
-        SymbolicExpression::Variable(SymbolicVariable::new(entry, $a))
-    }};
-}
-
-type Expr = SymbolicExpression<G>;
-type Degree = u8;
-
-/// Holds data for a function circuit.
-pub struct Constraints {
-    pub zeros: Vec<Expr>,
-    pub selectors: Range<usize>,
-    pub width: usize,
-}
-
-struct ConstraintState {
-    function_index: G,
-    layout: FunctionLayout,
-    column: usize,
-    lookup: usize,
-    lookups: Vec<Lookup<Expr>>,
-    map: Vec<(Expr, Degree)>,
-    constraints: Constraints,
-}
-
-struct SharedState {
-    column: usize,
-    lookup: usize,
-    map_len: usize,
-}
-
-impl ConstraintState {
-    fn selector_index(&self, sel: usize) -> usize {
-        sel + self.layout.input_size
-    }
-
-    fn next_lookup(&mut self) -> &mut Lookup<Expr> {
-        let lookup = &mut self.lookups[self.lookup];
-        self.lookup += 1;
-        lookup
-    }
-
-    fn next_auxiliary(&mut self) -> Expr {
-        self.column += 1;
-        sym_var!(self.column - 1)
-    }
-
-    fn save(&mut self) -> SharedState {
-        SharedState {
-            column: self.column,
-            lookup: self.lookup,
-            map_len: self.map.len(),
-        }
-    }
-
-    #[allow(clippy::needless_pass_by_value)]
-    fn restore(&mut self, init: SharedState) {
-        self.column = init.column;
-        self.lookup = init.lookup;
-        self.map.truncate(init.map_len);
-    }
-}
-
-impl Toplevel {
-    pub fn build_constraints(&self, function_index: usize) -> (Constraints, Vec<Lookup<Expr>>) {
-        let function = &self.functions[function_index];
-        let empty_lookup = Lookup {
-            multiplicity: Expr::Constant(G::ZERO),
-            args: vec![],
-        };
-        let constraints = Constraints {
-            zeros: vec![],
-            selectors: 0..0,
-            width: function.layout.width(),
-        };
-        let mut state = ConstraintState {
-            function_index: G::from_usize(function_index),
-            layout: function.layout,
-            column: 0,
-            lookup: 0,
-            map: vec![],
-            lookups: vec![empty_lookup; function.layout.lookups],
-            constraints,
-        };
-        function.build_constraints(&mut state, self);
-        (state.constraints, state.lookups)
-    }
-}
-
-impl Function {
-    fn build_constraints(&self, state: &mut ConstraintState, toplevel: &Toplevel) {
-        // 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((sym_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 = sym_var!(state.column);
-        state.column += 1;
-        // the return lookup occupies the first lookup slot
-        state.lookups[0].multiplicity = -multiplicity.clone();
-        state.lookup += 1;
-        // the multiplicity can only be set if one and only one selector is set
-        let sel = self.body.get_block_selector(state);
-        state
-            .constraints
-            .zeros
-            .push(multiplicity * (Expr::from(G::ONE) - sel.clone()));
-        self.body.collect_constraints(sel, state, toplevel);
-    }
-}
-
-impl Block {
-    fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState, toplevel: &Toplevel) {
-        self.ops
-            .iter()
-            .for_each(|op| op.collect_constraints(&sel, state));
-        self.ctrl.collect_constraints(sel, state, toplevel);
-    }
-
-    fn get_block_selector(&self, state: &mut ConstraintState) -> Expr {
-        (self.min_sel_included..self.max_sel_excluded)
-            .map(|i| sym_var!(state.selector_index(i)))
-            .fold(Expr::Constant(G::ZERO), |var, acc| var + acc)
-    }
-}
-
-impl Ctrl {
-    #[allow(clippy::needless_pass_by_value)]
-    fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState, toplevel: &Toplevel) {
-        match self {
-            Ctrl::Return(_, values) => {
-                // channel and function index
-                let mut vector = vec![
-                    sel.clone() * Channel::Function.to_field(),
-                    sel.clone() * state.function_index,
-                ];
-                // input
-                vector.extend(
-                    (0..state.layout.input_size).map(|arg| sel.clone() * state.map[arg].0.clone()),
-                );
-                // output
-                vector.extend(
-                    values
-                        .iter()
-                        .map(|arg| sel.clone() * state.map[*arg].0.clone()),
-                );
-                let mut values_iter = vector.into_iter();
-                let lookup = &mut state.lookups[0];
-                lookup
-                    .args
-                    .iter_mut()
-                    .zip(values_iter.by_ref())
-                    .for_each(|(arg, value)| {
-                        *arg += value;
-                    });
-                lookup.args.extend(values_iter);
-                // multiplicity is already set
-            }
-            Ctrl::Match(var, cases, def) => {
-                let (var, _) = state.map[*var].clone();
-                for (&value, branch) in cases.iter() {
-                    let init = state.save();
-                    let branch_sel = branch.get_block_selector(state);
-                    state
-                        .constraints
-                        .zeros
-                        .push(branch_sel.clone() * (var.clone() - Expr::from(value)));
-                    branch.collect_constraints(branch_sel, state, toplevel);
-                    state.restore(init);
-                }
-                def.iter().for_each(|branch| {
-                    let init = state.save();
-                    let branch_sel = branch.get_block_selector(state);
-                    for &value in cases.keys() {
-                        let inverse = state.next_auxiliary();
-                        state.constraints.zeros.push(
-                            branch_sel.clone()
-                                * ((var.clone() - Expr::from(value)) * inverse
-                                    - Expr::from(G::ONE)),
-                        );
-                    }
-                    branch.collect_constraints(branch_sel, state, toplevel);
-                    state.restore(init);
-                })
-            }
-        }
-    }
-}
-
-impl Op {
-    fn collect_constraints(&self, sel: &Expr, state: &mut ConstraintState) {
-        match self {
-            Op::Const(f) => state.map.push(((*f).into(), 0)),
-            Op::Add(a, b) => {
-                let (a, a_deg) = &state.map[*a];
-                let (b, b_deg) = &state.map[*b];
-                let deg = a_deg.max(b_deg);
-                state.map.push((a.clone() + b.clone(), *deg));
-            }
-            Op::Sub(a, b) => {
-                let (a, a_deg) = &state.map[*a];
-                let (b, b_deg) = &state.map[*b];
-                let deg = a_deg.max(b_deg);
-                state.map.push((a.clone() - b.clone(), *deg));
-            }
-            Op::Mul(a, b) => {
-                let (a, a_deg) = &state.map[*a];
-                let (b, b_deg) = &state.map[*b];
-                let deg = a_deg + b_deg;
-                let mul = a.clone() * b.clone();
-                if deg < 2 {
-                    state.map.push((mul, deg));
-                } else {
-                    let col = state.next_auxiliary();
-                    state.map.push((col.clone(), 1));
-                    state.constraints.zeros.push(sel.clone() * (col - mul));
-                }
-            }
-            Op::Call(function_index, inputs, output_size) => {
-                // channel and function index
-                let mut vector = vec![
-                    sel.clone() * Channel::Function.to_field(),
-                    sel.clone() * G::from_usize(*function_index),
-                ];
-                // input
-                vector.extend(
-                    inputs
-                        .iter()
-                        .map(|arg| sel.clone() * state.map[*arg].0.clone()),
-                );
-                // output
-                let output = (0..*output_size).map(|_| {
-                    let col = state.next_auxiliary();
-                    state.map.push((col.clone(), 1));
-                    col
-                });
-                vector.extend(output);
-                let mut values_iter = vector.into_iter();
-                let lookup = state.next_lookup();
-                lookup
-                    .args
-                    .iter_mut()
-                    .zip(values_iter.by_ref())
-                    .for_each(|(arg, value)| {
-                        *arg += value;
-                    });
-                lookup.args.extend(values_iter);
-                lookup.multiplicity += sel.clone();
-            }
-            Op::Store(values) => {
-                let size = values.len();
-                // channel, function index and pointer
-                let ptr = state.next_auxiliary();
-                state.map.push((ptr.clone(), 1));
-                let mut vector = vec![
-                    sel.clone() * Channel::Memory.to_field(),
-                    sel.clone() * G::from_usize(size),
-                    sel.clone() * ptr.clone(),
-                ];
-                // stored values
-                vector.extend(
-                    values
-                        .iter()
-                        .map(|value| sel.clone() * state.map[*value].0.clone()),
-                );
-                let mut values_iter = vector.into_iter();
-                let lookup = state.next_lookup();
-                lookup
-                    .args
-                    .iter_mut()
-                    .zip(values_iter.by_ref())
-                    .for_each(|(arg, value)| {
-                        *arg += value;
-                    });
-                lookup.args.extend(values_iter);
-                lookup.multiplicity += sel.clone();
-            }
-            Op::Load(size, ptr) => {
-                // channel, size and pointer
-                let mut vector = vec![
-                    sel.clone() * Channel::Memory.to_field(),
-                    sel.clone() * G::from_usize(*size),
-                    sel.clone() * state.map[*ptr].0.clone(),
-                ];
-                // loaded values
-                let values = (0..*size).map(|_| {
-                    let col = state.next_auxiliary();
-                    state.map.push((col.clone(), 1));
-                    col
-                });
-                vector.extend(values);
-                let mut values_iter = vector.into_iter();
-                let lookup = state.next_lookup();
-                lookup
-                    .args
-                    .iter_mut()
-                    .zip(values_iter.by_ref())
-                    .for_each(|(arg, value)| {
-                        *arg += value;
-                    });
-                lookup.args.extend(values_iter);
-                lookup.multiplicity += sel.clone();
-            }
-        }
-    }
-}
diff --git a/src/aiur2/execute.rs b/src/aiur2/execute.rs
deleted file mode 100644
index 7c3ab38a..00000000
--- a/src/aiur2/execute.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
-
-use super::{
-    G,
-    bytecode::{Ctrl, FunIdx, Function, FxIndexMap, Op, Toplevel},
-};
-
-pub struct QueryResult {
-    pub(crate) output: Vec<G>,
-    pub(crate) multiplicity: G,
-}
-
-pub type QueryMap = FxIndexMap<Vec<G>, QueryResult>;
-
-pub struct QueryRecord {
-    pub(crate) function_queries: Vec<QueryMap>,
-    pub(crate) memory_queries: FxIndexMap<usize, QueryMap>,
-}
-
-impl QueryRecord {
-    fn new(toplevel: &Toplevel) -> Self {
-        let function_queries = toplevel
-            .functions
-            .iter()
-            .map(|_| QueryMap::default())
-            .collect();
-        let memory_queries = toplevel
-            .memory_sizes
-            .iter()
-            .map(|width| (*width, QueryMap::default()))
-            .collect();
-        Self {
-            function_queries,
-            memory_queries,
-        }
-    }
-}
-
-impl Toplevel {
-    pub fn execute(&self, fun_idx: FunIdx, args: Vec<G>) -> (QueryRecord, Vec<G>) {
-        let mut record = QueryRecord::new(self);
-        let function = &self.functions[fun_idx];
-        let output = function.execute(fun_idx, args, self, &mut record);
-        (record, output)
-    }
-}
-
-enum ExecEntry<'a> {
-    Op(&'a Op),
-    Ctrl(&'a Ctrl),
-}
-
-struct CallerState {
-    fun_idx: FunIdx,
-    map: Vec<G>,
-}
-
-impl Function {
-    fn execute(
-        &self,
-        mut fun_idx: FunIdx,
-        mut map: Vec<G>,
-        toplevel: &Toplevel,
-        record: &mut QueryRecord,
-    ) -> Vec<G> {
-        let mut exec_entries_stack = vec![];
-        let mut callers_states_stack = vec![];
-        macro_rules! push_block_exec_entries {
-            ($block:expr) => {
-                exec_entries_stack.push(ExecEntry::Ctrl(&$block.ctrl));
-                exec_entries_stack.extend($block.ops.iter().rev().map(ExecEntry::Op));
-            };
-        }
-        push_block_exec_entries!(&self.body);
-        while let Some(exec_entry) = exec_entries_stack.pop() {
-            match exec_entry {
-                ExecEntry::Op(Op::Const(c)) => map.push(*c),
-                ExecEntry::Op(Op::Add(a, b)) => {
-                    let a = map[*a];
-                    let b = map[*b];
-                    map.push(a + b);
-                }
-                ExecEntry::Op(Op::Sub(a, b)) => {
-                    let a = map[*a];
-                    let b = map[*b];
-                    map.push(a - b);
-                }
-                ExecEntry::Op(Op::Mul(a, b)) => {
-                    let a = map[*a];
-                    let b = map[*b];
-                    map.push(a * b);
-                }
-                ExecEntry::Op(Op::Call(callee_idx, args, _)) => {
-                    let args = args.iter().map(|i| map[*i]).collect();
-                    if let Some(result) = record.function_queries[*callee_idx].get_mut(&args) {
-                        result.multiplicity += G::ONE;
-                        map.extend(result.output.clone());
-                    } else {
-                        let saved_map = std::mem::replace(&mut map, args);
-                        // Save the current caller state.
-                        callers_states_stack.push(CallerState {
-                            fun_idx,
-                            map: saved_map,
-                        });
-                        // Prepare outer variables to go into the new func scope.
-                        fun_idx = *callee_idx;
-                        let function = &toplevel.functions[fun_idx];
-                        push_block_exec_entries!(&function.body);
-                    }
-                }
-                ExecEntry::Op(Op::Store(values)) => {
-                    let values = values.iter().map(|v| map[*v]).collect::<Vec<_>>();
-                    let size = values.len();
-                    let memory_queries = record
-                        .memory_queries
-                        .get_mut(&size)
-                        .expect("Invalid memory size");
-                    if let Some(result) = memory_queries.get_mut(&values) {
-                        result.multiplicity += G::ONE;
-                        map.extend(&result.output);
-                    } else {
-                        let ptr = G::from_usize(memory_queries.len());
-                        let result = QueryResult {
-                            output: vec![ptr],
-                            multiplicity: G::ONE,
-                        };
-                        memory_queries.insert(values, result);
-                        map.push(ptr);
-                    }
-                }
-                ExecEntry::Op(Op::Load(size, ptr)) => {
-                    let memory_queries = record
-                        .memory_queries
-                        .get_mut(size)
-                        .expect("Invalid memory size");
-                    let ptr = &map[*ptr];
-                    let ptr_u64 = ptr.as_canonical_u64();
-                    let ptr_usize = usize::try_from(ptr_u64).expect("Pointer is too big");
-                    let (args, result) = memory_queries
-                        .get_index_mut(ptr_usize)
-                        .expect("Unbound pointer");
-                    result.multiplicity += G::ONE;
-                    map.extend(args);
-                }
-                ExecEntry::Ctrl(Ctrl::Match(val_idx, cases, default)) => {
-                    let val = &map[*val_idx];
-                    if let Some(block) = cases.get(val) {
-                        push_block_exec_entries!(block);
-                    } else {
-                        let default = default.as_ref().expect("No match");
-                        push_block_exec_entries!(default);
-                    }
-                }
-                ExecEntry::Ctrl(Ctrl::Return(_, output)) => {
-                    // Register the query.
-                    let input_size = toplevel.functions[fun_idx].layout.input_size;
-                    let args = map[..input_size].to_vec();
-                    let output = output.iter().map(|i| map[*i]).collect::<Vec<_>>();
-                    let result = QueryResult {
-                        output: output.clone(),
-                        multiplicity: G::ONE,
-                    };
-                    record.function_queries[fun_idx].insert(args, result);
-                    if let Some(CallerState {
-                        fun_idx: caller_idx,
-                        map: caller_map,
-                    }) = callers_states_stack.pop()
-                    {
-                        // Recover the state of the caller.
-                        fun_idx = caller_idx;
-                        map = caller_map;
-                        map.extend(output);
-                    } else {
-                        // No outer caller. About to exit.
-                        assert!(exec_entries_stack.is_empty());
-                        map = output;
-                        break;
-                    }
-                }
-            }
-        }
-        map
-    }
-}
diff --git a/src/aiur2/memory.rs b/src/aiur2/memory.rs
deleted file mode 100644
index 583f4949..00000000
--- a/src/aiur2/memory.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-use multi_stark::{
-    builder::symbolic::SymbolicExpression,
-    lookup::Lookup,
-    p3_air::{Air, AirBuilder, BaseAir},
-    p3_field::PrimeCharacteristicRing,
-    p3_matrix::{Matrix, dense::RowMajorMatrix},
-};
-use rayon::{
-    iter::{
-        IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator,
-        ParallelIterator,
-    },
-    slice::ParallelSliceMut,
-};
-
-use crate::{
-    aiur2::{G, execute::QueryRecord, trace::Channel},
-    sym_var,
-};
-
-pub struct Memory {
-    width: usize,
-}
-
-impl Memory {
-    pub(super) fn lookup(multiplicity: G, size: G, ptr: G, values: &[G]) -> Lookup<G> {
-        let mut args = vec![Channel::Memory.to_field(), size, ptr];
-        args.extend(values);
-        Lookup { multiplicity, args }
-    }
-
-    fn width(size: usize) -> usize {
-        // Multiplicity, selector, pointer and values.
-        3 + size
-    }
-
-    pub fn build(size: usize) -> (Self, Lookup<SymbolicExpression<G>>) {
-        let multiplicity = -sym_var!(0);
-        let selector = sym_var!(1);
-        let pointer = sym_var!(2);
-        let mut args = Vec::with_capacity(3 + size);
-        args.push(selector.clone() * Channel::Memory.to_field());
-        args.push(selector.clone() * G::from_usize(size));
-        args.push(selector.clone() * pointer);
-        for val_idx in 0..size {
-            args.push(selector.clone() * sym_var!(3 + val_idx));
-        }
-        let width = Self::width(size);
-        (Self { width }, Lookup { multiplicity, args })
-    }
-
-    pub fn generate_trace(
-        size: usize,
-        record: &QueryRecord,
-    ) -> (RowMajorMatrix<G>, Vec<Vec<Lookup<G>>>) {
-        let queries = record.memory_queries.get(&size).expect("Invalid size");
-        let width = Self::width(size);
-        let height_no_padding = queries.len();
-        let height = height_no_padding.next_power_of_two();
-
-        let mut rows = vec![G::ZERO; height * width];
-        let rows_no_padding = &mut rows[0..height_no_padding * width];
-
-        let empty_lookup = Lookup {
-            multiplicity: G::ZERO,
-            args: vec![],
-        };
-        let mut lookups = vec![vec![empty_lookup]; height];
-        let lookups_no_padding = &mut lookups[0..height_no_padding];
-
-        rows_no_padding
-            .par_chunks_mut(width)
-            .zip(queries.par_iter())
-            .zip(lookups_no_padding.par_iter_mut())
-            .enumerate()
-            .for_each(|(i, ((row, (values, result)), row_lookups))| {
-                row[0] = result.multiplicity;
-                row[1] = G::ONE;
-                row[2] = G::from_usize(i);
-                row[3..].copy_from_slice(values);
-
-                row_lookups[0] = Self::lookup(-row[0], G::from_usize(size), row[2], &row[3..]);
-            });
-
-        let trace = RowMajorMatrix::new(rows, width);
-        (trace, lookups)
-    }
-}
-
-impl BaseAir<G> for Memory {
-    fn width(&self) -> usize {
-        self.width
-    }
-}
-
-impl<AB> Air<AB> for Memory
-where
-    AB: AirBuilder<F = G>,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local: &[AB::Var] = &main.row_slice(0).unwrap();
-        let next: &[AB::Var] = &main.row_slice(1).unwrap();
-
-        let (is_real, ptr) = (local[1].clone(), local[2].clone());
-        let (is_real_next, ptr_next) = (next[1].clone(), next[2].clone());
-
-        builder.assert_bool(is_real.clone());
-
-        // Whether the next row is real.
-        let is_real_transition = is_real_next * builder.is_transition();
-
-        // If the next row is real, the current row is real.
-        builder.when(is_real_transition.clone()).assert_one(is_real);
-
-        // Is this necessary?
-        // builder.when_first_row().when(is_real).assert_zero(ptr);
-
-        // Pointer increases by one
-        builder
-            .when(is_real_transition)
-            .assert_eq(ptr + AB::Expr::ONE, ptr_next);
-    }
-}
diff --git a/src/aiur2/mod.rs b/src/aiur2/mod.rs
deleted file mode 100644
index ec2e5cd2..00000000
--- a/src/aiur2/mod.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-pub mod bytecode;
-pub mod constraints;
-pub mod execute;
-pub mod memory;
-pub mod synthesis;
-pub mod trace;
-
-pub type G = multi_stark::p3_goldilocks::Goldilocks;
diff --git a/src/aiur2/synthesis.rs b/src/aiur2/synthesis.rs
deleted file mode 100644
index d0080627..00000000
--- a/src/aiur2/synthesis.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use multi_stark::{
-    lookup::LookupAir,
-    p3_air::{Air, AirBuilder, BaseAir},
-    p3_field::PrimeCharacteristicRing,
-    p3_matrix::Matrix,
-    prover::Proof,
-    system::{Circuit, System, SystemWitness},
-    types::{FriParameters, PcsError, new_stark_config},
-    verifier::VerificationError,
-};
-
-use crate::aiur2::{
-    G,
-    bytecode::{FunIdx, Toplevel},
-    constraints::Constraints,
-    memory::Memory,
-    trace::Channel,
-};
-
-pub struct AiurSystem {
-    toplevel: Toplevel,
-    system: System<AiurCircuit>,
-}
-
-enum AiurCircuit {
-    Function(Constraints),
-    Memory(Memory),
-}
-
-impl BaseAir<G> for AiurCircuit {
-    fn width(&self) -> usize {
-        // Even though the inner types might have `width` attributes, we dispatch
-        // to their trait implementations for correctness.
-        match self {
-            Self::Function(constraints) => constraints.width(),
-            Self::Memory(memory) => memory.width(),
-        }
-    }
-}
-
-impl<AB> Air<AB> for AiurCircuit
-where
-    AB: AirBuilder<F = G>,
-{
-    fn eval(&self, builder: &mut AB) {
-        match self {
-            Self::Function(constraints) => constraints.eval(builder),
-            Self::Memory(memory) => memory.eval(builder),
-        }
-    }
-}
-
-impl BaseAir<G> for Constraints {
-    fn width(&self) -> usize {
-        self.width
-    }
-}
-
-impl<AB> Air<AB> for Constraints
-where
-    AB: AirBuilder<F = G>,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let row = main.row_slice(0).unwrap();
-        for zero in self.zeros.iter() {
-            builder.assert_zero(zero.interpret(&row));
-        }
-        for sel in self.selectors.clone() {
-            builder.assert_bool(row[sel].clone());
-        }
-    }
-}
-
-impl AiurSystem {
-    pub fn build(toplevel: Toplevel) -> Self {
-        let function_circuits = (0..toplevel.functions.len()).map(|i| {
-            let (constraints, lookups) = toplevel.build_constraints(i);
-            let air = LookupAir::new(AiurCircuit::Function(constraints), lookups);
-            Circuit::from_air(air).unwrap()
-        });
-        let memory_circuits = toplevel.memory_sizes.iter().map(|&width| {
-            let (memory, lookup) = Memory::build(width);
-            let air = LookupAir::new(AiurCircuit::Memory(memory), vec![lookup]);
-            Circuit::from_air(air).unwrap()
-        });
-        let system = System::new(function_circuits.chain(memory_circuits));
-        AiurSystem { system, toplevel }
-    }
-
-    pub fn prove(
-        &self,
-        fri_parameters: &FriParameters,
-        fun_idx: FunIdx,
-        input: &[G],
-    ) -> (Vec<G>, Proof) {
-        let (query_record, output) = self.toplevel.execute(fun_idx, input.to_vec());
-        let mut witness = SystemWitness {
-            traces: vec![],
-            lookups: vec![],
-        };
-        // TODO: parallelize
-        for function_index in 0..self.toplevel.functions.len() {
-            let (trace, lookups_per_function) =
-                self.toplevel.generate_trace(function_index, &query_record);
-            witness.traces.push(trace);
-            witness.lookups.push(lookups_per_function);
-        }
-        // TODO: parallelize
-        for width in &self.toplevel.memory_sizes {
-            let (trace, lookups) = Memory::generate_trace(*width, &query_record);
-            witness.traces.push(trace);
-            witness.lookups.push(lookups);
-        }
-        let mut claim = vec![Channel::Function.to_field(), G::from_usize(fun_idx)];
-        claim.extend(input);
-        claim.extend(output);
-        let config = new_stark_config(fri_parameters);
-        let proof = self.system.prove(&config, &claim, witness);
-        (claim, proof)
-    }
-
-    #[inline]
-    pub fn verify(
-        &self,
-        fri_parameters: &FriParameters,
-        claim: &[G],
-        proof: &Proof,
-    ) -> Result<(), VerificationError<PcsError>> {
-        let config = new_stark_config(fri_parameters);
-        self.system.verify(&config, claim, proof)
-    }
-}
diff --git a/src/aiur2/trace.rs b/src/aiur2/trace.rs
deleted file mode 100644
index ee92836f..00000000
--- a/src/aiur2/trace.rs
+++ /dev/null
@@ -1,304 +0,0 @@
-use multi_stark::{
-    lookup::Lookup,
-    p3_field::{Field, PrimeCharacteristicRing, PrimeField64},
-    p3_matrix::dense::RowMajorMatrix,
-};
-use rayon::{
-    iter::{IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator},
-    slice::ParallelSliceMut,
-};
-
-use super::{
-    G,
-    bytecode::{Block, Ctrl, Function, Op, Toplevel},
-    execute::QueryRecord,
-    memory::Memory,
-};
-
-pub enum Channel {
-    Function,
-    Memory,
-}
-
-impl Channel {
-    pub fn to_field(&self) -> G {
-        match self {
-            Channel::Function => G::ZERO,
-            Channel::Memory => G::ONE,
-        }
-    }
-}
-
-struct ColumnIndex {
-    auxiliary: usize,
-    lookup: usize,
-}
-
-struct ColumnMutSlice<'a> {
-    inputs: &'a mut [G],
-    selectors: &'a mut [G],
-    auxiliaries: &'a mut [G],
-    lookups: &'a mut [Lookup<G>],
-}
-
-type Degree = u8;
-
-impl<'a> ColumnMutSlice<'a> {
-    fn from_slice(function: &Function, slice: &'a mut [G], lookups: &'a mut [Lookup<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());
-        Self {
-            inputs,
-            selectors,
-            auxiliaries,
-            lookups,
-        }
-    }
-
-    fn push_auxiliary(&mut self, index: &mut ColumnIndex, t: G) {
-        self.auxiliaries[index.auxiliary] = t;
-        index.auxiliary += 1;
-    }
-
-    fn push_lookup(&mut self, index: &mut ColumnIndex, t: Lookup<G>) {
-        self.lookups[index.lookup] = t;
-        index.lookup += 1;
-    }
-}
-
-#[derive(Clone, Copy)]
-struct TraceContext<'a> {
-    function_index: G,
-    multiplicity: G,
-    inputs: &'a [G],
-    output: &'a [G],
-    query_record: &'a QueryRecord,
-}
-
-impl Toplevel {
-    pub fn generate_trace(
-        &self,
-        function_index: usize,
-        query_record: &QueryRecord,
-    ) -> (RowMajorMatrix<G>, Vec<Vec<Lookup<G>>>) {
-        let func = &self.functions[function_index];
-        let width = func.width();
-        let queries = &query_record.function_queries[function_index];
-        let height_no_padding = queries.len();
-        let height = height_no_padding.next_power_of_two();
-        let mut rows = vec![G::ZERO; height * width];
-        let rows_no_padding = &mut rows[0..height_no_padding * width];
-        let empty_lookup = Lookup {
-            multiplicity: G::ZERO,
-            args: vec![],
-        };
-        let mut lookups = vec![vec![empty_lookup; func.layout.lookups]; height];
-        let lookups_no_padding = &mut lookups[0..height_no_padding];
-        rows_no_padding
-            .par_chunks_mut(width)
-            .zip(lookups_no_padding.par_iter_mut())
-            .enumerate()
-            .for_each(|(i, (row, lookups))| {
-                let (inputs, result) = queries.get_index(i).unwrap();
-                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 context = TraceContext {
-                    function_index: G::from_usize(function_index),
-                    inputs,
-                    multiplicity: result.multiplicity,
-                    output: &result.output,
-                    query_record,
-                };
-                func.populate_row(index, slice, context);
-            });
-        let trace = RowMajorMatrix::new(rows, width);
-        (trace, lookups)
-    }
-}
-
-impl Function {
-    pub fn width(&self) -> usize {
-        self.layout.input_size + self.layout.auxiliaries + self.layout.selectors
-    }
-
-    fn populate_row(
-        &self,
-        index: &mut ColumnIndex,
-        slice: &mut ColumnMutSlice<'_>,
-        context: TraceContext<'_>,
-    ) {
-        debug_assert_eq!(
-            self.layout.input_size,
-            context.inputs.len(),
-            "Argument mismatch"
-        );
-        // Variable to value map
-        let map = &mut context.inputs.iter().map(|arg| (*arg, 1)).collect();
-        // One column per input
-        context
-            .inputs
-            .iter()
-            .enumerate()
-            .for_each(|(i, arg)| slice.inputs[i] = *arg);
-        // Push the multiplicity
-        slice.push_auxiliary(index, context.multiplicity);
-        self.body.populate_row(map, index, slice, context);
-    }
-}
-
-impl Block {
-    fn populate_row(
-        &self,
-        map: &mut Vec<(G, Degree)>,
-        index: &mut ColumnIndex,
-        slice: &mut ColumnMutSlice<'_>,
-        context: TraceContext<'_>,
-    ) {
-        self.ops
-            .iter()
-            .for_each(|op| op.populate_row(map, index, slice, context));
-        self.ctrl.populate_row(map, index, slice, context);
-    }
-}
-
-impl Ctrl {
-    fn populate_row(
-        &self,
-        map: &mut Vec<(G, Degree)>,
-        index: &mut ColumnIndex,
-        slice: &mut ColumnMutSlice<'_>,
-        context: TraceContext<'_>,
-    ) {
-        match self {
-            Ctrl::Return(sel, _) => {
-                slice.selectors[*sel] = G::ONE;
-                let lookup = function_lookup(
-                    -context.multiplicity,
-                    context.function_index,
-                    context.inputs,
-                    context.output,
-                );
-                slice.lookups[0] = lookup;
-            }
-            Ctrl::Match(var, cases, def) => {
-                let val = map[*var].0;
-                let branch = cases
-                    .get(&val)
-                    .or_else(|| {
-                        for &case in cases.keys() {
-                            // the witness shows that val is different from case
-                            let witness = (val - case).inverse();
-                            slice.push_auxiliary(index, witness);
-                        }
-                        def.as_deref()
-                    })
-                    .expect("No match");
-                branch.populate_row(map, index, slice, context);
-            }
-        }
-    }
-}
-
-impl Op {
-    fn populate_row(
-        &self,
-        map: &mut Vec<(G, Degree)>,
-        index: &mut ColumnIndex,
-        slice: &mut ColumnMutSlice<'_>,
-        context: TraceContext<'_>,
-    ) {
-        match self {
-            Op::Const(f) => map.push((*f, 0)),
-            Op::Add(a, b) => {
-                let (a, a_deg) = map[*a];
-                let (b, b_deg) = map[*b];
-                let deg = a_deg.max(b_deg);
-                map.push((a + b, deg));
-            }
-            Op::Sub(a, b) => {
-                let (a, a_deg) = map[*a];
-                let (b, b_deg) = map[*b];
-                let deg = a_deg.max(b_deg);
-                map.push((a - b, deg));
-            }
-            Op::Mul(a, b) => {
-                let (a, a_deg) = map[*a];
-                let (b, b_deg) = map[*b];
-                let deg = a_deg + b_deg;
-                let f = a * b;
-                if deg < 2 {
-                    map.push((f, deg));
-                } else {
-                    map.push((f, 1));
-                    slice.push_auxiliary(index, f);
-                }
-            }
-            Op::Call(function_index, inputs, _) => {
-                let inputs = inputs.iter().map(|a| map[*a].0).collect::<Vec<_>>();
-                let queries = &context.query_record.function_queries[*function_index];
-                let result = queries.get(&inputs).expect("Cannot find query result");
-                for f in result.output.iter() {
-                    map.push((*f, 1));
-                    slice.push_auxiliary(index, *f);
-                }
-                let lookup = function_lookup(
-                    G::ONE,
-                    G::from_usize(*function_index),
-                    &inputs,
-                    &result.output,
-                );
-                slice.push_lookup(index, lookup);
-            }
-            Op::Store(values) => {
-                let size = values.len();
-                let memory_queries = context
-                    .query_record
-                    .memory_queries
-                    .get(&size)
-                    .expect("Invalid memory size");
-                let values = values.iter().map(|a| map[*a].0).collect::<Vec<_>>();
-                let ptr = G::from_usize(
-                    memory_queries
-                        .get_index_of(&values)
-                        .expect("Unbound pointer"),
-                );
-                map.push((ptr, 1));
-                slice.push_auxiliary(index, ptr);
-                let lookup = Memory::lookup(G::ONE, G::from_usize(size), ptr, &values);
-                slice.push_lookup(index, lookup);
-            }
-            Op::Load(size, ptr) => {
-                let memory_queries = context
-                    .query_record
-                    .memory_queries
-                    .get(size)
-                    .expect("Invalid memory size");
-                let (ptr, _) = map[*ptr];
-                let ptr_u64 = ptr.as_canonical_u64();
-                let ptr_usize = usize::try_from(ptr_u64).expect("Pointer is too big");
-                let (values, _) = memory_queries
-                    .get_index(ptr_usize)
-                    .expect("Unbound pointer");
-                for f in values.iter() {
-                    map.push((*f, 1));
-                    slice.push_auxiliary(index, *f);
-                }
-                let lookup = Memory::lookup(G::ONE, G::from_usize(*size), ptr, values);
-                slice.push_lookup(index, lookup);
-            }
-        }
-    }
-}
-
-fn function_lookup(multiplicity: G, function_index: G, inputs: &[G], output: &[G]) -> Lookup<G> {
-    let mut args = vec![Channel::Function.to_field(), function_index];
-    args.extend(inputs);
-    args.extend(output);
-    Lookup { multiplicity, args }
-}
diff --git a/src/archon/arith_expr.rs b/src/archon/arith_expr.rs
deleted file mode 100644
index 80c3c450..00000000
--- a/src/archon/arith_expr.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use binius_core::oracle::OracleId;
-use binius_math::ArithExpr as ArithExprCore;
-
-use super::{F, OracleIdx};
-
-#[derive(Clone, PartialEq)]
-pub enum ArithExpr {
-    Const(F),
-    Var(usize),
-    Oracle(OracleIdx),
-    Add(Box<ArithExpr>, Box<ArithExpr>),
-    Mul(Box<ArithExpr>, Box<ArithExpr>),
-    Pow(Box<ArithExpr>, u64),
-}
-
-impl std::ops::Add for ArithExpr {
-    type Output = Self;
-    fn add(self, rhs: Self) -> Self::Output {
-        Self::Add(Box::new(self), Box::new(rhs))
-    }
-}
-
-impl std::ops::Mul for ArithExpr {
-    type Output = Self;
-    fn mul(self, rhs: Self) -> Self::Output {
-        Self::Mul(Box::new(self), Box::new(rhs))
-    }
-}
-
-impl ArithExpr {
-    #[inline]
-    pub fn pow(self, e: u64) -> Self {
-        Self::Pow(Box::new(self), e)
-    }
-
-    pub(crate) fn offset_oracles(&mut self, by: usize) {
-        match self {
-            Self::Oracle(o) => o.offset(by),
-            Self::Add(a, b) | Self::Mul(a, b) => {
-                a.offset_oracles(by);
-                b.offset_oracles(by);
-            }
-            Self::Pow(a, _) => a.offset_oracles(by),
-            _ => (),
-        }
-    }
-
-    pub(crate) fn into_arith_expr_core(self, binds: &mut Vec<OracleId>) -> ArithExprCore<F> {
-        match self {
-            Self::Const(c) => ArithExprCore::Const(c),
-            Self::Var(i) => ArithExprCore::Var(i),
-            Self::Oracle(o) => {
-                let i = binds
-                    .iter()
-                    .position(|id| o.val() == id.index())
-                    .unwrap_or_else(|| {
-                        binds.push(o.oracle_id(0));
-                        binds.len() - 1
-                    });
-                ArithExprCore::Var(i)
-            }
-            Self::Add(a, b) => {
-                let a = a.into_arith_expr_core(binds);
-                let b = b.into_arith_expr_core(binds);
-                a + b
-            }
-            Self::Mul(a, b) => {
-                let a = a.into_arith_expr_core(binds);
-                let b = b.into_arith_expr_core(binds);
-                a * b
-            }
-            Self::Pow(a, e) => a.into_arith_expr_core(binds).pow(e),
-        }
-    }
-}
diff --git a/src/archon/canonical.rs b/src/archon/canonical.rs
deleted file mode 100644
index 2a4629c1..00000000
--- a/src/archon/canonical.rs
+++ /dev/null
@@ -1,421 +0,0 @@
-use binius_core::{constraint_system::channel::FlushDirection, oracle::ShiftVariant};
-use binius_field::BinaryField128b;
-use binius_utils::checked_arithmetics::log2_strict_usize;
-
-use super::{
-    OracleIdx, OracleInfo, OracleKind, RelativeHeight,
-    arith_expr::ArithExpr,
-    circuit::{CircuitModule, Constraint, Exp, Flush, OracleOrConst},
-    transparent::Transparent,
-};
-
-pub(crate) trait Canonical {
-    fn size(&self) -> usize;
-    fn write(&self, buffer: &mut Vec<u8>);
-}
-
-impl Canonical for usize {
-    fn size(&self) -> usize {
-        size_of::<usize>()
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        buffer.extend(self.to_le_bytes());
-    }
-}
-
-impl Canonical for u32 {
-    fn size(&self) -> usize {
-        size_of::<u32>()
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        buffer.extend(self.to_le_bytes());
-    }
-}
-
-impl Canonical for u64 {
-    fn size(&self) -> usize {
-        size_of::<u64>()
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        buffer.extend(self.to_le_bytes());
-    }
-}
-
-impl Canonical for BinaryField128b {
-    fn size(&self) -> usize {
-        size_of::<u128>()
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        buffer.extend(self.val().to_le_bytes());
-    }
-}
-
-impl Canonical for Transparent {
-    fn size(&self) -> usize {
-        match self {
-            Self::Constant(b128) => 1 + Canonical::size(b128),
-            Self::Incremental => 1,
-        }
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        match self {
-            Self::Constant(b128) => {
-                buffer.push(0);
-                Canonical::write(b128, buffer);
-            }
-            Self::Incremental => buffer.push(1),
-        }
-    }
-}
-
-impl Canonical for ShiftVariant {
-    fn size(&self) -> usize {
-        1
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        match self {
-            Self::CircularLeft => buffer.push(0),
-            Self::LogicalLeft => buffer.push(1),
-            Self::LogicalRight => buffer.push(2),
-        }
-    }
-}
-
-impl<A: Canonical, B: Canonical> Canonical for (A, B) {
-    fn size(&self) -> usize {
-        let (a, b) = self;
-        Canonical::size(a) + Canonical::size(b)
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        let (a, b) = self;
-        Canonical::write(a, buffer);
-        Canonical::write(b, buffer);
-    }
-}
-
-impl<T: Canonical> Canonical for Vec<T> {
-    fn size(&self) -> usize {
-        self.iter().map(Canonical::size).sum()
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        for t in self {
-            Canonical::write(t, buffer);
-        }
-    }
-}
-
-impl Canonical for OracleIdx {
-    fn size(&self) -> usize {
-        Canonical::size(&self.val())
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        Canonical::write(&self.val(), buffer);
-    }
-}
-
-impl Canonical for OracleKind {
-    fn size(&self) -> usize {
-        match self {
-            Self::Committed | Self::StepDown => 1,
-            Self::LinearCombination { offset, inner } => {
-                1 + Canonical::size(offset) + Canonical::size(inner)
-            }
-            Self::Packed { inner, log_degree } => {
-                1 + Canonical::size(inner) + Canonical::size(log_degree)
-            }
-            Self::Transparent(transparent) => 1 + Canonical::size(transparent),
-            Self::Shifted {
-                inner,
-                shift_offset,
-                block_bits,
-                variant,
-            } => {
-                1 + Canonical::size(inner)
-                    + Canonical::size(shift_offset)
-                    + Canonical::size(block_bits)
-                    + Canonical::size(variant)
-            }
-            Self::Projected {
-                inner, selection, ..
-            } => 1 + Canonical::size(inner) + Canonical::size(selection) + size_of::<u8>(),
-        }
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        match self {
-            Self::Committed => buffer.push(0),
-            Self::LinearCombination { offset, inner } => {
-                buffer.push(1);
-                Canonical::write(offset, buffer);
-                Canonical::write(inner, buffer);
-            }
-            Self::Packed { inner, log_degree } => {
-                buffer.push(2);
-                Canonical::write(inner, buffer);
-                Canonical::write(log_degree, buffer);
-            }
-            Self::Transparent(transparent) => {
-                buffer.push(3);
-                Canonical::write(transparent, buffer);
-            }
-            Self::StepDown => buffer.push(4),
-            Self::Shifted {
-                inner,
-                shift_offset,
-                block_bits,
-                variant,
-            } => {
-                buffer.push(5);
-                Canonical::write(inner, buffer);
-                Canonical::write(shift_offset, buffer);
-                Canonical::write(block_bits, buffer);
-                Canonical::write(variant, buffer);
-            }
-            Self::Projected {
-                inner,
-                selection,
-                chunk_size,
-                ..
-            } => {
-                buffer.push(6);
-                Canonical::write(inner, buffer);
-                Canonical::write(selection, buffer);
-                buffer.push(log2_strict_usize(*chunk_size).to_le_bytes()[0]);
-            }
-        }
-    }
-}
-
-impl Canonical for RelativeHeight {
-    fn size(&self) -> usize {
-        match self {
-            Self::Base => 1,
-            Self::Div2(_) | Self::Mul2(_) => 2,
-        }
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        match self {
-            Self::Base => buffer.push(0),
-            Self::Div2(x) => {
-                buffer.push(1);
-                buffer.push(*x);
-            }
-            Self::Mul2(x) => {
-                buffer.push(2);
-                buffer.push(*x);
-            }
-        }
-    }
-}
-
-impl Canonical for OracleInfo {
-    fn size(&self) -> usize {
-        let Self {
-            name: _,
-            tower_level,
-            kind,
-            relative_height,
-        } = self;
-        Canonical::size(tower_level) + Canonical::size(kind) + Canonical::size(relative_height)
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        let Self {
-            name: _,
-            tower_level,
-            kind,
-            relative_height,
-        } = self;
-        Canonical::write(tower_level, buffer);
-        Canonical::write(kind, buffer);
-        Canonical::write(relative_height, buffer);
-    }
-}
-
-impl Canonical for FlushDirection {
-    fn size(&self) -> usize {
-        1
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        match self {
-            Self::Push => buffer.push(0),
-            Self::Pull => buffer.push(1),
-        }
-    }
-}
-
-impl Canonical for Flush {
-    fn size(&self) -> usize {
-        let Self {
-            values,
-            channel_id,
-            direction,
-            selector,
-            multiplicity,
-        } = self;
-        Canonical::size(values)
-            + Canonical::size(channel_id)
-            + Canonical::size(direction)
-            + Canonical::size(selector)
-            + Canonical::size(multiplicity)
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        let Self {
-            values,
-            channel_id,
-            direction,
-            selector,
-            multiplicity,
-        } = self;
-        Canonical::write(values, buffer);
-        Canonical::write(channel_id, buffer);
-        Canonical::write(direction, buffer);
-        Canonical::write(selector, buffer);
-        Canonical::write(multiplicity, buffer);
-    }
-}
-
-impl Canonical for ArithExpr {
-    fn size(&self) -> usize {
-        match self {
-            Self::Const(b128) => 1 + Canonical::size(b128),
-            Self::Var(v) => 1 + Canonical::size(v),
-            Self::Oracle(o) => 1 + Canonical::size(o),
-            Self::Add(a, b) | Self::Mul(a, b) => {
-                1 + Canonical::size(a.as_ref()) + Canonical::size(b.as_ref())
-            }
-            Self::Pow(a, e) => 1 + Canonical::size(a.as_ref()) + Canonical::size(e),
-        }
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        match self {
-            Self::Const(b128) => {
-                buffer.push(0);
-                Canonical::write(b128, buffer);
-            }
-            Self::Var(v) => {
-                buffer.push(1);
-                Canonical::write(v, buffer);
-            }
-            Self::Oracle(o) => {
-                buffer.push(2);
-                Canonical::write(o, buffer);
-            }
-            Self::Add(a, b) => {
-                buffer.push(3);
-                Canonical::write(a.as_ref(), buffer);
-                Canonical::write(b.as_ref(), buffer);
-            }
-            Self::Mul(a, b) => {
-                buffer.push(4);
-                Canonical::write(a.as_ref(), buffer);
-                Canonical::write(b.as_ref(), buffer);
-            }
-            Self::Pow(a, e) => {
-                buffer.push(5);
-                Canonical::write(a.as_ref(), buffer);
-                Canonical::write(e, buffer);
-            }
-        }
-    }
-}
-
-impl Canonical for Constraint {
-    fn size(&self) -> usize {
-        let Self {
-            name: _,
-            oracle_idxs: oracle_ids,
-            composition,
-        } = self;
-        Canonical::size(oracle_ids) + Canonical::size(composition)
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        let Self {
-            name: _,
-            oracle_idxs: oracle_ids,
-            composition,
-        } = self;
-        Canonical::write(oracle_ids, buffer);
-        Canonical::write(composition, buffer);
-    }
-}
-
-impl Canonical for OracleOrConst {
-    fn size(&self) -> usize {
-        match self {
-            Self::Oracle(o) => 1 + Canonical::size(o),
-            Self::Const { base, tower_level } => {
-                1 + Canonical::size(base) + Canonical::size(tower_level)
-            }
-        }
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        match self {
-            Self::Oracle(o) => {
-                buffer.push(0);
-                Canonical::write(o, buffer);
-            }
-            Self::Const { base, tower_level } => {
-                buffer.push(1);
-                Canonical::write(base, buffer);
-                Canonical::write(tower_level, buffer);
-            }
-        }
-    }
-}
-
-impl Canonical for Exp {
-    fn size(&self) -> usize {
-        let Self {
-            exp_bits,
-            base,
-            result,
-        } = self;
-        Canonical::size(exp_bits) + Canonical::size(base) + Canonical::size(result)
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        let Self {
-            exp_bits,
-            base,
-            result,
-        } = self;
-        Canonical::write(exp_bits, buffer);
-        Canonical::write(base, buffer);
-        Canonical::write(result, buffer);
-    }
-}
-
-impl Canonical for CircuitModule {
-    fn size(&self) -> usize {
-        let Self {
-            module_id,
-            oracles,
-            flushes,
-            constraints,
-            non_zero_oracle_idxs,
-            exponents,
-            namespacer: _,
-        } = self;
-        Canonical::size(module_id)
-            + Canonical::size(oracles.get_ref())
-            + Canonical::size(flushes)
-            + Canonical::size(constraints)
-            + Canonical::size(non_zero_oracle_idxs)
-            + Canonical::size(exponents)
-    }
-    fn write(&self, buffer: &mut Vec<u8>) {
-        let Self {
-            module_id,
-            oracles,
-            flushes,
-            constraints,
-            non_zero_oracle_idxs,
-            exponents,
-            namespacer: _,
-        } = self;
-        Canonical::write(module_id, buffer);
-        Canonical::write(oracles.get_ref(), buffer);
-        Canonical::write(flushes, buffer);
-        Canonical::write(constraints, buffer);
-        Canonical::write(non_zero_oracle_idxs, buffer);
-        Canonical::write(exponents, buffer);
-    }
-}
diff --git a/src/archon/circuit.rs b/src/archon/circuit.rs
deleted file mode 100644
index 95b903d1..00000000
--- a/src/archon/circuit.rs
+++ /dev/null
@@ -1,606 +0,0 @@
-use anyhow::{Result, bail, ensure};
-use binius_core::{
-    constraint_system::{
-        ConstraintSystem,
-        channel::{
-            ChannelId, Flush as BiniusFlush, FlushDirection, OracleOrConst as BiniusOracleOrConst,
-        },
-        exp::Exp as BiniusExp,
-    },
-    oracle::{ConstraintSetBuilder, MultilinearOracleSet, ShiftVariant},
-    transparent::step_down::StepDown,
-};
-use binius_field::TowerField;
-use binius_utils::checked_arithmetics::log2_strict_usize;
-use rayon::iter::{IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator};
-use std::sync::Arc;
-
-use super::{
-    F, ModuleId, ModuleMode, OracleIdx, OracleInfo, OracleKind, RelativeHeight,
-    arith_expr::ArithExpr,
-    transparent::{Incremental, Transparent, constant_from_b128},
-    witness::WitnessModule,
-};
-
-#[inline]
-pub fn freeze_circuit_modules_oracles(circuit_modules: &mut [CircuitModule]) {
-    circuit_modules
-        .par_iter_mut()
-        .for_each(|module| module.freeze_oracles())
-}
-
-#[inline]
-pub fn init_witness_modules(circuit_modules: &[CircuitModule]) -> Result<Vec<WitnessModule>> {
-    circuit_modules
-        .par_iter()
-        .map(CircuitModule::init_witness_module)
-        .collect()
-}
-
-#[derive(PartialEq, Eq)]
-pub enum OracleOrConst {
-    Oracle(OracleIdx),
-    Const { base: F, tower_level: usize },
-}
-
-pub(super) struct Flush {
-    pub(super) values: Vec<OracleOrConst>,
-    pub(super) channel_id: ChannelId,
-    pub(super) direction: FlushDirection,
-    pub(super) selector: OracleIdx,
-    pub(super) multiplicity: u64,
-}
-
-pub(super) struct Exp {
-    pub(super) exp_bits: Vec<OracleIdx>,
-    pub(super) base: OracleOrConst,
-    pub(super) result: OracleIdx,
-}
-
-pub struct CircuitModule {
-    pub(super) module_id: ModuleId,
-    pub(super) oracles: Freezable<Vec<OracleInfo>>,
-    pub(super) flushes: Vec<Flush>,
-    pub(super) constraints: Vec<Constraint>,
-    pub(super) non_zero_oracle_idxs: Vec<OracleIdx>,
-    pub(super) exponents: Vec<Exp>,
-    pub(super) namespacer: Namespacer,
-}
-
-impl CircuitModule {
-    #[inline]
-    pub fn new(module_id: ModuleId) -> Self {
-        let step_down = OracleInfo {
-            name: format!("step_down-module-{module_id}"),
-            tower_level: 0,
-            kind: OracleKind::StepDown,
-            relative_height: RelativeHeight::Base,
-        };
-        let oracles = Freezable::Raw(vec![step_down]);
-        Self {
-            module_id,
-            oracles,
-            flushes: vec![],
-            constraints: vec![],
-            non_zero_oracle_idxs: vec![],
-            exponents: vec![],
-            namespacer: Namespacer::default(),
-        }
-    }
-
-    #[inline]
-    pub const fn selector() -> OracleIdx {
-        OracleIdx(0)
-    }
-
-    #[inline]
-    pub fn freeze_oracles(&mut self) {
-        self.oracles.freeze()
-    }
-
-    #[inline]
-    pub fn init_witness_module(&self) -> Result<WitnessModule> {
-        Ok(WitnessModule::new(
-            self.module_id,
-            self.oracles.get_frozen()?,
-        ))
-    }
-
-    #[inline]
-    pub fn flush(
-        &mut self,
-        direction: FlushDirection,
-        channel_id: ChannelId,
-        selector: OracleIdx,
-        values: impl IntoIterator<Item = OracleOrConst>,
-        multiplicity: u64,
-    ) {
-        self.flushes.push(Flush {
-            values: values.into_iter().collect(),
-            channel_id,
-            direction,
-            selector,
-            multiplicity,
-        });
-    }
-
-    #[inline]
-    pub fn assert_zero(
-        &mut self,
-        name: &(impl ToString + ?Sized),
-        oracle_idxs: impl IntoIterator<Item = OracleIdx>,
-        composition: ArithExpr,
-    ) {
-        self.constraints.push(Constraint {
-            name: name.to_string(),
-            oracle_idxs: oracle_idxs.into_iter().collect(),
-            composition,
-        });
-    }
-
-    #[inline]
-    pub fn assert_not_zero(&mut self, oracle_idx: OracleIdx) {
-        self.non_zero_oracle_idxs.push(oracle_idx);
-    }
-
-    #[inline]
-    pub fn assert_exp(&mut self, exp_bits: Vec<OracleIdx>, result: OracleIdx, base: OracleOrConst) {
-        self.exponents.push(Exp {
-            exp_bits,
-            base,
-            result,
-        })
-    }
-
-    #[inline]
-    pub fn add_committed<FS: TowerField>(
-        &mut self,
-        name: &(impl ToString + ?Sized),
-        relative_height: RelativeHeight,
-    ) -> Result<OracleIdx> {
-        let oracle_info = OracleInfo {
-            name: self.namespacer.scoped_name(name),
-            tower_level: FS::TOWER_LEVEL,
-            kind: OracleKind::Committed,
-            relative_height,
-        };
-        self.add_oracle_info(oracle_info)
-    }
-
-    #[inline]
-    pub fn add_transparent(
-        &mut self,
-        name: &(impl ToString + ?Sized),
-        transparent: Transparent,
-        relative_height: RelativeHeight,
-    ) -> Result<OracleIdx> {
-        let oracle_info = OracleInfo {
-            name: self.namespacer.scoped_name(name),
-            tower_level: transparent.tower_level(),
-            kind: OracleKind::Transparent(transparent),
-            relative_height,
-        };
-        self.add_oracle_info(oracle_info)
-    }
-
-    pub fn add_linear_combination(
-        &mut self,
-        name: &(impl ToString + ?Sized),
-        offset: F,
-        inner: impl IntoIterator<Item = (OracleIdx, F)>,
-        relative_height: RelativeHeight,
-    ) -> Result<OracleIdx> {
-        let inner = inner.into_iter().collect::<Vec<_>>();
-        if inner.is_empty() {
-            self.add_transparent(name, Transparent::Constant(offset), relative_height)
-        } else {
-            let mut tower_level = offset.min_tower_level();
-            for (oracle_idx, coeff) in &inner {
-                let inner_ref = &self.oracles.get_ref()[oracle_idx.val()];
-                ensure!(relative_height == inner_ref.relative_height);
-                tower_level = tower_level
-                    .max(inner_ref.tower_level)
-                    .max(coeff.min_tower_level());
-            }
-            let oracle_info = OracleInfo {
-                name: self.namespacer.scoped_name(name),
-                tower_level,
-                kind: OracleKind::LinearCombination { offset, inner },
-                relative_height,
-            };
-            self.add_oracle_info(oracle_info)
-        }
-    }
-
-    #[inline]
-    pub fn add_packed(
-        &mut self,
-        name: &(impl ToString + ?Sized),
-        inner: OracleIdx,
-        log_degree: usize,
-    ) -> Result<OracleIdx> {
-        let inner_tower_level = self.oracles.get_ref()[inner.val()].tower_level;
-        let oracle_info = OracleInfo {
-            name: self.namespacer.scoped_name(name),
-            tower_level: inner_tower_level + log_degree,
-            kind: OracleKind::Packed { inner, log_degree },
-            relative_height: RelativeHeight::Div2(log_degree.try_into()?),
-        };
-        self.add_oracle_info(oracle_info)
-    }
-
-    pub fn add_shifted(
-        &mut self,
-        name: &(impl ToString + ?Sized),
-        inner: OracleIdx,
-        shift_offset: u32,
-        block_bits: usize,
-        variant: ShiftVariant,
-    ) -> Result<OracleIdx> {
-        let inner_ref = &self.oracles.get_ref()[inner.val()];
-        let inner_tower_level = inner_ref.tower_level;
-        let relative_height = inner_ref.relative_height;
-        let oracle_info = OracleInfo {
-            name: self.namespacer.scoped_name(name),
-            tower_level: inner_tower_level,
-            kind: OracleKind::Shifted {
-                inner,
-                shift_offset,
-                block_bits,
-                variant,
-            },
-            relative_height,
-        };
-        self.add_oracle_info(oracle_info)
-    }
-
-    pub fn add_projected(
-        &mut self,
-        name: &(impl ToString + ?Sized),
-        inner: OracleIdx,
-        selection: u64,
-        chunk_size: usize,
-    ) -> Result<OracleIdx> {
-        ensure!(chunk_size.is_power_of_two());
-        ensure!(selection < chunk_size as u64);
-
-        let inner_tower_level = self.oracles.get_ref()[inner.val()].tower_level;
-
-        let log_chunk_size: u8 = log2_strict_usize(chunk_size).try_into()?;
-        let selection_bits = (0..log_chunk_size)
-            .map(|n| F::from(((selection >> n) & 1) as u128))
-            .collect();
-
-        let oracle_info = OracleInfo {
-            name: self.namespacer.scoped_name(name),
-            tower_level: inner_tower_level,
-            kind: OracleKind::Projected {
-                inner,
-                selection,
-                chunk_size,
-                selection_bits,
-            },
-            relative_height: RelativeHeight::Div2(log_chunk_size),
-        };
-
-        self.add_oracle_info(oracle_info)
-    }
-
-    #[inline]
-    pub fn push_namespace<S: ToString + ?Sized>(&mut self, name: &S) {
-        self.namespacer.push(name);
-    }
-
-    #[inline]
-    pub fn pop_namespace(&mut self) {
-        self.namespacer.pop();
-    }
-
-    #[inline]
-    fn add_oracle_info(&mut self, oracle_info: OracleInfo) -> Result<OracleIdx> {
-        self.oracles.get_mut()?.push(oracle_info);
-        Ok(OracleIdx(self.oracles.get_ref().len() - 1))
-    }
-}
-
-pub fn compile_circuit_modules(
-    modules: &[&CircuitModule],
-    modes: &[ModuleMode],
-) -> Result<ConstraintSystem<F>> {
-    ensure!(
-        modules.len() == modes.len(),
-        "Number of modules is incompatible with the number of modes"
-    );
-    let mut oracle_offset = 0;
-    let mut oracles = MultilinearOracleSet::new();
-    let mut constraint_builder = ConstraintSetBuilder::new();
-    let mut flushes = Vec::new();
-    let mut non_zero_oracle_ids = Vec::new();
-    let mut exponents = Vec::new();
-    let mut max_channel_id = 0;
-    for (module_idx, (module, mode)) in modules.iter().zip(modes).enumerate() {
-        let ModuleMode::Active { log_height, depth } = *mode else {
-            // Deactivated module. Skip.
-            continue;
-        };
-        ensure!(
-            module_idx == module.module_id,
-            "Wrong compilation order. Expected module {module_idx}, but got {}.",
-            module.module_id
-        );
-
-        let log_height_usize = log_height as usize;
-        let depth_usize: usize = depth.try_into()?;
-
-        for OracleInfo {
-            name,
-            tower_level,
-            kind,
-            relative_height,
-        } in module.oracles.get_ref()
-        {
-            match kind {
-                OracleKind::Committed => {
-                    let n_vars = relative_height.transform(log_height) as usize;
-                    oracles.add_named(name).committed(n_vars, *tower_level);
-                }
-                OracleKind::LinearCombination { offset, inner } => {
-                    let n_vars = relative_height.transform(log_height) as usize;
-                    let inner = inner
-                        .iter()
-                        .map(|(oracle_idx, f)| (oracle_idx.oracle_id(oracle_offset), *f));
-                    oracles
-                        .add_named(name)
-                        .linear_combination_with_offset(n_vars, *offset, inner)?;
-                }
-                OracleKind::Packed { inner, log_degree } => {
-                    oracles
-                        .add_named(name)
-                        .packed(inner.oracle_id(oracle_offset), *log_degree)?;
-                }
-                OracleKind::Transparent(Transparent::Constant(b128)) => {
-                    let n_vars = relative_height.transform(log_height) as usize;
-                    oracles
-                        .add_named(name)
-                        .transparent(constant_from_b128(*b128, n_vars))?;
-                }
-                OracleKind::Transparent(Transparent::Incremental) => {
-                    let log_height = relative_height.transform(log_height);
-                    oracles.add_named(name).transparent(Incremental {
-                        n_vars: log_height as usize,
-                        tower_level: Incremental::min_tower_level(log_height),
-                    })?;
-                }
-                OracleKind::StepDown => {
-                    oracles
-                        .add_named(name)
-                        .transparent(StepDown::new(log_height_usize, depth_usize)?)?;
-                }
-
-                OracleKind::Shifted {
-                    inner,
-                    shift_offset,
-                    block_bits,
-                    variant,
-                } => {
-                    oracles.add_named(name).shifted(
-                        inner.oracle_id(oracle_offset),
-                        *shift_offset as usize,
-                        *block_bits,
-                        *variant,
-                    )?;
-                }
-                OracleKind::Projected {
-                    inner,
-                    selection_bits,
-                    ..
-                } => {
-                    oracles.add_named(name).projected(
-                        inner.oracle_id(oracle_offset),
-                        selection_bits.clone(),
-                        0,
-                    )?;
-                }
-            };
-        }
-
-        for Constraint {
-            name,
-            oracle_idxs,
-            composition,
-        } in &module.constraints
-        {
-            let mut oracle_idxs = oracle_idxs
-                .iter()
-                .map(|o| o.oracle_id(oracle_offset))
-                .collect();
-            let mut composition = composition.clone();
-            composition.offset_oracles(oracle_offset);
-            let composition = composition.into_arith_expr_core(&mut oracle_idxs);
-            constraint_builder.add_zerocheck(name, oracle_idxs, composition.into());
-        }
-
-        for non_zero_oracle_idx in &module.non_zero_oracle_idxs {
-            non_zero_oracle_ids.push(non_zero_oracle_idx.oracle_id(oracle_offset));
-        }
-
-        let mk_binius_oracle_or_const = |oracle_or_const: &OracleOrConst| match oracle_or_const {
-            OracleOrConst::Oracle(o) => BiniusOracleOrConst::Oracle(o.oracle_id(oracle_offset)),
-            OracleOrConst::Const { base, tower_level } => BiniusOracleOrConst::Const {
-                base: *base,
-                tower_level: *tower_level,
-            },
-        };
-
-        for Exp {
-            exp_bits,
-            base,
-            result,
-        } in &module.exponents
-        {
-            let bits_ids = exp_bits
-                .iter()
-                .map(|o| o.oracle_id(oracle_offset))
-                .collect();
-            let exp_result_id = result.oracle_id(oracle_offset);
-            exponents.push(BiniusExp {
-                bits_ids,
-                base: mk_binius_oracle_or_const(base),
-                exp_result_id,
-            });
-        }
-
-        for Flush {
-            values,
-            channel_id,
-            direction,
-            selector,
-            multiplicity,
-        } in &module.flushes
-        {
-            max_channel_id = max_channel_id.max(*channel_id);
-            flushes.push(BiniusFlush {
-                channel_id: *channel_id,
-                direction: *direction,
-                selectors: vec![selector.oracle_id(oracle_offset)],
-                oracles: values.iter().map(mk_binius_oracle_or_const).collect(),
-                multiplicity: *multiplicity,
-            });
-        }
-
-        oracle_offset += module.oracles.get_ref().len();
-    }
-    let table_constraints = constraint_builder.build(&oracles)?;
-    Ok(ConstraintSystem {
-        oracles,
-        table_constraints,
-        flushes,
-        non_zero_oracle_ids,
-        max_channel_id,
-        exponents,
-    })
-}
-
-pub(super) struct Constraint {
-    pub(super) name: String,
-    pub(super) oracle_idxs: Vec<OracleIdx>,
-    pub(super) composition: ArithExpr,
-}
-
-#[derive(Clone)]
-pub(super) enum Freezable<T> {
-    Raw(T),
-    Frozen(Arc<T>),
-}
-
-impl<T> Freezable<T> {
-    fn freeze(&mut self)
-    where
-        T: Default,
-    {
-        if let Self::Raw(data) = self {
-            *self = Self::Frozen(Arc::new(std::mem::take(data)))
-        }
-    }
-
-    pub(super) fn get_ref(&self) -> &T {
-        match self {
-            Self::Raw(data) => data,
-            Self::Frozen(data) => data,
-        }
-    }
-
-    fn get_mut(&mut self) -> Result<&mut T> {
-        match self {
-            Self::Raw(data) => Ok(data),
-            Self::Frozen(_) => bail!("Data is frozen"),
-        }
-    }
-
-    fn get_frozen(&self) -> Result<Arc<T>> {
-        match self {
-            Self::Raw(_) => bail!("Data is not frozen"),
-            Self::Frozen(data) => Ok(data.clone()),
-        }
-    }
-}
-
-/// A namespacing struct that caches joined paths.
-#[derive(Default)]
-pub(super) struct Namespacer {
-    path: Vec<String>,
-    joined_path: Option<String>,
-}
-
-impl Namespacer {
-    fn push<S: ToString + ?Sized>(&mut self, limb: &S) {
-        self.path.push(limb.to_string());
-        self.joined_path = None;
-    }
-
-    fn pop(&mut self) {
-        self.path.pop();
-        self.joined_path = None;
-    }
-
-    fn scoped_name<S: ToString + ?Sized>(&mut self, name: &S) -> String {
-        let concat = |joined: &str, name| {
-            if joined.is_empty() {
-                name
-            } else {
-                format!("{joined}::{name}")
-            }
-        };
-        if let Some(joined) = &self.joined_path {
-            concat(joined, name.to_string())
-        } else {
-            let joined = self.path.join("::");
-            let concatenated = concat(&joined, name.to_string());
-            self.joined_path = Some(joined);
-            concatenated
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Namespacer;
-
-    #[test]
-    fn test_namespace() {
-        let test_when_empty = |namespacer: &mut Namespacer| {
-            assert_eq!(namespacer.scoped_name("a"), "a");
-            assert_eq!(namespacer.scoped_name("b"), "b");
-        };
-        let test_with_foo = |namespacer: &mut Namespacer| {
-            assert_eq!(namespacer.scoped_name("a"), "foo::a");
-        };
-        let test_with_foo_bar = |namespacer: &mut Namespacer| {
-            assert_eq!(namespacer.scoped_name("a"), "foo::bar::a");
-        };
-
-        let namespacer = &mut Namespacer::default();
-        test_when_empty(namespacer);
-
-        namespacer.pop();
-        test_when_empty(namespacer);
-
-        namespacer.push("foo");
-        test_with_foo(namespacer);
-
-        namespacer.push("bar");
-        test_with_foo_bar(namespacer);
-
-        namespacer.pop();
-        test_with_foo(namespacer);
-
-        namespacer.push("bar");
-        test_with_foo_bar(namespacer);
-
-        namespacer.pop();
-        test_with_foo(namespacer);
-
-        namespacer.pop();
-        test_when_empty(namespacer);
-    }
-}
diff --git a/src/archon/mod.rs b/src/archon/mod.rs
deleted file mode 100644
index 89fe0baa..00000000
--- a/src/archon/mod.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-pub mod arith_expr;
-pub mod canonical;
-pub mod circuit;
-pub mod populate;
-pub mod precompiles;
-pub mod protocol;
-pub mod transparent;
-pub mod witness;
-
-use binius_core::oracle::{OracleId, ShiftVariant};
-use binius_field::BinaryField128b;
-
-use transparent::Transparent;
-
-pub(crate) type F = BinaryField128b;
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct OracleIdx(pub(crate) usize);
-
-impl OracleIdx {
-    #[inline]
-    pub(crate) fn oracle_id(&self, offset: usize) -> OracleId {
-        OracleId::from_index(self.0 + offset)
-    }
-
-    #[inline]
-    pub(crate) fn val(&self) -> usize {
-        self.0
-    }
-
-    #[inline]
-    pub(crate) fn offset(&mut self, by: usize) {
-        self.0 += by
-    }
-}
-
-impl std::fmt::Display for OracleIdx {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(&self.val(), f)
-    }
-}
-
-pub enum OracleKind {
-    Committed,
-    LinearCombination {
-        offset: F,
-        inner: Vec<(OracleIdx, F)>,
-    },
-    Packed {
-        inner: OracleIdx,
-        log_degree: usize,
-    },
-    Transparent(Transparent),
-    StepDown,
-    Shifted {
-        inner: OracleIdx,
-        shift_offset: u32,
-        block_bits: usize,
-        variant: ShiftVariant,
-    },
-    Projected {
-        inner: OracleIdx,
-        selection: u64,
-        chunk_size: usize,
-        /// Cached bits for slightly faster circuit compilation
-        selection_bits: Vec<F>,
-    },
-}
-
-pub type ModuleId = usize;
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum RelativeHeight {
-    Base,
-    Div2(u8),
-    Mul2(u8),
-}
-
-impl RelativeHeight {
-    pub fn transform(&self, base_log_height: u8) -> u8 {
-        match self {
-            Self::Base => base_log_height,
-            Self::Div2(x) => base_log_height - x,
-            Self::Mul2(x) => base_log_height + x,
-        }
-    }
-}
-
-pub struct OracleInfo {
-    pub name: String,
-    pub tower_level: usize,
-    pub kind: OracleKind,
-    pub relative_height: RelativeHeight,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum ModuleMode {
-    /// An inactive module must be skipped during compilation.
-    Inactive,
-    /// An active module has a selector column with `height = 1 << log_height`
-    /// rows. This column is a `StepDown` oracle with `index = depth <= height`.
-    Active { log_height: u8, depth: u64 },
-}
-
-impl ModuleMode {
-    #[inline]
-    pub const fn active(log_height: u8, depth: u64) -> Self {
-        Self::Active { log_height, depth }
-    }
-}
diff --git a/src/archon/populate.rs b/src/archon/populate.rs
deleted file mode 100644
index a8a5d3f6..00000000
--- a/src/archon/populate.rs
+++ /dev/null
@@ -1,1400 +0,0 @@
-use anyhow::{Result, bail, ensure};
-use binius_core::oracle::ShiftVariant;
-use binius_field::{
-    BinaryField1b as B1, BinaryField8b as B8, BinaryField16b as B16, BinaryField32b as B32,
-    BinaryField64b as B64, BinaryField128b as B128, Field, TowerField,
-    arch::OptimalUnderlier,
-    underlier::{UnderlierType, UnderlierWithBitOps},
-};
-use binius_utils::checked_arithmetics::log2_strict_usize;
-use indexmap::IndexSet;
-use rayon::{
-    iter::{
-        IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator,
-        ParallelIterator,
-    },
-    slice::{ParallelSlice, ParallelSliceMut},
-};
-use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
-use std::{collections::hash_map::Entry, iter::repeat_n, mem::transmute};
-
-use super::{
-    ModuleMode, OracleIdx, OracleKind, RelativeHeight,
-    transparent::{Incremental, Transparent, replicate_within_u128},
-    witness::{UNDERLIER_SIZE, WitnessModule},
-};
-
-impl WitnessModule {
-    /// Populates a witness module according to a given `ModuleMode`.
-    ///
-    /// Note: Parts of this algorithm assume that the dependency oracles are
-    /// optimally packed. That is, there is no sparse data encoded.
-    pub fn populate(&mut self, mode: ModuleMode) -> Result<()> {
-        let ModuleMode::Active { log_height, depth } = mode else {
-            // Deactivated module.
-            return Ok(());
-        };
-
-        let log_height_usize = log_height as usize;
-
-        // "Root oracles" are those which aren't committed and aren't dependencies
-        // of any other oracle. `root_oracles` starts with all oracles, which are
-        // removed as the following loop finds out they break such condition.
-        //
-        // The loop also uses ensures that committed oracles are bound to entries,
-        // accumulating the amount of missing bytes for each entry to be padded
-        // with zero afterwards in order to empty out their buffers.
-        let mut root_oracles: FxHashSet<_> = (0..self.num_oracles()).map(OracleIdx).collect();
-        let mut missing_bytes_map = FxHashMap::default();
-        for (oracle_idx, oracle_info) in self.oracles.iter().enumerate() {
-            let oracle_idx = OracleIdx(oracle_idx);
-            match &oracle_info.kind {
-                OracleKind::Committed => {
-                    let Some(&(entry_id, tower_level)) = self.entry_map.get(&oracle_idx) else {
-                        bail!(
-                            "Committed oracle {} (id={oracle_idx}) for witness module {} is unbound",
-                            &oracle_info.name,
-                            &self.module_id,
-                        );
-                    };
-
-                    let target_log_height = oracle_info.relative_height.transform(log_height);
-                    let target_log_num_bits = target_log_height as usize + tower_level;
-                    ensure!(
-                        target_log_num_bits >= OptimalUnderlier::LOG_BITS,
-                        "Committed oracle {} (id={oracle_idx}) for witness module {} doesn't fulfill 128 bits",
-                        &oracle_info.name,
-                        &self.module_id,
-                    );
-                    let target_num_bytes = (1 << target_log_num_bits) / 8;
-
-                    let current_num_bytes = UNDERLIER_SIZE * self.entries[entry_id].len()
-                        + self.buffers[entry_id].len();
-                    ensure!(
-                        current_num_bytes <= target_num_bytes,
-                        "Too many bytes for oracle {} (id={oracle_idx}). Maximum allowed is {target_num_bytes}",
-                        &oracle_info.name
-                    );
-
-                    // Compute and accumulate the amount of missing bytes.
-                    if current_num_bytes < target_num_bytes {
-                        let num_missing_bytes = target_num_bytes - current_num_bytes;
-                        if let Some(existing_num_missing_bytes) =
-                            missing_bytes_map.insert(entry_id, num_missing_bytes)
-                        {
-                            ensure!(
-                                num_missing_bytes == existing_num_missing_bytes,
-                                "Incompatible amount of missing data for entry {entry_id}"
-                            );
-                        }
-                    }
-
-                    // A committed oracle is not a root oracle.
-                    root_oracles.remove(&oracle_idx);
-                }
-                OracleKind::LinearCombination { inner, .. } => {
-                    for (inner_oracle_id, _) in inner {
-                        root_oracles.remove(inner_oracle_id);
-                    }
-                }
-                OracleKind::Packed { inner, .. }
-                | OracleKind::Shifted { inner, .. }
-                | OracleKind::Projected { inner, .. } => {
-                    root_oracles.remove(inner);
-                }
-                OracleKind::Transparent(_) | OracleKind::StepDown => (),
-            }
-        }
-
-        // Pad missing bytes with zeros.
-        for (entry_id, num_missing_bytes) in missing_bytes_map {
-            self.push_u8s_to(repeat_n(0, num_missing_bytes), entry_id);
-        }
-
-        // The incoming code block aims to calculate a compute order for the
-        // oracles, in which the root oracles will be last and the leaf oracles
-        // will be first. It is stored in `compute_order` in reverse so that
-        // iterating over the oracles should be done by popping.
-        let mut compute_order = IndexSet::<_, FxBuildHasher>::default();
-        let mut to_visit_stack = Vec::from_iter(root_oracles);
-        macro_rules! stack_to_visit {
-            ($o:ident) => {
-                if !compute_order.contains($o) {
-                    to_visit_stack.push(*$o);
-                }
-            };
-        }
-        while let Some(oracle_idx) = to_visit_stack.pop() {
-            let mut is_committed = false;
-            match &self.oracles[oracle_idx.val()].kind {
-                OracleKind::Committed => is_committed = true,
-                OracleKind::LinearCombination { inner, .. } => {
-                    for (inner_oracle_id, _) in inner {
-                        stack_to_visit!(inner_oracle_id);
-                    }
-                }
-                OracleKind::Packed { inner, .. }
-                | OracleKind::Shifted { inner, .. }
-                | OracleKind::Projected { inner, .. } => {
-                    stack_to_visit!(inner)
-                }
-                OracleKind::Transparent(_) | OracleKind::StepDown => (),
-            }
-            if !is_committed {
-                compute_order.insert(oracle_idx);
-            }
-        }
-
-        // And now we're finally able to populate the witness, following the
-        // correct compute order and making the assumption that dependency oracles
-        // were already populated.
-        while let Some(oracle_idx) = compute_order.pop() {
-            if self.entry_map.contains_key(&oracle_idx) {
-                // Already populated. Skip.
-                continue;
-            }
-            let oracle_info = &self.oracles[oracle_idx.val()];
-            let oracle_entry = match &oracle_info.kind {
-                OracleKind::Committed => unreachable!("Committed oracles shouldn't be computed"),
-                OracleKind::LinearCombination { offset, inner } => {
-                    // The strategy to compute linear combinations is to pack the same number
-                    // of binary field elements in an underlier as the target oracle. For example,
-                    // if the target oracle is in the tower level 6, that means it will contain
-                    // two B64's in a single underlier and thus we need to pack the dependencies
-                    // in the same manner.
-
-                    let mut tower_level = offset.min_tower_level();
-                    let mut inner_data = Vec::with_capacity(inner.len());
-
-                    // Extract entry data from `inner`, assuming it was already computed.
-                    for (inner_oracle_id, coeff) in inner {
-                        let &(entry_id, inner_tower_level) = self
-                            .entry_map
-                            .get(inner_oracle_id)
-                            .expect("Data should be available");
-                        tower_level = tower_level
-                            .max(inner_tower_level)
-                            .max(coeff.min_tower_level());
-                        inner_data.push((inner_oracle_id, coeff, entry_id, inner_tower_level));
-                    }
-
-                    let log_height = oracle_info.relative_height.transform(log_height);
-
-                    // The number of underliers for the target oracle and also for the dependencies
-                    let entry_len =
-                        (1 << (log_height as usize + tower_level)) / OptimalUnderlier::BITS;
-                    ensure!(
-                        entry_len != 0,
-                        "Not enough data to compute linear combination. 128 bits are required."
-                    );
-
-                    // Expand an underlier into multiple underliers, extracting binary field elements
-                    // data for upcasts into the tower level of the target oracle
-                    let expand = |u, tower_diff| {
-                        assert_ne!(tower_diff, 0);
-                        let u128 = unsafe { transmute::<OptimalUnderlier, u128>(u) };
-                        let tower_diff_pow = 1usize << tower_diff;
-                        let step = 128 / tower_diff_pow;
-                        let mask = (1u128 << step) - 1;
-                        (0..tower_diff_pow)
-                            .map(|i| OptimalUnderlier::from((u128 >> (i * step)) & mask))
-                            .collect::<Vec<_>>()
-                    };
-                    // For every inner oracle dependency, cache the underliers needed to compute
-                    // the linear combination, according to the tower diff w.r.t. the target oracle
-                    let mut dependencies = FxHashMap::default();
-                    for &(inner_oracle_id, _, entry_id, inner_tower_level) in &inner_data {
-                        let tower_diff = tower_level - inner_tower_level;
-                        if let Entry::Vacant(e) = dependencies.entry(inner_oracle_id) {
-                            let underliers = if tower_diff == 0 {
-                                self.entries[entry_id].clone()
-                            } else {
-                                let entries = &self.entries[entry_id];
-                                let mut dep_underliers = vec![OptimalUnderlier::ZERO; entry_len];
-                                dep_underliers
-                                    .par_chunks_mut(1 << tower_diff)
-                                    .enumerate()
-                                    .for_each(|(chunk_idx, chunk)| {
-                                        let expanded = expand(entries[chunk_idx], tower_diff);
-                                        assert_eq!(chunk.len(), expanded.len());
-                                        for (chunk_elt, expanded_item) in
-                                            chunk.iter_mut().zip(expanded)
-                                        {
-                                            *chunk_elt = expanded_item;
-                                        }
-                                    });
-                                dep_underliers
-                            };
-                            e.insert(underliers);
-                        }
-                    }
-                    // Convenient getter for the i-th underlier from `dependencies`
-                    let get_dep_underlier = |inner_oracle_id, i| {
-                        dependencies
-                            .get(inner_oracle_id)
-                            .expect("Data should be available")[i]
-                    };
-
-                    // The resulting underliers start with zeros and are mutated in parallel for
-                    // extra speed.
-                    let mut underliers = vec![OptimalUnderlier::ZERO; entry_len];
-                    match tower_level {
-                        0 => {
-                            let span = |b| if b == &B128::ZERO { 0 } else { u128::MAX };
-                            let offset = span(offset);
-                            underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                let res = inner_data.iter().fold(
-                                    offset,
-                                    |acc, (inner_oracle_id, coeff, ..)| {
-                                        let underlier = get_dep_underlier(inner_oracle_id, i);
-                                        let u128 = unsafe {
-                                            transmute::<OptimalUnderlier, u128>(underlier)
-                                        };
-                                        let coeff = span(*coeff);
-                                        // In `B1`, addition is bitwise XOR and multiplication
-                                        // is bitwise AND
-                                        acc ^ (coeff & u128)
-                                    },
-                                );
-                                *u = unsafe { transmute::<u128, OptimalUnderlier>(res) };
-                            });
-                        }
-                        1 | 2 => todo!(),
-                        3 => {
-                            let offset: B8 =
-                                (*offset).try_into().expect("Wrong minimal tower level");
-                            underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                #[rustfmt::skip]
-                                let res = inner_data.iter().fold(
-                                    [offset; 16],
-                                    |[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15],
-                                    (inner_oracle_id, coeff, ..)| {
-                                        let underlier = get_dep_underlier(inner_oracle_id, i);
-                                        let [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15] = unsafe {
-                                            transmute::<OptimalUnderlier, [B8; 16]>(underlier)
-                                        };
-                                        let coeff: B8 =
-                                            (**coeff).try_into().expect("Wrong minimal tower");
-                                        [
-                                            a0 + coeff * b0, a1 + coeff * b1, a2 + coeff * b2, a3 + coeff * b3,
-                                            a4 + coeff * b4, a5 + coeff * b5, a6 + coeff * b6, a7 + coeff * b7,
-                                            a8 + coeff * b8, a9 + coeff * b9, a10 + coeff * b10, a11 + coeff * b11,
-                                            a12 + coeff * b12, a13 + coeff * b13, a14 + coeff * b14, a15 + coeff * b15
-                                        ]
-                                    },
-                                );
-                                *u = unsafe { transmute::<[B8; 16], OptimalUnderlier>(res) };
-                            })
-                        }
-                        4 => {
-                            let offset: B16 =
-                                (*offset).try_into().expect("Wrong minimal tower level");
-                            underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                let res = inner_data.iter().fold(
-                                    [offset; 8],
-                                    |[a0, a1, a2, a3, a4, a5, a6, a7], (inner_oracle_id, coeff, ..)| {
-                                        let underlier = get_dep_underlier(inner_oracle_id, i);
-                                        let [b0, b1, b2, b3, b4, b5, b6, b7] = unsafe {
-                                            transmute::<OptimalUnderlier, [B16; 8]>(underlier)
-                                        };
-                                        let coeff: B16 =
-                                            (**coeff).try_into().expect("Wrong minimal tower");
-                                        [
-                                            a0 + coeff * b0, a1 + coeff * b1, a2 + coeff * b2, a3 + coeff * b3,
-                                            a4 + coeff * b4, a5 + coeff * b5, a6 + coeff * b6, a7 + coeff * b7,
-                                        ]
-                                    },
-                                );
-                                *u = unsafe { transmute::<[B16; 8], OptimalUnderlier>(res) };
-                            })
-                        }
-                        5 => {
-                            let offset: B32 =
-                                (*offset).try_into().expect("Wrong minimal tower level");
-                            underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                let res = inner_data.iter().fold(
-                                    [offset; 4],
-                                    |[a0, a1, a2, a3], (inner_oracle_id, coeff, ..)| {
-                                        let underlier = get_dep_underlier(inner_oracle_id, i);
-                                        let [b0, b1, b2, b3] = unsafe {
-                                            transmute::<OptimalUnderlier, [B32; 4]>(underlier)
-                                        };
-                                        let coeff: B32 =
-                                            (**coeff).try_into().expect("Wrong minimal tower");
-                                        [
-                                            a0 + coeff * b0,
-                                            a1 + coeff * b1,
-                                            a2 + coeff * b2,
-                                            a3 + coeff * b3,
-                                        ]
-                                    },
-                                );
-                                *u = unsafe { transmute::<[B32; 4], OptimalUnderlier>(res) };
-                            })
-                        }
-                        6 => {
-                            let offset: B64 =
-                                (*offset).try_into().expect("Wrong minimal tower level");
-                            underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                let res = inner_data.iter().fold(
-                                    [offset; 2],
-                                    |[a0, a1], (inner_oracle_id, coeff, ..)| {
-                                        let underlier = get_dep_underlier(inner_oracle_id, i);
-                                        let [b0, b1] = unsafe {
-                                            transmute::<OptimalUnderlier, [B64; 2]>(underlier)
-                                        };
-                                        let coeff: B64 =
-                                            (**coeff).try_into().expect("Wrong minimal tower");
-                                        [a0 + coeff * b0, a1 + coeff * b1]
-                                    },
-                                );
-                                *u = unsafe { transmute::<[B64; 2], OptimalUnderlier>(res) };
-                            })
-                        }
-                        7 => underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                            let res = inner_data.iter().fold(
-                                *offset,
-                                |acc, (inner_oracle_id, coeff, ..)| {
-                                    let underlier = get_dep_underlier(inner_oracle_id, i);
-                                    let b =
-                                        unsafe { transmute::<OptimalUnderlier, B128>(underlier) };
-                                    acc + **coeff * b
-                                },
-                            );
-                            *u = unsafe { transmute::<B128, OptimalUnderlier>(res) };
-                        }),
-                        _ => bail!("Unsupported tower level: {tower_level}"),
-                    }
-                    let entry_id = self.new_entry();
-                    self.entries[entry_id] = underliers;
-                    (entry_id, tower_level)
-                }
-                OracleKind::Packed { inner, log_degree } => {
-                    let &(inner_entry_id, inner_tower_level) =
-                        self.entry_map.get(inner).expect("Data should be available");
-                    (inner_entry_id, inner_tower_level + log_degree)
-                }
-                OracleKind::Transparent(transparent) => match transparent {
-                    Transparent::Constant(c) => {
-                        let log_height = oracle_info.relative_height.transform(log_height);
-                        let log_height_usize = log_height as usize;
-                        let tower_level = oracle_info.tower_level;
-                        let log_num_bits = log_height_usize + tower_level;
-                        if log_num_bits >= OptimalUnderlier::LOG_BITS {
-                            let u = OptimalUnderlier::from(replicate_within_u128(*c));
-                            let num_underliers = (1 << log_num_bits) / OptimalUnderlier::BITS;
-                            let entry_id = self.new_entry();
-                            self.entries[entry_id] = vec![u; num_underliers];
-                            (entry_id, tower_level)
-                        } else {
-                            let height = 1 << log_height;
-                            let shift_size = OptimalUnderlier::BITS / height;
-                            let mut u128 = 0u128;
-                            for i in 0..height {
-                                u128 |= c.val() << (i * shift_size);
-                            }
-                            let entry_id = self.new_entry();
-                            self.entries[entry_id] = vec![OptimalUnderlier::from(u128)];
-                            (entry_id, OptimalUnderlier::LOG_BITS - log_height_usize)
-                        }
-                    }
-                    Transparent::Incremental => {
-                        let log_height = oracle_info.relative_height.transform(log_height);
-                        let log_height_usize = log_height as usize;
-                        let tower_level = Incremental::min_tower_level(log_height);
-                        let log_num_bits = log_height_usize + tower_level;
-                        if log_num_bits >= OptimalUnderlier::LOG_BITS {
-                            let num_underliers = (1 << log_num_bits) / OptimalUnderlier::BITS;
-                            let mut underliers = vec![OptimalUnderlier::ZERO; num_underliers];
-                            match tower_level {
-                                3 => {
-                                    underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                        let i = (i % (u8::MAX as usize)).try_into().unwrap();
-                                        let (start, _) = 16u8.overflowing_mul(i);
-                                        #[rustfmt::skip]
-                                        let data = [
-                                            start,      start +  1, start +  2, start +  3,
-                                            start +  4, start +  5, start +  6, start +  7,
-                                            start +  8, start +  9, start + 10, start + 11,
-                                            start + 12, start + 13, start + 14, start + 15,
-                                        ];
-                                        *u = unsafe {
-                                            transmute::<[u8; 16], OptimalUnderlier>(data)
-                                        };
-                                    });
-                                }
-                                4 => {
-                                    underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                        let i = (i % (u16::MAX as usize)).try_into().unwrap();
-                                        let (start, _) = 8u16.overflowing_mul(i);
-                                        #[rustfmt::skip]
-                                        let data = [
-                                            start,     start + 1, start + 2, start + 3,
-                                            start + 4, start + 5, start + 6, start + 7,
-                                        ];
-                                        *u = unsafe {
-                                            transmute::<[u16; 8], OptimalUnderlier>(data)
-                                        };
-                                    });
-                                }
-                                5 => {
-                                    underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                        let i = (i % (u32::MAX as usize)).try_into().unwrap();
-                                        let (start, _) = 4u32.overflowing_mul(i);
-                                        let data = [start, start + 1, start + 2, start + 3];
-                                        *u = unsafe {
-                                            transmute::<[u32; 4], OptimalUnderlier>(data)
-                                        };
-                                    });
-                                }
-                                6 => {
-                                    underliers.par_iter_mut().enumerate().for_each(|(i, u)| {
-                                        let (start, _) = 2u64.overflowing_mul(i as u64);
-                                        let data = [start, start + 1];
-                                        *u = unsafe {
-                                            transmute::<[u64; 2], OptimalUnderlier>(data)
-                                        };
-                                    });
-                                }
-                                _ => todo!(),
-                            };
-                            let entry_id = self.new_entry();
-                            self.entries[entry_id] = underliers;
-                            (entry_id, tower_level)
-                        } else {
-                            let height = 1 << log_height;
-                            let shift_size = OptimalUnderlier::BITS / height;
-                            let mut u128 = 0u128;
-                            for i in 0..height {
-                                u128 |= (i as u128) << (i * shift_size);
-                            }
-                            let entry_id = self.new_entry();
-                            self.entries[entry_id] = vec![OptimalUnderlier::from(u128)];
-                            (entry_id, OptimalUnderlier::LOG_BITS - log_height_usize)
-                        }
-                    }
-                },
-                OracleKind::StepDown => {
-                    let tower_level = oracle_info.tower_level;
-                    assert_eq!(tower_level, 0);
-                    assert_eq!(oracle_info.relative_height, RelativeHeight::Base);
-                    let depth_usize: usize = depth.try_into()?;
-                    if log_height_usize >= OptimalUnderlier::LOG_BITS {
-                        let num_underliers = (1 << log_height) / OptimalUnderlier::BITS;
-                        let mut underliers = vec![OptimalUnderlier::from(0u128); num_underliers];
-                        let step_down_changes_at = depth_usize / OptimalUnderlier::BITS;
-
-                        // Set the first bits to 1.
-                        underliers[..step_down_changes_at]
-                            .par_iter_mut()
-                            .for_each(|u| *u = OptimalUnderlier::from(u128::MAX));
-
-                        if step_down_changes_at < num_underliers {
-                            // Produce an `u128` with the `depth_usize % OptimalUnderlier::BITS`
-                            // least significant bits set to one and the rest set to zero.
-                            let u128: u128 = (1 << (depth_usize % OptimalUnderlier::BITS)) - 1;
-                            underliers[step_down_changes_at] = OptimalUnderlier::from(u128);
-                        }
-
-                        let entry_id = self.new_entry();
-                        self.entries[entry_id] = underliers;
-                        (entry_id, tower_level)
-                    } else {
-                        // Fill an `OptimalUnderlier` with sparse data
-                        let shift_size = OptimalUnderlier::BITS / (1 << log_height);
-                        let mut u = 0u128;
-                        for i in 0..depth_usize {
-                            u |= 1 << (i * shift_size)
-                        }
-
-                        let entry_id = self.new_entry();
-                        self.entries[entry_id] = vec![OptimalUnderlier::from(u)];
-                        (entry_id, OptimalUnderlier::LOG_BITS - log_height_usize)
-                    }
-                }
-                OracleKind::Shifted {
-                    inner,
-                    shift_offset,
-                    block_bits,
-                    variant,
-                } => {
-                    let tower_level = oracle_info.tower_level;
-
-                    let &(inner_entry_id, _) =
-                        self.entry_map.get(inner).expect("Data should be available");
-
-                    let mut underliers = self.entries[inner_entry_id].clone();
-
-                    macro_rules! shift_underliers {
-                        ($parts_typ:ty, $f:expr) => {
-                            underliers.par_iter_mut().for_each(|underlier| {
-                                let mut out = unsafe {
-                                    transmute::<OptimalUnderlier, $parts_typ>(*underlier)
-                                };
-                                for out_i in out.iter_mut() {
-                                    *out_i = $f(out_i).into();
-                                }
-                                *underlier =
-                                    unsafe { transmute::<$parts_typ, OptimalUnderlier>(out) };
-                            });
-                        };
-                    }
-
-                    match (block_bits, variant) {
-                        (3, ShiftVariant::LogicalRight) => {
-                            shift_underliers!([B8; 16], |x: &B8| x.val() >> shift_offset);
-                        }
-                        (3, ShiftVariant::LogicalLeft) => {
-                            shift_underliers!([B8; 16], |x: &B8| x.val() << shift_offset);
-                        }
-                        (3, ShiftVariant::CircularLeft) => {
-                            shift_underliers!([B8; 16], |x: &B8| x
-                                .val()
-                                .rotate_left(*shift_offset));
-                        }
-                        (4, ShiftVariant::LogicalRight) => {
-                            shift_underliers!([B16; 8], |x: &B16| x.val() >> shift_offset);
-                        }
-                        (4, ShiftVariant::LogicalLeft) => {
-                            shift_underliers!([B16; 8], |x: &B16| x.val() << shift_offset);
-                        }
-                        (4, ShiftVariant::CircularLeft) => {
-                            shift_underliers!([B16; 8], |x: &B16| x
-                                .val()
-                                .rotate_left(*shift_offset));
-                        }
-                        (5, ShiftVariant::LogicalRight) => {
-                            shift_underliers!([B32; 4], |x: &B32| x.val() >> shift_offset);
-                        }
-                        (5, ShiftVariant::LogicalLeft) => {
-                            shift_underliers!([B32; 4], |x: &B32| x.val() << shift_offset);
-                        }
-                        (5, ShiftVariant::CircularLeft) => {
-                            shift_underliers!([B32; 4], |x: &B32| x
-                                .val()
-                                .rotate_left(*shift_offset));
-                        }
-                        (6, ShiftVariant::LogicalRight) => {
-                            shift_underliers!([B64; 2], |x: &B64| x.val() >> shift_offset);
-                        }
-                        (6, ShiftVariant::LogicalLeft) => {
-                            shift_underliers!([B64; 2], |x: &B64| x.val() << shift_offset);
-                        }
-                        (6, ShiftVariant::CircularLeft) => {
-                            shift_underliers!([B64; 2], |x: &B64| x
-                                .val()
-                                .rotate_left(*shift_offset));
-                        }
-                        (7, ShiftVariant::LogicalRight) => {
-                            shift_underliers!([B128; 1], |x: &B128| x.val() >> shift_offset);
-                        }
-                        (7, ShiftVariant::LogicalLeft) => {
-                            shift_underliers!([B128; 1], |x: &B128| x.val() << shift_offset);
-                        }
-                        (7, ShiftVariant::CircularLeft) => {
-                            shift_underliers!([B128; 1], |x: &B128| x
-                                .val()
-                                .rotate_left(*shift_offset));
-                        }
-                        _ => unimplemented!(),
-                    };
-
-                    let entry_id = self.new_entry();
-                    self.entries[entry_id] = underliers;
-                    (entry_id, tower_level)
-                }
-
-                OracleKind::Projected {
-                    inner,
-                    selection,
-                    chunk_size,
-                    ..
-                } => {
-                    let tower_level = oracle_info.tower_level;
-                    let &(inner_entry_id, _) =
-                        self.entry_map.get(inner).expect("Data should be available");
-
-                    macro_rules! project_underliers {
-                        ($d:literal, $ty:ident, $uty:ident, $unpack:expr, $pack:expr) => {{
-                            const DIVISOR: usize = $d;
-
-                            let chunk_size = *chunk_size;
-                            let selection_usize = usize::try_from(*selection)?;
-
-                            // Compute total number of elements
-                            let num_elts = self.entries[inner_entry_id].len() * DIVISOR;
-                            let num_chunks = num_elts.div_ceil(chunk_size);
-
-                            let unpacked_data = self.entries[inner_entry_id]
-                                .par_iter()
-                                .flat_map($unpack)
-                                .collect::<Vec<_>>();
-
-                            let num_projections = (1 << tower_level) * num_chunks;
-                            if num_projections >= 128 {
-                                // An `OptimalUnderlier` won't exceed the expected amount of data
-
-                                // Pre-allocate the projected field elements
-                                let mut projected_field_elements = Vec::with_capacity(num_chunks);
-
-                                unpacked_data
-                                    .par_chunks_exact(chunk_size)
-                                    .map(|chunk| chunk[selection_usize])
-                                    .collect_into_vec(&mut projected_field_elements);
-
-                                // Pad to multiple of DIVISOR
-                                #[allow(clippy::modulo_one)]
-                                let pad_len = projected_field_elements.len() % DIVISOR;
-                                if pad_len != 0 {
-                                    projected_field_elements
-                                        .extend(repeat_n($ty::ZERO, DIVISOR - pad_len));
-                                }
-
-                                // Compose underliers in parallel
-                                let underliers = projected_field_elements
-                                    .par_chunks_exact(DIVISOR)
-                                    .map(|chunk| $pack(chunk.try_into().unwrap()))
-                                    .collect();
-                                (underliers, tower_level)
-                            } else {
-                                // We need to fill an `OptimalUnderlier` with sparse data
-                                let shift_size = 128 / num_projections;
-                                let new_tower_level = log2_strict_usize(shift_size);
-                                let mut u = 0u128;
-
-                                #[allow(trivial_numeric_casts)]
-                                for (chunk_idx, chunk) in
-                                    unpacked_data.chunks_exact(chunk_size).enumerate()
-                                {
-                                    let uty =
-                                        unsafe { transmute::<$ty, $uty>(chunk[selection_usize]) };
-                                    u |= (uty as u128) << (chunk_idx * shift_size);
-                                }
-                                (vec![OptimalUnderlier::from(u)], new_tower_level)
-                            }
-                        }};
-                    }
-
-                    let (projected_underliers, new_tower_level) = match tower_level {
-                        0 => project_underliers!(
-                            128,
-                            B1,
-                            u8,
-                            |u| {
-                                let u = unsafe { transmute::<OptimalUnderlier, u128>(*u) };
-                                let mut arr = [B1::ZERO; 128];
-                                for (i, b) in arr.iter_mut().enumerate() {
-                                    if (u >> i) & 1 == 1 {
-                                        *b = B1::ONE;
-                                    }
-                                }
-                                arr
-                            },
-                            |a: [B1; 128]| {
-                                let mut u = 0;
-                                for (i, b) in a.into_iter().enumerate() {
-                                    if b == B1::ONE {
-                                        u |= 1 << i;
-                                    }
-                                }
-                                unsafe { transmute::<u128, OptimalUnderlier>(u) }
-                            }
-                        ),
-                        3 => project_underliers!(
-                            16,
-                            B8,
-                            u8,
-                            |u| unsafe { transmute::<OptimalUnderlier, [B8; 16]>(*u) },
-                            |a| unsafe { transmute::<[B8; 16], OptimalUnderlier>(a) }
-                        ),
-                        4 => project_underliers!(
-                            8,
-                            B16,
-                            u16,
-                            |u| unsafe { transmute::<OptimalUnderlier, [B16; 8]>(*u) },
-                            |a| unsafe { transmute::<[B16; 8], OptimalUnderlier>(a) }
-                        ),
-                        5 => project_underliers!(
-                            4,
-                            B32,
-                            u32,
-                            |u| unsafe { transmute::<OptimalUnderlier, [B32; 4]>(*u) },
-                            |a| unsafe { transmute::<[B32; 4], OptimalUnderlier>(a) }
-                        ),
-                        6 => project_underliers!(
-                            2,
-                            B64,
-                            u64,
-                            |u| unsafe { transmute::<OptimalUnderlier, [B64; 2]>(*u) },
-                            |a| unsafe { transmute::<[B64; 2], OptimalUnderlier>(a) }
-                        ),
-                        7 => project_underliers!(
-                            1,
-                            B128,
-                            u128,
-                            |u| unsafe { transmute::<OptimalUnderlier, [B128; 1]>(*u) },
-                            |a| unsafe { transmute::<[B128; 1], OptimalUnderlier>(a) }
-                        ),
-                        _ => unimplemented!(),
-                    };
-
-                    let entry_id = self.new_entry();
-                    self.entries[entry_id] = projected_underliers;
-                    (entry_id, new_tower_level)
-                }
-            };
-
-            self.entry_map.insert(oracle_idx, oracle_entry);
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use binius_core::oracle::ShiftVariant;
-    use binius_field::{
-        BinaryField1b as B1, BinaryField2b as B2, BinaryField4b as B4, BinaryField8b as B8,
-        BinaryField16b as B16, BinaryField32b as B32, BinaryField64b as B64,
-        BinaryField128b as B128, Field, arch::OptimalUnderlier, underlier::UnderlierType,
-    };
-    use binius_utils::checked_arithmetics::log2_ceil_usize;
-    use rayon::iter::{IntoParallelIterator, ParallelIterator};
-
-    use crate::archon::{
-        ModuleMode, RelativeHeight,
-        arith_expr::ArithExpr,
-        circuit::{CircuitModule, init_witness_modules},
-        protocol::validate_witness,
-        transparent::Transparent,
-        witness::compile_witness_modules,
-    };
-
-    fn f(u128: u128) -> B128 {
-        B128::new(u128)
-    }
-
-    const DEPTHS: [usize; 15] = [1, 2, 3, 5, 14, 30, 60, 65, 66, 128, 200, 256, 400, 512, 600];
-
-    #[test]
-    fn test_populate_constant() {
-        let mut circuit_module = CircuitModule::new(0);
-        macro_rules! constant_for {
-            ($t:ident) => {
-                Transparent::Constant(f(($t::MAX - $t::MAX / 3) as u128))
-            };
-        }
-        circuit_module
-            .add_transparent("b1_0", Transparent::Constant(f(0)), RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_transparent("b1_1", Transparent::Constant(f(1)), RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_transparent("b2", Transparent::Constant(f(2)), RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_transparent("b4", Transparent::Constant(f(9)), RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_transparent("b8", constant_for!(u8), RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_transparent("b16", constant_for!(u16), RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_transparent("b32", constant_for!(u32), RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_transparent("b64", constant_for!(u64), RelativeHeight::Base)
-            .unwrap();
-        #[allow(trivial_numeric_casts)]
-        circuit_module
-            .add_transparent("b128", constant_for!(u128), RelativeHeight::Base)
-            .unwrap();
-
-        circuit_module.freeze_oracles();
-        let circuit_modules = [circuit_module];
-
-        let test_with_depth = |depth| {
-            let mut witness_modules = init_witness_modules(&circuit_modules).unwrap();
-            let log_height = log2_ceil_usize(depth).try_into().unwrap();
-            let depth = depth as u64;
-            let mode = ModuleMode::active(log_height, depth);
-            witness_modules[0].populate(mode).unwrap();
-            assert!(!witness_modules[0].entry_map.is_empty());
-            let witness = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-            assert!(validate_witness(&circuit_modules, &[], &witness).is_ok());
-        };
-
-        DEPTHS.into_par_iter().for_each(test_with_depth);
-    }
-
-    #[test]
-    fn test_populate_incremental() {
-        let mut circuit_module = CircuitModule::new(0);
-        circuit_module
-            .add_transparent("incr", Transparent::Incremental, RelativeHeight::Base)
-            .unwrap();
-        circuit_module.freeze_oracles();
-        let circuit_modules = [circuit_module];
-
-        let test_with_depth = |depth| {
-            let mut witness_modules = init_witness_modules(&circuit_modules).unwrap();
-            let log_height = log2_ceil_usize(depth).try_into().unwrap();
-            let depth = depth as u64;
-            let mode = ModuleMode::active(log_height, depth);
-            witness_modules[0].populate(mode).unwrap();
-            assert!(!witness_modules[0].entry_map.is_empty());
-            let witness = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-            assert!(validate_witness(&circuit_modules, &[], &witness).is_ok());
-        };
-
-        DEPTHS.into_par_iter().for_each(test_with_depth);
-    }
-
-    #[test]
-    fn test_populate_linear_combination() {
-        let mut circuit_module = CircuitModule::new(0);
-        let b1 = circuit_module
-            .add_committed::<B1>("b1", RelativeHeight::Base)
-            .unwrap();
-        let b2 = circuit_module
-            .add_committed::<B2>("b2", RelativeHeight::Base)
-            .unwrap();
-        let b4 = circuit_module
-            .add_committed::<B4>("b4", RelativeHeight::Base)
-            .unwrap();
-        let b8 = circuit_module
-            .add_committed::<B8>("b8", RelativeHeight::Base)
-            .unwrap();
-        let b16 = circuit_module
-            .add_committed::<B16>("b16", RelativeHeight::Base)
-            .unwrap();
-        let b32 = circuit_module
-            .add_committed::<B32>("b32", RelativeHeight::Base)
-            .unwrap();
-        let b64 = circuit_module
-            .add_committed::<B64>("b64", RelativeHeight::Base)
-            .unwrap();
-        let b128 = circuit_module
-            .add_committed::<B128>("b128", RelativeHeight::Base)
-            .unwrap();
-
-        circuit_module
-            .add_linear_combination(
-                "lcb128",
-                f(3),
-                [
-                    (b1, f(3)),
-                    (b2, f(4)),
-                    (b4, f(5)),
-                    (b8, f(6)),
-                    (b16, f(7)),
-                    (b32, f(8)),
-                    (b64, f(9)),
-                    (b128, f(10)),
-                ],
-                RelativeHeight::Base,
-            )
-            .unwrap();
-
-        circuit_module
-            .add_linear_combination(
-                "lcb64",
-                f(907898),
-                [
-                    (b1, f(500)),
-                    (b2, f(2000)),
-                    (b4, f(5)),
-                    (b8, f(4)),
-                    (b16, f(7)),
-                    (b32, f(8)),
-                    (b64, f(9879)),
-                ],
-                RelativeHeight::Base,
-            )
-            .unwrap();
-
-        circuit_module.freeze_oracles();
-        let circuit_modules = [circuit_module];
-
-        let mut witness_modules = init_witness_modules(&circuit_modules).unwrap();
-
-        let mut oracles = [b1, b2, b4, b8, b16, b32, b64, b128];
-        oracles.sort_by_key(|x| ((x.val() + 3) * (x.val() + 5)) % 7);
-        for (i, oracle_id) in oracles.into_iter().enumerate() {
-            let entry_id = witness_modules[0].new_entry();
-            for j in 0..1u128 << i {
-                witness_modules[0].push_u128s_to([j * j + 17], entry_id);
-            }
-            match i {
-                0 => witness_modules[0].bind_oracle_to::<B1>(oracle_id, entry_id),
-                1 => witness_modules[0].bind_oracle_to::<B2>(oracle_id, entry_id),
-                2 => witness_modules[0].bind_oracle_to::<B4>(oracle_id, entry_id),
-                3 => witness_modules[0].bind_oracle_to::<B8>(oracle_id, entry_id),
-                4 => witness_modules[0].bind_oracle_to::<B16>(oracle_id, entry_id),
-                5 => witness_modules[0].bind_oracle_to::<B32>(oracle_id, entry_id),
-                6 => witness_modules[0].bind_oracle_to::<B64>(oracle_id, entry_id),
-                7 => witness_modules[0].bind_oracle_to::<B128>(oracle_id, entry_id),
-                _ => unreachable!(),
-            }
-        }
-        let mode = ModuleMode::active(7, 0);
-        witness_modules[0].populate(mode).unwrap();
-        assert!(!witness_modules[0].entry_map.is_empty());
-        let witness = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok())
-    }
-
-    #[test]
-    fn test_populate_linear_combination_b1() {
-        let mut circuit_module = CircuitModule::new(0);
-        let a = circuit_module
-            .add_committed::<B1>("a", RelativeHeight::Base)
-            .unwrap();
-        let b = circuit_module
-            .add_committed::<B1>("b", RelativeHeight::Base)
-            .unwrap();
-        let c = circuit_module
-            .add_committed::<B1>("c", RelativeHeight::Base)
-            .unwrap();
-
-        circuit_module
-            .add_linear_combination("lc1", B128::ZERO, [], RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_linear_combination("lc2", B128::ONE, [], RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_linear_combination("lc3", B128::ZERO, [(a, B128::ONE)], RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_linear_combination("lc4", B128::ONE, [(b, B128::ONE)], RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_linear_combination(
-                "lc5",
-                B128::ZERO,
-                [(a, B128::ONE), (b, B128::ONE)],
-                RelativeHeight::Base,
-            )
-            .unwrap();
-        circuit_module
-            .add_linear_combination(
-                "lc6",
-                B128::ONE,
-                [(a, B128::ONE), (b, B128::ONE)],
-                RelativeHeight::Base,
-            )
-            .unwrap();
-        circuit_module
-            .add_linear_combination(
-                "lc7",
-                B128::ZERO,
-                [(a, B128::ONE), (b, B128::ONE), (c, B128::ONE)],
-                RelativeHeight::Base,
-            )
-            .unwrap();
-        circuit_module
-            .add_linear_combination(
-                "lc8",
-                B128::ONE,
-                [(a, B128::ONE), (b, B128::ONE), (c, B128::ONE)],
-                RelativeHeight::Base,
-            )
-            .unwrap();
-
-        circuit_module.freeze_oracles();
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-
-        let entry_a = witness_module.new_entry_with_capacity(7);
-        witness_module.push_u128s_to([u128::MAX - u128::MAX / 2 + u128::MAX / 4], entry_a);
-        witness_module.bind_oracle_to::<B1>(a, entry_a);
-
-        let entry_b = witness_module.new_entry_with_capacity(7);
-        witness_module.push_u128s_to([u128::MAX - u128::MAX / 3 + u128::MAX / 7], entry_b);
-        witness_module.bind_oracle_to::<B1>(b, entry_b);
-
-        let entry_c = witness_module.new_entry_with_capacity(7);
-        witness_module.push_u128s_to([u128::MAX - u128::MAX / 5 + u128::MAX / 11], entry_c);
-        witness_module.bind_oracle_to::<B1>(c, entry_c);
-
-        let mode = ModuleMode::active(7, 0);
-        witness_module.populate(mode).unwrap();
-
-        let witness_modules = [witness_module];
-        let witness = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-
-        let circuit_modules = [circuit_module];
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok())
-    }
-
-    #[test]
-    fn test_packed() {
-        let mut circuit_module = CircuitModule::new(0);
-        let input = circuit_module
-            .add_committed::<B1>("input", RelativeHeight::Base)
-            .unwrap();
-        for log_degree in 0..=7 {
-            circuit_module
-                .add_packed(&format!("packed-{input}-{log_degree}"), input, log_degree)
-                .unwrap();
-        }
-        circuit_module.freeze_oracles();
-
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-        let entry_id = witness_module.new_entry_with_capacity(7);
-        witness_module.push_u128s_to([u128::MAX - u128::MAX / 2 + u128::MAX / 4], entry_id);
-        witness_module.bind_oracle_to::<B1>(input, entry_id);
-        let mode = ModuleMode::active(7, 0);
-        witness_module.populate(mode).unwrap();
-
-        let witness_modules = [witness_module];
-        let witness = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-
-        let circuit_modules = [circuit_module];
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok())
-    }
-
-    #[test]
-    fn test_xor_via_linear_combination() {
-        let log_height = 3;
-        let mode = ModuleMode::active(log_height, 0);
-        let mut circuit_module = CircuitModule::new(0);
-        let a = circuit_module
-            .add_committed::<B32>("a", RelativeHeight::Base)
-            .unwrap();
-        let b = circuit_module
-            .add_committed::<B32>("b", RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_linear_combination(
-                "lc",
-                f(0),
-                [(a, B128::ONE), (b, B128::ONE)],
-                RelativeHeight::Base,
-            )
-            .unwrap();
-        circuit_module.freeze_oracles();
-
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-        let a_id = witness_module.new_entry();
-        let b_id = witness_module.new_entry();
-
-        let height = 1 << log_height;
-        // we use U32 field for 'a' and 'b' columns, so divide height by 4 (4 u32 in 1 u128)
-        for _ in 0..height / 4 {
-            witness_module.push_u32s_to([0x0000bbbb, 0x0000bbbb, 0x0000bbbb, 0x0000bbbb], a_id);
-            witness_module.push_u32s_to([0xaaaa0000, 0xaaaa0000, 0xaaaa0000, 0xaaaa0000], b_id);
-        }
-
-        witness_module.bind_oracle_to::<B32>(a, a_id);
-        witness_module.bind_oracle_to::<B32>(b, b_id);
-        witness_module.populate(mode).unwrap();
-
-        let witness_modules = [witness_module];
-        let circuit_modules = [circuit_module];
-        let witness_archon = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness_archon).is_ok());
-    }
-
-    #[test]
-    fn test_packed_b8_b32() {
-        let mode = ModuleMode::active(4, 0);
-        let packed_log_degree = 2usize;
-
-        let mut circuit_module = CircuitModule::new(0);
-        let input = circuit_module
-            .add_committed::<B8>("input", RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_packed(
-                &format!("packed-{input}-{packed_log_degree}"),
-                input,
-                packed_log_degree,
-            )
-            .unwrap();
-        circuit_module.freeze_oracles();
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-        let entry_id = witness_module.new_entry();
-        witness_module.push_u8s_to(
-            [
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff,
-            ],
-            entry_id,
-        );
-        witness_module.bind_oracle_to::<B8>(input, entry_id);
-
-        witness_module.populate(mode).unwrap();
-        let witness_modules = [witness_module];
-        let witness_archon = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-        let circuit_modules = [circuit_module];
-
-        assert!(validate_witness(&circuit_modules, &[], &witness_archon).is_ok());
-    }
-
-    #[test]
-    fn test_shifted() {
-        fn test_inner(
-            input_value: u8,
-            shift_offset: u32,
-            block_bits: usize,
-            optimal_underliers_num: usize,
-            variant: ShiftVariant,
-        ) {
-            let log_height = (OptimalUnderlier::LOG_BITS + optimal_underliers_num)
-                .try_into()
-                .unwrap();
-            let mode = ModuleMode::active(log_height, 0);
-            let height = 1usize << log_height;
-            let mut circuit_module = CircuitModule::new(0);
-            let input = circuit_module
-                .add_committed::<B1>("input", RelativeHeight::Base)
-                .unwrap();
-            circuit_module
-                .add_shifted("shifted", input, shift_offset, block_bits, variant)
-                .unwrap();
-
-            circuit_module.freeze_oracles();
-
-            let mut witness_module = circuit_module.init_witness_module().unwrap();
-            let entry_id = witness_module.new_entry();
-            let input_values = [input_value; 16];
-
-            for _ in 0..height / OptimalUnderlier::BITS {
-                witness_module.push_u8s_to(input_values, entry_id);
-            }
-
-            witness_module.bind_oracle_to::<B1>(input, entry_id);
-
-            witness_module.populate(mode).unwrap();
-
-            let witness_modules = [witness_module];
-            let circuit_modules = [circuit_module];
-            let witness_archon = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-
-            assert!(validate_witness(&circuit_modules, &[], &witness_archon).is_ok())
-        }
-
-        let input_value = 0b10000000u8;
-        let shift_offset = 7;
-        let block_bits = 3usize; // we consider input column storing data as bytes
-        let optimal_underliers_num_powered = 3;
-
-        test_inner(
-            input_value,
-            shift_offset,
-            block_bits,
-            optimal_underliers_num_powered,
-            ShiftVariant::LogicalRight,
-        );
-
-        let input_value = 0b11100011u8;
-        let shift_offset = 1;
-        let block_bits = 5usize; // we consider input column storing data as u32s
-        let optimal_underliers_num_powered = 7;
-
-        test_inner(
-            input_value,
-            shift_offset,
-            block_bits,
-            optimal_underliers_num_powered,
-            ShiftVariant::LogicalRight,
-        );
-
-        let input_value = 0b10000000u8;
-        let shift_offset = 5;
-        let block_bits = 3usize; // we consider input column storing data as bytes
-        let optimal_underliers_num_powered = 8;
-
-        test_inner(
-            input_value,
-            shift_offset,
-            block_bits,
-            optimal_underliers_num_powered,
-            ShiftVariant::LogicalLeft,
-        );
-
-        // this test case is important for Blake3 compression
-        let input_value = 0b10100111u8;
-        let shift_offset = 1;
-        let block_bits = 5usize; // we consider input column storing data as u32s
-        let optimal_underliers_num_powered = 12;
-
-        test_inner(
-            input_value,
-            shift_offset,
-            block_bits,
-            optimal_underliers_num_powered,
-            ShiftVariant::LogicalLeft,
-        );
-
-        // this test case is important for Blake3 compression
-        let input_value = 0b11011010u8;
-        let shift_offset = 16;
-        let block_bits = 5usize; // we consider input column storing data as u32s
-        let optimal_underliers_num_powered = 10;
-
-        test_inner(
-            input_value,
-            shift_offset,
-            block_bits,
-            optimal_underliers_num_powered,
-            ShiftVariant::CircularLeft,
-        );
-    }
-
-    #[test]
-    fn test_projected() {
-        let mut circuit_module = CircuitModule::new(0);
-        let b1 = circuit_module
-            .add_committed::<B1>("b1", RelativeHeight::Base)
-            .unwrap();
-        let b8 = circuit_module
-            .add_committed::<B8>("b8", RelativeHeight::Base)
-            .unwrap();
-        let b16 = circuit_module
-            .add_committed::<B16>("b16", RelativeHeight::Base)
-            .unwrap();
-        let b32 = circuit_module
-            .add_committed::<B32>("b32", RelativeHeight::Base)
-            .unwrap();
-        let b64 = circuit_module
-            .add_committed::<B64>("b64", RelativeHeight::Base)
-            .unwrap();
-        let b128 = circuit_module
-            .add_committed::<B128>("b128", RelativeHeight::Base)
-            .unwrap();
-
-        circuit_module.add_projected("p1_1", b1, 27, 32).unwrap();
-        circuit_module.add_projected("p1_2", b1, 63, 64).unwrap();
-        circuit_module.add_projected("p1_3", b1, 87, 128).unwrap();
-        circuit_module.add_projected("p1_4", b1, 151, 256).unwrap();
-        circuit_module.add_projected("p8_1", b8, 3, 4).unwrap();
-        circuit_module.add_projected("p8_2", b8, 3, 8).unwrap();
-        circuit_module.add_projected("p8_2", b8, 15, 16).unwrap();
-        circuit_module.add_projected("p16", b16, 5, 16).unwrap();
-        circuit_module.add_projected("p32", b32, 7, 8).unwrap();
-        circuit_module.add_projected("p64_1", b64, 3, 4).unwrap();
-        circuit_module
-            .add_projected("p64_2", b64, 101, 128)
-            .unwrap();
-        circuit_module.add_projected("p128", b128, 11, 16).unwrap();
-        circuit_module.freeze_oracles();
-
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-
-        let b1_entry = witness_module.new_entry();
-        let b1_data: [u8; 32] = rand::random(); // 256 bits
-        witness_module.push_u8s_to(b1_data, b1_entry);
-        witness_module.bind_oracle_to::<B1>(b1, b1_entry);
-
-        let b8_entry = witness_module.new_entry();
-        let b8_data: [u8; 256] = rand::random();
-        witness_module.push_u8s_to(b8_data, b8_entry);
-        witness_module.bind_oracle_to::<B8>(b8, b8_entry);
-
-        let b16_entry = witness_module.new_entry();
-        let b16_data: [u16; 256] = rand::random();
-        witness_module.push_u16s_to(b16_data, b16_entry);
-        witness_module.bind_oracle_to::<B16>(b16, b16_entry);
-
-        let b32_entry = witness_module.new_entry();
-        let b32_data: [u32; 256] = rand::random();
-        witness_module.push_u32s_to(b32_data, b32_entry);
-        witness_module.bind_oracle_to::<B32>(b32, b32_entry);
-
-        let b64_entry = witness_module.new_entry();
-        let b64_data: [u64; 256] = rand::random();
-        witness_module.push_u64s_to(b64_data, b64_entry);
-        witness_module.bind_oracle_to::<B64>(b64, b64_entry);
-
-        let b128_entry = witness_module.new_entry();
-        let b128_data: [u128; 256] = rand::random();
-        witness_module.push_u128s_to(b128_data, b128_entry);
-        witness_module.bind_oracle_to::<B128>(b128, b128_entry);
-
-        let mode = ModuleMode::active(8, 0);
-        witness_module.populate(mode).unwrap();
-
-        let witness_modules = [witness_module];
-        let witness_archon = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-        let circuit_modules = [circuit_module];
-
-        assert!(validate_witness(&circuit_modules, &[], &witness_archon).is_ok());
-    }
-
-    #[test]
-    fn test_projected_u32() {
-        let log_height = 6;
-        let mode = ModuleMode::active(log_height, 0);
-        let selection = 0u64; // we have long input and every "selected" item is taken into projection
-
-        let height = 1 << log_height;
-        let chunk_size = height / 4;
-
-        let mut circuit_module = CircuitModule::new(0);
-        let input = circuit_module
-            .add_committed::<B32>("input", RelativeHeight::Base)
-            .unwrap();
-        circuit_module
-            .add_projected(
-                &format!("projected-{input}"),
-                input,
-                selection,
-                chunk_size.try_into().unwrap(),
-            )
-            .unwrap();
-        circuit_module.freeze_oracles();
-
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-        let entry_id = witness_module.new_entry();
-
-        // let's use 'push_u32s_to' for populating
-        for _ in 0..chunk_size {
-            let push: [u32; 4] = rand::random();
-            witness_module.push_u32s_to(push, entry_id);
-        }
-
-        witness_module.bind_oracle_to::<B32>(input, entry_id);
-        witness_module.populate(mode).unwrap();
-
-        let witness_modules = [witness_module];
-        let witness_archon = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-        let circuit_modules = [circuit_module];
-
-        assert!(validate_witness(&circuit_modules, &[], &witness_archon).is_ok());
-    }
-
-    #[test]
-    fn test_autocomplete() {
-        let mut circuit_module = CircuitModule::new(0);
-        let x = circuit_module
-            .add_committed::<B8>("b8", RelativeHeight::Base)
-            .unwrap();
-        let y = circuit_module
-            .add_committed::<B8>("b8", RelativeHeight::Base)
-            .unwrap();
-        use ArithExpr::*;
-        circuit_module.assert_zero("x = y", [], Oracle(x) + Oracle(y));
-        circuit_module.freeze_oracles();
-
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-        let entry_id = witness_module.new_entry();
-        witness_module.push_u8s_to([42], entry_id); // This wouldn't be enough
-        witness_module.bind_oracle_to::<B8>(x, entry_id);
-        witness_module.bind_oracle_to::<B8>(y, entry_id);
-
-        let mode = ModuleMode::active(4, 0);
-        witness_module.populate(mode).unwrap();
-
-        let witness_modules = [witness_module];
-        let witness_archon = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-        let circuit_modules = [circuit_module];
-
-        assert!(validate_witness(&circuit_modules, &[], &witness_archon).is_ok());
-    }
-}
diff --git a/src/archon/precompiles/blake3.rs b/src/archon/precompiles/blake3.rs
deleted file mode 100644
index 40fa61ce..00000000
--- a/src/archon/precompiles/blake3.rs
+++ /dev/null
@@ -1,1015 +0,0 @@
-#![allow(dead_code)]
-
-use crate::archon::arith_expr::ArithExpr;
-use crate::archon::circuit::CircuitModule;
-use crate::archon::witness::WitnessModule;
-use crate::archon::{ModuleId, ModuleMode, OracleIdx, RelativeHeight};
-use binius_circuits::arithmetic::u32::LOG_U32_BITS;
-use binius_core::oracle::ShiftVariant;
-use binius_field::{BinaryField1b, BinaryField32b, BinaryField128b, Field};
-use binius_utils::checked_arithmetics::log2_ceil_usize;
-
-const STATE_SIZE: usize = 32;
-const SINGLE_COMPRESSION_N_VARS: usize = 6;
-#[allow(clippy::cast_possible_truncation)]
-const SINGLE_COMPRESSION_HEIGHT: usize = 2usize.pow(SINGLE_COMPRESSION_N_VARS as u32);
-const ADDITION_OPERATIONS_NUMBER: usize = 6;
-const PROJECTED_SELECTOR_INPUT: u64 = 0;
-const PROJECTED_SELECTOR_OUTPUT: u64 = 57;
-const OUT_HEIGHT: usize = 8;
-
-const IV: [u32; 8] = [
-    0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19,
-];
-const MSG_PERMUTATION: [usize; 16] = [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8];
-
-type B128 = BinaryField128b;
-type B32 = BinaryField32b;
-type B1 = BinaryField1b;
-
-#[derive(Debug, Clone)]
-pub struct Trace {
-    state_trace: [Vec<u32>; STATE_SIZE],
-    a_in_trace: Vec<u32>,
-    b_in_trace: Vec<u32>,
-    c_in_trace: Vec<u32>,
-    d_in_trace: Vec<u32>,
-    mx_in_trace: Vec<u32>,
-    my_in_trace: Vec<u32>,
-
-    a_0_tmp_trace: Vec<u32>,
-    a_0_trace: Vec<u32>,
-    d_in_xor_a_0_trace: Vec<u32>,
-    d_0_trace: Vec<u32>,
-    c_0_trace: Vec<u32>,
-    _b_in_xor_c_0_trace: Vec<u32>,
-    b_0_trace: Vec<u32>,
-    a_1_tmp_trace: Vec<u32>,
-    a_1_trace: Vec<u32>,
-    _d_0_xor_a_1_trace: Vec<u32>,
-    d_1_trace: Vec<u32>,
-    c_1_trace: Vec<u32>,
-    _b_0_xor_c_1_trace: Vec<u32>,
-    _b_1_trace: Vec<u32>,
-
-    _cin_trace: [Vec<u32>; ADDITION_OPERATIONS_NUMBER],
-    cout_trace: [Vec<u32>; ADDITION_OPERATIONS_NUMBER],
-
-    cv_trace: Vec<u32>,
-    state_i_trace: Vec<u32>,
-    state_i_8_trace: Vec<u32>,
-    _state_i_xor_state_i_8_trace: Vec<u32>,
-    _state_i_8_xor_cv_trace: Vec<u32>,
-}
-
-pub struct Blake3CompressionOracles {
-    pub input: [OracleIdx; STATE_SIZE],
-    pub output: [OracleIdx; STATE_SIZE],
-}
-
-#[allow(clippy::type_complexity)]
-pub fn blake3_compress(
-    traces: &Trace,
-    traces_len: usize,
-) -> Result<
-    (
-        Vec<CircuitModule>,
-        Vec<WitnessModule>,
-        Vec<ModuleMode>,
-        Blake3CompressionOracles,
-    ),
-    anyhow::Error,
-> {
-    // FIXME: Implement modules' gluing
-
-    let (compression_oracles, circuit_module_0, witness_module_0, mode_0) =
-        state_transition_module(0, traces, traces_len)?;
-    let (circuit_module_1, witness_module_1, mode_1) =
-        additions_xor_rotates_module(1, traces, traces_len)?;
-    let (circuit_module_2, witness_module_2, mode_2) = cv_output_module(2, traces, traces_len)?;
-
-    let witness_modules = vec![witness_module_0, witness_module_1, witness_module_2];
-    let circuit_modules = vec![circuit_module_0, circuit_module_1, circuit_module_2];
-    let modes = vec![mode_0, mode_1, mode_2];
-
-    Ok((circuit_modules, witness_modules, modes, compression_oracles))
-}
-
-fn state_transition_module(
-    id: ModuleId,
-    traces: &Trace,
-    traces_len: usize,
-) -> Result<
-    (
-        Blake3CompressionOracles,
-        CircuitModule,
-        WitnessModule,
-        ModuleMode,
-    ),
-    anyhow::Error,
-> {
-    let state_n_vars = log2_ceil_usize(traces_len * SINGLE_COMPRESSION_HEIGHT);
-    let log_height = state_n_vars.try_into()?;
-
-    let mut circuit_module = CircuitModule::new(id);
-    let state_transitions: [OracleIdx; STATE_SIZE] = array_util::try_from_fn(|xy| {
-        circuit_module
-            .add_committed::<B32>(&format!("state-transition-{xy:?}"), RelativeHeight::Base)
-    })?;
-
-    let input: [OracleIdx; STATE_SIZE] = array_util::try_from_fn(|xy| {
-        circuit_module.add_projected(
-            &format!("input-{xy:?}"),
-            state_transitions[xy],
-            PROJECTED_SELECTOR_INPUT,
-            SINGLE_COMPRESSION_HEIGHT,
-        )
-    })?;
-
-    let output: [OracleIdx; STATE_SIZE] = array_util::try_from_fn(|xy| {
-        circuit_module.add_projected(
-            &format!("output-{xy:?}"),
-            state_transitions[xy],
-            PROJECTED_SELECTOR_OUTPUT,
-            SINGLE_COMPRESSION_HEIGHT,
-        )
-    })?;
-    circuit_module.freeze_oracles();
-
-    let mut witness_module = circuit_module.init_witness_module()?;
-
-    for (xy, trace) in traces.clone().state_trace.into_iter().enumerate() {
-        let entry_id_xy = witness_module.new_entry();
-        witness_module.push_u32s_to(trace, entry_id_xy);
-        witness_module.bind_oracle_to::<B32>(state_transitions[xy], entry_id_xy);
-    }
-
-    let mode = ModuleMode::active(log_height, 0);
-    witness_module.populate(mode)?;
-
-    Ok((
-        Blake3CompressionOracles { input, output },
-        circuit_module,
-        witness_module,
-        mode,
-    ))
-}
-
-fn additions_xor_rotates_module(
-    id: ModuleId,
-    traces: &Trace,
-    traces_len: usize,
-) -> Result<(CircuitModule, WitnessModule, ModuleMode), anyhow::Error> {
-    let state_n_vars = log2_ceil_usize(traces_len * SINGLE_COMPRESSION_HEIGHT);
-    let log_height = (state_n_vars + 5).try_into()?;
-
-    let mut circuit_module = CircuitModule::new(id);
-
-    let a_in = circuit_module.add_committed::<B1>("a_in", RelativeHeight::Base)?;
-    let b_in = circuit_module.add_committed::<B1>("b_in", RelativeHeight::Base)?;
-    let c_in = circuit_module.add_committed::<B1>("c_in", RelativeHeight::Base)?;
-    let d_in = circuit_module.add_committed::<B1>("d_in", RelativeHeight::Base)?;
-    let mx_in = circuit_module.add_committed::<B1>("mx_in", RelativeHeight::Base)?;
-    let my_in = circuit_module.add_committed::<B1>("my_in", RelativeHeight::Base)?;
-
-    let a_0 = circuit_module.add_committed::<B1>("a_0", RelativeHeight::Base)?;
-    let a_0_tmp = circuit_module.add_committed::<B1>("a_0_tmp", RelativeHeight::Base)?;
-    let c_0 = circuit_module.add_committed::<B1>("c_0", RelativeHeight::Base)?;
-    let a_1 = circuit_module.add_committed::<B1>("a_1", RelativeHeight::Base)?;
-    let a_1_tmp = circuit_module.add_committed::<B1>("a_1_tmp", RelativeHeight::Base)?;
-    let c_1 = circuit_module.add_committed::<B1>("c_1", RelativeHeight::Base)?;
-
-    let b_in_xor_c_0 = circuit_module.add_linear_combination(
-        "b_in_xor_c_0",
-        B128::ZERO,
-        [(b_in, B128::ONE), (c_0, B128::ONE)],
-        RelativeHeight::Base,
-    )?;
-
-    let d_in_xor_a_0 = circuit_module.add_linear_combination(
-        "d_in_xor_a_0",
-        B128::ZERO,
-        [(d_in, B128::ONE), (a_0, B128::ONE)],
-        RelativeHeight::Base,
-    )?;
-
-    let b_0 = circuit_module.add_shifted(
-        "b_0",
-        b_in_xor_c_0,
-        32 - 12,
-        LOG_U32_BITS,
-        ShiftVariant::CircularLeft,
-    )?;
-    let d_0 = circuit_module.add_shifted(
-        "d_0",
-        d_in_xor_a_0,
-        32 - 16,
-        LOG_U32_BITS,
-        ShiftVariant::CircularLeft,
-    )?;
-
-    let d_0_xor_a_1 = circuit_module.add_linear_combination(
-        "d_0_xor_a_1",
-        B128::ZERO,
-        [(d_0, B128::ONE), (a_1, B128::ONE)],
-        RelativeHeight::Base,
-    )?;
-
-    let b_0_xor_c_1 = circuit_module.add_linear_combination(
-        "b_0_xor_c_1",
-        B128::ZERO,
-        [(b_0, B128::ONE), (c_1, B128::ONE)],
-        RelativeHeight::Base,
-    )?;
-
-    let d_1 = circuit_module.add_shifted(
-        "d_1",
-        d_0_xor_a_1,
-        32 - 8,
-        LOG_U32_BITS,
-        ShiftVariant::CircularLeft,
-    )?;
-    let _b_1 = circuit_module.add_shifted(
-        "b_1",
-        b_0_xor_c_1,
-        32 - 7,
-        LOG_U32_BITS,
-        ShiftVariant::CircularLeft,
-    )?;
-
-    let couts: [OracleIdx; ADDITION_OPERATIONS_NUMBER] = array_util::try_from_fn(|xy| {
-        circuit_module.add_committed::<B1>(&format!("cout-{xy:?}"), RelativeHeight::Base)
-    })?;
-    let cins: [OracleIdx; ADDITION_OPERATIONS_NUMBER] = array_util::try_from_fn(|xy| {
-        circuit_module.add_shifted(
-            &format!("cin-{xy:?}"),
-            couts[xy],
-            1,
-            5,
-            ShiftVariant::LogicalLeft,
-        )
-    })?;
-
-    let xins = [a_in, a_0_tmp, c_in, a_0, a_1_tmp, c_0];
-    let yins = [b_in, mx_in, d_0, b_0, my_in, d_1];
-    let zouts = [a_0_tmp, a_0, c_0, a_1_tmp, a_1, c_1];
-
-    for xy in 0..ADDITION_OPERATIONS_NUMBER {
-        circuit_module.assert_zero(
-            "sum",
-            [xins[xy], yins[xy], cins[xy], zouts[xy]],
-            ArithExpr::Oracle(xins[xy])
-                + ArithExpr::Oracle(yins[xy])
-                + ArithExpr::Oracle(cins[xy])
-                + ArithExpr::Oracle(zouts[xy]),
-        );
-        circuit_module.assert_zero(
-            "carry",
-            [xins[xy], yins[xy], cins[xy], couts[xy]],
-            (ArithExpr::Oracle(xins[xy]) + ArithExpr::Oracle(cins[xy]))
-                * (ArithExpr::Oracle(yins[xy]) + ArithExpr::Oracle(cins[xy]))
-                + ArithExpr::Oracle(cins[xy])
-                + ArithExpr::Oracle(couts[xy]),
-        );
-    }
-
-    circuit_module.freeze_oracles();
-
-    let mut witness_module = circuit_module.init_witness_module()?;
-
-    let xin_traces = [
-        traces.a_in_trace.clone(),
-        traces.a_0_tmp_trace.clone(),
-        traces.c_in_trace.clone(),
-        traces.a_0_trace.clone(),
-        traces.a_1_tmp_trace.clone(),
-        traces.c_0_trace.clone(),
-    ];
-    let yin_traces = [
-        traces.b_in_trace.clone(),
-        traces.mx_in_trace.clone(),
-        traces.d_0_trace.clone(),
-        traces.b_0_trace.clone(),
-        traces.my_in_trace.clone(),
-        traces.d_1_trace.clone(),
-    ];
-    let zout_traces = [
-        traces.a_0_tmp_trace.clone(),
-        traces.a_0_trace.clone(),
-        traces.c_0_trace.clone(),
-        traces.a_1_tmp_trace.clone(),
-        traces.a_1_trace.clone(),
-        traces.c_1_trace.clone(),
-    ];
-
-    for xy in 0..ADDITION_OPERATIONS_NUMBER {
-        let cout_entry = witness_module.new_entry();
-        let xin_entry = witness_module.new_entry();
-        let yin_entry = witness_module.new_entry();
-        let zout_entry = witness_module.new_entry();
-
-        witness_module.push_u32s_to(xin_traces[xy].clone(), xin_entry);
-        witness_module.push_u32s_to(yin_traces[xy].clone(), yin_entry);
-        witness_module.push_u32s_to(traces.cout_trace[xy].clone(), cout_entry);
-        witness_module.push_u32s_to(zout_traces[xy].clone(), zout_entry);
-
-        witness_module.bind_oracle_to::<B1>(xins[xy], xin_entry);
-        witness_module.bind_oracle_to::<B1>(yins[xy], yin_entry);
-        witness_module.bind_oracle_to::<B1>(couts[xy], cout_entry);
-        witness_module.bind_oracle_to::<B1>(zouts[xy], zout_entry);
-    }
-
-    // not to forget about d_in
-    let d_in_entry = witness_module.new_entry();
-    witness_module.push_u32s_to(traces.d_in_trace.clone(), d_in_entry);
-    witness_module.bind_oracle_to::<B1>(d_in, d_in_entry);
-
-    let mode = ModuleMode::active(log_height, 0);
-    witness_module.populate(mode)?;
-
-    Ok((circuit_module, witness_module, mode))
-}
-
-fn cv_output_module(
-    id: ModuleId,
-    traces: &Trace,
-    traces_len: usize,
-) -> Result<(CircuitModule, WitnessModule, ModuleMode), anyhow::Error> {
-    let out_n_vars = log2_ceil_usize(traces_len * OUT_HEIGHT);
-    let log_height = out_n_vars.try_into()?;
-
-    let mut circuit_module = CircuitModule::new(id);
-
-    let cv = circuit_module.add_committed::<B32>("cv", RelativeHeight::Base)?;
-    let state_i = circuit_module.add_committed::<B32>("state_i", RelativeHeight::Base)?;
-    let state_i_8 = circuit_module.add_committed::<B32>("state_i_8", RelativeHeight::Base)?;
-
-    let _state_i_xor_state_i_8 = circuit_module.add_linear_combination(
-        "state_i_xor_state_i_8",
-        B128::ZERO,
-        [(state_i, B128::ONE), (state_i_8, B128::ONE)],
-        RelativeHeight::Base,
-    )?;
-
-    let _cv_oracle_xor_state_i_8 = circuit_module.add_linear_combination(
-        "cv_oracle_xor_state_i_8",
-        B128::ZERO,
-        [(cv, B128::ONE), (state_i_8, B128::ONE)],
-        RelativeHeight::Base,
-    )?;
-
-    circuit_module.freeze_oracles();
-
-    let mut witness_module = circuit_module.init_witness_module()?;
-
-    let cv_entry = witness_module.new_entry();
-    let state_i_entry = witness_module.new_entry();
-    let state_i_8_entry = witness_module.new_entry();
-
-    witness_module.push_u32s_to(traces.cv_trace.clone(), cv_entry);
-    witness_module.push_u32s_to(traces.state_i_trace.clone(), state_i_entry);
-    witness_module.push_u32s_to(traces.state_i_8_trace.clone(), state_i_8_entry);
-
-    witness_module.bind_oracle_to::<B32>(cv, cv_entry);
-    witness_module.bind_oracle_to::<B32>(state_i, state_i_entry);
-    witness_module.bind_oracle_to::<B32>(state_i_8, state_i_8_entry);
-
-    let mode = ModuleMode::active(log_height, 0);
-    witness_module.populate(mode)?;
-
-    Ok((circuit_module, witness_module, mode))
-}
-
-#[cfg(test)]
-pub mod tests {
-    use crate::archon::circuit::{CircuitModule, init_witness_modules};
-    use crate::archon::precompiles::blake3::{
-        ADDITION_OPERATIONS_NUMBER, B1, B128, Blake3CompressionOracles, IV, MSG_PERMUTATION,
-        OUT_HEIGHT, PROJECTED_SELECTOR_OUTPUT, SINGLE_COMPRESSION_HEIGHT, STATE_SIZE, Trace,
-        additions_xor_rotates_module, cv_output_module, state_transition_module,
-    };
-    use crate::archon::protocol::validate_witness;
-    use crate::archon::witness::{WitnessModule, compile_witness_modules};
-    use crate::archon::{ModuleMode, RelativeHeight};
-    use binius_field::Field;
-    use binius_utils::checked_arithmetics::log2_ceil_usize;
-    use rand::prelude::StdRng;
-    use rand::{Rng, SeedableRng};
-    use std::array;
-
-    #[derive(Debug, Default, Copy, Clone)]
-    pub(super) struct Blake3CompressState {
-        pub cv: [u32; 8],
-        pub block: [u32; 16],
-        pub counter_low: u32,
-        pub counter_high: u32,
-        pub block_len: u32,
-        pub flags: u32,
-    }
-
-    // taken (and slightly refactored) from reference Blake3 implementation:
-    // https://github.com/BLAKE3-team/BLAKE3/blob/master/reference_impl/reference_impl.rs
-    fn compress(
-        chaining_value: &[u32; 8],
-        block_words: &[u32; 16],
-        counter: u64,
-        block_len: u32,
-        flags: u32,
-    ) -> [u32; 16] {
-        #[allow(clippy::cast_possible_truncation)]
-        let counter_low = counter as u32;
-        #[allow(clippy::cast_possible_truncation)]
-        let counter_high = (counter >> 32) as u32;
-
-        let mut state = [
-            chaining_value[0],
-            chaining_value[1],
-            chaining_value[2],
-            chaining_value[3],
-            chaining_value[4],
-            chaining_value[5],
-            chaining_value[6],
-            chaining_value[7],
-            IV[0],
-            IV[1],
-            IV[2],
-            IV[3],
-            counter_low,
-            counter_high,
-            block_len,
-            flags,
-            block_words[0],
-            block_words[1],
-            block_words[2],
-            block_words[3],
-            block_words[4],
-            block_words[5],
-            block_words[6],
-            block_words[7],
-            block_words[8],
-            block_words[9],
-            block_words[10],
-            block_words[11],
-            block_words[12],
-            block_words[13],
-            block_words[14],
-            block_words[15],
-        ];
-
-        let a = [0, 1, 2, 3, 0, 1, 2, 3];
-        let b = [4, 5, 6, 7, 5, 6, 7, 4];
-        let c = [8, 9, 10, 11, 10, 11, 8, 9];
-        let d = [12, 13, 14, 15, 15, 12, 13, 14];
-        let mx = [16, 18, 20, 22, 24, 26, 28, 30];
-        let my = [17, 19, 21, 23, 25, 27, 29, 31];
-
-        // we have 7 rounds in total
-        for round_idx in 0..7 {
-            for j in 0..8 {
-                let a_in = state[a[j]];
-                let b_in = state[b[j]];
-                let c_in = state[c[j]];
-                let d_in = state[d[j]];
-                let mx_in = state[mx[j]];
-                let my_in = state[my[j]];
-
-                let a_0 = a_in.wrapping_add(b_in).wrapping_add(mx_in);
-                let d_0 = (d_in ^ a_0).rotate_right(16);
-                let c_0 = c_in.wrapping_add(d_0);
-                let b_0 = (b_in ^ c_0).rotate_right(12);
-
-                let a_1 = a_0.wrapping_add(b_0).wrapping_add(my_in);
-                let d_1 = (d_0 ^ a_1).rotate_right(8);
-                let c_1 = c_0.wrapping_add(d_1);
-                let b_1 = (b_0 ^ c_1).rotate_right(7);
-
-                state[a[j]] = a_1;
-                state[b[j]] = b_1;
-                state[c[j]] = c_1;
-                state[d[j]] = d_1;
-            }
-
-            // execute permutation for the 6 first rounds
-            if round_idx < 6 {
-                let mut permuted = [0; 16];
-                for i in 0..16 {
-                    permuted[i] = state[16 + MSG_PERMUTATION[i]];
-                }
-                state[16..32].copy_from_slice(&permuted);
-            }
-        }
-
-        for i in 0..8 {
-            state[i] ^= state[i + 8];
-            state[i + 8] ^= chaining_value[i];
-        }
-
-        let state_out: [u32; 16] = array::from_fn(|i| state[i]);
-        state_out
-    }
-
-    pub fn generate_trace(size: usize) -> (Vec<Vec<u32>>, Trace) {
-        let compressions = size;
-
-        let mut rng = StdRng::seed_from_u64(0);
-        let mut expected = vec![];
-        let inputs = (0..compressions)
-            .map(|_| {
-                let cv: [u32; 8] = array::from_fn(|_| rng.random::<u32>());
-                let block: [u32; 16] = array::from_fn(|_| rng.random::<u32>());
-                let counter = rng.random::<u64>();
-                #[allow(clippy::cast_possible_truncation)]
-                let counter_low = counter as u32;
-                #[allow(clippy::cast_possible_truncation)]
-                let counter_high = (counter >> 32) as u32;
-                let block_len = rng.random::<u32>();
-                let flags = rng.random::<u32>();
-
-                // save expected value to use later in test
-                expected.push(compress(&cv, &block, counter, block_len, flags).to_vec());
-
-                Blake3CompressState {
-                    cv,
-                    block,
-                    counter_low,
-                    counter_high,
-                    block_len,
-                    flags,
-                }
-            })
-            .collect::<Vec<Blake3CompressState>>();
-
-        // <trace>
-        let mut state_trace: [Vec<u32>; STATE_SIZE] =
-            array::from_fn(|_xy| vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT]);
-        fn write_state_trace(
-            state_trace: &mut [Vec<u32>; STATE_SIZE],
-            index: usize,
-            state: [u32; STATE_SIZE],
-        ) {
-            for xy in 0..STATE_SIZE {
-                state_trace[xy][index] = state[xy];
-            }
-        }
-
-        let mut cv_trace = vec![0u32; compressions * OUT_HEIGHT];
-        let mut state_i_trace = vec![0u32; compressions * OUT_HEIGHT];
-        let mut state_i_8_trace = vec![0u32; compressions * OUT_HEIGHT];
-        let mut state_i_xor_state_i_8_trace = vec![0u32; compressions * OUT_HEIGHT];
-        let mut state_i_8_xor_cv_trace = vec![0u32; compressions * OUT_HEIGHT];
-
-        let mut a_in_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut b_in_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut c_in_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut d_in_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut mx_in_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut my_in_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-
-        let mut a_0_tmp_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut a_0_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut d_in_xor_a_0_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut d_0_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut c_0_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut b_in_xor_c_0_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut b_0_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut a_1_tmp_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut a_1_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut d_0_xor_a_1_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut d_1_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut c_1_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut b_0_xor_c_1_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        let mut b_1_trace = vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT];
-        fn write_var_trace(var_trace: &mut [u32], index: usize, value: u32) {
-            var_trace[index] = value;
-        }
-
-        let mut cin_trace: [Vec<u32>; ADDITION_OPERATIONS_NUMBER] =
-            array::from_fn(|_xy| vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT]);
-        let mut cout_trace: [Vec<u32>; ADDITION_OPERATIONS_NUMBER] =
-            array::from_fn(|_xy| vec![0u32; compressions * SINGLE_COMPRESSION_HEIGHT]);
-        fn write_addition_trace(
-            addition_trace: &mut [Vec<u32>; ADDITION_OPERATIONS_NUMBER],
-            add_offset: usize,
-            var_offset: usize,
-            addition: u32,
-        ) {
-            addition_trace[add_offset][var_offset] = addition;
-        }
-        //
-
-        // execute Blake3 compression and save execution trace
-        let mut compression_offset = 0;
-        for (input_idx, input) in inputs.into_iter().enumerate() {
-            let counter_low = input.counter_low;
-            let counter_high = input.counter_high;
-
-            let mut state = [
-                input.cv[0],
-                input.cv[1],
-                input.cv[2],
-                input.cv[3],
-                input.cv[4],
-                input.cv[5],
-                input.cv[6],
-                input.cv[7],
-                IV[0],
-                IV[1],
-                IV[2],
-                IV[3],
-                counter_low,
-                counter_high,
-                input.block_len,
-                input.flags,
-                input.block[0],
-                input.block[1],
-                input.block[2],
-                input.block[3],
-                input.block[4],
-                input.block[5],
-                input.block[6],
-                input.block[7],
-                input.block[8],
-                input.block[9],
-                input.block[10],
-                input.block[11],
-                input.block[12],
-                input.block[13],
-                input.block[14],
-                input.block[15],
-            ];
-
-            // <trace>
-            write_state_trace(&mut state_trace, compression_offset, state);
-            //
-
-            let a = [0, 1, 2, 3, 0, 1, 2, 3];
-            let b = [4, 5, 6, 7, 5, 6, 7, 4];
-            let c = [8, 9, 10, 11, 10, 11, 8, 9];
-            let d = [12, 13, 14, 15, 15, 12, 13, 14];
-            let mx = [16, 18, 20, 22, 24, 26, 28, 30];
-            let my = [17, 19, 21, 23, 25, 27, 29, 31];
-
-            let mut state_offset = 1usize;
-            let mut temp_vars_offset = 0usize;
-
-            fn add(a: u32, b: u32) -> (u32, u32, u32) {
-                let zout;
-                let carry;
-
-                (zout, carry) = a.overflowing_add(b);
-                let cin = a ^ b ^ zout;
-                let cout = ((carry as u32) << 31) | (cin >> 1);
-
-                (cin, cout, zout)
-            }
-
-            for round_idx in 0..7 {
-                for j in 0..8 {
-                    // <trace>
-                    let state_transition_idx = state_offset + compression_offset;
-                    let var_offset = temp_vars_offset + compression_offset;
-                    let mut add_offset = 0usize;
-                    //
-
-                    let a_in = state[a[j]];
-                    let b_in = state[b[j]];
-                    let c_in = state[c[j]];
-                    let d_in = state[d[j]];
-                    let mx_in = state[mx[j]];
-                    let my_in = state[my[j]];
-
-                    // <trace>
-                    write_var_trace(&mut a_in_trace, var_offset, a_in);
-                    write_var_trace(&mut b_in_trace, var_offset, b_in);
-                    write_var_trace(&mut c_in_trace, var_offset, c_in);
-                    write_var_trace(&mut d_in_trace, var_offset, d_in);
-                    write_var_trace(&mut mx_in_trace, var_offset, mx_in);
-                    write_var_trace(&mut my_in_trace, var_offset, my_in);
-                    //
-
-                    let (cin, cout, a_0_tmp) = add(a_in, b_in);
-                    // <trace>
-                    write_addition_trace(&mut cin_trace, add_offset, var_offset, cin);
-                    write_addition_trace(&mut cout_trace, add_offset, var_offset, cout);
-                    add_offset += 1;
-                    //
-
-                    let (cin, cout, a_0) = add(a_0_tmp, mx_in);
-                    // <trace>
-                    write_addition_trace(&mut cin_trace, add_offset, var_offset, cin);
-                    write_addition_trace(&mut cout_trace, add_offset, var_offset, cout);
-                    add_offset += 1;
-                    //
-
-                    let d_in_xor_a_0 = d_in ^ a_0;
-                    let d_0 = d_in_xor_a_0.rotate_right(16);
-
-                    let (cin, cout, c_0) = add(c_in, d_0);
-                    // <trace>
-                    write_addition_trace(&mut cin_trace, add_offset, var_offset, cin);
-                    write_addition_trace(&mut cout_trace, add_offset, var_offset, cout);
-                    add_offset += 1;
-                    //
-
-                    let b_in_xor_c_0 = b_in ^ c_0;
-                    let b_0 = b_in_xor_c_0.rotate_right(12);
-
-                    let (cin, cout, a_1_tmp) = add(a_0, b_0);
-                    // <trace>
-                    write_addition_trace(&mut cin_trace, add_offset, var_offset, cin);
-                    write_addition_trace(&mut cout_trace, add_offset, var_offset, cout);
-                    add_offset += 1;
-                    //
-
-                    let (cin, cout, a_1) = add(a_1_tmp, my_in);
-                    // <trace>
-                    write_addition_trace(&mut cin_trace, add_offset, var_offset, cin);
-                    write_addition_trace(&mut cout_trace, add_offset, var_offset, cout);
-                    add_offset += 1;
-                    //
-
-                    let d_0_xor_a_1 = d_0 ^ a_1;
-                    let d_1 = d_0_xor_a_1.rotate_right(8);
-
-                    let (cin, cout, c_1) = add(c_0, d_1);
-                    // <trace>
-                    write_addition_trace(&mut cin_trace, add_offset, var_offset, cin);
-                    write_addition_trace(&mut cout_trace, add_offset, var_offset, cout);
-                    //
-
-                    let b_0_xor_c_1 = b_0 ^ c_1;
-                    let b_1 = b_0_xor_c_1.rotate_right(7);
-
-                    // <trace>
-                    write_var_trace(&mut a_0_tmp_trace, var_offset, a_0_tmp);
-                    write_var_trace(&mut a_0_trace, var_offset, a_0);
-                    write_var_trace(&mut d_in_xor_a_0_trace, var_offset, d_in_xor_a_0);
-                    write_var_trace(&mut d_0_trace, var_offset, d_0);
-                    write_var_trace(&mut c_0_trace, var_offset, c_0);
-                    write_var_trace(&mut b_in_xor_c_0_trace, var_offset, b_in_xor_c_0);
-                    write_var_trace(&mut b_0_trace, var_offset, b_0);
-                    write_var_trace(&mut a_1_tmp_trace, var_offset, a_1_tmp);
-                    write_var_trace(&mut a_1_trace, var_offset, a_1);
-                    write_var_trace(&mut d_0_xor_a_1_trace, var_offset, d_0_xor_a_1);
-                    write_var_trace(&mut d_1_trace, var_offset, d_1);
-                    write_var_trace(&mut c_1_trace, var_offset, c_1);
-                    write_var_trace(&mut b_0_xor_c_1_trace, var_offset, b_0_xor_c_1);
-                    write_var_trace(&mut b_1_trace, var_offset, b_1);
-                    //
-
-                    state[a[j]] = a_1;
-                    state[b[j]] = b_1;
-                    state[c[j]] = c_1;
-                    state[d[j]] = d_1;
-
-                    // <trace>
-                    write_state_trace(&mut state_trace, state_transition_idx, state);
-                    //
-
-                    state_offset += 1;
-                    temp_vars_offset += 1;
-                }
-
-                // execute permutation for the 6 first rounds
-                if round_idx < 6 {
-                    let mut permuted = [0; 16];
-                    for i in 0..16 {
-                        permuted[i] = state[16 + MSG_PERMUTATION[i]];
-                    }
-                    state[16..32].copy_from_slice(&permuted);
-                }
-            }
-
-            for i in 0..8 {
-                // <trace>
-                write_var_trace(&mut cv_trace, input_idx * 8 + i, input.cv[i]);
-                write_var_trace(&mut state_i_trace, input_idx * 8 + i, state[i]);
-                write_var_trace(&mut state_i_8_trace, input_idx * 8 + i, state[i + 8]);
-                //
-
-                state[i] ^= state[i + 8];
-                // <trace>
-                write_var_trace(
-                    &mut state_i_xor_state_i_8_trace,
-                    input_idx * 8 + i,
-                    state[i],
-                );
-                //
-
-                state[i + 8] ^= input.cv[i];
-                // <trace>
-                write_var_trace(&mut state_i_8_xor_cv_trace, input_idx * 8 + i, state[i + 8]);
-                //
-            }
-
-            // <trace>
-            write_state_trace(
-                &mut state_trace,
-                compression_offset + usize::try_from(PROJECTED_SELECTOR_OUTPUT).unwrap(),
-                state,
-            );
-            //
-
-            compression_offset += SINGLE_COMPRESSION_HEIGHT;
-        }
-
-        (
-            expected,
-            Trace {
-                state_trace,
-                a_in_trace,
-                b_in_trace,
-                c_in_trace,
-                d_in_trace,
-                mx_in_trace,
-                my_in_trace,
-                a_0_tmp_trace,
-                a_0_trace,
-                d_in_xor_a_0_trace,
-                d_0_trace,
-                c_0_trace,
-                _b_in_xor_c_0_trace: b_in_xor_c_0_trace,
-                b_0_trace,
-                a_1_tmp_trace,
-                a_1_trace,
-                _d_0_xor_a_1_trace: d_0_xor_a_1_trace,
-                d_1_trace,
-                c_1_trace,
-                _b_0_xor_c_1_trace: b_0_xor_c_1_trace,
-                _b_1_trace: b_1_trace,
-                _cin_trace: cin_trace,
-                cout_trace,
-                cv_trace,
-                state_i_trace,
-                state_i_8_trace,
-                _state_i_xor_state_i_8_trace: state_i_xor_state_i_8_trace,
-                _state_i_8_xor_cv_trace: state_i_8_xor_cv_trace,
-            },
-        )
-    }
-
-    const COMPRESSIONS_LOG_TEST: u32 = 5;
-
-    #[test]
-    fn test_state_transition_module() {
-        let trace_len = 2usize.pow(COMPRESSIONS_LOG_TEST);
-        let (expected, traces) = generate_trace(trace_len);
-
-        let (compression_oracles, circuit_module, witness_module, mode) =
-            state_transition_module(0, &traces, trace_len).unwrap();
-
-        assert_expected_output(&compression_oracles, &expected, &witness_module);
-
-        // check that Binius proof can be constructed and verified
-        let witness_modules = [witness_module];
-        let circuit_modules = [circuit_module];
-        let modes = vec![mode];
-
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok());
-    }
-
-    #[test]
-    fn test_additions_xor_rotates_module() {
-        let trace_len = 2usize.pow(COMPRESSIONS_LOG_TEST);
-        let (_, traces) = generate_trace(trace_len);
-
-        let (circuit_module, witness_module, mode) =
-            additions_xor_rotates_module(0, &traces, trace_len).unwrap();
-
-        let witness_modules = [witness_module];
-        let circuit_modules = [circuit_module];
-        let modes = vec![mode];
-
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok());
-    }
-
-    #[test]
-    fn test_cv_output_module() {
-        let trace_len = 2usize.pow(COMPRESSIONS_LOG_TEST);
-        let (_, traces) = generate_trace(trace_len);
-
-        let (circuit_module, witness_module, mode) =
-            cv_output_module(0, &traces, trace_len).unwrap();
-
-        let witness_modules = [witness_module];
-        let circuit_modules = [circuit_module];
-        let modes = vec![mode];
-
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok());
-    }
-
-    #[test]
-    fn test_whole_blake3_compression() {
-        let trace_len = 2usize.pow(COMPRESSIONS_LOG_TEST);
-        let (expected, traces) = generate_trace(trace_len);
-
-        let (compression_oracles, circuit_module_0, witness_module_0, mode_0) =
-            state_transition_module(0, &traces, trace_len).unwrap();
-        let (circuit_module_1, witness_module_1, mode_1) =
-            additions_xor_rotates_module(1, &traces, trace_len).unwrap();
-        let (circuit_module_2, witness_module_2, mode_2) =
-            cv_output_module(2, &traces, trace_len).unwrap();
-
-        assert_expected_output(&compression_oracles, &expected, &witness_module_0);
-
-        let witness_modules = [witness_module_0, witness_module_1, witness_module_2];
-        let circuit_modules = [circuit_module_0, circuit_module_1, circuit_module_2];
-        let modes = vec![mode_0, mode_1, mode_2];
-
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok());
-    }
-
-    #[test]
-    fn test_lc_over_bits() {
-        let trace_len = 2usize.pow(COMPRESSIONS_LOG_TEST);
-        let (_, traces) = generate_trace(trace_len);
-
-        let state_n_vars = log2_ceil_usize(trace_len * SINGLE_COMPRESSION_HEIGHT);
-        let log_height = (state_n_vars + 5).try_into().unwrap();
-        let mode = ModuleMode::active(log_height, 0);
-
-        let circuit_module_id = 0;
-        let mut circuit_module_1 = CircuitModule::new(circuit_module_id);
-
-        let a_0 = circuit_module_1
-            .add_committed::<B1>("a_0", RelativeHeight::Base)
-            .unwrap();
-        let d_in = circuit_module_1
-            .add_committed::<B1>("d_in", RelativeHeight::Base)
-            .unwrap();
-
-        let d_in_xor_a_0 = circuit_module_1
-            .add_linear_combination(
-                "d_in_xor_a_0",
-                B128::ZERO,
-                [(a_0, B128::ONE), (d_in, B128::ONE)],
-                RelativeHeight::Base,
-            )
-            .unwrap();
-
-        circuit_module_1.freeze_oracles();
-
-        let circuit_modules = [circuit_module_1];
-        let mut witness_modules = init_witness_modules(&circuit_modules).unwrap();
-
-        let witness_module_id = 0;
-
-        let a_0_entry = witness_modules[witness_module_id].new_entry();
-        let d_in_entry = witness_modules[witness_module_id].new_entry();
-
-        let Trace {
-            a_0_trace,
-            d_in_trace,
-            ..
-        } = traces;
-        witness_modules[witness_module_id].push_u32s_to(a_0_trace, a_0_entry);
-        witness_modules[witness_module_id].push_u32s_to(d_in_trace, d_in_entry);
-
-        witness_modules[witness_module_id].bind_oracle_to::<B1>(a_0, a_0_entry);
-        witness_modules[witness_module_id].bind_oracle_to::<B1>(d_in, d_in_entry);
-
-        witness_modules[witness_module_id].populate(mode).unwrap();
-
-        let lc_data = witness_modules[witness_module_id].get_data(&d_in_xor_a_0);
-        let expected = traces
-            .d_in_xor_a_0_trace
-            .into_iter()
-            .flat_map(u32::to_le_bytes)
-            .collect::<Vec<_>>();
-        assert_eq!(lc_data, expected);
-
-        let witness_archon = compile_witness_modules(&witness_modules, vec![mode]).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness_archon).is_ok());
-    }
-
-    fn transpose<T>(v: &[Vec<T>]) -> Vec<Vec<T>>
-    where
-        T: Clone,
-    {
-        assert!(!v.is_empty());
-        (0..v[0].len())
-            .map(|i| v.iter().map(|inner| inner[i].clone()).collect::<Vec<T>>())
-            .collect()
-    }
-
-    // checks that output of the circuit contains expected values
-    pub fn assert_expected_output(
-        oracles: &Blake3CompressionOracles,
-        expected: &[Vec<u32>],
-        witness_module: &WitnessModule,
-    ) {
-        let expected = transpose(expected);
-        for (i, expected_i) in expected.into_iter().enumerate() {
-            let actual = witness_module.get_data(&oracles.output[i]);
-            let expected_i = expected_i
-                .into_iter()
-                .flat_map(u32::to_le_bytes)
-                .collect::<Vec<_>>();
-            assert_eq!(actual, expected_i);
-        }
-    }
-}
diff --git a/src/archon/precompiles/mod.rs b/src/archon/precompiles/mod.rs
deleted file mode 100644
index 6bc7d825..00000000
--- a/src/archon/precompiles/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod blake3;
diff --git a/src/archon/protocol.rs b/src/archon/protocol.rs
deleted file mode 100644
index 4f6af5d0..00000000
--- a/src/archon/protocol.rs
+++ /dev/null
@@ -1,255 +0,0 @@
-use anyhow::Result;
-use binius_circuits::builder::types::U;
-use binius_core::{
-    constraint_system::{
-        Proof as ProofCore, channel::Boundary, prove as prove_binius,
-        validate::validate_witness as validate_witness_binius, verify as verify_binius,
-    },
-    fiat_shamir::HasherChallenger,
-};
-use binius_field::tower::CanonicalTowerFamily;
-use binius_hal::ComputationBackend;
-use binius_hash::groestl::Groestl256ByteCompression;
-use groestl_crypto::Groestl256;
-
-use super::{
-    F, ModuleMode,
-    circuit::{CircuitModule, compile_circuit_modules},
-    witness::Witness,
-};
-
-pub struct Proof {
-    pub(crate) modes: Vec<ModuleMode>,
-    pub(crate) proof_core: ProofCore,
-}
-
-impl Default for Proof {
-    fn default() -> Self {
-        Proof {
-            modes: vec![],
-            proof_core: ProofCore { transcript: vec![] },
-        }
-    }
-}
-
-pub fn validate_witness_core(
-    circuit_modules: &[&CircuitModule],
-    boundaries: &[Boundary<F>],
-    witness: &Witness<'_>,
-) -> Result<()> {
-    let Witness { mlei, modes } = witness;
-    let constraint_system = compile_circuit_modules(circuit_modules, modes)?;
-    validate_witness_binius(&constraint_system, boundaries, mlei)?;
-    Ok(())
-}
-
-#[inline]
-pub fn validate_witness(
-    circuit_modules: &[CircuitModule],
-    boundaries: &[Boundary<F>],
-    witness: &Witness<'_>,
-) -> Result<()> {
-    validate_witness_core(
-        &circuit_modules.iter().collect::<Vec<_>>(),
-        boundaries,
-        witness,
-    )
-}
-
-pub fn prove_core<Backend: ComputationBackend>(
-    circuit_modules: &[&CircuitModule],
-    boundaries: &[Boundary<F>],
-    log_inv_rate: usize,
-    security_bits: usize,
-    witness: Witness<'_>,
-    backend: &Backend,
-) -> Result<Proof> {
-    let Witness { mlei, modes } = witness;
-    let constraint_system = compile_circuit_modules(circuit_modules, &modes)?;
-    let proof_core = prove_binius::<
-        U,
-        CanonicalTowerFamily,
-        Groestl256,
-        Groestl256ByteCompression,
-        HasherChallenger<Groestl256>,
-        _,
-    >(
-        &constraint_system,
-        log_inv_rate,
-        security_bits,
-        boundaries,
-        mlei,
-        backend,
-    )?;
-    Ok(Proof { modes, proof_core })
-}
-
-#[inline]
-pub fn prove<Backend: ComputationBackend>(
-    circuit_modules: &[CircuitModule],
-    boundaries: &[Boundary<F>],
-    log_inv_rate: usize,
-    security_bits: usize,
-    witness: Witness<'_>,
-    backend: &Backend,
-) -> Result<Proof> {
-    prove_core::<Backend>(
-        &circuit_modules.iter().collect::<Vec<_>>(),
-        boundaries,
-        log_inv_rate,
-        security_bits,
-        witness,
-        backend,
-    )
-}
-
-pub fn verify_core(
-    circuit_modules: &[&CircuitModule],
-    boundaries: &[Boundary<F>],
-    proof: Proof,
-    log_inv_rate: usize,
-    security_bits: usize,
-) -> Result<()> {
-    let Proof { modes, proof_core } = proof;
-    let constraint_system = compile_circuit_modules(circuit_modules, &modes)?;
-    verify_binius::<
-        U,
-        CanonicalTowerFamily,
-        Groestl256,
-        Groestl256ByteCompression,
-        HasherChallenger<Groestl256>,
-    >(
-        &constraint_system,
-        log_inv_rate,
-        security_bits,
-        boundaries,
-        proof_core,
-    )?;
-    Ok(())
-}
-
-#[inline]
-pub fn verify(
-    circuit_modules: &[CircuitModule],
-    boundaries: &[Boundary<F>],
-    proof: Proof,
-    log_inv_rate: usize,
-    security_bits: usize,
-) -> Result<()> {
-    verify_core(
-        &circuit_modules.iter().collect::<Vec<_>>(),
-        boundaries,
-        proof,
-        log_inv_rate,
-        security_bits,
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::archon::{
-        ModuleId, ModuleMode, OracleIdx, RelativeHeight,
-        arith_expr::ArithExpr,
-        circuit::{CircuitModule, init_witness_modules},
-        precompiles::blake3::{blake3_compress, tests::generate_trace},
-        protocol::{prove, validate_witness, verify},
-        witness::{WitnessModule, compile_witness_modules},
-    };
-    use anyhow::Result;
-    use binius_field::BinaryField1b as B1;
-    use binius_hal::make_portable_backend;
-
-    struct Oracles {
-        s: OracleIdx,
-        a: OracleIdx,
-        b: OracleIdx,
-    }
-
-    fn a_xor_b_circuit_module(module_id: ModuleId) -> Result<(CircuitModule, Oracles)> {
-        let mut circuit_module = CircuitModule::new(module_id);
-        let s = CircuitModule::selector();
-        let a = circuit_module.add_committed::<B1>("a", RelativeHeight::Base)?;
-        let b = circuit_module.add_committed::<B1>("b", RelativeHeight::Base)?;
-        circuit_module.assert_zero("a xor b", [], ArithExpr::Oracle(a) + ArithExpr::Oracle(b));
-        circuit_module.freeze_oracles();
-        Ok((circuit_module, Oracles { s, a, b }))
-    }
-
-    fn populate_a_xor_b_witness_with_ones(witness_module: &mut WitnessModule, oracles: &Oracles) {
-        let ones = witness_module.new_entry_with_capacity(7);
-        witness_module.push_u128s_to([u128::MAX], ones);
-        witness_module.bind_oracle_to::<B1>(oracles.s, ones);
-        witness_module.bind_oracle_to::<B1>(oracles.a, ones);
-        witness_module.bind_oracle_to::<B1>(oracles.b, ones);
-    }
-
-    #[test]
-    fn test_invalid_witness() {
-        let (circuit_module, oracles) = a_xor_b_circuit_module(0).unwrap();
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-        let zeros = witness_module.new_entry_with_capacity(7);
-        let ones = witness_module.new_entry_with_capacity(7);
-        witness_module.push_u128s_to([0], zeros);
-        witness_module.push_u128s_to([u128::MAX], ones);
-        witness_module.bind_oracle_to::<B1>(oracles.s, ones);
-        witness_module.bind_oracle_to::<B1>(oracles.a, ones);
-        witness_module.bind_oracle_to::<B1>(oracles.b, zeros);
-        let witness_modules = [witness_module];
-        let modes = vec![ModuleMode::active(7, 128)];
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-        assert!(validate_witness(&[circuit_module], &[], &witness).is_err());
-    }
-
-    #[test]
-    fn test_single_module() {
-        let (circuit_module, oracles) = a_xor_b_circuit_module(0).unwrap();
-        let mut witness_module = circuit_module.init_witness_module().unwrap();
-        populate_a_xor_b_witness_with_ones(&mut witness_module, &oracles);
-        let witness_modules = [witness_module];
-        let modes = vec![ModuleMode::active(7, 128)];
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-        assert!(validate_witness(&[circuit_module], &[], &witness).is_ok());
-    }
-
-    #[test]
-    fn test_multiple_modules() {
-        let (circuit_module0, oracles0) = a_xor_b_circuit_module(0).unwrap();
-        let (circuit_module1, oracles1) = a_xor_b_circuit_module(1).unwrap();
-        let circuit_modules = [circuit_module0, circuit_module1];
-        let mut witness_modules = init_witness_modules(&circuit_modules).unwrap();
-        populate_a_xor_b_witness_with_ones(&mut witness_modules[0], &oracles0);
-        populate_a_xor_b_witness_with_ones(&mut witness_modules[1], &oracles1);
-        let modes = vec![ModuleMode::active(7, 128); 2];
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok());
-    }
-
-    #[test]
-    fn test_deactivated_module() {
-        let (circuit_module0, oracles0) = a_xor_b_circuit_module(0).unwrap();
-        let (circuit_module1, _) = a_xor_b_circuit_module(1).unwrap();
-        let circuit_modules = [circuit_module0, circuit_module1];
-        let mut witness_modules = init_witness_modules(&circuit_modules).unwrap();
-        populate_a_xor_b_witness_with_ones(&mut witness_modules[0], &oracles0);
-        // Witness module 1 isn't populated
-        let modes = vec![ModuleMode::active(7, 128), ModuleMode::Inactive];
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-        assert!(validate_witness(&circuit_modules, &[], &witness).is_ok());
-    }
-
-    #[test]
-    fn test_blake3_compression_end_to_end() {
-        // FIXME: length of traces must be power of 2. Investigate later if we can tackle this limitation
-        let trace_len = 2usize.pow(5u32);
-        let (_, traces) = generate_trace(trace_len);
-
-        let (circuit_modules, witness_modules, modes, _) =
-            blake3_compress(&traces, trace_len).unwrap();
-
-        let witness = compile_witness_modules(&witness_modules, modes).unwrap();
-
-        let backend = make_portable_backend();
-        let proof = prove(&circuit_modules, &[], 1usize, 100usize, witness, &backend).unwrap();
-        assert!(verify(&circuit_modules, &[], proof, 1usize, 100usize).is_ok());
-    }
-}
diff --git a/src/archon/transparent.rs b/src/archon/transparent.rs
deleted file mode 100644
index b1c3c41a..00000000
--- a/src/archon/transparent.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-use binius_core::{
-    polynomial::{Error, MultivariatePoly},
-    transparent::constant::Constant,
-};
-use binius_field::{
-    BinaryField1b as B1, BinaryField2b as B2, BinaryField4b as B4, BinaryField8b as B8,
-    BinaryField16b as B16, BinaryField32b as B32, BinaryField64b as B64, BinaryField128b as B128,
-    Field, TowerField, underlier::WithUnderlier,
-};
-
-use super::F;
-
-#[derive(PartialEq, Eq)]
-pub enum Transparent {
-    Constant(B128),
-    Incremental,
-}
-
-impl Transparent {
-    #[inline]
-    pub(crate) fn tower_level(&self) -> usize {
-        match self {
-            Self::Constant(b) => b.min_tower_level(),
-            Self::Incremental => B64::TOWER_LEVEL,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Incremental {
-    pub(crate) n_vars: usize,
-    pub(crate) tower_level: usize,
-}
-
-impl Incremental {
-    // #[inline]
-    // pub(crate) fn min_tower_level(height: u64) -> usize {
-    //     // It's impossible to satisfy the evaluation within an underlier for
-    //     // tower levels below 3.
-    //     B64::new(height).min_tower_level().max(3)
-    // }
-
-    #[inline]
-    pub(crate) fn min_tower_level(log_height: u8) -> usize {
-        B64::new((1 << log_height) - 1).min_tower_level()
-    }
-}
-
-impl MultivariatePoly<F> for Incremental {
-    fn degree(&self) -> usize {
-        1
-    }
-
-    fn n_vars(&self) -> usize {
-        self.n_vars
-    }
-
-    fn evaluate(&self, query: &[F]) -> Result<F, Error> {
-        let n_vars = self.n_vars;
-        if query.len() != n_vars {
-            binius_utils::bail!(Error::IncorrectQuerySize { expected: n_vars });
-        }
-        let mut result = F::ZERO;
-        let mut coeff = 1;
-        for &arg in query {
-            result += arg * F::from_underlier(coeff);
-            coeff <<= 1;
-        }
-
-        Ok(result)
-    }
-
-    fn binary_tower_level(&self) -> usize {
-        self.tower_level
-    }
-}
-
-macro_rules! downcast {
-    ($t:ident, $b128:ident) => {{
-        let Ok(b) = TryInto::<$t>::try_into($b128) else {
-            unreachable!();
-        };
-        b
-    }};
-}
-
-pub(crate) fn constant_from_b128(b128: B128, n_vars: usize) -> Constant<F> {
-    match b128.min_tower_level() {
-        0 => Constant::new(n_vars, downcast!(B1, b128)),
-        1 => Constant::new(n_vars, downcast!(B2, b128)),
-        2 => Constant::new(n_vars, downcast!(B4, b128)),
-        3 => Constant::new(n_vars, downcast!(B8, b128)),
-        4 => Constant::new(n_vars, downcast!(B16, b128)),
-        5 => Constant::new(n_vars, downcast!(B32, b128)),
-        6 => Constant::new(n_vars, downcast!(B64, b128)),
-        7 => Constant::new(n_vars, b128),
-        _ => unreachable!(),
-    }
-}
-
-pub(crate) fn replicate_within_u128(b128: B128) -> u128 {
-    if b128 == B128::ZERO {
-        return 0;
-    }
-    match b128.min_tower_level() {
-        0 => u128::MAX,
-        1 => replicate_2_bits(downcast!(B2, b128).to_underlier().val()),
-        2 => replicate_4_bits(downcast!(B4, b128).to_underlier().val()),
-        3 => u128::from_le_bytes([downcast!(B8, b128).to_underlier(); 16]),
-        4 => {
-            let u16s = [downcast!(B16, b128).to_underlier(); 8];
-            unsafe { std::mem::transmute::<[u16; 8], u128>(u16s) }
-        }
-        5 => {
-            let u32s = [downcast!(B32, b128).to_underlier(); 4];
-            unsafe { std::mem::transmute::<[u32; 4], u128>(u32s) }
-        }
-        6 => {
-            let u64s = [downcast!(B64, b128).to_underlier(); 2];
-            unsafe { std::mem::transmute::<[u64; 2], u128>(u64s) }
-        }
-        7 => b128.to_underlier(),
-        _ => unreachable!(),
-    }
-}
-
-#[inline(always)]
-fn replicate_2_bits(byte: u8) -> u128 {
-    let bits = (byte & 0b11) as u128; // Extract the first 2 bits
-    bits * 0x55555555555555555555555555555555u128 // Repeat pattern 64 times
-}
-
-#[inline(always)]
-fn replicate_4_bits(byte: u8) -> u128 {
-    let bits = (byte & 0b1111) as u128; // Extract first 4 bits
-    bits * 0x11111111111111111111111111111111u128 // Repeat pattern 16 times
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::archon::transparent::{replicate_2_bits, replicate_4_bits};
-
-    #[test]
-    fn test_replicate_2_bits() {
-        [
-            (0b00000000, 0x00000000000000000000000000000000u128),
-            (0b00000001, 0x55555555555555555555555555555555u128),
-            (0b00000010, 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu128),
-            (0b00000011, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFu128),
-        ]
-        .into_iter()
-        .for_each(|(byte, u128)| assert_eq!(replicate_2_bits(byte), u128));
-    }
-
-    #[test]
-    fn test_replicate_4_bits() {
-        [
-            (0b00000000, 0x00000000000000000000000000000000u128),
-            (0b00000001, 0x11111111111111111111111111111111u128),
-            (0b00000010, 0x22222222222222222222222222222222u128),
-            (0b00000011, 0x33333333333333333333333333333333u128),
-            (0b00000100, 0x44444444444444444444444444444444u128),
-            (0b00000101, 0x55555555555555555555555555555555u128),
-            (0b00000110, 0x66666666666666666666666666666666u128),
-            (0b00000111, 0x77777777777777777777777777777777u128),
-            (0b00001000, 0x88888888888888888888888888888888u128),
-            (0b00001001, 0x99999999999999999999999999999999u128),
-            (0b00001010, 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu128),
-            (0b00001011, 0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBu128),
-            (0b00001100, 0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCu128),
-            (0b00001101, 0xDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDu128),
-            (0b00001110, 0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEu128),
-            (0b00001111, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFu128),
-        ]
-        .into_iter()
-        .for_each(|(byte, u128)| assert_eq!(replicate_4_bits(byte), u128));
-    }
-}
diff --git a/src/archon/witness.rs b/src/archon/witness.rs
deleted file mode 100644
index c77abaa1..00000000
--- a/src/archon/witness.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-use anyhow::{Context, Result, bail, ensure};
-use binius_core::witness::MultilinearExtensionIndex;
-use binius_field::{
-    BinaryField1b as B1, BinaryField2b as B2, BinaryField4b as B4, BinaryField8b as B8,
-    BinaryField16b as B16, BinaryField32b as B32, BinaryField64b as B64, BinaryField128b as B128,
-    TowerField,
-    arch::OptimalUnderlier,
-    as_packed_field::PackedType,
-    underlier::{UnderlierType, WithUnderlier},
-};
-use binius_math::MultilinearExtension;
-use rayon::iter::{
-    IndexedParallelIterator, IntoParallelIterator, IntoParallelRefIterator,
-    IntoParallelRefMutIterator, ParallelIterator,
-};
-use rustc_hash::{FxBuildHasher, FxHashMap};
-use std::{collections::HashMap, mem::transmute, sync::Arc};
-
-use super::{ModuleId, ModuleMode, OracleIdx, OracleInfo};
-
-pub type EntryId = usize;
-
-pub(super) const UNDERLIER_SIZE: usize = size_of::<OptimalUnderlier>();
-
-#[derive(Default)]
-pub struct WitnessModule {
-    pub(super) module_id: ModuleId,
-    pub(super) oracles: Arc<Vec<OracleInfo>>,
-    pub(super) entries: Vec<Vec<OptimalUnderlier>>,
-    pub(super) buffers: Vec<Vec<u8>>,
-    /// Maps oracles to their entries and tower levels
-    pub(super) entry_map: FxHashMap<OracleIdx, (EntryId, usize)>,
-}
-
-#[derive(Default)]
-pub struct Witness<'a> {
-    pub(crate) mlei: MultilinearExtensionIndex<'a, PackedType<OptimalUnderlier, B128>>,
-    pub(crate) modes: Vec<ModuleMode>,
-}
-
-#[inline]
-pub fn populate_witness_modules(
-    witness_modules: &mut [WitnessModule],
-    modes: Vec<ModuleMode>,
-) -> Result<()> {
-    ensure!(
-        witness_modules.len() == modes.len(),
-        "Incompatible numbers of modules and modes"
-    );
-    witness_modules
-        .par_iter_mut()
-        .zip(modes)
-        .try_for_each(|(module, mode)| module.populate(mode))
-}
-
-pub fn compile_witness_modules(
-    modules: &[WitnessModule],
-    modes: Vec<ModuleMode>,
-) -> Result<Witness<'_>> {
-    ensure!(modules.len() == modes.len());
-    let mut witness = Witness::with_capacity(modules.len());
-    let mut oracle_offset = 0;
-    for (module_idx, (module, mode)) in modules.iter().zip(modes).enumerate() {
-        ensure!(
-            module_idx == module.module_id,
-            "Wrong compilation order. Expected module {module_idx}, but got {}.",
-            module.module_id
-        );
-        let ModuleMode::Active { log_height, depth } = mode else {
-            // Deactivate module.
-            witness.modes.push(ModuleMode::Inactive);
-            continue;
-        };
-        let num_oracles = module.num_oracles();
-        let oracles_poly_results = (0..num_oracles)
-            .into_par_iter()
-            .map(|oracle_idx| {
-                let oracle_idx = OracleIdx(oracle_idx);
-                let Some(&(entry_id, tower_level)) = module.entry_map.get(&oracle_idx) else {
-                    bail!("Entry not found for oracle {oracle_idx}, module {module_idx}.");
-                };
-                let entry = &module.entries[entry_id];
-                macro_rules! oracle_poly {
-                    ($bf:ident) => {{
-                        let values =
-                            PackedType::<OptimalUnderlier, $bf>::from_underliers_ref(entry);
-                        let mle = MultilinearExtension::from_values_generic(values)
-                            .context(format!(
-                                "MLE instantiation for entry {entry_id}, oracle {oracle_idx}, module {module_idx}"
-                            ))?
-                            .specialize_arc_dyn();
-                        Ok((oracle_idx.oracle_id(oracle_offset), mle))
-                    }};
-                }
-                match tower_level {
-                    0 => oracle_poly!(B1),
-                    1 => oracle_poly!(B2),
-                    2 => oracle_poly!(B4),
-                    3 => oracle_poly!(B8),
-                    4 => oracle_poly!(B16),
-                    5 => oracle_poly!(B32),
-                    6 => oracle_poly!(B64),
-                    7 => oracle_poly!(B128),
-                    _ => bail!(
-                        "Unsupported tower level {tower_level} for oracle {oracle_idx}, module {module_idx}"
-                    ),
-                }
-            })
-            .collect::<Vec<_>>();
-        let mut oracle_poly_vec = Vec::with_capacity(oracles_poly_results.len());
-        for oracle_data_result in oracles_poly_results {
-            oracle_poly_vec.push(oracle_data_result?);
-        }
-        witness.mlei.update_multilin_poly(oracle_poly_vec)?;
-        witness.modes.push(ModuleMode::Active { log_height, depth });
-        oracle_offset += num_oracles;
-    }
-    Ok(witness)
-}
-
-impl WitnessModule {
-    #[inline]
-    pub fn new_entry(&mut self) -> EntryId {
-        self.entries.push(vec![]);
-        self.buffers.push(vec![]);
-        self.entries.len() - 1
-    }
-
-    #[inline]
-    pub fn new_entry_with_capacity(&mut self, log_bits: u8) -> EntryId {
-        let bits = 1 << log_bits;
-        let num_underliers = bits / OptimalUnderlier::BITS;
-        let num_bytes = bits / 8;
-        self.entries.push(Vec::with_capacity(num_underliers));
-        self.buffers.push(Vec::with_capacity(num_bytes));
-        self.entries.len() - 1
-    }
-
-    #[inline]
-    pub fn bind_oracle_to<FS: TowerField>(&mut self, oracle_idx: OracleIdx, entry_id: EntryId) {
-        self.entry_map
-            .insert(oracle_idx, (entry_id, FS::TOWER_LEVEL));
-    }
-
-    #[inline]
-    pub fn push_u8s_to(&mut self, u8s: impl IntoIterator<Item = u8>, entry_id: EntryId) {
-        self.buffers[entry_id].extend(u8s);
-        self.drain_buffer(entry_id);
-    }
-
-    #[inline]
-    pub fn push_u16s_to(&mut self, u16s: impl IntoIterator<Item = u16>, entry_id: EntryId) {
-        let u8s = u16s.into_iter().flat_map(u16::to_le_bytes);
-        self.push_u8s_to(u8s, entry_id);
-    }
-
-    #[inline]
-    pub fn push_u32s_to(&mut self, u32s: impl IntoIterator<Item = u32>, entry_id: EntryId) {
-        let u8s = u32s.into_iter().flat_map(u32::to_le_bytes);
-        self.push_u8s_to(u8s, entry_id);
-    }
-
-    #[inline]
-    pub fn push_u64s_to(&mut self, u64s: impl IntoIterator<Item = u64>, entry_id: EntryId) {
-        let u8s = u64s.into_iter().flat_map(u64::to_le_bytes);
-        self.push_u8s_to(u8s, entry_id);
-    }
-
-    #[inline]
-    pub fn push_u128s_to(&mut self, u128s: impl IntoIterator<Item = u128>, entry_id: EntryId) {
-        let u8s = u128s.into_iter().flat_map(u128::to_le_bytes);
-        self.push_u8s_to(u8s, entry_id);
-    }
-
-    fn drain_buffer(&mut self, entry_id: EntryId) {
-        const CHUNK_SIZE: usize = size_of::<u128>() / size_of::<u8>();
-        let num_chunks = self.buffers[entry_id].len() / CHUNK_SIZE;
-        for chunk_idx in 0..num_chunks {
-            let start = chunk_idx * CHUNK_SIZE;
-            let end = start + CHUNK_SIZE;
-            let mut bytes = [0; CHUNK_SIZE];
-            bytes.copy_from_slice(&self.buffers[entry_id][start..end]);
-            self.entries[entry_id].push(OptimalUnderlier::from(u128::from_le_bytes(bytes)));
-        }
-        self.buffers[entry_id].drain(..num_chunks * CHUNK_SIZE);
-    }
-
-    pub fn get_data_num_bytes(&self, oracle_idx: &OracleIdx) -> usize {
-        let (entry_id, _) = self.entry_map.get(oracle_idx).expect("No entry found");
-        UNDERLIER_SIZE * self.entries[*entry_id].len() + self.buffers[*entry_id].len()
-    }
-
-    pub fn get_data(&self, oracle_idx: &OracleIdx) -> Vec<u8> {
-        let (entry_id, _) = self.entry_map.get(oracle_idx).expect("No entry found");
-        self.entries[*entry_id]
-            .par_iter()
-            .flat_map(|&u| unsafe { transmute::<OptimalUnderlier, [u8; 16]>(u) })
-            .chain(self.buffers[*entry_id].clone())
-            .collect::<Vec<_>>()
-    }
-
-    #[inline]
-    pub(crate) fn new(module_id: ModuleId, oracles: Arc<Vec<OracleInfo>>) -> Self {
-        let num_oracles = oracles.len();
-        Self {
-            module_id,
-            oracles,
-            entries: vec![],
-            buffers: vec![],
-            entry_map: HashMap::with_capacity_and_hasher(num_oracles, FxBuildHasher),
-        }
-    }
-
-    pub(super) fn num_oracles(&self) -> usize {
-        self.oracles.len()
-    }
-}
-
-impl Witness<'_> {
-    #[inline]
-    fn with_capacity(num_modules: usize) -> Self {
-        Self {
-            mlei: MultilinearExtensionIndex::new(),
-            modes: Vec::with_capacity(num_modules),
-        }
-    }
-}
diff --git a/src/lean/ffi/aiur2/mod.rs b/src/lean/ffi/aiur/mod.rs
similarity index 87%
rename from src/lean/ffi/aiur2/mod.rs
rename to src/lean/ffi/aiur/mod.rs
index ad8596e1..78c334b8 100644
--- a/src/lean/ffi/aiur2/mod.rs
+++ b/src/lean/ffi/aiur/mod.rs
@@ -1,15 +1,15 @@
 use multi_stark::p3_field::integers::QuotientMap;
 use std::ffi::c_void;
 
+pub mod protocol;
+pub mod toplevel;
+
 use crate::{
-    aiur2::G,
-    lean::ffi::{lean_is_scalar, lean_unbox_u64},
+    aiur::G,
+    lean::{lean_is_scalar, lean_unbox_u64},
     lean_unbox,
 };
 
-pub mod protocol;
-pub mod toplevel;
-
 #[inline]
 pub(super) fn lean_unbox_nat_as_usize(ptr: *const c_void) -> usize {
     assert!(lean_is_scalar(ptr));
diff --git a/src/lean/ffi/aiur2/protocol.rs b/src/lean/ffi/aiur/protocol.rs
similarity index 95%
rename from src/lean/ffi/aiur2/protocol.rs
rename to src/lean/ffi/aiur/protocol.rs
index 8dd3bc67..ab316dd4 100644
--- a/src/lean/ffi/aiur2/protocol.rs
+++ b/src/lean/ffi/aiur/protocol.rs
@@ -2,15 +2,16 @@ use multi_stark::{p3_field::PrimeField64, prover::Proof, types::FriParameters};
 use std::ffi::{CString, c_void};
 
 use crate::{
-    aiur2::{G, synthesis::AiurSystem},
+    aiur::{G, synthesis::AiurSystem},
     lean::{
         array::LeanArrayObject,
+        as_mut_unsafe,
         boxed::BoxedU64,
         ctor::LeanCtorObject,
         ffi::{
             BytesData, CResult,
-            aiur2::{lean_unbox_g, lean_unbox_nat_as_usize, toplevel::lean_ctor_to_toplevel},
-            as_mut_unsafe, drop_raw, to_raw,
+            aiur::{lean_unbox_g, lean_unbox_nat_as_usize, toplevel::lean_ctor_to_toplevel},
+            drop_raw, to_raw,
         },
         sarray::LeanSArrayObject,
     },
diff --git a/src/lean/ffi/aiur2/toplevel.rs b/src/lean/ffi/aiur/toplevel.rs
similarity index 97%
rename from src/lean/ffi/aiur2/toplevel.rs
rename to src/lean/ffi/aiur/toplevel.rs
index 310b881d..a903ece9 100644
--- a/src/lean/ffi/aiur2/toplevel.rs
+++ b/src/lean/ffi/aiur/toplevel.rs
@@ -1,7 +1,7 @@
 use std::ffi::c_void;
 
 use crate::{
-    aiur2::{
+    aiur::{
         G,
         bytecode::{Block, Ctrl, Function, FunctionLayout, FxIndexMap, Op, Toplevel, ValIdx},
     },
@@ -9,9 +9,10 @@ use crate::{
         array::LeanArrayObject,
         ctor::LeanCtorObject,
         ffi::{
-            aiur2::{lean_unbox_g, lean_unbox_nat_as_usize},
-            as_ref_unsafe, lean_is_scalar,
+            aiur::{lean_unbox_g, lean_unbox_nat_as_usize},
+            as_ref_unsafe,
         },
+        lean_is_scalar,
     },
 };
 
diff --git a/src/lean/ffi/archon/arith_expr.rs b/src/lean/ffi/archon/arith_expr.rs
deleted file mode 100644
index 38586844..00000000
--- a/src/lean/ffi/archon/arith_expr.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use binius_field::BinaryField128b;
-
-use crate::{
-    archon::{OracleIdx, arith_expr::ArithExpr},
-    lean::{ctor::LeanCtorObject, ffi::as_ref_unsafe, sarray::LeanSArrayObject},
-};
-
-use super::{boxed_usize_ptr_to_oracle_idx, external_ptr_to_u128};
-
-pub(super) fn lean_ctor_to_arith_expr(ctor: &LeanCtorObject) -> ArithExpr {
-    match ctor.tag() {
-        0 => {
-            // Const
-            let [u128_ptr] = ctor.objs();
-            let u128 = external_ptr_to_u128(u128_ptr);
-            ArithExpr::Const(BinaryField128b::new(u128))
-        }
-        1 => {
-            // Var
-            let [ptr_as_usize] = ctor.objs();
-            ArithExpr::Var(ptr_as_usize as usize)
-        }
-        2 => {
-            // Oracle
-            let [ptr] = ctor.objs();
-            ArithExpr::Oracle(boxed_usize_ptr_to_oracle_idx(ptr))
-        }
-        3 => {
-            // Add
-            let [x, y] = ctor.objs();
-            let x = lean_ctor_to_arith_expr(as_ref_unsafe(x.cast()));
-            let y = lean_ctor_to_arith_expr(as_ref_unsafe(y.cast()));
-            ArithExpr::Add(Box::new(x), Box::new(y))
-        }
-        4 => {
-            // Mul
-            let [x, y] = ctor.objs();
-            let x = lean_ctor_to_arith_expr(as_ref_unsafe(x.cast()));
-            let y = lean_ctor_to_arith_expr(as_ref_unsafe(y.cast()));
-            ArithExpr::Mul(Box::new(x), Box::new(y))
-        }
-        5 => {
-            // Pow
-            let [x, e] = ctor.objs();
-            let x = lean_ctor_to_arith_expr(as_ref_unsafe(x.cast()));
-            ArithExpr::Pow(Box::new(x), e as u64)
-        }
-        _ => panic!("Invalid ctor tag"),
-    }
-}
-
-fn arith_expr_from_bytes(bytes: &[u8]) -> ArithExpr {
-    match bytes[0] {
-        0 => {
-            let mut slice = [0; size_of::<u128>()];
-            slice.copy_from_slice(&bytes[1..size_of::<u128>() + 1]);
-            let u = u128::from_le_bytes(slice);
-            ArithExpr::Const(BinaryField128b::new(u))
-        }
-        1 => {
-            let mut slice = [0; size_of::<usize>()];
-            slice.copy_from_slice(&bytes[1..size_of::<usize>() + 1]);
-            let u = usize::from_le_bytes(slice);
-            ArithExpr::Var(u)
-        }
-        2 => {
-            let mut slice = [0; size_of::<usize>()];
-            slice.copy_from_slice(&bytes[1..size_of::<usize>() + 1]);
-            let idx = usize::from_le_bytes(slice);
-            ArithExpr::Oracle(OracleIdx(idx))
-        }
-        3 => {
-            let x_size = bytes[1] as usize;
-            let x = arith_expr_from_bytes(&bytes[2..x_size + 2]);
-            let y = arith_expr_from_bytes(&bytes[x_size + 2..]);
-            ArithExpr::Add(Box::new(x), Box::new(y))
-        }
-        4 => {
-            let x_size = bytes[1] as usize;
-            let x = arith_expr_from_bytes(&bytes[2..x_size + 2]);
-            let y = arith_expr_from_bytes(&bytes[x_size + 2..]);
-            ArithExpr::Mul(Box::new(x), Box::new(y))
-        }
-        5 => {
-            let u64_start = bytes.len() - size_of::<u64>();
-            let mut u64_bytes = [0; size_of::<u64>()];
-            u64_bytes.copy_from_slice(&bytes[u64_start..]);
-            let e = u64::from_le_bytes(u64_bytes);
-            let x = arith_expr_from_bytes(&bytes[1..u64_start]);
-            ArithExpr::Pow(Box::new(x), e)
-        }
-        _ => panic!("Invalid ctor tag"),
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_arith_expr_is_equivalent_to_bytes(
-    arith_expr: &LeanCtorObject,
-    bytes: &LeanSArrayObject,
-) -> bool {
-    lean_ctor_to_arith_expr(arith_expr) == arith_expr_from_bytes(bytes.data())
-}
diff --git a/src/lean/ffi/archon/circuit.rs b/src/lean/ffi/archon/circuit.rs
deleted file mode 100644
index ff3901f7..00000000
--- a/src/lean/ffi/archon/circuit.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-use binius_core::{constraint_system::channel::FlushDirection, oracle::ShiftVariant};
-use binius_field::{
-    BinaryField1b as B1, BinaryField2b as B2, BinaryField4b as B4, BinaryField8b as B8,
-    BinaryField16b as B16, BinaryField32b as B32, BinaryField64b as B64, BinaryField128b as B128,
-};
-use std::ffi::c_char;
-
-use crate::{
-    archon::{
-        ModuleId, OracleIdx, canonical::Canonical, circuit::CircuitModule, witness::WitnessModule,
-    },
-    lean::{
-        CArray,
-        array::LeanArrayObject,
-        ctor::LeanCtorObject,
-        ffi::{
-            archon::{
-                arith_expr::lean_ctor_to_arith_expr, boxed_usize_ptr_to_oracle_idx,
-                ctor_ptr_to_lc_factor, oracle_or_const::lean_ctor_ptr_to_oracle_or_const,
-                relative_height::lean_ctor_ptr_to_relative_height,
-                transparent::lean_ctor_ptr_to_transparent,
-            },
-            drop_raw, raw_to_str, to_raw,
-        },
-    },
-};
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_new(module_id: ModuleId) -> *const CircuitModule {
-    to_raw(CircuitModule::new(module_id))
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_free(ptr: *mut CircuitModule) {
-    drop_raw(ptr);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_freeze_oracles(circuit_module: &mut CircuitModule) {
-    circuit_module.freeze_oracles();
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_init_witness_module(
-    circuit_module: &CircuitModule,
-) -> *const WitnessModule {
-    to_raw(
-        circuit_module
-            .init_witness_module()
-            .expect("CircuitModule::init_witness_module failure"),
-    )
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_flush(
-    circuit_module: &mut CircuitModule,
-    direction_pull: bool,
-    channel_idx: usize,
-    selector: OracleIdx,
-    values: &LeanArrayObject,
-    multiplicity: u64,
-) {
-    let values = values.to_vec(|ptr| lean_ctor_ptr_to_oracle_or_const(ptr.cast()));
-    use FlushDirection::{Pull, Push};
-    let direction = if direction_pull { Pull } else { Push };
-    let channel_id = channel_idx;
-    circuit_module.flush(direction, channel_id, selector, values, multiplicity);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_assert_zero(
-    circuit_module: &mut CircuitModule,
-    name: *const c_char,
-    oracle_idxs: &LeanArrayObject,
-    composition: &LeanCtorObject,
-) {
-    let oracle_idxs = oracle_idxs.to_vec(boxed_usize_ptr_to_oracle_idx);
-    let composition = lean_ctor_to_arith_expr(composition);
-    circuit_module.assert_zero(raw_to_str(name), oracle_idxs, composition);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_assert_not_zero(
-    circuit_module: &mut CircuitModule,
-    oracle_idx: OracleIdx,
-) {
-    circuit_module.assert_not_zero(oracle_idx);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_assert_exp(
-    circuit_module: &mut CircuitModule,
-    exp_bits: &LeanArrayObject,
-    result: OracleIdx,
-    base: &LeanCtorObject,
-) {
-    let exp_bits = exp_bits.to_vec(boxed_usize_ptr_to_oracle_idx);
-    let base = lean_ctor_ptr_to_oracle_or_const(base);
-    circuit_module.assert_exp(exp_bits, result, base);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_add_committed(
-    circuit_module: &mut CircuitModule,
-    name: *const c_char,
-    tower_level: u8,
-    relative_height: *const LeanCtorObject,
-) -> OracleIdx {
-    let name = raw_to_str(name);
-    let relative_height = lean_ctor_ptr_to_relative_height(relative_height);
-    match tower_level {
-        0 => circuit_module.add_committed::<B1>(name, relative_height),
-        1 => circuit_module.add_committed::<B2>(name, relative_height),
-        2 => circuit_module.add_committed::<B4>(name, relative_height),
-        3 => circuit_module.add_committed::<B8>(name, relative_height),
-        4 => circuit_module.add_committed::<B16>(name, relative_height),
-        5 => circuit_module.add_committed::<B32>(name, relative_height),
-        6 => circuit_module.add_committed::<B64>(name, relative_height),
-        7 => circuit_module.add_committed::<B128>(name, relative_height),
-        _ => unreachable!(),
-    }
-    .expect("CircuitModule::add_committed failure")
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_add_transparent(
-    circuit_module: &mut CircuitModule,
-    name: *const c_char,
-    transparent_ptr: *const LeanCtorObject,
-    relative_height: *const LeanCtorObject,
-) -> OracleIdx {
-    let name = raw_to_str(name);
-    let transparent = lean_ctor_ptr_to_transparent(transparent_ptr);
-    let relative_height = lean_ctor_ptr_to_relative_height(relative_height);
-    circuit_module
-        .add_transparent(name, transparent, relative_height)
-        .expect("CircuitModule::add_transparent failure")
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_add_linear_combination(
-    circuit_module: &mut CircuitModule,
-    name: *const c_char,
-    offset: &u128,
-    inner: &LeanArrayObject,
-    relative_height: *const LeanCtorObject,
-) -> OracleIdx {
-    let inner = inner.to_vec(ctor_ptr_to_lc_factor);
-    let offset = B128::new(*offset);
-    let relative_height = lean_ctor_ptr_to_relative_height(relative_height);
-    circuit_module
-        .add_linear_combination(raw_to_str(name), offset, inner, relative_height)
-        .expect("CircuitModule::add_linear_combination failure")
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_add_packed(
-    circuit_module: &mut CircuitModule,
-    name: *const c_char,
-    inner: OracleIdx,
-    log_degree: usize,
-) -> OracleIdx {
-    circuit_module
-        .add_packed(raw_to_str(name), inner, log_degree)
-        .expect("CircuitModule::add_packed failure")
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_add_shifted(
-    circuit_module: &mut CircuitModule,
-    name: *const c_char,
-    inner: OracleIdx,
-    shift_offset: u32,
-    block_bits: usize,
-    shift_variant: u8,
-) -> OracleIdx {
-    let shift_variant = match shift_variant {
-        0 => ShiftVariant::CircularLeft,
-        1 => ShiftVariant::LogicalLeft,
-        2 => ShiftVariant::LogicalRight,
-        _ => unreachable!(),
-    };
-    circuit_module
-        .add_shifted(
-            raw_to_str(name),
-            inner,
-            shift_offset,
-            block_bits,
-            shift_variant,
-        )
-        .expect("CircuitModule::add_shifted failure")
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_add_projected(
-    circuit_module: &mut CircuitModule,
-    name: *const c_char,
-    inner: OracleIdx,
-    selection: u64,
-    chunk_size: usize,
-) -> OracleIdx {
-    circuit_module
-        .add_projected(raw_to_str(name), inner, selection, chunk_size)
-        .expect("CircuitModule::add_projected failure")
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_push_namespace(
-    circuit_module: &mut CircuitModule,
-    name: *const c_char,
-) {
-    circuit_module.push_namespace(raw_to_str(name));
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_pop_namespace(circuit_module: &mut CircuitModule) {
-    circuit_module.pop_namespace();
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_canonical_bytes_size(circuit_module: &CircuitModule) -> usize {
-    Canonical::size(circuit_module)
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_circuit_module_canonical_bytes(
-    circuit_module: &CircuitModule,
-    size: usize,
-    bytes: &mut CArray<u8>,
-) {
-    let mut buffer = Vec::with_capacity(size);
-    Canonical::write(circuit_module, &mut buffer);
-    bytes.copy_from_slice(&buffer);
-}
diff --git a/src/lean/ffi/archon/mod.rs b/src/lean/ffi/archon/mod.rs
deleted file mode 100644
index a9008407..00000000
--- a/src/lean/ffi/archon/mod.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-pub mod arith_expr;
-pub mod circuit;
-pub mod module_mode;
-pub mod oracle_or_const;
-pub mod protocol;
-pub mod relative_height;
-pub mod transparent;
-pub mod witness;
-
-use binius_field::BinaryField128b;
-use std::ffi::c_void;
-
-use crate::{
-    archon::OracleIdx,
-    lean::{
-        ctor::LeanCtorObject,
-        ffi::{as_ref_unsafe, boxed_usize_ptr_to_usize, external_ptr_to_u128},
-    },
-};
-
-#[inline]
-pub(super) fn boxed_usize_ptr_to_oracle_idx(ptr: *const c_void) -> OracleIdx {
-    OracleIdx(boxed_usize_ptr_to_usize(ptr))
-}
-
-pub(super) fn ctor_ptr_to_lc_factor(ptr: *const c_void) -> (OracleIdx, BinaryField128b) {
-    let ctor_ptr = ptr.cast::<LeanCtorObject>();
-    let ctor = as_ref_unsafe(ctor_ptr);
-    let [oracle_idx_ptr, u128_external_ptr] = ctor.objs();
-    let oracle_idx = boxed_usize_ptr_to_oracle_idx(oracle_idx_ptr);
-    let u128 = external_ptr_to_u128(u128_external_ptr);
-    (oracle_idx, BinaryField128b::new(u128))
-}
diff --git a/src/lean/ffi/archon/module_mode.rs b/src/lean/ffi/archon/module_mode.rs
deleted file mode 100644
index 8962bc31..00000000
--- a/src/lean/ffi/archon/module_mode.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use crate::{
-    archon::ModuleMode,
-    lean::{
-        ctor::LeanCtorObject,
-        ffi::{as_ref_unsafe, lean_is_scalar},
-        sarray::LeanSArrayObject,
-    },
-    lean_unbox,
-};
-
-pub(super) fn lean_ctor_ptr_to_module_mode(ctor: *const LeanCtorObject) -> ModuleMode {
-    if lean_is_scalar(ctor) {
-        match lean_unbox!(usize, ctor) {
-            0 => ModuleMode::Inactive,
-            _ => unreachable!(),
-        }
-    } else {
-        let mode = as_ref_unsafe(ctor);
-        match mode.tag() {
-            1 => {
-                let [depth_ptr, log_height_ptr] = mode.objs();
-                ModuleMode::active(log_height_ptr as u8, depth_ptr as u64)
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-fn module_mode_from_bytes(bytes: &[u8]) -> ModuleMode {
-    match bytes[0] {
-        0 => ModuleMode::Inactive,
-        1 => {
-            let log_height = bytes[1];
-            let mut depth_bytes = [0; size_of::<u64>()];
-            depth_bytes.copy_from_slice(&bytes[2..2 + size_of::<u64>()]);
-            let depth = u64::from_le_bytes(depth_bytes);
-            ModuleMode::active(log_height, depth)
-        }
-        _ => unreachable!(),
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_module_mode_is_equivalent_to_bytes(
-    module_mode_ptr: *const LeanCtorObject,
-    bytes: &LeanSArrayObject,
-) -> bool {
-    lean_ctor_ptr_to_module_mode(module_mode_ptr) == module_mode_from_bytes(bytes.data())
-}
diff --git a/src/lean/ffi/archon/oracle_or_const.rs b/src/lean/ffi/archon/oracle_or_const.rs
deleted file mode 100644
index a57276be..00000000
--- a/src/lean/ffi/archon/oracle_or_const.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use binius_field::BinaryField128b;
-
-use crate::{
-    archon::{OracleIdx, circuit::OracleOrConst},
-    lean::{
-        ctor::LeanCtorObject,
-        ffi::{archon::boxed_usize_ptr_to_oracle_idx, as_ref_unsafe, external_ptr_to_u128},
-        sarray::LeanSArrayObject,
-    },
-};
-
-pub(super) fn lean_ctor_ptr_to_oracle_or_const(ctor: *const LeanCtorObject) -> OracleOrConst {
-    let ctor = as_ref_unsafe(ctor);
-    match ctor.tag() {
-        0 => {
-            let [oracle_idx_ptr] = ctor.objs();
-            OracleOrConst::Oracle(boxed_usize_ptr_to_oracle_idx(oracle_idx_ptr))
-        }
-        1 => {
-            let [base_ptr, tower_level_ptr] = ctor.objs();
-            let base = BinaryField128b::new(external_ptr_to_u128(base_ptr));
-            let tower_level = tower_level_ptr as usize;
-            OracleOrConst::Const { base, tower_level }
-        }
-        _ => unreachable!(),
-    }
-}
-
-fn oracle_or_const_from_bytes(bytes: &[u8]) -> OracleOrConst {
-    match bytes[0] {
-        0 => {
-            let mut oracle_idx_bytes = [0; size_of::<usize>()];
-            oracle_idx_bytes.copy_from_slice(&bytes[1..]);
-            let oracle_idx = OracleIdx(usize::from_le_bytes(oracle_idx_bytes));
-            OracleOrConst::Oracle(oracle_idx)
-        }
-        1 => {
-            let mut base_u128_bytes = [0; size_of::<u128>()];
-            base_u128_bytes.copy_from_slice(&bytes[1..size_of::<u128>() + 1]);
-            let base = BinaryField128b::new(u128::from_le_bytes(base_u128_bytes));
-            let tower_level = bytes[size_of::<u128>() + 1] as usize;
-            OracleOrConst::Const { base, tower_level }
-        }
-        _ => unreachable!(),
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_oracle_or_const_is_equivalent_to_bytes(
-    oracle_or_const_ptr: *const LeanCtorObject,
-    bytes: &LeanSArrayObject,
-) -> bool {
-    lean_ctor_ptr_to_oracle_or_const(oracle_or_const_ptr)
-        == oracle_or_const_from_bytes(bytes.data())
-}
diff --git a/src/lean/ffi/archon/protocol.rs b/src/lean/ffi/archon/protocol.rs
deleted file mode 100644
index 9e5e755e..00000000
--- a/src/lean/ffi/archon/protocol.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-use binius_core::constraint_system::Proof as ProofCore;
-use binius_hal::make_portable_backend;
-use std::{ffi::CString, ptr};
-
-use crate::{
-    archon::{
-        ModuleMode,
-        circuit::CircuitModule,
-        protocol::{Proof, prove_core, validate_witness_core, verify_core},
-    },
-    lean::{
-        CArray,
-        array::LeanArrayObject,
-        ffi::{
-            CResult, archon::witness::WitnessWrap, binius::ctor_ptr_to_boundary, drop_raw, to_raw,
-        },
-        sarray::LeanSArrayObject,
-    },
-};
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_validate_witness(
-    num_modules: usize,
-    circuit_modules: &CArray<&CircuitModule>,
-    boundaries: &LeanArrayObject,
-    witness_wrap: &WitnessWrap,
-) -> *const CResult {
-    let circuit_modules = circuit_modules.slice(num_modules);
-    let boundaries = boundaries.to_vec(ctor_ptr_to_boundary);
-    let WitnessWrap { witness, .. } = witness_wrap;
-    let c_result = match validate_witness_core(circuit_modules, &boundaries, witness) {
-        Ok(_) => CResult {
-            is_ok: true,
-            data: ptr::null(),
-        },
-        Err(err) => {
-            let msg = CString::new(err.to_string()).expect("CString::new failure");
-            CResult {
-                is_ok: false,
-                data: msg.into_raw().cast(),
-            }
-        }
-    };
-    to_raw(c_result)
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_proof_free(ptr: *mut Proof) {
-    drop_raw(ptr);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_prove(
-    num_modules: usize,
-    circuit_modules: &CArray<&CircuitModule>,
-    boundaries: &LeanArrayObject,
-    log_inv_rate: usize,
-    security_bits: usize,
-    witness_wrap: &mut WitnessWrap,
-) -> *const Proof {
-    let circuit_modules = circuit_modules.slice(num_modules);
-    let boundaries = boundaries.to_vec(ctor_ptr_to_boundary);
-    let witness = std::mem::take(&mut witness_wrap.witness);
-    let proof = prove_core(
-        circuit_modules,
-        &boundaries,
-        log_inv_rate,
-        security_bits,
-        witness,
-        &make_portable_backend(),
-    )
-    .expect("protocol::prove_core failure");
-    to_raw(proof)
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_verify(
-    num_modules: usize,
-    circuit_modules: &CArray<&CircuitModule>,
-    boundaries: &LeanArrayObject,
-    log_inv_rate: usize,
-    security_bits: usize,
-    proof: &mut Proof,
-) -> *const CResult {
-    let circuit_modules = circuit_modules.slice(num_modules);
-    let boundaries = boundaries.to_vec(ctor_ptr_to_boundary);
-    let proof = std::mem::take(proof);
-    let c_result = match verify_core(
-        circuit_modules,
-        &boundaries,
-        proof,
-        log_inv_rate,
-        security_bits,
-    ) {
-        Ok(_) => CResult {
-            is_ok: true,
-            data: ptr::null(),
-        },
-        Err(err) => {
-            let msg = CString::new(err.to_string()).expect("CString::new failure");
-            CResult {
-                is_ok: false,
-                data: msg.into_raw().cast(),
-            }
-        }
-    };
-    to_raw(c_result)
-}
-
-/// Just a byte flag with value 0.
-const INACTIVE_MODE_SIZE: usize = 1;
-
-/// Byte flag with value 0, the `log_height: u8` and the `depth: u64`.
-const ACTIVE_MODE_SIZE: usize = 1 + size_of::<u8>() + size_of::<u64>();
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_proof_size(proof: &Proof) -> usize {
-    let modes_size: usize = proof
-        .modes
-        .iter()
-        .map(|mode| match mode {
-            ModuleMode::Inactive => INACTIVE_MODE_SIZE,
-            ModuleMode::Active { .. } => ACTIVE_MODE_SIZE,
-        })
-        .sum();
-    size_of::<u16>() // An `u16` is enough to indicate the number of modules
-        + modes_size
-        + proof.proof_core.get_proof_size()
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_proof_to_bytes(proof: &Proof, proof_size: usize, bytes: &mut CArray<u8>) {
-    let mut buffer = Vec::with_capacity(proof_size);
-    let num_modules: u16 = proof.modes.len().try_into().expect("Too many modules");
-    buffer.extend(num_modules.to_le_bytes());
-    for mode in &proof.modes {
-        match mode {
-            ModuleMode::Inactive => buffer.push(0),
-            ModuleMode::Active { log_height, depth } => {
-                buffer.push(1);
-                buffer.extend(log_height.to_le_bytes());
-                buffer.extend(depth.to_le_bytes());
-            }
-        }
-    }
-    buffer.extend(&proof.proof_core.transcript);
-    bytes.copy_from_slice(&buffer);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_proof_of_bytes(bytes: &LeanSArrayObject) -> *const Proof {
-    let bytes = bytes.data();
-
-    // Deserialize the number of modules
-    let num_modules = bytes[0] as usize + 256 * (bytes[1] as usize);
-
-    // Deserialize `modes`
-    let mut modes = Vec::with_capacity(num_modules);
-    let mut modes_size = 0;
-    let modes_start = 2; // Skip the 2 bytes for `num_modules`
-    for _ in 0..num_modules {
-        match bytes[modes_start + modes_size] {
-            0 => {
-                modes.push(ModuleMode::Inactive);
-                modes_size += INACTIVE_MODE_SIZE;
-            }
-            1 => {
-                let log_height_idx = modes_start + modes_size + 1;
-                let log_height = bytes[log_height_idx];
-                let mut depth_bytes = [0; size_of::<u64>()];
-                let depth_start = log_height_idx + 1;
-                depth_bytes.copy_from_slice(&bytes[depth_start..depth_start + size_of::<u64>()]);
-                let depth = u64::from_le_bytes(depth_bytes);
-                modes.push(ModuleMode::active(log_height, depth));
-                modes_size += ACTIVE_MODE_SIZE;
-            }
-            _ => panic!("Invalid ModuleMode flag"),
-        }
-    }
-
-    // Deserialize `transcript`
-    let transcript_start = modes_start + modes_size;
-    let transcript = bytes[transcript_start..].to_vec();
-    let proof_core = ProofCore { transcript };
-    to_raw(Proof { modes, proof_core })
-}
diff --git a/src/lean/ffi/archon/relative_height.rs b/src/lean/ffi/archon/relative_height.rs
deleted file mode 100644
index 45b24bc1..00000000
--- a/src/lean/ffi/archon/relative_height.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use crate::{
-    archon::RelativeHeight,
-    lean::{
-        ctor::LeanCtorObject,
-        ffi::{as_ref_unsafe, lean_is_scalar},
-        sarray::LeanSArrayObject,
-    },
-    lean_unbox,
-};
-
-pub(super) fn lean_ctor_ptr_to_relative_height(ctor: *const LeanCtorObject) -> RelativeHeight {
-    if lean_is_scalar(ctor) {
-        match lean_unbox!(usize, ctor) {
-            0 => RelativeHeight::Base,
-            _ => unreachable!(),
-        }
-    } else {
-        let relative_height = as_ref_unsafe(ctor);
-        match relative_height.tag() {
-            1 => {
-                let [n_ptr] = relative_height.objs();
-                RelativeHeight::Div2(n_ptr as u8)
-            }
-            2 => {
-                let [n_ptr] = relative_height.objs();
-                RelativeHeight::Mul2(n_ptr as u8)
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-fn relative_height_from_bytes(bytes: &[u8]) -> RelativeHeight {
-    match bytes[0] {
-        0 => RelativeHeight::Base,
-        1 => RelativeHeight::Div2(bytes[1]),
-        2 => RelativeHeight::Mul2(bytes[1]),
-        _ => unreachable!(),
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_relative_height_is_equivalent_to_bytes(
-    relative_height_ptr: *const LeanCtorObject,
-    bytes: &LeanSArrayObject,
-) -> bool {
-    lean_ctor_ptr_to_relative_height(relative_height_ptr)
-        == relative_height_from_bytes(bytes.data())
-}
diff --git a/src/lean/ffi/archon/transparent.rs b/src/lean/ffi/archon/transparent.rs
deleted file mode 100644
index 7bfc0293..00000000
--- a/src/lean/ffi/archon/transparent.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use binius_field::BinaryField128b as B128;
-
-use crate::{
-    archon::transparent::Transparent,
-    lean::{
-        ctor::LeanCtorObject,
-        ffi::{as_ref_unsafe, external_ptr_to_u128, lean_is_scalar},
-        sarray::LeanSArrayObject,
-    },
-    lean_unbox,
-};
-
-pub(super) fn lean_ctor_ptr_to_transparent(ctor: *const LeanCtorObject) -> Transparent {
-    if lean_is_scalar(ctor) {
-        match lean_unbox!(usize, ctor) {
-            1 => Transparent::Incremental,
-            _ => unreachable!(),
-        }
-    } else {
-        let transparent = as_ref_unsafe(ctor);
-        match transparent.tag() {
-            0 => {
-                let [value_ptr] = transparent.objs();
-                Transparent::Constant(B128::new(external_ptr_to_u128(value_ptr)))
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-fn transparent_from_bytes(bytes: &[u8]) -> Transparent {
-    match bytes[0] {
-        0 => {
-            let mut slice = [0; size_of::<u128>()];
-            slice.copy_from_slice(&bytes[1..size_of::<u128>() + 1]);
-            let u = u128::from_le_bytes(slice);
-            Transparent::Constant(B128::new(u))
-        }
-        1 => Transparent::Incremental,
-        _ => unreachable!(),
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_transparent_is_equivalent_to_bytes(
-    transparent_ptr: *const LeanCtorObject,
-    bytes: &LeanSArrayObject,
-) -> bool {
-    lean_ctor_ptr_to_transparent(transparent_ptr) == transparent_from_bytes(bytes.data())
-}
diff --git a/src/lean/ffi/archon/witness.rs b/src/lean/ffi/archon/witness.rs
deleted file mode 100644
index 7ec429f1..00000000
--- a/src/lean/ffi/archon/witness.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-use binius_field::{
-    BinaryField1b as B1, BinaryField2b as B2, BinaryField4b as B4, BinaryField8b as B8,
-    BinaryField16b as B16, BinaryField32b as B32, BinaryField64b as B64, BinaryField128b as B128,
-};
-use rayon::iter::{IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator};
-
-use crate::{
-    archon::{
-        OracleIdx,
-        witness::{EntryId, Witness, WitnessModule, compile_witness_modules},
-    },
-    lean::{
-        CArray,
-        array::LeanArrayObject,
-        ctor::LeanCtorObject,
-        ffi::{
-            archon::module_mode::lean_ctor_ptr_to_module_mode, drop_raw, external_ptr_to_u128,
-            lean_unbox_u32, lean_unbox_u64, to_raw,
-        },
-        sarray::LeanSArrayObject,
-    },
-    lean_unbox,
-};
-
-/// Also holds a reference to the witness modules vector, which lives in the heap
-/// and needs to be deallocated manually.
-pub(crate) struct WitnessWrap {
-    pub(crate) witness_modules: &'static Vec<WitnessModule>,
-    pub(crate) witness: Witness<'static>,
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_free(ptr: *mut WitnessWrap) {
-    let witness_wrap = unsafe { Box::from_raw(ptr) };
-    let modules =
-        witness_wrap.witness_modules as *const Vec<WitnessModule> as *mut Vec<WitnessModule>;
-    drop_raw(modules);
-    drop(witness_wrap);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_free(ptr: *mut WitnessModule) {
-    drop_raw(ptr);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_add_entry(witness_module: &mut WitnessModule) -> EntryId {
-    witness_module.new_entry()
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_add_entry_with_capacity(
-    witness_module: &mut WitnessModule,
-    log_bits: u8,
-) -> EntryId {
-    witness_module.new_entry_with_capacity(log_bits)
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_bind_oracle_to(
-    witness_module: &mut WitnessModule,
-    oracle_idx: OracleIdx,
-    entry_id: EntryId,
-    tower_level: u8,
-) {
-    match tower_level {
-        0 => witness_module.bind_oracle_to::<B1>(oracle_idx, entry_id),
-        1 => witness_module.bind_oracle_to::<B2>(oracle_idx, entry_id),
-        2 => witness_module.bind_oracle_to::<B4>(oracle_idx, entry_id),
-        3 => witness_module.bind_oracle_to::<B8>(oracle_idx, entry_id),
-        4 => witness_module.bind_oracle_to::<B16>(oracle_idx, entry_id),
-        5 => witness_module.bind_oracle_to::<B32>(oracle_idx, entry_id),
-        6 => witness_module.bind_oracle_to::<B64>(oracle_idx, entry_id),
-        7 => witness_module.bind_oracle_to::<B128>(oracle_idx, entry_id),
-        _ => unreachable!(),
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_push_u8s_to(
-    witness_module: &mut WitnessModule,
-    u8s: &LeanArrayObject,
-    entry_id: EntryId,
-) {
-    let u8s = u8s.to_vec(|ptr| lean_unbox!(u8, ptr));
-    witness_module.push_u8s_to(u8s, entry_id);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_push_u16s_to(
-    witness_module: &mut WitnessModule,
-    u16s: &LeanArrayObject,
-    entry_id: EntryId,
-) {
-    let u16s = u16s.to_vec(|ptr| lean_unbox!(u16, ptr));
-    witness_module.push_u16s_to(u16s, entry_id);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_push_u32s_to(
-    witness_module: &mut WitnessModule,
-    u32s: &LeanArrayObject,
-    entry_id: EntryId,
-) {
-    let u32s = u32s.to_vec(lean_unbox_u32);
-    witness_module.push_u32s_to(u32s, entry_id);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_push_u64s_to(
-    witness_module: &mut WitnessModule,
-    u64s: &LeanArrayObject,
-    entry_id: EntryId,
-) {
-    let u64s = u64s.to_vec(lean_unbox_u64);
-    witness_module.push_u64s_to(u64s, entry_id);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_push_u128s_to(
-    witness_module: &mut WitnessModule,
-    u128s: &LeanArrayObject,
-    entry_id: EntryId,
-) {
-    let u128s = u128s.to_vec(external_ptr_to_u128);
-    witness_module.push_u128s_to(u128s, entry_id);
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_populate(
-    witness_module: &mut WitnessModule,
-    mode: &LeanCtorObject,
-) {
-    let mode = lean_ctor_ptr_to_module_mode(mode);
-    witness_module
-        .populate(mode)
-        .expect("WitnessModule::populate failure");
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_par_populate(
-    witness_modules: &CArray<*mut WitnessModule>,
-    modes: &LeanArrayObject,
-) {
-    let modes = modes.to_vec(|ptr| lean_ctor_ptr_to_module_mode(ptr.cast()));
-    let mut witness_modules = witness_modules
-        .slice(modes.len())
-        .iter()
-        .map(|&ptr| unsafe { &mut *ptr })
-        .collect::<Vec<_>>();
-    witness_modules
-        .par_iter_mut()
-        .zip(modes)
-        .enumerate()
-        .for_each(|(i, (w, m))| {
-            if let Err(e) = w.populate(m) {
-                panic!("rs_witness_module_par_populate failure at index {i}: {e}");
-            }
-        });
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_get_data_num_bytes(
-    witness_module: &WitnessModule,
-    oracle_idx: OracleIdx,
-) -> usize {
-    witness_module.get_data_num_bytes(&oracle_idx)
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_witness_module_get_data(
-    witness_module: &WitnessModule,
-    oracle_idx: OracleIdx,
-    bytes: &mut LeanSArrayObject,
-) {
-    bytes.set_data(&witness_module.get_data(&oracle_idx));
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_compile_witness_modules(
-    modules_ptrs: &CArray<*mut WitnessModule>,
-    modes: &LeanArrayObject,
-) -> *const WitnessWrap {
-    let modes = modes.to_vec(|ptr| lean_ctor_ptr_to_module_mode(ptr.cast()));
-    let witness_modules = modules_ptrs
-        .slice(modes.len())
-        .iter()
-        .map(|&ptr| std::mem::take(unsafe { &mut *ptr }))
-        .collect::<Vec<_>>();
-    let witness_modules = Box::leak(Box::new(witness_modules));
-    let witness =
-        compile_witness_modules(witness_modules, modes).expect("compile_witness_modules failure");
-    to_raw(WitnessWrap {
-        witness_modules,
-        witness,
-    })
-}
diff --git a/src/lean/ffi/binius.rs b/src/lean/ffi/binius.rs
deleted file mode 100644
index e605b4fd..00000000
--- a/src/lean/ffi/binius.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-use binius_core::constraint_system::channel::{Boundary, FlushDirection};
-use binius_field::{BinaryField64b as B64, BinaryField128b as B128, Field};
-use std::ffi::c_void;
-
-use crate::lean::{
-    array::LeanArrayObject,
-    ctor::LeanCtorObject,
-    ffi::{as_ref_unsafe, boxed_usize_ptr_to_usize, external_ptr_to_u128, to_raw},
-    sarray::LeanSArrayObject,
-};
-
-pub(super) fn ctor_ptr_to_boundary(ptr: *const c_void) -> Boundary<B128> {
-    let ctor = as_ref_unsafe(ptr.cast::<LeanCtorObject>());
-    let [values_ptr, channel_id_ptr, multiplicity_ptr, direction_ptr] = ctor.objs();
-    let values = as_ref_unsafe(values_ptr.cast::<LeanArrayObject>()).to_vec(external_ptr_to_u128);
-    let values = values.into_iter().map(B128::new).collect();
-    let channel_id = boxed_usize_ptr_to_usize(channel_id_ptr);
-    let multiplicity = multiplicity_ptr as u64;
-    let direction_pull = direction_ptr as usize == 1;
-    use FlushDirection::{Pull, Push};
-    let direction = if direction_pull { Pull } else { Push };
-    Boundary {
-        values,
-        channel_id,
-        direction,
-        multiplicity,
-    }
-}
-
-fn boundary_from_bytes(bytes: &[u8]) -> Boundary<B128> {
-    let mut usize_bytes = [0; size_of::<usize>()];
-    usize_bytes.copy_from_slice(&bytes[..size_of::<usize>()]);
-    let num_values = usize::from_le_bytes(usize_bytes);
-    let mut values = Vec::with_capacity(num_values);
-    let values_start = size_of::<usize>();
-    let mut u128_bytes = [0; size_of::<u128>()];
-    for i in 0..num_values {
-        let u128_start = values_start + i * size_of::<u128>();
-        u128_bytes.copy_from_slice(&bytes[u128_start..u128_start + size_of::<u128>()]);
-        values.push(B128::new(u128::from_le_bytes(u128_bytes)));
-    }
-    let channel_start = values_start + num_values * size_of::<u128>();
-    usize_bytes.copy_from_slice(&bytes[channel_start..channel_start + size_of::<usize>()]);
-    let channel_id = usize::from_le_bytes(usize_bytes);
-    let direction_idx = channel_start + size_of::<usize>();
-    let direction_byte = bytes[direction_idx];
-    use FlushDirection::{Pull, Push};
-    let direction = if direction_byte == 0 { Push } else { Pull };
-    let multiplicity_start = direction_idx + size_of::<u8>();
-    let mut u64_bytes = [0; size_of::<u64>()];
-    u64_bytes.copy_from_slice(&bytes[multiplicity_start..]);
-    let multiplicity = u64::from_le_bytes(u64_bytes);
-    Boundary {
-        values,
-        channel_id,
-        direction,
-        multiplicity,
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_binius_boundary_is_equivalent_to_bytes(
-    boundary_ptr: *const c_void,
-    bytes: &LeanSArrayObject,
-) -> bool {
-    ctor_ptr_to_boundary(boundary_ptr) == boundary_from_bytes(bytes.data())
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_add_u128_in_binary_field(a: &u128, b: &u128) -> *const u128 {
-    let a = B128::new(*a);
-    let b = B128::new(*b);
-    let c = a + b;
-    to_raw(c.val())
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_mul_u128_in_binary_field(a: &u128, b: &u128) -> *const u128 {
-    let a = B128::new(*a);
-    let b = B128::new(*b);
-    let c = a * b;
-    to_raw(c.val())
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_mul_u64_in_binary_field(a: u64, b: u64) -> u64 {
-    let a = B64::new(a);
-    let b = B64::new(b);
-    let c = a * b;
-    c.val()
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_pow_u64_in_binary_field(a: u64, b: u64) -> u64 {
-    let a = B64::new(a);
-    let c = a.pow([b]);
-    c.val()
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_pow_u128_in_binary_field(a: &u128, b: u64) -> *const u128 {
-    let a = B128::new(*a);
-    let c = a.pow([b]);
-    to_raw(c.val())
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_inv_u64_in_binary_field(a: u64) -> u64 {
-    let a = B64::new(a);
-    let c = a.invert().unwrap_or(B64::new(0));
-    c.val()
-}
diff --git a/src/lean/ffi/mod.rs b/src/lean/ffi/mod.rs
index 25a33281..e1c38ba5 100644
--- a/src/lean/ffi/mod.rs
+++ b/src/lean/ffi/mod.rs
@@ -1,17 +1,12 @@
-pub mod aiur2;
-pub mod archon;
-pub mod binius;
+pub mod aiur;
 pub mod byte_array;
-pub mod iroh;
+// pub mod iroh;
 pub mod keccak;
 
 use std::ffi::{CStr, CString, c_char, c_void};
 
 use crate::lean::{
-    array::LeanArrayObject,
-    boxed::{BoxedU64, BoxedUSize},
-    external::LeanExternalObject,
-    sarray::LeanSArrayObject,
+    array::LeanArrayObject, as_ref_unsafe, lean_unbox_u32, sarray::LeanSArrayObject,
 };
 
 /// ```c
@@ -52,62 +47,12 @@ pub(super) fn drop_raw<T>(ptr: *mut T) {
 }
 
 #[inline]
+#[allow(dead_code)]
 pub(super) fn raw_to_str<'a>(ptr: *const c_char) -> &'a str {
     let c_str = unsafe { CStr::from_ptr(ptr) };
     c_str.to_str().expect("Invalid UTF-8 string")
 }
 
-#[inline]
-pub(super) fn as_ref_unsafe<'a, T>(ptr: *const T) -> &'a T {
-    let t_ref = unsafe { ptr.as_ref() };
-    t_ref.expect("Null pointer dereference")
-}
-
-#[inline]
-pub(super) fn as_mut_unsafe<'a, T>(ptr: *mut T) -> &'a mut T {
-    let t_ref = unsafe { ptr.as_mut() };
-    t_ref.expect("Null pointer dereference")
-}
-
-/// ```c
-/// bool lean_is_scalar(lean_object * o) { return ((size_t)(o) & 1) == 1; }
-/// ```
-#[inline]
-pub(super) fn lean_is_scalar<T>(ptr: *const T) -> bool {
-    ptr as usize & 1 == 1
-}
-
-/// ```c
-/// size_t lean_unbox(lean_object * o) { return (size_t)(o) >> 1; }
-/// ```
-#[macro_export]
-macro_rules! lean_unbox {
-    ($t:ident, $e:expr) => {
-        $t::try_from(($e as usize) >> 1).expect("Unintended truncation")
-    };
-}
-
-/// ```c
-/// unsigned lean_unbox_uint32(b_lean_obj_arg o) {
-///     if (sizeof(void*) == 4) {
-///         /* 32-bit implementation */
-///         return lean_ctor_get_uint32(o, 0);
-///     } else {
-///         /* 64-bit implementation */
-///         return lean_unbox(o);
-///     }
-/// }
-/// ```
-#[inline]
-pub(super) fn lean_unbox_u32(ptr: *const c_void) -> u32 {
-    if cfg!(target_pointer_width = "32") {
-        let boxed_usize: &BoxedUSize = as_ref_unsafe(ptr.cast());
-        u32::try_from(boxed_usize.value).expect("Cannot convert from usize")
-    } else {
-        lean_unbox!(u32, ptr)
-    }
-}
-
 #[unsafe(no_mangle)]
 extern "C" fn rs_boxed_u32s_are_equivalent_to_bytes(
     u32s: &LeanArrayObject,
@@ -121,34 +66,6 @@ extern "C" fn rs_boxed_u32s_are_equivalent_to_bytes(
     u32s == bytes.data()
 }
 
-/// ```c
-/// uint64_t lean_unbox_uint64(b_lean_obj_arg o) {
-///     return lean_ctor_get_uint64(o, 0);
-/// }
-/// ```
-#[inline]
-pub(super) fn lean_unbox_u64(ptr: *const c_void) -> u64 {
-    let boxed_usize: &BoxedU64 = as_ref_unsafe(ptr.cast());
-    boxed_usize.value
-}
-
-pub(super) fn boxed_usize_ptr_to_usize(ptr: *const c_void) -> usize {
-    let boxed_usize_ptr = ptr.cast::<BoxedUSize>();
-    let boxed_usize = as_ref_unsafe(boxed_usize_ptr);
-    boxed_usize.value
-}
-
-pub(super) fn external_ptr_to_u128(ptr: *const c_void) -> u128 {
-    let u128_external = as_ref_unsafe(ptr.cast::<LeanExternalObject>());
-    *as_ref_unsafe(u128_external.cast_data())
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_exterior_mul_u64(a: u64, b: u64) -> *const u128 {
-    let c = a as u128 * b as u128;
-    to_raw(c)
-}
-
 #[repr(C)]
 pub struct BytesData {
     size: usize,
diff --git a/src/lean/mod.rs b/src/lean/mod.rs
index 69c68671..19868e83 100644
--- a/src/lean/mod.rs
+++ b/src/lean/mod.rs
@@ -13,6 +13,80 @@ pub mod object;
 pub mod sarray;
 pub mod string;
 
+use std::ffi::c_void;
+
+use crate::lean::boxed::{BoxedU64, BoxedUSize};
+
+#[inline]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub fn as_ref_unsafe<'a, T>(ptr: *const T) -> &'a T {
+    let t_ref = unsafe { ptr.as_ref() };
+    t_ref.expect("Null pointer dereference")
+}
+
+#[inline]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub fn as_mut_unsafe<'a, T>(ptr: *mut T) -> &'a mut T {
+    let t_ref = unsafe { ptr.as_mut() };
+    t_ref.expect("Null pointer dereference")
+}
+
+/// ```c
+/// bool lean_is_scalar(lean_object * o) { return ((size_t)(o) & 1) == 1; }
+/// ```
+#[inline]
+pub fn lean_is_scalar<T>(ptr: *const T) -> bool {
+    ptr as usize & 1 == 1
+}
+
+/// ```c
+/// size_t lean_unbox(lean_object * o) { return (size_t)(o) >> 1; }
+/// ```
+#[macro_export]
+macro_rules! lean_unbox {
+    ($t:ident, $e:expr) => {
+        $t::try_from(($e as usize) >> 1).expect("Unintended truncation")
+    };
+}
+
+/// ```c
+/// unsigned lean_unbox_uint32(b_lean_obj_arg o) {
+///     if (sizeof(void*) == 4) {
+///         /* 32-bit implementation */
+///         return lean_ctor_get_uint32(o, 0);
+///     } else {
+///         /* 64-bit implementation */
+///         return lean_unbox(o);
+///     }
+/// }
+/// ```
+#[inline]
+pub fn lean_unbox_u32(ptr: *const c_void) -> u32 {
+    if cfg!(target_pointer_width = "32") {
+        let boxed_usize: &BoxedUSize = as_ref_unsafe(ptr.cast());
+        u32::try_from(boxed_usize.value).expect("Cannot convert from usize")
+    } else {
+        lean_unbox!(u32, ptr)
+    }
+}
+
+/// ```c
+/// uint64_t lean_unbox_uint64(b_lean_obj_arg o) {
+///     return lean_ctor_get_uint64(o, 0);
+/// }
+/// ```
+#[inline]
+pub fn lean_unbox_u64(ptr: *const c_void) -> u64 {
+    let boxed_usize: &BoxedU64 = as_ref_unsafe(ptr.cast());
+    boxed_usize.value
+}
+
+pub fn boxed_usize_ptr_to_usize(ptr: *const c_void) -> usize {
+    let boxed_usize_ptr = ptr.cast::<BoxedUSize>();
+    let boxed_usize = as_ref_unsafe(boxed_usize_ptr);
+    boxed_usize.value
+}
+
 /// Emulates arrays of flexible size from C.
 #[repr(C)]
 pub struct CArray<T>([T; 0]);
diff --git a/src/lib.rs b/src/lib.rs
index c4b7c92a..42aee2b3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,10 @@
 pub mod aiur;
-pub mod aiur2;
-pub mod archon;
 pub mod lean;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}

From 104d546d1dbf0b5d8668bbcc45a8c3bf0607302f Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Fri, 25 Jul 2025 10:44:37 -0300
Subject: [PATCH 31/74] Bench (#186)

* add a `clock` executable for performance analysis

* clean up for a benchmarking implementation
---
 Benchmarks/Main.lean  | 72 ++++++++++++++++++++++++++++++++++++++++---
 lakefile.lean         |  1 -
 src/aiur/synthesis.rs | 32 +++++++++++++------
 3 files changed, 90 insertions(+), 15 deletions(-)

diff --git a/Benchmarks/Main.lean b/Benchmarks/Main.lean
index 8d2bbb6b..488e8345 100644
--- a/Benchmarks/Main.lean
+++ b/Benchmarks/Main.lean
@@ -1,5 +1,62 @@
+import Ix.Aiur.Meta
+import Ix.Aiur.Simple
+import Ix.Aiur.Compile
+import Ix.Aiur.Protocol
 import Ix.Benchmark.Bench
 
+def toplevel := ⟦
+  enum Nat {
+    Zero,
+    Succ(&Nat)
+  }
+
+  fn g_to_nat(g: G) -> Nat {
+    match g {
+      0 => Nat.Zero,
+      _ => Nat.Succ(store(g_to_nat(sub(g, 1)))),
+    }
+  }
+
+  fn nat_to_g(n: Nat) -> G {
+    match n {
+      Nat.Zero => 0,
+      Nat.Succ(ptr) => add(nat_to_g(load(ptr)), 1),
+    }
+  }
+
+  fn nat_add(a: Nat, b: Nat) -> Nat {
+    match b {
+      Nat.Zero => a,
+      Nat.Succ(b'ptr) => nat_add(Nat.Succ(store(a)), load(b'ptr)),
+    }
+  }
+
+  fn nat_fib(n: Nat) -> Nat {
+    match n {
+      Nat.Zero => Nat.Succ(store(Nat.Zero)),
+      Nat.Succ(n'ptr) =>
+        let n' = load(n'ptr);
+        match n' {
+          Nat.Zero => Nat.Succ(store(Nat.Zero)),
+          Nat.Succ(n''ptr) =>
+            let n'' = load(n''ptr);
+            nat_add(nat_fib(n'), nat_fib(n'')),
+        },
+    }
+  }
+
+  fn main(g: G) -> G {
+    nat_to_g(nat_fib(g_to_nat(g)))
+  }
+⟧
+
+def friParameters : Aiur.FriParameters := {
+  logBlowup := 1
+  logFinalPolyLen := 0
+  numQueries := 100
+  proofOfWorkBits := 20
+}
+
 def fib (n : Nat) : Nat :=
   match n with
   | 0 => 0
@@ -16,7 +73,14 @@ def addBench := (bgroup "add" [
   bench "add 1 2" (Nat.add 1) 2
 ])
 
--- TODO: Add Ix benchmarks
-
-def main : IO Unit := do
-  let _result ← fibBench
+def main (_args : List String) : IO UInt32 := do
+  match toplevel.checkAndSimplify with
+  | .error e => IO.eprintln e; return 1
+  | .ok decls =>
+    let bytecode := decls.compile
+    let system := Aiur.AiurSystem.build bytecode
+    let funIdx := toplevel.getFuncIdx `main |>.get!
+    let (claim, proof) := system.prove friParameters funIdx #[26]
+    match system.verify friParameters claim proof with
+    | .ok _ => return 0
+    | .error e => IO.eprintln e; return 1
diff --git a/lakefile.lean b/lakefile.lean
index 1f071fc3..61d05563 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -23,7 +23,6 @@ require Cli from git
 require batteries from git
   "https://github.com/leanprover-community/batteries" @ "613510345e4d4b3ce3d8c129595e7241990d5b39"
 
-
 section Tests
 
 lean_lib Tests
diff --git a/src/aiur/synthesis.rs b/src/aiur/synthesis.rs
index fb395357..48a64524 100644
--- a/src/aiur/synthesis.rs
+++ b/src/aiur/synthesis.rs
@@ -8,6 +8,7 @@ use multi_stark::{
     types::{FriParameters, PcsError, new_stark_config},
     verifier::VerificationError,
 };
+use rayon::iter::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
 
 use crate::aiur::{
     G,
@@ -72,6 +73,11 @@ where
     }
 }
 
+enum CircuitType {
+    Function { idx: usize },
+    Memory { width: usize },
+}
+
 impl AiurSystem {
     pub fn build(toplevel: Toplevel) -> Self {
         let function_circuits = (0..toplevel.functions.len()).map(|i| {
@@ -99,16 +105,22 @@ impl AiurSystem {
             traces: vec![],
             lookups: vec![],
         };
-        // TODO: parallelize
-        for function_index in 0..self.toplevel.functions.len() {
-            let (trace, lookups_per_function) =
-                self.toplevel.generate_trace(function_index, &query_record);
-            witness.traces.push(trace);
-            witness.lookups.push(lookups_per_function);
-        }
-        // TODO: parallelize
-        for width in &self.toplevel.memory_sizes {
-            let (trace, lookups) = Memory::generate_trace(*width, &query_record);
+        let functions = (0..self.toplevel.functions.len())
+            .into_par_iter()
+            .map(|idx| CircuitType::Function { idx });
+        let memories = self
+            .toplevel
+            .memory_sizes
+            .par_iter()
+            .map(|&width| CircuitType::Memory { width });
+        let witness_data = functions
+            .chain(memories)
+            .map(|circuit_type| match circuit_type {
+                CircuitType::Function { idx } => self.toplevel.generate_trace(idx, &query_record),
+                CircuitType::Memory { width } => Memory::generate_trace(width, &query_record),
+            })
+            .collect::<Vec<_>>();
+        for (trace, lookups) in witness_data {
             witness.traces.push(trace);
             witness.lookups.push(lookups);
         }

From fc3eaa8a9a2d5f7c6f33df98af52fdaf0caa7c90 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 6 Aug 2025 01:41:27 -0400
Subject: [PATCH 32/74] initial ixon serialization framework

---
 Cargo.toml            |   7 +++
 src/ixon.rs           |  10 +++
 src/ixon/address.rs   |  36 +++++++++++
 src/ixon/claim.rs     |  16 +++++
 src/ixon/cnst.rs      | 141 +++++++++++++++++++++++++++++++++++++++++
 src/ixon/common.rs    |  13 ++++
 src/ixon/expr.rs      |  17 +++++
 src/ixon/meta.rs      |  18 ++++++
 src/ixon/name.rs      |  10 +++
 src/ixon/nat.rs       |   7 +++
 src/ixon/serialize.rs | 142 ++++++++++++++++++++++++++++++++++++++++++
 src/ixon/univ.rs      |  96 ++++++++++++++++++++++++++++
 src/lib.rs            |  17 +++--
 13 files changed, 526 insertions(+), 4 deletions(-)
 create mode 100644 src/ixon.rs
 create mode 100644 src/ixon/address.rs
 create mode 100644 src/ixon/claim.rs
 create mode 100644 src/ixon/cnst.rs
 create mode 100644 src/ixon/common.rs
 create mode 100644 src/ixon/expr.rs
 create mode 100644 src/ixon/meta.rs
 create mode 100644 src/ixon/name.rs
 create mode 100644 src/ixon/nat.rs
 create mode 100644 src/ixon/serialize.rs
 create mode 100644 src/ixon/univ.rs

diff --git a/Cargo.toml b/Cargo.toml
index 197b6c12..6cbc2264 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,13 @@ rayon = "1"
 rustc-hash = "2"
 indexmap = { version = "2", features = ["rayon"] }
 tiny-keccak = { version = "2", features = ["keccak"] }
+num-bigint = "0.4.6"
+blake3 = "1.8.2"
+
+[dev-dependencies]
+quickcheck = "1.0.3"
+rand = "0.8.5"
+quickcheck_macros = "1.0.0"
 
 # bytes = "1.10.1"
 # [target.'cfg(not(all(target_os = "macos", target_arch = "aarch64")))'.dependencies]
diff --git a/src/ixon.rs b/src/ixon.rs
new file mode 100644
index 00000000..dd35ea55
--- /dev/null
+++ b/src/ixon.rs
@@ -0,0 +1,10 @@
+pub mod address;
+pub mod claim;
+pub mod cnst;
+pub mod common;
+pub mod expr;
+pub mod meta;
+pub mod name;
+pub mod nat;
+pub mod serialize;
+pub mod univ;
diff --git a/src/ixon/address.rs b/src/ixon/address.rs
new file mode 100644
index 00000000..46446083
--- /dev/null
+++ b/src/ixon/address.rs
@@ -0,0 +1,36 @@
+use crate::ixon::serialize::Serialize;
+use blake3::Hash;
+use std::cmp::{Ordering, PartialOrd};
+
+#[derive(PartialEq, Eq, Clone)]
+pub struct Address {
+  pub hash: Hash,
+}
+
+impl Serialize for Address {
+  fn put(self, buf: &mut Vec<u8>) {
+    buf.extend_from_slice(self.hash.as_bytes())
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(32) {
+      Some((head, rest)) => {
+        *buf = rest;
+        Ok(Address { hash: Hash::from_slice(head).unwrap() })
+      },
+      None => Err("get Address out of input".to_string()),
+    }
+  }
+}
+
+impl Ord for Address {
+  fn cmp(&self, other: &Address) -> Ordering {
+    self.hash.as_bytes().cmp(other.hash.as_bytes())
+  }
+}
+
+impl PartialOrd for Address {
+  fn partial_cmp(&self, other: &Address) -> Option<Ordering> {
+    Some(self.cmp(other))
+  }
+}
diff --git a/src/ixon/claim.rs b/src/ixon/claim.rs
new file mode 100644
index 00000000..136d85e9
--- /dev/null
+++ b/src/ixon/claim.rs
@@ -0,0 +1,16 @@
+use crate::ixon::address::Address;
+use std::collections::BTreeSet;
+
+pub enum Claim {
+  Checks { lvls: Address, typ_: Address, value: Address },
+  Evals { lvls: Address, typ_: Address, input: Address, output: Address },
+}
+
+pub struct Proof {
+  pub claim: Claim,
+  pub proof: Vec<u8>,
+}
+
+pub struct Claims {
+  pub map: BTreeSet<Address>,
+}
diff --git a/src/ixon/cnst.rs b/src/ixon/cnst.rs
new file mode 100644
index 00000000..6a3c0e72
--- /dev/null
+++ b/src/ixon/cnst.rs
@@ -0,0 +1,141 @@
+use crate::ixon::address::Address;
+use crate::ixon::claim::{Claim, Claims, Proof};
+use crate::ixon::expr::Expr;
+use crate::ixon::meta::Metadata;
+use crate::ixon::nat::Nat;
+
+pub enum QuotKind {
+  Type,
+  Ctor,
+  Lift,
+  Ind,
+}
+
+pub struct Quotient {
+  pub lvls: Nat,
+  pub typ: Box<Expr>,
+  pub kind: QuotKind,
+}
+
+pub struct Axiom {
+  pub lvls: Nat,
+  pub typ: Box<Expr>,
+  pub is_unsafe: bool,
+}
+
+pub enum DefKind {
+  Definition,
+  Opaque,
+  Theorem,
+}
+
+pub enum DefSafety {
+  Unsafe,
+  Safe,
+  Partial,
+}
+
+pub struct Definition {
+  pub lvls: Nat,
+  pub typ: Box<Expr>,
+  pub mode: DefKind,
+  pub value: Box<Expr>,
+  pub safety: DefSafety,
+}
+
+pub struct Constructor {
+  pub lvls: Nat,
+  pub typ: Box<Expr>,
+  pub cidx: Nat,
+  pub params: Nat,
+  pub fields: Nat,
+  pub is_unsafe: bool,
+}
+
+pub struct RecursorRule {
+  pub fields: Nat,
+  pub rhs: Box<Expr>,
+}
+
+pub struct Recursor {
+  pub lvls: Nat,
+  pub typ: Box<Expr>,
+  pub params: Nat,
+  pub indices: Nat,
+  pub motives: Nat,
+  pub minors: Nat,
+  pub rules: Vec<RecursorRule>,
+  pub k: bool,
+  pub is_unsafe: bool,
+}
+
+pub struct Inductive {
+  pub lvls: Nat,
+  pub typ: Box<Expr>,
+  pub params: Nat,
+  pub indices: Nat,
+  pub ctors: Vec<Constructor>,
+  pub recrs: Vec<Recursor>,
+  pub nested: Nat,
+  pub recr: bool,
+  pub refl: bool,
+  pub is_unsafe: bool,
+}
+
+pub struct InductiveProj {
+  pub block: Address,
+  pub idx: Nat,
+}
+
+pub struct ConstructorProj {
+  pub block: Address,
+  pub idx: Nat,
+  pub cidx: Nat,
+}
+
+pub struct RecursorProj {
+  pub block: Address,
+  pub idx: Nat,
+  pub ridx: Nat,
+}
+
+pub struct DefinitionProj {
+  pub block: Address,
+  pub idx: Nat,
+}
+
+pub struct Comm {
+  pub secret: Address,
+  pub payload: Address,
+}
+
+pub enum Const {
+  // 0xC0
+  Defn(Definition),
+  // 0xC1
+  Axio(Axiom),
+  // 0xC2
+  Quot(Quotient),
+  // 0xC3
+  CtorProj(ConstructorProj),
+  // 0xC4
+  RecrProj(RecursorProj),
+  // 0xC5
+  IndcProj(InductiveProj),
+  // 0xC6
+  DefnProj(DefinitionProj),
+  // 0xC7
+  MutDef(Vec<Definition>),
+  // 0xC8
+  MutInd(Vec<Inductive>),
+  // 0xC9
+  Meta(Metadata),
+  // 0xCA
+  Proof(Proof),
+  // 0xCB
+  Claim(Claim),
+  // 0xCC
+  Comm(Comm),
+  // 0xCD
+  Env(Claims),
+}
diff --git a/src/ixon/common.rs b/src/ixon/common.rs
new file mode 100644
index 00000000..df0ee56c
--- /dev/null
+++ b/src/ixon/common.rs
@@ -0,0 +1,13 @@
+pub enum BinderInfo {
+  Default,
+  Implicit,
+  StrictImplicit,
+  InstImplicit,
+  AuxDecl,
+}
+
+pub enum ReducibilityHints {
+  Opaque,
+  Abbrev,
+  Regular,
+}
diff --git a/src/ixon/expr.rs b/src/ixon/expr.rs
new file mode 100644
index 00000000..13a5ed3f
--- /dev/null
+++ b/src/ixon/expr.rs
@@ -0,0 +1,17 @@
+use crate::ixon::address::Address;
+use crate::ixon::nat::Nat;
+use crate::ixon::univ::Univ;
+
+pub enum Expr {
+  Vari(u64),
+  Sort(Box<Univ>),
+  Refr(Address, Vec<Univ>),
+  Recr(u64, Vec<Univ>),
+  Apps(Box<Expr>, Box<Expr>, Vec<Expr>),
+  Lams(Vec<Expr>, Box<Expr>),
+  Alls(Vec<Expr>, Box<Expr>),
+  Let(bool, Box<Expr>, Box<Expr>, Box<Expr>),
+  Proj(Address, u64, Box<Expr>),
+  Strl(String),
+  Natl(Nat),
+}
diff --git a/src/ixon/meta.rs b/src/ixon/meta.rs
new file mode 100644
index 00000000..59740b53
--- /dev/null
+++ b/src/ixon/meta.rs
@@ -0,0 +1,18 @@
+use crate::ixon::address::Address;
+use crate::ixon::common::{BinderInfo, ReducibilityHints};
+use crate::ixon::name::Name;
+use crate::ixon::nat::Nat;
+use std::collections::BTreeMap;
+
+pub enum Metadatum {
+  Name(Name),
+  Info(BinderInfo),
+  Link(Address),
+  Hints(ReducibilityHints),
+  All(Vec<Name>),
+  MutCtx(Vec<Vec<Name>>),
+}
+
+pub struct Metadata {
+  pub map: BTreeMap<Nat, Metadatum>,
+}
diff --git a/src/ixon/name.rs b/src/ixon/name.rs
new file mode 100644
index 00000000..9e9b6450
--- /dev/null
+++ b/src/ixon/name.rs
@@ -0,0 +1,10 @@
+use crate::ixon::nat::Nat;
+
+pub enum NamePart {
+  Str(String),
+  Num(Nat),
+}
+
+pub struct Name {
+  pub parts: Vec<NamePart>,
+}
diff --git a/src/ixon/nat.rs b/src/ixon/nat.rs
new file mode 100644
index 00000000..19fb130e
--- /dev/null
+++ b/src/ixon/nat.rs
@@ -0,0 +1,7 @@
+use num_bigint::BigUint;
+
+pub struct Nat {
+  pub val: BigUint,
+}
+
+//impl Nat {}
diff --git a/src/ixon/serialize.rs b/src/ixon/serialize.rs
new file mode 100644
index 00000000..59861cc9
--- /dev/null
+++ b/src/ixon/serialize.rs
@@ -0,0 +1,142 @@
+pub trait Serialize: Sized {
+  fn put(self, buf: &mut Vec<u8>);
+  fn get(buf: &mut &[u8]) -> Result<Self, String>;
+}
+
+impl Serialize for u8 {
+  fn put(self, buf: &mut Vec<u8>) {
+    buf.push(self)
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_first() {
+      Some((&x, rest)) => {
+        *buf = rest;
+        Ok(x)
+      },
+      None => Err("get u8 EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for u16 {
+  fn put(self, buf: &mut Vec<u8>) {
+    buf.extend_from_slice(&self.to_le_bytes());
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(2) {
+      Some((head, rest)) => {
+        *buf = rest;
+        Ok(u16::from_le_bytes([head[0], head[1]]))
+      },
+      None => Err("get u16 EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for u32 {
+  fn put(self, buf: &mut Vec<u8>) {
+    buf.extend_from_slice(&self.to_le_bytes());
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(4) {
+      Some((head, rest)) => {
+        *buf = rest;
+        Ok(u32::from_le_bytes([head[0], head[1], head[2], head[3]]))
+      },
+      None => Err("get u32 EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for u64 {
+  fn put(self, buf: &mut Vec<u8>) {
+    buf.extend_from_slice(&self.to_le_bytes());
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(8) {
+      Some((head, rest)) => {
+        *buf = rest;
+        Ok(u64::from_le_bytes([
+          head[0], head[1], head[2], head[3], head[4], head[5], head[6],
+          head[7],
+        ]))
+      },
+      None => Err("get u64 EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for bool {
+  fn put(self, buf: &mut Vec<u8>) {
+    match self {
+      false => Serialize::put(0u8, buf),
+      true => Serialize::put(1u8, buf),
+    }
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match <u8 as Serialize>::get(buf) {
+      Ok(0u8) => Ok(false),
+      Ok(1u8) => Ok(true),
+      Ok(x) => Err(format!("get bool invalid {x}")),
+      Err(e) => Err(e),
+    }
+  }
+}
+
+pub fn u64_byte_count(x: u64) -> u8 {
+  match x {
+    0 => 0,
+    x if x < 0x0000000000000100 => 1,
+    x if x < 0x0000000000010000 => 2,
+    x if x < 0x0000000001000000 => 3,
+    x if x < 0x0000000100000000 => 4,
+    x if x < 0x0000010000000000 => 5,
+    x if x < 0x0001000000000000 => 6,
+    x if x < 0x0100000000000000 => 7,
+    _ => 8,
+  }
+}
+
+pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
+  let n = u64_byte_count(x) as usize;
+  buf.extend_from_slice(&x.to_le_bytes()[..n])
+}
+
+pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
+  let mut res = [0u8; 8];
+  if len > 8 {
+    return Err("get trimmed_le_64 len > 8".to_string());
+  }
+  match buf.split_at_checked(len) {
+    Some((head, rest)) => {
+      *buf = rest;
+      res[..len].copy_from_slice(head);
+      Ok(u64::from_le_bytes(res))
+    },
+    None => Err("get trimmed_le_u64 EOF".to_string()),
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use quickcheck::{Arbitrary, Gen};
+
+  #[quickcheck]
+  fn prop_u64_trimmed_le_readback(x: u64) -> bool {
+    let mut buf = Vec::new();
+    let n = u64_byte_count(x);
+    u64_put_trimmed_le(x, &mut buf);
+    match u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
+      Ok(y) => x == y,
+      Err(e) => {
+        println!("err: {}", e);
+        false
+      },
+    }
+  }
+}
diff --git a/src/ixon/univ.rs b/src/ixon/univ.rs
new file mode 100644
index 00000000..eec490e6
--- /dev/null
+++ b/src/ixon/univ.rs
@@ -0,0 +1,96 @@
+use crate::ixon::serialize::{
+  u64_byte_count, u64_get_trimmed_le, u64_put_trimmed_le, Serialize,
+};
+
+// 0xTTTL_XXXX
+pub enum Univ {
+  // 0x0, 1
+  Const(u64),
+  // 0x1, ^1
+  Var(u64),
+  // 0x2, (+ x y)
+  Add(u64, Box<Univ>),
+  // 0x3, (max x y)
+  Max(Box<Univ>, Box<Univ>),
+  // 0x4, (imax x y)
+  IMax(Box<Univ>, Box<Univ>),
+}
+
+impl Univ {
+  fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
+    if val < 16 {
+      buf.push((tag << 5) | (val as u8));
+    } else {
+      buf.push((tag << 5) | 0b1_0000 | (u64_byte_count(val)));
+      u64_put_trimmed_le(val, buf);
+    }
+  }
+
+  fn get_tag(
+    is_large: bool,
+    small: u8,
+    buf: &mut &[u8],
+  ) -> Result<u64, String> {
+    if is_large {
+      u64_get_trimmed_le((small + 1) as usize, buf)
+    } else {
+      Ok(small as u64)
+    }
+  }
+}
+
+impl Serialize for Univ {
+  fn put(self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Const(x) => Univ::put_tag(0x0, x, buf),
+      Self::Var(x) => Univ::put_tag(0x1, x, buf),
+      Self::Add(x, y) => {
+        Univ::put_tag(0x2, x, buf);
+        y.put(buf)
+      },
+      Self::Max(x, y) => {
+        Univ::put_tag(0x3, 0, buf);
+        x.put(buf);
+        y.put(buf);
+      },
+      Self::IMax(x, y) => {
+        Univ::put_tag(0x4, 0, buf);
+        x.put(buf);
+        y.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let tag_byte = u8::get(buf)?;
+    let tag = tag_byte >> 5;
+    let small_size = tag_byte & 0b1111;
+    let is_large = tag_byte & 0b10000 == 0;
+    match tag {
+      0x0 => {
+        let x = Univ::get_tag(is_large, small_size, buf)?;
+        Ok(Self::Const(x))
+      },
+      0x1 => {
+        let x = Univ::get_tag(is_large, small_size, buf)?;
+        Ok(Self::Var(x))
+      },
+      0x2 => {
+        let x = Univ::get_tag(is_large, small_size, buf)?;
+        let y = Univ::get(buf)?;
+        Ok(Self::Add(x, Box::new(y)))
+      },
+      0x3 => {
+        let x = Univ::get(buf)?;
+        let y = Univ::get(buf)?;
+        Ok(Self::Max(Box::new(x), Box::new(y)))
+      },
+      0x4 => {
+        let x = Univ::get(buf)?;
+        let y = Univ::get(buf)?;
+        Ok(Self::IMax(Box::new(x), Box::new(y)))
+      },
+      x => Err(format!("get Univ invalid tag {x}")),
+    }
+  }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 42aee2b3..1affea88 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,19 @@
+#[cfg(test)]
+extern crate quickcheck;
+#[cfg(test)]
+#[macro_use(quickcheck)]
+extern crate quickcheck_macros;
+#[cfg(test)]
+extern crate rand;
+
 pub mod aiur;
+pub mod ixon;
 pub mod lean;
 
 #[cfg(test)]
 mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
+  #[test]
+  fn it_works() {
+    assert_eq!(2 + 2, 4);
+  }
 }

From 3b57c87c249d06a681b2e744941d76ed8a59f833 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 6 Aug 2025 01:41:43 -0400
Subject: [PATCH 33/74] rustfmt

---
 rustfmt.toml | 102 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 rustfmt.toml

diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 00000000..6f89b02c
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1,102 @@
+# title: Ix Standard Rustfmt Configuration
+# author: John C. Burnham <john@argument.xyz>
+
+# For additional information about Rustfmt options see:
+# https://rust-lang.github.io/rustfmt/?version=v1.8.0
+#
+# General
+version              = "One"              # rustfmt 2.0 is not released yet
+edition              = "2021"             # Rust edition
+
+unstable_features    = false              # don't use unstable rustfmt features
+
+newline_style        = "Unix"             # Never allow Windows' \n\r newlines
+
+# disable_all_formatting = false            # mostly useless setting
+
+# Indent
+hard_tabs            = false              # hard tabs break consistent layout
+tab_spaces           = 2                  # override default 4 space indent
+indent_style         = "Block"
+
+# Imports
+
+imports_layout       = "Vertical"         # each import on its own line
+imports_granularity  = "Crate"            # combine imports by crate
+reorder_imports      = true               # reorder from source
+group_imports        = "StdExternalCrate" # in three groups
+
+# Width
+max_width            = 80                 # Don't go over 80 columns
+use_small_heuristics = "Max"              # Inherit max width for most objects
+
+# Braces
+brace_style          = "SameLineWhere"    # open braces stay on the same line
+control_brace_style  = "ClosingNextLine"  # control flow gets a new line
+
+# Layout
+blank_lines_lower_bound      = 0          # 0 to 1 blank lines betwen things
+blank_lines_upper_bound      = 1
+fn_args_layout               = "Tall"     # single line if short, else vertical 
+overflow_delimited_expr      = false      # don't let args overflow
+format_strings               = true       # add line breaks for long strings
+combine_control_expr         = true
+struct_field_align_threshold = 1          # no vertical alignment on structs
+enum_discrim_align_threshold = 0          # .. and on enums
+force_explicit_abi           = true       # C doesn't deserve to be special
+force_multiline_blocks       = false
+skip_children                = false      # include the children
+
+# Single Line Declarations
+empty_item_single_line      = true        # allow single_line for various things
+struct_lit_single_line      = true
+fn_single_line              = true
+where_single_line           = true
+
+# Reordering
+reorder_impl_items          = true        # allow reordering
+reorder_modules             = true
+condense_wildcard_suffixes  = true
+
+# Punctuation
+space_before_colon          = false       # type annotations look like `x: A`
+space_after_colon           = true
+type_punctuation_density    = "Wide"      # wrap + and = in spaces in types
+spaces_around_ranges        = false       # 0..10, not 0 .. 10
+binop_separator             = "Front"     # puts binops || in beginning of line
+remove_nested_parens        = true        # ((foo)) => (foo)
+trailing_semicolon = true                 # add trailing semicolon
+trailing_comma = "Vertical"               # add trailing comma only when vertical
+
+# Comments
+wrap_comments               = true        # wrap long comments
+normalize_comments          = true        # convert /* */ to //
+format_code_in_doc_comments = true        # apply formatting to code in docs
+comment_width               = 80          # comment width = max width
+normalize_doc_attributes    = true        # #[doc] becomes ///
+
+# Match blocks
+match_arm_blocks            = true        # put match arms in { } blocks
+match_arm_leading_pipes     = "Never"     # no leading | in match arms
+match_block_trailing_comma  = true        # put a , after a { } match block
+
+# Attributes
+merge_derives               = true        # merge trait derives to one line
+inline_attribute_width      = 0
+
+# Literals
+hex_literal_case            = "Lower"     # Convert hex literals to lowercase
+
+# Shorthand
+use_field_init_shorthand    = true        # replace Foo { x: x } with Foo { x }
+use_try_shorthand           = true        # replace try! with ?
+
+# Macros
+format_macro_matchers       = true        # turn on macro formatting
+format_macro_bodies         = true
+
+# Misc
+format_generated_files        = true      # apply formatting to generated files
+hide_parse_errors             = false     # don't hide the parser's errors
+error_on_line_overflow        = false     # but don't throw your own errors
+error_on_unformatted          = false

From a13133eccea0dfdbf07ad775b68e402838d20e5c Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 11 Aug 2025 15:37:17 -0400
Subject: [PATCH 34/74] ixon univ/expr roundtrip

---
 Cargo.lock            | 237 ++++++++++++++++++++++-
 src/ixon/address.rs   |  20 +-
 src/ixon/common.rs    |  35 ++++
 src/ixon/expr.rs      | 433 ++++++++++++++++++++++++++++++++++++++++++
 src/ixon/nat.rs       |  37 +++-
 src/ixon/serialize.rs |  58 +++++-
 src/ixon/univ.rs      | 121 +++++++++++-
 7 files changed, 912 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 68ef234d..3dba597e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,12 +2,33 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "anyhow"
 version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -34,6 +55,40 @@ dependencies = [
  "virtue",
 ]
 
+[[package]]
+name = "blake3"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "deec109607ca693028562ed836a5f1c4b8bd77755c4e132fc5ce11b0b6211ae7"
+dependencies = [
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
+
+[[package]]
+name = "constant_time_eq"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
+
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -71,12 +126,33 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
+[[package]]
+name = "env_logger"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
+dependencies = [
+ "log",
+ "regex",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.15.4"
@@ -108,13 +184,36 @@ name = "ix_rs"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "blake3",
  "indexmap",
  "multi-stark",
+ "num-bigint",
+ "quickcheck",
+ "quickcheck_macros",
+ "rand 0.8.5",
  "rayon",
  "rustc-hash",
  "tiny-keccak",
 ]
 
+[[package]]
+name = "libc"
+version = "0.2.174"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+
+[[package]]
+name = "log"
+version = "0.4.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
+[[package]]
+name = "memchr"
+version = "2.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+
 [[package]]
 name = "multi-stark"
 version = "0.1.0"
@@ -223,7 +322,7 @@ dependencies = [
  "p3-maybe-rayon",
  "p3-util",
  "paste",
- "rand",
+ "rand 0.9.2",
  "serde",
  "tracing",
 ]
@@ -242,7 +341,7 @@ dependencies = [
  "p3-matrix",
  "p3-maybe-rayon",
  "p3-util",
- "rand",
+ "rand 0.9.2",
  "serde",
  "tracing",
 ]
@@ -260,7 +359,7 @@ dependencies = [
  "p3-symmetric",
  "p3-util",
  "paste",
- "rand",
+ "rand 0.9.2",
  "serde",
 ]
 
@@ -295,7 +394,7 @@ dependencies = [
  "p3-field",
  "p3-maybe-rayon",
  "p3-util",
- "rand",
+ "rand 0.9.2",
  "serde",
  "tracing",
  "transpose",
@@ -318,7 +417,7 @@ dependencies = [
  "p3-field",
  "p3-symmetric",
  "p3-util",
- "rand",
+ "rand 0.9.2",
 ]
 
 [[package]]
@@ -333,7 +432,7 @@ dependencies = [
  "p3-maybe-rayon",
  "p3-symmetric",
  "p3-util",
- "rand",
+ "rand 0.9.2",
  "serde",
  "tracing",
 ]
@@ -347,7 +446,7 @@ dependencies = [
  "p3-mds",
  "p3-symmetric",
  "p3-util",
- "rand",
+ "rand 0.9.2",
 ]
 
 [[package]]
@@ -380,6 +479,15 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.95"
@@ -389,6 +497,28 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "quickcheck"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
+dependencies = [
+ "env_logger",
+ "log",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "quickcheck_macros"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f71ee38b42f8459a88d3362be6f9b841ad2d5421844f61eb1c59c11bff3ac14a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.40"
@@ -398,13 +528,43 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core 0.6.4",
+]
+
 [[package]]
 name = "rand"
 version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
- "rand_core",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
 ]
 
 [[package]]
@@ -433,6 +593,35 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.1"
@@ -459,6 +648,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "strength_reduce"
 version = "0.2.4"
@@ -540,3 +735,29 @@ name = "virtue"
 version = "0.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/src/ixon/address.rs b/src/ixon/address.rs
index 46446083..744b7676 100644
--- a/src/ixon/address.rs
+++ b/src/ixon/address.rs
@@ -2,13 +2,13 @@ use crate::ixon::serialize::Serialize;
 use blake3::Hash;
 use std::cmp::{Ordering, PartialOrd};
 
-#[derive(PartialEq, Eq, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Address {
   pub hash: Hash,
 }
 
 impl Serialize for Address {
-  fn put(self, buf: &mut Vec<u8>) {
+  fn put(&self, buf: &mut Vec<u8>) {
     buf.extend_from_slice(self.hash.as_bytes())
   }
 
@@ -34,3 +34,19 @@ impl PartialOrd for Address {
     Some(self.cmp(other))
   }
 }
+
+#[cfg(test)]
+pub mod tests {
+  use super::*;
+  use quickcheck::{Arbitrary, Gen};
+
+  impl Arbitrary for Address {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let mut bytes = [0u8; 32];
+      for b in &mut bytes {
+        *b = u8::arbitrary(g);
+      }
+      Address { hash: Hash::from_slice(&bytes).unwrap() }
+    }
+  }
+}
diff --git a/src/ixon/common.rs b/src/ixon/common.rs
index df0ee56c..4d27bb5c 100644
--- a/src/ixon/common.rs
+++ b/src/ixon/common.rs
@@ -11,3 +11,38 @@ pub enum ReducibilityHints {
   Abbrev,
   Regular,
 }
+
+#[cfg(test)]
+pub mod tests {
+  use quickcheck::{Arbitrary, Gen};
+  use std::ops::Range;
+
+  pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
+    let res: usize = Arbitrary::arbitrary(g);
+    if range.is_empty() {
+      0
+    } else {
+      (res % (range.end - range.start)) + range.start
+    }
+  }
+
+  pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
+    let sum: usize = gens.iter().map(|x| x.0).sum();
+    let mut weight: usize = gen_range(g, 1..sum);
+    for (n, case) in gens {
+      if *n == 0 {
+        continue;
+      } else {
+        match weight.checked_sub(*n) {
+          None | Some(0) => {
+            return *case;
+          },
+          _ => {
+            weight -= *n;
+          },
+        }
+      }
+    }
+    unreachable!()
+  }
+}
diff --git a/src/ixon/expr.rs b/src/ixon/expr.rs
index 13a5ed3f..f706ceae 100644
--- a/src/ixon/expr.rs
+++ b/src/ixon/expr.rs
@@ -1,17 +1,450 @@
 use crate::ixon::address::Address;
 use crate::ixon::nat::Nat;
+use crate::ixon::serialize::{
+  u64_byte_count, u64_get_trimmed_le, u64_put_trimmed_le, Serialize,
+};
 use crate::ixon::univ::Univ;
+use num_bigint::BigUint;
 
+// 0xTTTT_LXXX
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[repr(C)]
 pub enum Expr {
+  // 0x0, ^1
   Vari(u64),
+  // 0x1, {max (add 1 2) (var 1)}
   Sort(Box<Univ>),
+  // 0x2 #dead_beef_cafe_babe {u1, u2, ... }
   Refr(Address, Vec<Univ>),
+  // 0x3 #1.{u1, u2, u3}
   Recr(u64, Vec<Univ>),
+  // 0x4 (f x y z)
   Apps(Box<Expr>, Box<Expr>, Vec<Expr>),
+  // 0x5 (λ A B C => body)
   Lams(Vec<Expr>, Box<Expr>),
+  // 0x6 (∀ A B C -> body)
   Alls(Vec<Expr>, Box<Expr>),
+  // 0x7 (let d : A in b)
   Let(bool, Box<Expr>, Box<Expr>, Box<Expr>),
+  // 0x8 .1
   Proj(Address, u64, Box<Expr>),
+  // 0x9 "foobar"
   Strl(String),
+  // 0xA 0xdead_beef
   Natl(Nat),
 }
+
+impl Default for Expr {
+  fn default() -> Self {
+    Self::Vari(0)
+  }
+}
+
+impl Expr {
+  fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
+    if val < 8 {
+      buf.push((tag << 4) | (val as u8));
+    } else {
+      buf.push((tag << 4) | 0b1000 | (u64_byte_count(val) - 1));
+      u64_put_trimmed_le(val, buf);
+    }
+  }
+
+  fn get_tag(
+    is_large: bool,
+    small: u8,
+    buf: &mut &[u8],
+  ) -> Result<u64, String> {
+    if is_large {
+      u64_get_trimmed_le((small + 1) as usize, buf)
+    } else {
+      Ok(small as u64)
+    }
+  }
+}
+
+impl Serialize for Expr {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Vari(x) => Self::put_tag(0x0, *x, buf),
+      Self::Sort(x) => {
+        Self::put_tag(0x1, 0, buf);
+        x.put(buf);
+      },
+      Self::Refr(addr, lvls) => {
+        Self::put_tag(0x2, lvls.len() as u64, buf);
+        addr.put(buf);
+        for l in lvls {
+          l.put(buf);
+        }
+      },
+      Self::Recr(x, lvls) => {
+        Self::put_tag(0x3, lvls.len() as u64, buf);
+        x.put(buf);
+        for l in lvls {
+          l.put(buf);
+        }
+      },
+      Self::Apps(f, a, args) => {
+        Self::put_tag(0x4, args.len() as u64, buf);
+        f.put(buf);
+        a.put(buf);
+        for x in args {
+          x.put(buf);
+        }
+      },
+      Self::Lams(ts, b) => {
+        Self::put_tag(0x5, ts.len() as u64, buf);
+        for t in ts {
+          t.put(buf);
+        }
+        b.put(buf);
+      },
+      Self::Alls(ts, b) => {
+        Self::put_tag(0x6, ts.len() as u64, buf);
+        for t in ts {
+          t.put(buf);
+        }
+        b.put(buf);
+      },
+      Self::Let(nd, t, d, b) => {
+        if *nd {
+          Self::put_tag(0x7, 1, buf);
+        } else {
+          Self::put_tag(0x7, 0, buf);
+        }
+        t.put(buf);
+        d.put(buf);
+        b.put(buf);
+      },
+      Self::Proj(t, n, x) => {
+        Self::put_tag(0x8, *n, buf);
+        t.put(buf);
+        x.put(buf);
+      },
+      Self::Strl(s) => {
+        let bytes = s.as_bytes();
+        Self::put_tag(0x9, bytes.len() as u64, buf);
+        buf.extend_from_slice(bytes);
+      },
+      Self::Natl(n) => {
+        let bytes = n.0.to_bytes_le();
+        Self::put_tag(0xA, bytes.len() as u64, buf);
+        buf.extend_from_slice(&bytes);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let tag_byte = u8::get(buf)?;
+    let tag = tag_byte >> 4;
+    let small_size = tag_byte & 0b111;
+    let is_large = tag_byte & 0b1000 != 0;
+    match tag {
+      0x0 => {
+        let x = Expr::get_tag(is_large, small_size, buf)?;
+        Ok(Self::Vari(x))
+      },
+      0x1 => {
+        let u = Univ::get(buf)?;
+        Ok(Self::Sort(Box::new(u)))
+      },
+      0x2 => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        let a = Address::get(buf)?;
+        let mut lvls = Vec::new();
+        for _ in 0..n {
+          let l = Univ::get(buf)?;
+          lvls.push(l);
+        }
+        Ok(Self::Refr(a, lvls))
+      },
+      0x3 => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        let x = u64::get(buf)?;
+        let mut lvls = Vec::new();
+        for _ in 0..n {
+          let l = Univ::get(buf)?;
+          lvls.push(l);
+        }
+        Ok(Self::Recr(x, lvls))
+      },
+      0x4 => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        let f = Expr::get(buf)?;
+        let a = Expr::get(buf)?;
+        let mut args = Vec::new();
+        for _ in 0..n {
+          let x = Expr::get(buf)?;
+          args.push(x);
+        }
+        Ok(Self::Apps(Box::new(f), Box::new(a), args))
+      },
+      0x5 => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        let mut ts = Vec::new();
+        for _ in 0..n {
+          let x = Expr::get(buf)?;
+          ts.push(x);
+        }
+        let b = Expr::get(buf)?;
+        Ok(Self::Lams(ts, Box::new(b)))
+      },
+      0x6 => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        let mut ts = Vec::new();
+        for _ in 0..n {
+          let x = Expr::get(buf)?;
+          ts.push(x);
+        }
+        let b = Expr::get(buf)?;
+        Ok(Self::Alls(ts, Box::new(b)))
+      },
+      0x7 => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        let nd = n == 1;
+        let t = Expr::get(buf)?;
+        let d = Expr::get(buf)?;
+        let b = Expr::get(buf)?;
+        Ok(Self::Let(nd, Box::new(t), Box::new(d), Box::new(b)))
+      },
+      0x8 => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        let t = Address::get(buf)?;
+        let x = Expr::get(buf)?;
+        Ok(Self::Proj(t, n, Box::new(x)))
+      },
+      0x9 => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        match buf.split_at_checked(n as usize) {
+          Some((head, rest)) => {
+            *buf = rest;
+            match String::from_utf8(head.to_owned()) {
+              Ok(s) => Ok(Expr::Strl(s)),
+              Err(e) => Err(format!("UTF8 Error: {e}")),
+            }
+          },
+          None => Err("get Expr Strl EOF".to_string()),
+        }
+      },
+      0xA => {
+        let n = Expr::get_tag(is_large, small_size, buf)?;
+        match buf.split_at_checked(n as usize) {
+          Some((head, rest)) => {
+            *buf = rest;
+            Ok(Expr::Natl(Nat(BigUint::from_bytes_le(head))))
+          },
+          None => Err("get Expr Natl EOF".to_string()),
+        }
+      },
+      x => Err(format!("get Expr invalid tag {x}")),
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::ixon::common::tests::{gen_range, next_case};
+  use crate::ixon::nat::tests::*;
+  use crate::ixon::univ::tests::*;
+  use quickcheck::{Arbitrary, Gen};
+
+  use std::ptr;
+
+  #[derive(Debug, Clone, Copy)]
+  pub enum ExprCase {
+    Vari,
+    Sort,
+    Refr,
+    Recr,
+    Apps,
+    Lams,
+    Alls,
+    Let,
+    Proj,
+    Strl,
+    Natl,
+  }
+
+  // incremental tree generation without recursion stack overflows
+  pub fn arbitrary_expr(g: &mut Gen, ctx: u64) -> Expr {
+    let mut root = Expr::default();
+    let mut stack = vec![&mut root as *mut Expr];
+
+    while let Some(ptr) = stack.pop() {
+      let gens: Vec<(usize, ExprCase)> = vec![
+        (100, ExprCase::Vari),
+        (100, ExprCase::Sort),
+        (75, ExprCase::Refr),
+        (50, ExprCase::Recr),
+        (25, ExprCase::Apps),
+        (25, ExprCase::Lams),
+        (50, ExprCase::Alls),
+        (50, ExprCase::Let),
+        (50, ExprCase::Proj),
+        (100, ExprCase::Strl),
+        (100, ExprCase::Natl),
+      ];
+
+      match next_case(g, &gens) {
+        ExprCase::Vari => {
+          let x: u64 = Arbitrary::arbitrary(g);
+          unsafe {
+            ptr::replace(ptr, Expr::Vari(x));
+          }
+        },
+        ExprCase::Sort => {
+          let u = arbitrary_univ(g, ctx);
+          unsafe {
+            ptr::replace(ptr, Expr::Sort(Box::new(u)));
+          }
+        },
+        ExprCase::Refr => {
+          let addr = Address::arbitrary(g);
+          let mut lvls = vec![];
+          for _ in 0..gen_range(g, 0..4) {
+            lvls.push(arbitrary_univ(g, ctx));
+          }
+          unsafe {
+            ptr::replace(ptr, Expr::Refr(addr, lvls));
+          }
+        },
+        ExprCase::Recr => {
+          let n = u64::arbitrary(g);
+          let mut lvls = vec![];
+          for _ in 0..gen_range(g, 0..4) {
+            lvls.push(arbitrary_univ(g, ctx));
+          }
+          unsafe {
+            ptr::replace(ptr, Expr::Recr(n, lvls));
+          }
+        },
+        ExprCase::Apps => {
+          let mut f_box = Box::new(Expr::default());
+          let f_ptr: *mut Expr = &mut *f_box;
+          stack.push(f_ptr);
+
+          let mut a_box = Box::new(Expr::default());
+          let a_ptr: *mut Expr = &mut *a_box;
+          stack.push(a_ptr);
+
+          let n = gen_range(g, 0..4);
+          let mut xs: Vec<Expr> = Vec::with_capacity(n);
+          xs.resize(n, Expr::Vari(0));
+          for i in 0..n {
+            let p = unsafe { xs.as_mut_ptr().add(i) };
+            stack.push(p);
+          }
+
+          unsafe {
+            std::ptr::replace(ptr, Expr::Apps(f_box, a_box, xs));
+          }
+        },
+        ExprCase::Lams => {
+          let n = gen_range(g, 0..4);
+          let mut ts: Vec<Expr> = Vec::with_capacity(n);
+          ts.resize(n, Expr::Vari(0));
+          for i in 0..n {
+            let p = unsafe { ts.as_mut_ptr().add(i) };
+            stack.push(p);
+          }
+
+          let mut b_box = Box::new(Expr::default());
+          let b_ptr: *mut Expr = &mut *b_box;
+          stack.push(b_ptr);
+
+          unsafe {
+            std::ptr::replace(ptr, Expr::Lams(ts, b_box));
+          }
+        },
+        ExprCase::Alls => {
+          let n = gen_range(g, 0..4);
+          let mut ts: Vec<Expr> = Vec::with_capacity(n);
+          ts.resize(n, Expr::Vari(0));
+          for i in 0..n {
+            let p = unsafe { ts.as_mut_ptr().add(i) };
+            stack.push(p);
+          }
+
+          let mut b_box = Box::new(Expr::default());
+          let b_ptr: *mut Expr = &mut *b_box;
+          stack.push(b_ptr);
+
+          unsafe {
+            std::ptr::replace(ptr, Expr::Alls(ts, b_box));
+          }
+        },
+        ExprCase::Let => {
+          let nd = bool::arbitrary(g);
+
+          let mut t_box = Box::new(Expr::default());
+          let t_ptr: *mut Expr = &mut *t_box;
+          stack.push(t_ptr);
+
+          let mut d_box = Box::new(Expr::default());
+          let d_ptr: *mut Expr = &mut *d_box;
+          stack.push(d_ptr);
+
+          let mut b_box = Box::new(Expr::default());
+          let b_ptr: *mut Expr = &mut *b_box;
+          stack.push(b_ptr);
+
+          unsafe {
+            ptr::replace(ptr, Expr::Let(nd, t_box, d_box, b_box));
+          }
+        },
+        ExprCase::Proj => {
+          let addr = Address::arbitrary(g);
+          let n = u64::arbitrary(g);
+
+          let mut t_box = Box::new(Expr::default());
+          let t_ptr: *mut Expr = &mut *t_box;
+          stack.push(t_ptr);
+
+          unsafe {
+            ptr::replace(ptr, Expr::Proj(addr, n, t_box));
+          }
+        },
+        ExprCase::Strl => {
+          let cs = gen_range(g, 0..4);
+          let mut s = String::new();
+          for _ in 0..cs {
+            s.push(char::arbitrary(g));
+          }
+
+          unsafe {
+            ptr::replace(ptr, Expr::Strl(s));
+          }
+        },
+        ExprCase::Natl => {
+          let size = gen_range(g, 0..4);
+          unsafe {
+            ptr::replace(ptr, Expr::Natl(arbitrary_nat(g, size)));
+          }
+        },
+      }
+    }
+    root
+  }
+
+  impl Arbitrary for Expr {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let ctx = gen_range(g, 0..4);
+      arbitrary_expr(g, ctx as u64)
+    }
+  }
+
+  #[quickcheck]
+  fn prop_expr_readback(x: Expr) -> bool {
+    let mut buf = Vec::new();
+    Expr::put(&x, &mut buf);
+    match Expr::get(&mut buf.as_slice()) {
+      Ok(y) => x == y,
+      Err(e) => {
+        println!("err: {e}");
+        false
+      },
+    }
+  }
+}
diff --git a/src/ixon/nat.rs b/src/ixon/nat.rs
index 19fb130e..4e53bab2 100644
--- a/src/ixon/nat.rs
+++ b/src/ixon/nat.rs
@@ -1,7 +1,38 @@
 use num_bigint::BigUint;
 
-pub struct Nat {
-  pub val: BigUint,
-}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Nat(pub BigUint);
 
 //impl Nat {}
+
+#[cfg(test)]
+pub mod tests {
+  use super::*;
+  use crate::ixon::common::tests::gen_range;
+  use quickcheck::{Arbitrary, Gen};
+
+  pub fn arbitrary_nat(g: &mut Gen, size: usize) -> Nat {
+    let mut bytes = vec![];
+
+    let b = u8::arbitrary(g);
+
+    if b == 0 {
+      bytes.push(b + 1);
+    } else {
+      bytes.push(b);
+    }
+
+    for _ in 0..size {
+      bytes.push(u8::arbitrary(g));
+    }
+
+    Nat(BigUint::from_bytes_be(&bytes))
+  }
+
+  impl Arbitrary for Nat {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let size = gen_range(g, 0..4);
+      arbitrary_nat(g, size)
+    }
+  }
+}
diff --git a/src/ixon/serialize.rs b/src/ixon/serialize.rs
index 59861cc9..73a86a98 100644
--- a/src/ixon/serialize.rs
+++ b/src/ixon/serialize.rs
@@ -1,11 +1,11 @@
 pub trait Serialize: Sized {
-  fn put(self, buf: &mut Vec<u8>);
+  fn put(&self, buf: &mut Vec<u8>);
   fn get(buf: &mut &[u8]) -> Result<Self, String>;
 }
 
 impl Serialize for u8 {
-  fn put(self, buf: &mut Vec<u8>) {
-    buf.push(self)
+  fn put(&self, buf: &mut Vec<u8>) {
+    buf.push(*self)
   }
 
   fn get(buf: &mut &[u8]) -> Result<Self, String> {
@@ -20,7 +20,7 @@ impl Serialize for u8 {
 }
 
 impl Serialize for u16 {
-  fn put(self, buf: &mut Vec<u8>) {
+  fn put(&self, buf: &mut Vec<u8>) {
     buf.extend_from_slice(&self.to_le_bytes());
   }
 
@@ -36,7 +36,7 @@ impl Serialize for u16 {
 }
 
 impl Serialize for u32 {
-  fn put(self, buf: &mut Vec<u8>) {
+  fn put(&self, buf: &mut Vec<u8>) {
     buf.extend_from_slice(&self.to_le_bytes());
   }
 
@@ -52,7 +52,7 @@ impl Serialize for u32 {
 }
 
 impl Serialize for u64 {
-  fn put(self, buf: &mut Vec<u8>) {
+  fn put(&self, buf: &mut Vec<u8>) {
     buf.extend_from_slice(&self.to_le_bytes());
   }
 
@@ -71,10 +71,10 @@ impl Serialize for u64 {
 }
 
 impl Serialize for bool {
-  fn put(self, buf: &mut Vec<u8>) {
+  fn put(&self, buf: &mut Vec<u8>) {
     match self {
-      false => Serialize::put(0u8, buf),
-      true => Serialize::put(1u8, buf),
+      false => Serialize::put(&0u8, buf),
+      true => Serialize::put(&1u8, buf),
     }
   }
   fn get(buf: &mut &[u8]) -> Result<Self, String> {
@@ -126,6 +126,44 @@ mod tests {
   use super::*;
   use quickcheck::{Arbitrary, Gen};
 
+  #[test]
+  fn unit_u64_trimmed() {
+    fn test(input: u64, expected: Vec<u8>) -> bool {
+      let mut tmp = Vec::new();
+      let n = u64_byte_count(input);
+      u64_put_trimmed_le(input, &mut tmp);
+      if tmp != expected {
+        return false;
+      }
+      match u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
+        Ok(out) => input == out,
+        Err(e) => {
+          println!("err: {e}");
+          false
+        },
+      }
+    }
+    assert!(test(0x0, vec![]));
+    assert!(test(0x01, vec![0x01]));
+    assert!(test(0x0000000000000100, vec![0x00, 0x01]));
+    assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
+    assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0000010000000000, vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(
+      0x0001000000000000,
+      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+    ));
+    assert!(test(
+      0x0100000000000000,
+      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+    ));
+    assert!(test(
+      0x0102030405060708,
+      vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+    ));
+  }
+
   #[quickcheck]
   fn prop_u64_trimmed_le_readback(x: u64) -> bool {
     let mut buf = Vec::new();
@@ -134,7 +172,7 @@ mod tests {
     match u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
       Ok(y) => x == y,
       Err(e) => {
-        println!("err: {}", e);
+        println!("err: {e}");
         false
       },
     }
diff --git a/src/ixon/univ.rs b/src/ixon/univ.rs
index eec490e6..69b2bb79 100644
--- a/src/ixon/univ.rs
+++ b/src/ixon/univ.rs
@@ -3,6 +3,8 @@ use crate::ixon::serialize::{
 };
 
 // 0xTTTL_XXXX
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[repr(C)]
 pub enum Univ {
   // 0x0, 1
   Const(u64),
@@ -16,12 +18,18 @@ pub enum Univ {
   IMax(Box<Univ>, Box<Univ>),
 }
 
+impl Default for Univ {
+  fn default() -> Self {
+    Self::Const(0)
+  }
+}
+
 impl Univ {
   fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
     if val < 16 {
       buf.push((tag << 5) | (val as u8));
     } else {
-      buf.push((tag << 5) | 0b1_0000 | (u64_byte_count(val)));
+      buf.push((tag << 5) | 0b1_0000 | (u64_byte_count(val) - 1));
       u64_put_trimmed_le(val, buf);
     }
   }
@@ -40,12 +48,12 @@ impl Univ {
 }
 
 impl Serialize for Univ {
-  fn put(self, buf: &mut Vec<u8>) {
+  fn put(&self, buf: &mut Vec<u8>) {
     match self {
-      Self::Const(x) => Univ::put_tag(0x0, x, buf),
-      Self::Var(x) => Univ::put_tag(0x1, x, buf),
+      Self::Const(x) => Univ::put_tag(0x0, *x, buf),
+      Self::Var(x) => Univ::put_tag(0x1, *x, buf),
       Self::Add(x, y) => {
-        Univ::put_tag(0x2, x, buf);
+        Univ::put_tag(0x2, *x, buf);
         y.put(buf)
       },
       Self::Max(x, y) => {
@@ -65,7 +73,7 @@ impl Serialize for Univ {
     let tag_byte = u8::get(buf)?;
     let tag = tag_byte >> 5;
     let small_size = tag_byte & 0b1111;
-    let is_large = tag_byte & 0b10000 == 0;
+    let is_large = tag_byte & 0b10000 != 0;
     match tag {
       0x0 => {
         let x = Univ::get_tag(is_large, small_size, buf)?;
@@ -94,3 +102,104 @@ impl Serialize for Univ {
     }
   }
 }
+
+#[cfg(test)]
+pub mod tests {
+  use super::*;
+  use crate::ixon::common::tests::{gen_range, next_case};
+  use quickcheck::{Arbitrary, Gen};
+
+  use std::ptr;
+
+  #[derive(Debug, Clone, Copy)]
+  pub enum UnivCase {
+    Const,
+    Var,
+    Add,
+    Max,
+    IMax,
+  }
+
+  // incremental tree generation without recursion stack overflows
+  pub fn arbitrary_univ(g: &mut Gen, ctx: u64) -> Univ {
+    let mut root = Univ::Const(0);
+    let mut stack: Vec<*mut Univ> = vec![&mut root as *mut Univ];
+
+    while let Some(ptr) = stack.pop() {
+      let gens: Vec<(usize, UnivCase)> = vec![
+        (100, UnivCase::Const),
+        (100, UnivCase::Var),
+        (75, UnivCase::Add),
+        (50, UnivCase::Max),
+        (50, UnivCase::IMax),
+      ];
+
+      match next_case(g, &gens) {
+        UnivCase::Const => {
+          let x: u64 = Arbitrary::arbitrary(g);
+          unsafe {
+            ptr::replace(ptr, Univ::Const(x));
+          }
+        },
+        UnivCase::Var => {
+          let x: u64 = gen_range(g, 0..(ctx as usize)) as u64;
+          unsafe {
+            ptr::replace(ptr, Univ::Var(x));
+          }
+        },
+        UnivCase::Add => {
+          let x: u64 = Arbitrary::arbitrary(g);
+          let mut y_box = Box::new(Univ::Const(0));
+          let y_ptr: *mut Univ = &mut *y_box;
+          stack.push(y_ptr);
+          unsafe {
+            ptr::replace(ptr, Univ::Add(x, y_box));
+          }
+        },
+        UnivCase::Max => {
+          let mut x_box = Box::new(Univ::Const(0));
+          let x_ptr: *mut Univ = &mut *x_box;
+          stack.push(x_ptr);
+          let mut y_box = Box::new(Univ::Const(0));
+          let y_ptr: *mut Univ = &mut *y_box;
+          stack.push(y_ptr);
+          unsafe {
+            ptr::replace(ptr, Univ::Max(x_box, y_box));
+          }
+        },
+        UnivCase::IMax => {
+          let mut x_box = Box::new(Univ::Const(0));
+          let x_ptr: *mut Univ = &mut *x_box;
+          stack.push(x_ptr);
+          let mut y_box = Box::new(Univ::Const(0));
+          let y_ptr: *mut Univ = &mut *y_box;
+          stack.push(y_ptr);
+          unsafe {
+            ptr::replace(ptr, Univ::Max(x_box, y_box));
+          }
+        },
+      }
+    }
+    root
+  }
+
+  impl Arbitrary for Univ {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let ctx: u64 = Arbitrary::arbitrary(g);
+      arbitrary_univ(g, ctx)
+    }
+  }
+
+  #[quickcheck]
+  fn prop_univ_readback(x: Univ) -> bool {
+    let mut buf = Vec::new();
+    Univ::put(&x, &mut buf);
+    match Univ::get(&mut buf.as_slice()) {
+      Ok(y) => x == y,
+      Err(e) => {
+        println!("err: {e}");
+        false
+      },
+    }
+  }
+}

From bcd28d3ae65d0447e998121a2f78559dc9b5918a Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 15 Aug 2025 17:23:32 -0400
Subject: [PATCH 35/74] new ixon format passing proptest roundtrip

---
 src/ixon.rs           | 812 +++++++++++++++++++++++++++++++++++++++++-
 src/ixon/claim.rs     | 129 ++++++-
 src/ixon/cnst.rs      | 470 ++++++++++++++++++++++++
 src/ixon/common.rs    |  14 -
 src/ixon/constant.rs  | 604 +++++++++++++++++++++++++++++++
 src/ixon/expr.rs      |  28 +-
 src/ixon/meta.rs      | 217 ++++++++++-
 src/ixon/name.rs      |  58 +++
 src/ixon/nat.rs       |  21 +-
 src/ixon/serialize.rs | 116 ++----
 src/ixon/univ.rs      |  44 ++-
 11 files changed, 2371 insertions(+), 142 deletions(-)
 create mode 100644 src/ixon/constant.rs

diff --git a/src/ixon.rs b/src/ixon.rs
index dd35ea55..6d0a16bc 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -1,10 +1,816 @@
+use blake3::Hash;
+use num_bigint::BigUint;
+
 pub mod address;
 pub mod claim;
-pub mod cnst;
-pub mod common;
-pub mod expr;
+pub mod constant;
 pub mod meta;
 pub mod name;
 pub mod nat;
 pub mod serialize;
 pub mod univ;
+
+use address::*;
+use claim::*;
+use constant::*;
+use meta::*;
+use name::*;
+use nat::*;
+use serialize::*;
+use univ::*;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Ixon {
+  Var(u64),                                   // 0x0X, variables
+  Sort(Box<Univ>),                            // 0xB0, universes
+  Ref(Address, Vec<Univ>),                    // 0x1X, global reference
+  Rec(u64, Vec<Univ>),                        // 0x2X, local const recursion
+  App(Box<Ixon>, Box<Ixon>, Vec<Ixon>),       // 0x3X, applications
+  Lam(Vec<Ixon>, Box<Ixon>),                  // 0x4X, lambdas
+  All(Vec<Ixon>, Box<Ixon>),                  // 0x5X, foralls
+  Proj(Address, u64, Box<Ixon>),              // 0x6X, structure projection
+  Strl(String),                               // 0x7X, unicode string
+  Natl(Nat),                                  // 0x8X, natural numbers
+  Let(bool, Box<Ixon>, Box<Ixon>, Box<Ixon>), // 0xB1, 0xB2, local binder
+  Array(Vec<Ixon>),                           // 0xA, array
+  Defn(Definition),                           // 0xC0, definition
+  Axio(Axiom),                                // 0xC1, axiom
+  Quot(Quotient),                             // 0xC2, quotient
+  CtorProj(ConstructorProj),                  // 0xC3, constructor projection
+  RecrProj(RecursorProj),                     // 0xC4, recursor projection
+  IndcProj(InductiveProj),                    // 0xC5, inductive projection
+  DefnProj(DefinitionProj),                   // 0xC6, definition projection
+  Meta(Metadata),                             // 0xC7, metadata
+  Proof(Proof),                               // 0xC8, zero-knowledge proof
+  Claim(Claim),                               // 0xC9, cryptographic claim
+  Comm(Comm),                                 // 0xCA, cryptographic commitment
+  Env(Env),                                   // 0xCB, multi-claim environment
+  MutDef(Vec<Definition>),                    // 0xDX, mutual definition
+  MutInd(Vec<Inductive>),                     // 0xEX, mutual inductive data
+                                              // unused: 0x9, 0xB3..0xBF, 0xFX
+}
+
+impl Default for Ixon {
+  fn default() -> Self {
+    Self::Var(0)
+  }
+}
+
+impl Ixon {
+  pub fn u64_byte_count(x: u64) -> u8 {
+    match x {
+      0 => 0,
+      x if x < 0x0000000000000100 => 1,
+      x if x < 0x0000000000010000 => 2,
+      x if x < 0x0000000001000000 => 3,
+      x if x < 0x0000000100000000 => 4,
+      x if x < 0x0000010000000000 => 5,
+      x if x < 0x0001000000000000 => 6,
+      x if x < 0x0100000000000000 => 7,
+      _ => 8,
+    }
+  }
+
+  pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
+    let n = Ixon::u64_byte_count(x) as usize;
+    buf.extend_from_slice(&x.to_le_bytes()[..n])
+  }
+
+  pub fn u64_get_trimmed_le(
+    len: usize,
+    buf: &mut &[u8],
+  ) -> Result<u64, String> {
+    let mut res = [0u8; 8];
+    if len > 8 {
+      return Err("get trimmed_le_64 len > 8".to_string());
+    }
+    match buf.split_at_checked(len) {
+      Some((head, rest)) => {
+        *buf = rest;
+        res[..len].copy_from_slice(head);
+        Ok(u64::from_le_bytes(res))
+      },
+      None => Err("get trimmed_le_u64 EOF".to_string()),
+    }
+  }
+
+  pub fn pack_bools<I>(bools: I) -> u8
+  where
+    I: IntoIterator<Item = bool>,
+  {
+    let mut acc: u8 = 0;
+    for (i, b) in bools.into_iter().take(8).enumerate() {
+      if b {
+        acc |= 1u8 << (i as u32);
+      }
+    }
+    acc
+  }
+
+  pub fn unpack_bools(n: usize, b: u8) -> Vec<bool> {
+    (0..8).map(|i| (b & (1u8 << (i as u32))) != 0).take(n.min(8)).collect()
+  }
+
+  fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
+    if val < 8 {
+      buf.push((tag << 4) | (val as u8));
+    } else {
+      buf.push((tag << 4) | 0b1000 | (Ixon::u64_byte_count(val) - 1));
+      Ixon::u64_put_trimmed_le(val, buf);
+    }
+  }
+
+  fn get_size(
+    is_large: bool,
+    small: u8,
+    buf: &mut &[u8],
+  ) -> Result<u64, String> {
+    if is_large {
+      Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
+    } else {
+      Ok(small as u64)
+    }
+  }
+
+  // put_array and get_array are separated from Ixon's serialize implementation
+  // in order to create a generic Serialize impl for Vec<S>
+  pub fn put_array<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
+    Self::put_tag(0xA, xs.len() as u64, buf);
+    for x in xs {
+      x.put(buf)
+    }
+  }
+
+  pub fn get_array<S: Serialize>(buf: &mut &[u8]) -> Result<Vec<S>, String> {
+    let tag_byte = u8::get(buf)?;
+    let tag = tag_byte >> 4;
+    let small_size = tag_byte & 0b111;
+    let is_large = tag_byte & 0b1000 != 0;
+    match tag {
+      0xA => {
+        let len = Self::get_size(is_large, small_size, buf)?;
+        let mut vec = vec![];
+        for _ in 0..len {
+          let s = S::get(buf)?;
+          vec.push(s);
+        }
+        Ok(vec)
+      },
+      x => Err(format!("get array invalid tag {x}")),
+    }
+  }
+}
+
+impl Serialize for Ixon {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Var(x) => Self::put_tag(0x0, *x, buf),
+      Self::Sort(x) => {
+        u8::put(&0xB0, buf);
+        x.put(buf);
+      },
+      Self::Ref(addr, lvls) => {
+        Self::put_tag(0x1, lvls.len() as u64, buf);
+        addr.put(buf);
+        for l in lvls {
+          l.put(buf);
+        }
+      },
+      Self::Rec(x, lvls) => {
+        Self::put_tag(0x2, lvls.len() as u64, buf);
+        x.put(buf);
+        for l in lvls {
+          l.put(buf);
+        }
+      },
+      Self::App(f, a, args) => {
+        Self::put_tag(0x3, args.len() as u64, buf);
+        f.put(buf);
+        a.put(buf);
+        for x in args {
+          x.put(buf);
+        }
+      },
+      Self::Lam(ts, b) => {
+        Self::put_tag(0x4, ts.len() as u64, buf);
+        for t in ts {
+          t.put(buf);
+        }
+        b.put(buf);
+      },
+      Self::All(ts, b) => {
+        Self::put_tag(0x5, ts.len() as u64, buf);
+        for t in ts {
+          t.put(buf);
+        }
+        b.put(buf);
+      },
+      Self::Proj(t, n, x) => {
+        Self::put_tag(0x6, *n, buf);
+        t.put(buf);
+        x.put(buf);
+      },
+      Self::Strl(s) => {
+        let bytes = s.as_bytes();
+        Self::put_tag(0x7, bytes.len() as u64, buf);
+        buf.extend_from_slice(bytes);
+      },
+      Self::Natl(n) => {
+        let bytes = n.0.to_bytes_le();
+        Self::put_tag(0x8, bytes.len() as u64, buf);
+        buf.extend_from_slice(&bytes);
+      },
+      Self::Let(nd, t, d, b) => {
+        if *nd {
+          u8::put(&0xB2, buf);
+        } else {
+          u8::put(&0xB1, buf);
+        }
+        t.put(buf);
+        d.put(buf);
+        b.put(buf);
+      },
+      Self::Array(xs) => Ixon::put_array(xs, buf),
+      Self::Defn(x) => {
+        u8::put(&0xC0, buf);
+        x.put(buf);
+      },
+      Self::Axio(x) => {
+        u8::put(&0xC1, buf);
+        x.put(buf);
+      },
+      Self::Quot(x) => {
+        u8::put(&0xC2, buf);
+        x.put(buf);
+      },
+      Self::CtorProj(x) => {
+        u8::put(&0xC3, buf);
+        x.put(buf);
+      },
+      Self::RecrProj(x) => {
+        u8::put(&0xC4, buf);
+        x.put(buf);
+      },
+      Self::IndcProj(x) => {
+        u8::put(&0xC5, buf);
+        x.put(buf);
+      },
+      Self::DefnProj(x) => {
+        u8::put(&0xC6, buf);
+        x.put(buf);
+      },
+      Self::Meta(x) => {
+        u8::put(&0xC7, buf);
+        x.put(buf);
+      },
+      Self::Proof(x) => {
+        u8::put(&0xC8, buf);
+        x.put(buf);
+      },
+      Self::Claim(x) => {
+        u8::put(&0xC9, buf);
+        x.put(buf);
+      },
+      Self::Comm(x) => {
+        u8::put(&0xCA, buf);
+        x.put(buf);
+      },
+      Self::Env(x) => {
+        u8::put(&0xCB, buf);
+        x.put(buf);
+      },
+      Self::MutDef(xs) => {
+        Self::put_tag(0xD, xs.len() as u64, buf);
+        for x in xs {
+          x.put(buf);
+        }
+      },
+      Self::MutInd(xs) => {
+        Self::put_tag(0xE, xs.len() as u64, buf);
+        for x in xs {
+          x.put(buf);
+        }
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let tag_byte = u8::get(buf)?;
+    let small_size = tag_byte & 0b111;
+    let is_large = tag_byte & 0b1000 != 0;
+    match tag_byte {
+      0x00..=0x0F => {
+        let x = Ixon::get_size(is_large, small_size, buf)?;
+        Ok(Self::Var(x))
+      },
+      0xB0 => {
+        let u = Univ::get(buf)?;
+        Ok(Self::Sort(Box::new(u)))
+      },
+      0x10..=0x1F => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        let a = Address::get(buf)?;
+        let mut lvls = Vec::new();
+        for _ in 0..n {
+          let l = Univ::get(buf)?;
+          lvls.push(l);
+        }
+        Ok(Self::Ref(a, lvls))
+      },
+      0x20..=0x2F => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        let x = u64::get(buf)?;
+        let mut lvls = Vec::new();
+        for _ in 0..n {
+          let l = Univ::get(buf)?;
+          lvls.push(l);
+        }
+        Ok(Self::Rec(x, lvls))
+      },
+      0x30..=0x3F => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        let f = Ixon::get(buf)?;
+        let a = Ixon::get(buf)?;
+        let mut args = Vec::new();
+        for _ in 0..n {
+          let x = Ixon::get(buf)?;
+          args.push(x);
+        }
+        Ok(Self::App(Box::new(f), Box::new(a), args))
+      },
+      0x40..=0x4F => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        let mut ts = Vec::new();
+        for _ in 0..n {
+          let x = Ixon::get(buf)?;
+          ts.push(x);
+        }
+        let b = Ixon::get(buf)?;
+        Ok(Self::Lam(ts, Box::new(b)))
+      },
+      0x50..=0x5F => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        let mut ts = Vec::new();
+        for _ in 0..n {
+          let x = Ixon::get(buf)?;
+          ts.push(x);
+        }
+        let b = Ixon::get(buf)?;
+        Ok(Self::All(ts, Box::new(b)))
+      },
+      0x60..=0x6F => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        let t = Address::get(buf)?;
+        let x = Ixon::get(buf)?;
+        Ok(Self::Proj(t, n, Box::new(x)))
+      },
+      0x70..=0x7F => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        match buf.split_at_checked(n as usize) {
+          Some((head, rest)) => {
+            *buf = rest;
+            match String::from_utf8(head.to_owned()) {
+              Ok(s) => Ok(Ixon::Strl(s)),
+              Err(e) => Err(format!("UTF8 Error: {e}")),
+            }
+          },
+          None => Err("get Ixon Strl EOF".to_string()),
+        }
+      },
+      0x80..=0x8F => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        match buf.split_at_checked(n as usize) {
+          Some((head, rest)) => {
+            *buf = rest;
+            Ok(Ixon::Natl(Nat(BigUint::from_bytes_le(head))))
+          },
+          None => Err("get Expr Natl EOF".to_string()),
+        }
+      },
+      0xB1..=0xB2 => {
+        let nd = tag_byte == 0xB2;
+        let t = Ixon::get(buf)?;
+        let d = Ixon::get(buf)?;
+        let b = Ixon::get(buf)?;
+        Ok(Self::Let(nd, Box::new(t), Box::new(d), Box::new(b)))
+      },
+      0xA0..=0xAF => {
+        let len = Self::get_size(is_large, small_size, buf)?;
+        let mut vec = vec![];
+        for _ in 0..len {
+          let s = Ixon::get(buf)?;
+          vec.push(s);
+        }
+        Ok(Self::Array(vec))
+      },
+      0xC0 => Ok(Self::Defn(Definition::get(buf)?)),
+      0xC1 => Ok(Self::Axio(Axiom::get(buf)?)),
+      0xC2 => Ok(Self::Quot(Quotient::get(buf)?)),
+      0xC3 => Ok(Self::CtorProj(ConstructorProj::get(buf)?)),
+      0xC4 => Ok(Self::RecrProj(RecursorProj::get(buf)?)),
+      0xC5 => Ok(Self::IndcProj(InductiveProj::get(buf)?)),
+      0xC6 => Ok(Self::DefnProj(DefinitionProj::get(buf)?)),
+      0xC7 => Ok(Self::Meta(Metadata::get(buf)?)),
+      0xC8 => Ok(Self::Proof(Proof::get(buf)?)),
+      0xC9 => Ok(Self::Claim(Claim::get(buf)?)),
+      0xCA => Ok(Self::Comm(Comm::get(buf)?)),
+      0xCB => Ok(Self::Env(Env::get(buf)?)),
+      0xD0..=0xDF => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        let mut defs = Vec::new();
+        for _ in 0..n {
+          let x = Definition::get(buf)?;
+          defs.push(x);
+        }
+        Ok(Self::MutDef(defs))
+      },
+      0xE0..=0xEF => {
+        let n = Ixon::get_size(is_large, small_size, buf)?;
+        let mut inds = Vec::new();
+        for _ in 0..n {
+          let x = Inductive::get(buf)?;
+          inds.push(x);
+        }
+        Ok(Self::MutInd(inds))
+      },
+      x => Err(format!("get Ixon invalid tag {x}")),
+    }
+  }
+}
+
+#[cfg(test)]
+pub mod tests {
+  use super::*;
+  use crate::ixon::nat::tests::arbitrary_nat;
+  use crate::ixon::univ::tests::arbitrary_univ;
+  use quickcheck::{Arbitrary, Gen};
+  use std::ops::Range;
+  use std::ptr;
+
+  pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
+    let res: usize = Arbitrary::arbitrary(g);
+    if range.is_empty() {
+      0
+    } else {
+      (res % (range.end - range.start)) + range.start
+    }
+  }
+
+  pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
+  where
+    F: FnMut(&mut Gen) -> A,
+  {
+    let len = gen_range(g, 0..size);
+    let mut vec = Vec::with_capacity(len);
+    for _ in 0..len {
+      vec.push(f(g));
+    }
+    vec
+  }
+
+  pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
+    let sum: usize = gens.iter().map(|x| x.0).sum();
+    let mut weight: usize = gen_range(g, 1..sum);
+    for (n, case) in gens {
+      if *n == 0 {
+        continue;
+      } else {
+        match weight.checked_sub(*n) {
+          None | Some(0) => {
+            return *case;
+          },
+          _ => {
+            weight -= *n;
+          },
+        }
+      }
+    }
+    unreachable!()
+  }
+
+  #[test]
+  fn unit_u64_trimmed() {
+    fn test(input: u64, expected: Vec<u8>) -> bool {
+      let mut tmp = Vec::new();
+      let n = Ixon::u64_byte_count(input);
+      Ixon::u64_put_trimmed_le(input, &mut tmp);
+      if tmp != expected {
+        return false;
+      }
+      match Ixon::u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
+        Ok(out) => input == out,
+        Err(e) => {
+          println!("err: {e}");
+          false
+        },
+      }
+    }
+    assert!(test(0x0, vec![]));
+    assert!(test(0x01, vec![0x01]));
+    assert!(test(0x0000000000000100, vec![0x00, 0x01]));
+    assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
+    assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0000010000000000, vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(
+      0x0001000000000000,
+      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+    ));
+    assert!(test(
+      0x0100000000000000,
+      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+    ));
+    assert!(test(
+      0x0102030405060708,
+      vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+    ));
+  }
+
+  #[quickcheck]
+  fn prop_u64_trimmed_le_readback(x: u64) -> bool {
+    let mut buf = Vec::new();
+    let n = Ixon::u64_byte_count(x);
+    Ixon::u64_put_trimmed_le(x, &mut buf);
+    match Ixon::u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
+      Ok(y) => x == y,
+      Err(e) => {
+        println!("err: {e}");
+        false
+      },
+    }
+  }
+
+  #[derive(Debug, Clone, Copy)]
+  pub enum IxonCase {
+    Var,
+    Sort,
+    Ref,
+    Rec,
+    App,
+    Lam,
+    All,
+    Proj,
+    Strl,
+    Natl,
+    Let,
+    Array,
+    Defn,
+    Axio,
+    Quot,
+    CtorProj,
+    RecrProj,
+    IndcProj,
+    DefnProj,
+    Meta,
+    Proof,
+    Claim,
+    Comm,
+    Env,
+    MutDef,
+    MutInd,
+  }
+
+  pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
+    let mut s = String::new();
+    for _ in 0..cs {
+      s.push(char::arbitrary(g));
+    }
+    s
+  }
+
+  // incremental tree generation without recursion stack overflows
+  pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
+    let mut root = Ixon::Var(0);
+    let mut stack = vec![&mut root as *mut Ixon];
+
+    while let Some(ptr) = stack.pop() {
+      let gens: Vec<(usize, IxonCase)> = vec![
+        (100, IxonCase::Var),
+        (100, IxonCase::Sort),
+        (15, IxonCase::Ref),
+        (15, IxonCase::Rec),
+        (15, IxonCase::App),
+        (15, IxonCase::Lam),
+        (15, IxonCase::All),
+        (50, IxonCase::Let),
+        (50, IxonCase::Proj),
+        (100, IxonCase::Strl),
+        (100, IxonCase::Natl),
+        (10, IxonCase::Array),
+        (100, IxonCase::Defn),
+        (100, IxonCase::Axio),
+        (100, IxonCase::Quot),
+        (100, IxonCase::CtorProj),
+        (100, IxonCase::RecrProj),
+        (100, IxonCase::IndcProj),
+        (100, IxonCase::DefnProj),
+        (100, IxonCase::Meta),
+        (100, IxonCase::Proof),
+        (100, IxonCase::Claim),
+        (100, IxonCase::Comm),
+        (100, IxonCase::Env),
+        (15, IxonCase::MutDef),
+        (15, IxonCase::MutInd),
+      ];
+
+      match next_case(g, &gens) {
+        IxonCase::Var => {
+          let x: u64 = Arbitrary::arbitrary(g);
+          unsafe {
+            ptr::replace(ptr, Ixon::Var(x));
+          }
+        },
+        IxonCase::Sort => {
+          let u = arbitrary_univ(g, ctx);
+          unsafe {
+            ptr::replace(ptr, Ixon::Sort(Box::new(u)));
+          }
+        },
+        IxonCase::Ref => {
+          let addr = Address::arbitrary(g);
+          let mut lvls = vec![];
+          for _ in 0..gen_range(g, 0..9) {
+            lvls.push(arbitrary_univ(g, ctx));
+          }
+          unsafe {
+            ptr::replace(ptr, Ixon::Ref(addr, lvls));
+          }
+        },
+        IxonCase::Rec => {
+          let n = u64::arbitrary(g);
+          let mut lvls = vec![];
+          for _ in 0..gen_range(g, 0..9) {
+            lvls.push(arbitrary_univ(g, ctx));
+          }
+          unsafe {
+            ptr::replace(ptr, Ixon::Rec(n, lvls));
+          }
+        },
+        IxonCase::App => {
+          let mut f_box = Box::new(Ixon::default());
+          let f_ptr: *mut Ixon = &mut *f_box;
+          stack.push(f_ptr);
+
+          let mut a_box = Box::new(Ixon::default());
+          let a_ptr: *mut Ixon = &mut *a_box;
+          stack.push(a_ptr);
+
+          let n = gen_range(g, 0..9);
+          let mut xs: Vec<Ixon> = Vec::with_capacity(n);
+          xs.resize(n, Ixon::Var(0));
+          for i in 0..n {
+            let p = unsafe { xs.as_mut_ptr().add(i) };
+            stack.push(p);
+          }
+          unsafe {
+            std::ptr::replace(ptr, Ixon::App(f_box, a_box, xs));
+          }
+        },
+        IxonCase::Lam => {
+          let n = gen_range(g, 0..9);
+          let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+          ts.resize(n, Ixon::Var(0));
+          for i in 0..n {
+            let p = unsafe { ts.as_mut_ptr().add(i) };
+            stack.push(p);
+          }
+          let mut b_box = Box::new(Ixon::default());
+          let b_ptr: *mut Ixon = &mut *b_box;
+          stack.push(b_ptr);
+          unsafe {
+            std::ptr::replace(ptr, Ixon::Lam(ts, b_box));
+          }
+        },
+        IxonCase::All => {
+          let n = gen_range(g, 0..9);
+          let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+          ts.resize(n, Ixon::Var(0));
+          for i in 0..n {
+            let p = unsafe { ts.as_mut_ptr().add(i) };
+            stack.push(p);
+          }
+          let mut b_box = Box::new(Ixon::default());
+          let b_ptr: *mut Ixon = &mut *b_box;
+          stack.push(b_ptr);
+          unsafe {
+            std::ptr::replace(ptr, Ixon::All(ts, b_box));
+          }
+        },
+        IxonCase::Let => {
+          let nd = bool::arbitrary(g);
+          let mut t_box = Box::new(Ixon::default());
+          let t_ptr: *mut Ixon = &mut *t_box;
+          stack.push(t_ptr);
+          let mut d_box = Box::new(Ixon::default());
+          let d_ptr: *mut Ixon = &mut *d_box;
+          stack.push(d_ptr);
+          let mut b_box = Box::new(Ixon::default());
+          let b_ptr: *mut Ixon = &mut *b_box;
+          stack.push(b_ptr);
+          unsafe {
+            ptr::replace(ptr, Ixon::Let(nd, t_box, d_box, b_box));
+          }
+        },
+        IxonCase::Proj => {
+          let addr = Address::arbitrary(g);
+          let n = u64::arbitrary(g);
+          let mut t_box = Box::new(Ixon::default());
+          let t_ptr: *mut Ixon = &mut *t_box;
+          stack.push(t_ptr);
+          unsafe {
+            ptr::replace(ptr, Ixon::Proj(addr, n, t_box));
+          }
+        },
+        IxonCase::Strl => unsafe {
+          let size = gen_range(g, 0..9);
+          ptr::replace(ptr, Ixon::Strl(arbitrary_string(g, size)));
+        },
+        IxonCase::Natl => {
+          let size = gen_range(g, 0..9);
+          unsafe {
+            ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
+          }
+        },
+        IxonCase::Array => {
+          let n = gen_range(g, 0..9);
+          let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+          ts.resize(n, Ixon::Var(0));
+          for i in 0..n {
+            let p = unsafe { ts.as_mut_ptr().add(i) };
+            stack.push(p);
+          }
+          unsafe {
+            std::ptr::replace(ptr, Ixon::Array(ts));
+          }
+        },
+        IxonCase::Quot => unsafe {
+          std::ptr::replace(ptr, Ixon::Quot(Quotient::arbitrary(g)));
+        },
+        IxonCase::Axio => unsafe {
+          std::ptr::replace(ptr, Ixon::Axio(Axiom::arbitrary(g)));
+        },
+        IxonCase::Defn => unsafe {
+          std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
+        },
+        IxonCase::CtorProj => unsafe {
+          std::ptr::replace(ptr, Ixon::CtorProj(ConstructorProj::arbitrary(g)));
+        },
+        IxonCase::RecrProj => unsafe {
+          std::ptr::replace(ptr, Ixon::RecrProj(RecursorProj::arbitrary(g)));
+        },
+        IxonCase::DefnProj => unsafe {
+          std::ptr::replace(ptr, Ixon::DefnProj(DefinitionProj::arbitrary(g)));
+        },
+        IxonCase::IndcProj => unsafe {
+          std::ptr::replace(ptr, Ixon::IndcProj(InductiveProj::arbitrary(g)));
+        },
+        IxonCase::Meta => unsafe {
+          std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
+        },
+        IxonCase::Proof => unsafe {
+          std::ptr::replace(ptr, Ixon::Proof(Proof::arbitrary(g)));
+        },
+        IxonCase::Claim => unsafe {
+          std::ptr::replace(ptr, Ixon::Claim(Claim::arbitrary(g)));
+        },
+        IxonCase::Comm => unsafe {
+          std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
+        },
+        IxonCase::Env => unsafe {
+          std::ptr::replace(ptr, Ixon::Env(Env::arbitrary(g)));
+        },
+        IxonCase::MutDef => unsafe {
+          let defs = gen_vec(g, 9, Definition::arbitrary);
+          std::ptr::replace(ptr, Ixon::MutDef(defs));
+        },
+        IxonCase::MutInd => unsafe {
+          let inds = gen_vec(g, 9, Inductive::arbitrary);
+          std::ptr::replace(ptr, Ixon::MutInd(inds));
+        },
+      }
+    }
+    root
+  }
+
+  impl Arbitrary for Ixon {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let ctx: u64 = Arbitrary::arbitrary(g);
+      arbitrary_ixon(g, ctx)
+    }
+  }
+
+  #[quickcheck]
+  fn prop_ixon_readback(x: Ixon) -> bool {
+    let mut buf = Vec::new();
+    Ixon::put(&x, &mut buf);
+    match Ixon::get(&mut buf.as_slice()) {
+      Ok(y) => x == y,
+      Err(e) => {
+        println!("err: {e}");
+        false
+      },
+    }
+  }
+}
+
+//}
diff --git a/src/ixon/claim.rs b/src/ixon/claim.rs
index 136d85e9..87d54e16 100644
--- a/src/ixon/claim.rs
+++ b/src/ixon/claim.rs
@@ -1,16 +1,135 @@
 use crate::ixon::address::Address;
-use std::collections::BTreeSet;
+use crate::ixon::serialize::Serialize;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Claim {
-  Checks { lvls: Address, typ_: Address, value: Address },
-  Evals { lvls: Address, typ_: Address, input: Address, output: Address },
+  Checks { lvls: Address, typ: Address, value: Address },
+  Evals { lvls: Address, typ: Address, input: Address, output: Address },
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Proof {
   pub claim: Claim,
   pub proof: Vec<u8>,
 }
 
-pub struct Claims {
-  pub map: BTreeSet<Address>,
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Env {
+  env: Vec<(Address, Address)>,
+}
+
+impl Serialize for Claim {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Checks { lvls, typ, value } => {
+        buf.push(0);
+        lvls.put(buf);
+        typ.put(buf);
+        value.put(buf);
+      },
+      Self::Evals { lvls, typ, input, output } => {
+        buf.push(1);
+        lvls.put(buf);
+        typ.put(buf);
+        input.put(buf);
+        output.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => {
+            let lvls = Address::get(buf)?;
+            let typ = Address::get(buf)?;
+            let value = Address::get(buf)?;
+            Ok(Self::Checks { lvls, typ, value })
+          },
+          1 => {
+            let lvls = Address::get(buf)?;
+            let typ = Address::get(buf)?;
+            let input = Address::get(buf)?;
+            let output = Address::get(buf)?;
+            Ok(Self::Evals { lvls, typ, input, output })
+          },
+          x => Err(format!("get Claim invalid {x}")),
+        }
+      },
+      None => Err("get Claim EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for Proof {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.claim.put(buf);
+    self.proof.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let claim = Claim::get(buf)?;
+    let proof = Serialize::get(buf)?;
+    Ok(Proof { claim, proof })
+  }
+}
+
+impl Serialize for Env {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.env.put(buf)
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    Ok(Env { env: Serialize::get(buf)? })
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::ixon::tests::gen_range;
+  use quickcheck::{Arbitrary, Gen};
+
+  impl Arbitrary for Claim {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..1);
+      match x {
+        0 => Self::Checks {
+          lvls: Address::arbitrary(g),
+          typ: Address::arbitrary(g),
+          value: Address::arbitrary(g),
+        },
+        _ => Self::Evals {
+          lvls: Address::arbitrary(g),
+          typ: Address::arbitrary(g),
+          input: Address::arbitrary(g),
+          output: Address::arbitrary(g),
+        },
+      }
+    }
+  }
+
+  impl Arbitrary for Proof {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..32);
+      let mut bytes = vec![];
+      for _ in 0..x {
+        bytes.push(u8::arbitrary(g));
+      }
+      Proof { claim: Claim::arbitrary(g), proof: bytes }
+    }
+  }
+
+  impl Arbitrary for Env {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..32);
+      let mut env = vec![];
+      for _ in 0..x {
+        env.push((Address::arbitrary(g), Address::arbitrary(g)));
+      }
+      Env { env }
+    }
+  }
 }
diff --git a/src/ixon/cnst.rs b/src/ixon/cnst.rs
index 6a3c0e72..ec18735a 100644
--- a/src/ixon/cnst.rs
+++ b/src/ixon/cnst.rs
@@ -3,6 +3,7 @@ use crate::ixon::claim::{Claim, Claims, Proof};
 use crate::ixon::expr::Expr;
 use crate::ixon::meta::Metadata;
 use crate::ixon::nat::Nat;
+use crate::ixon::serialize::{pack_bools, unpack_bools, Serialize};
 
 pub enum QuotKind {
   Type,
@@ -139,3 +140,472 @@ pub enum Const {
   // 0xCD
   Env(Claims),
 }
+
+pub enum Ixon {
+  // Expressions
+  EVar(u64),                              // 0x0X
+  ERef(Address, Vec<Ixon>),               // 0x1X
+  ERec(u64, Vec<Ixon>),                   // 0x2X
+  EApp(Box<Ixon>, Box<Ixon>, Vec<Ixon>),  // 0x3X
+  ELam(Vec<Ixon>, Box<Ixon>),             // 0x4X
+  EAll(Vec<Ixon>, Box<Ixon>),             // 0x5X
+  EPrj(Address, u64, Box<Ixon>),          // 0x6X
+  EStr(String),                           // 0x7X
+  ENat(Nat),                              // 0x8X
+  ELet(Box<Ixon>, Box<Ixon>, Box<Ixon>),  // 0xE0
+  ELetD(Box<Ixon>, Box<Ixon>, Box<Ixon>), // 0xE1
+  // Arrays
+  Array(Vec<Ixon>), //0xA
+  // Constants
+  Defn(Definition),          // 0xC0
+  Axio(Axiom),               // 0xC1
+  Quot(Quotient),            // 0xC2
+  CtorProj(ConstructorProj), // 0xC3
+  RecrProj(RecursorProj),    // 0xC4
+  IndcProj(InductiveProj),   // 0xC5
+  DefnProj(DefinitionProj),  // 0xC6
+  MutDef(Vec<Definition>),   // 0xC7
+  MutInd(Vec<Inductive>),    // 0xC8
+  Meta(Metadata),            // 0xC9
+  Proof(Proof),              // 0xCA
+  Claim(Claim),              // 0xCB
+  Comm(Comm),                // 0xCC
+  Env(Claims),               // 0xCD
+  // Universes
+  UVar(u64),                   // 0x9X
+  UConst(u64),                 // 0xBX
+  UAdd(u64, Box<Ixon>),        // 0xDX
+  UMax(Box<Ixon>, Box<Ixon>),  // 0xE2
+  UIMax(Box<Ixon>, Box<Ixon>), // 0xE3
+}
+
+impl Const {}
+
+impl Serialize for Const {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Defn(x) => {
+        u8::put(&0xC0, buf);
+        x.put(buf);
+      },
+      Self::Axio(x) => {
+        u8::put(&0xC1, buf);
+        x.put(buf);
+      },
+      Self::Quot(x) => {
+        u8::put(&0xC2, buf);
+        x.put(buf);
+      },
+      Self::CtorProj(x) => {
+        u8::put(&0xC3, buf);
+        x.put(buf);
+      },
+      Self::RecrProj(x) => {
+        u8::put(&0xC4, buf);
+        x.put(buf);
+      },
+      Self::IndcProj(x) => {
+        u8::put(&0xC5, buf);
+        x.put(buf);
+      },
+      Self::DefnProj(x) => {
+        u8::put(&0xC6, buf);
+        x.put(buf);
+      },
+      Self::MutDef(x) => {
+        u8::put(&0xC7, buf);
+        Expr::put_array(x, buf);
+      },
+      Self::MutInd(x) => {
+        u8::put(&0xC8, buf);
+        Expr::put_array(x, buf);
+      },
+      Self::Meta(x) => {
+        u8::put(&0xC9, buf);
+        x.put(buf);
+      },
+      Self::Proof(x) => {
+        u8::put(&0xCA, buf);
+        x.put(buf);
+      },
+      Self::Claim(x) => {
+        u8::put(&0xCB, buf);
+        x.put(buf);
+      },
+      Self::Comm(x) => {
+        u8::put(&0xCC, buf);
+        x.put(buf);
+      },
+      Self::Env(x) => {
+        u8::put(&0xCD, buf);
+        x.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let tag = u8::get(buf)?;
+    match tag {
+      0xC0 => Ok(Self::Defn(Definition::get(buf)?)),
+      0xC1 => Ok(Self::Axio(Axiom::get(buf)?)),
+      0xC2 => Ok(Self::Quot(Quotient::get(buf)?)),
+      0xC3 => Ok(Self::CtorProj(ConstructorProj::get(buf)?)),
+      0xC4 => Ok(Self::RecrProj(RecursorProj::get(buf)?)),
+      0xC5 => Ok(Self::IndcProj(InductiveProj::get(buf)?)),
+      0xC6 => Ok(Self::DefnProj(DefinitionProj::get(buf)?)),
+      0xC7 => Ok(Self::MutDef(Expr::get_array(buf)?)),
+      0xC8 => Ok(Self::MutInd(Expr::get_array(buf)?)),
+      0xC9 => Ok(Self::Meta(Metadata::get(buf)?)),
+      0xCA => Ok(Self::Proof(Proof::get(buf)?)),
+      0xCB => Ok(Self::Claim(Claim::get(buf)?)),
+      0xCC => Ok(Self::Comm(Comm::get(buf)?)),
+      0xCD => Ok(Self::Env(Claims::get(buf)?)),
+      x => Err(format!("get Expr invalid tag {x}")),
+    }
+  }
+}
+
+impl Serialize for QuotKind {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Type => buf.push(0),
+      Self::Ctor => buf.push(1),
+      Self::Lift => buf.push(2),
+      Self::Ind => buf.push(3),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Type),
+          1 => Ok(Self::Ctor),
+          2 => Ok(Self::Lift),
+          3 => Ok(Self::Ind),
+          x => Err(format!("get QuotKind invalid {x}")),
+        }
+      },
+      None => Err("get QuotKind EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for Quotient {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.kind.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Expr::get(buf)?;
+    let kind = QuotKind::get(buf)?;
+    Ok(Quotient { lvls, typ: Box::new(typ), kind })
+  }
+}
+
+impl Serialize for Axiom {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.is_unsafe.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Expr::get(buf)?;
+    let is_unsafe = bool::get(buf)?;
+    Ok(Axiom { lvls, typ: Box::new(typ), is_unsafe })
+  }
+}
+
+impl Serialize for DefKind {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Definition => buf.push(0),
+      Self::Opaque => buf.push(1),
+      Self::Theorem => buf.push(2),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Definition),
+          1 => Ok(Self::Opaque),
+          2 => Ok(Self::Theorem),
+          x => Err(format!("get DefKind invalid {x}")),
+        }
+      },
+      None => Err("get DefKind EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for DefSafety {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Unsafe => buf.push(0),
+      Self::Safe => buf.push(1),
+      Self::Partial => buf.push(2),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Unsafe),
+          1 => Ok(Self::Safe),
+          2 => Ok(Self::Partial),
+          x => Err(format!("get DefSafety invalid {x}")),
+        }
+      },
+      None => Err("get DefSafety EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for Definition {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.mode.put(buf);
+    self.value.put(buf);
+    self.safety.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Expr::get(buf)?;
+    let mode = DefKind::get(buf)?;
+    let value = Expr::get(buf)?;
+    let safety = DefSafety::get(buf)?;
+    Ok(Definition {
+      lvls,
+      typ: Box::new(typ),
+      mode,
+      value: Box::new(value),
+      safety,
+    })
+  }
+}
+
+impl Serialize for Constructor {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.cidx.put(buf);
+    self.params.put(buf);
+    self.fields.put(buf);
+    self.is_unsafe.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Expr::get(buf)?;
+    let cidx = Nat::get(buf)?;
+    let params = Nat::get(buf)?;
+    let fields = Nat::get(buf)?;
+    let is_unsafe = bool::get(buf)?;
+    Ok(Constructor {
+      lvls,
+      typ: Box::new(typ),
+      cidx,
+      params,
+      fields,
+      is_unsafe,
+    })
+  }
+}
+
+impl Serialize for RecursorRule {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.fields.put(buf);
+    self.rhs.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let fields = Nat::get(buf)?;
+    let rhs = Expr::get(buf)?;
+    Ok(RecursorRule { fields, rhs: Box::new(rhs) })
+  }
+}
+
+impl Serialize for Recursor {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.params.put(buf);
+    self.indices.put(buf);
+    self.motives.put(buf);
+    self.minors.put(buf);
+    Expr::put_array(&self.rules, buf);
+    pack_bools(vec![self.k, self.is_unsafe]).put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Expr::get(buf)?;
+    let params = Nat::get(buf)?;
+    let indices = Nat::get(buf)?;
+    let motives = Nat::get(buf)?;
+    let minors = Nat::get(buf)?;
+    let rules = Expr::get_array(buf)?;
+    let bools = unpack_bools(2, u8::get(buf)?);
+    Ok(Recursor {
+      lvls,
+      typ: Box::new(typ),
+      params,
+      indices,
+      motives,
+      minors,
+      rules,
+      k: bools[0],
+      is_unsafe: bools[1],
+    })
+  }
+}
+
+impl Serialize for Inductive {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.params.put(buf);
+    self.indices.put(buf);
+    Expr::put_array(&self.ctors, buf);
+    Expr::put_array(&self.recrs, buf);
+    self.nested.put(buf);
+    pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Expr::get(buf)?;
+    let params = Nat::get(buf)?;
+    let indices = Nat::get(buf)?;
+    let ctors = Expr::get_array(buf)?;
+    let recrs = Expr::get_array(buf)?;
+    let nested = Nat::get(buf)?;
+    let bools = unpack_bools(3, u8::get(buf)?);
+    Ok(Inductive {
+      lvls,
+      typ: Box::new(typ),
+      params,
+      indices,
+      ctors,
+      recrs,
+      nested,
+      recr: bools[0],
+      refl: bools[1],
+      is_unsafe: bools[2],
+    })
+  }
+}
+
+impl Serialize for InductiveProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.block.put(buf);
+    self.idx.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let block = Address::get(buf)?;
+    let idx = Nat::get(buf)?;
+    Ok(InductiveProj { block, idx })
+  }
+}
+
+impl Serialize for ConstructorProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.block.put(buf);
+    self.idx.put(buf);
+    self.cidx.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let block = Address::get(buf)?;
+    let idx = Nat::get(buf)?;
+    let cidx = Nat::get(buf)?;
+    Ok(ConstructorProj { block, idx, cidx })
+  }
+}
+
+impl Serialize for RecursorProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.block.put(buf);
+    self.idx.put(buf);
+    self.ridx.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let block = Address::get(buf)?;
+    let idx = Nat::get(buf)?;
+    let ridx = Nat::get(buf)?;
+    Ok(RecursorProj { block, idx, ridx })
+  }
+}
+
+impl Serialize for DefinitionProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.block.put(buf);
+    self.idx.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let block = Address::get(buf)?;
+    let idx = Nat::get(buf)?;
+    Ok(DefinitionProj { block, idx })
+  }
+}
+
+impl Serialize for Comm {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.secret.put(buf);
+    self.payload.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let secret = Address::get(buf)?;
+    let payload = Address::get(buf)?;
+    Ok(Comm { secret, payload })
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::ixon::common::tests::{gen_range, next_case};
+  use crate::ixon::expr::tests::*;
+  use crate::ixon::nat::tests::*;
+  use crate::ixon::univ::tests::*;
+  use quickcheck::{Arbitrary, Gen};
+
+  use std::ptr;
+
+  //impl Arbitrary for Expr {
+  //  fn arbitrary(g: &mut Gen) -> Self {
+  //    let ctx = gen_range(g, 0..4);
+  //    arbitrary_expr(g, ctx as u64)
+  //  }
+  //}
+
+  //#[quickcheck]
+  //fn prop_expr_readback(x: Expr) -> bool {
+  //  let mut buf = Vec::new();
+  //  Expr::put(&x, &mut buf);
+  //  match Expr::get(&mut buf.as_slice()) {
+  //    Ok(y) => x == y,
+  //    Err(e) => {
+  //      println!("err: {e}");
+  //      false
+  //    },
+  //  }
+  //}
+}
diff --git a/src/ixon/common.rs b/src/ixon/common.rs
index 4d27bb5c..c56f40de 100644
--- a/src/ixon/common.rs
+++ b/src/ixon/common.rs
@@ -1,17 +1,3 @@
-pub enum BinderInfo {
-  Default,
-  Implicit,
-  StrictImplicit,
-  InstImplicit,
-  AuxDecl,
-}
-
-pub enum ReducibilityHints {
-  Opaque,
-  Abbrev,
-  Regular,
-}
-
 #[cfg(test)]
 pub mod tests {
   use quickcheck::{Arbitrary, Gen};
diff --git a/src/ixon/constant.rs b/src/ixon/constant.rs
new file mode 100644
index 00000000..3835530d
--- /dev/null
+++ b/src/ixon/constant.rs
@@ -0,0 +1,604 @@
+use crate::ixon::address::Address;
+use crate::ixon::nat::Nat;
+use crate::ixon::serialize::Serialize;
+use crate::ixon::*;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum QuotKind {
+  Type,
+  Ctor,
+  Lift,
+  Ind,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Quotient {
+  pub lvls: Nat,
+  pub typ: Address,
+  pub kind: QuotKind,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Axiom {
+  pub lvls: Nat,
+  pub typ: Address,
+  pub is_unsafe: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DefKind {
+  Definition,
+  Opaque,
+  Theorem,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DefSafety {
+  Unsafe,
+  Safe,
+  Partial,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Definition {
+  pub lvls: Nat,
+  pub typ: Address,
+  pub mode: DefKind,
+  pub value: Address,
+  pub safety: DefSafety,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Constructor {
+  pub lvls: Nat,
+  pub typ: Address,
+  pub cidx: Nat,
+  pub params: Nat,
+  pub fields: Nat,
+  pub is_unsafe: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RecursorRule {
+  pub fields: Nat,
+  pub rhs: Address,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Recursor {
+  pub lvls: Nat,
+  pub typ: Address,
+  pub params: Nat,
+  pub indices: Nat,
+  pub motives: Nat,
+  pub minors: Nat,
+  pub rules: Vec<RecursorRule>,
+  pub k: bool,
+  pub is_unsafe: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Inductive {
+  pub lvls: Nat,
+  pub typ: Address,
+  pub params: Nat,
+  pub indices: Nat,
+  pub ctors: Vec<Constructor>,
+  pub recrs: Vec<Recursor>,
+  pub nested: Nat,
+  pub recr: bool,
+  pub refl: bool,
+  pub is_unsafe: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InductiveProj {
+  pub block: Address,
+  pub idx: Nat,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConstructorProj {
+  pub block: Address,
+  pub idx: Nat,
+  pub cidx: Nat,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RecursorProj {
+  pub block: Address,
+  pub idx: Nat,
+  pub ridx: Nat,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DefinitionProj {
+  pub block: Address,
+  pub idx: Nat,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Comm {
+  pub secret: Address,
+  pub payload: Address,
+}
+
+impl Serialize for QuotKind {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Type => buf.push(0),
+      Self::Ctor => buf.push(1),
+      Self::Lift => buf.push(2),
+      Self::Ind => buf.push(3),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Type),
+          1 => Ok(Self::Ctor),
+          2 => Ok(Self::Lift),
+          3 => Ok(Self::Ind),
+          x => Err(format!("get QuotKind invalid {x}")),
+        }
+      },
+      None => Err("get QuotKind EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for Quotient {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.kind.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    let kind = QuotKind::get(buf)?;
+    Ok(Quotient { lvls, typ, kind })
+  }
+}
+
+impl Serialize for Axiom {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.is_unsafe.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    let is_unsafe = bool::get(buf)?;
+    Ok(Axiom { lvls, typ, is_unsafe })
+  }
+}
+
+impl Serialize for DefKind {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Definition => buf.push(0),
+      Self::Opaque => buf.push(1),
+      Self::Theorem => buf.push(2),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Definition),
+          1 => Ok(Self::Opaque),
+          2 => Ok(Self::Theorem),
+          x => Err(format!("get DefKind invalid {x}")),
+        }
+      },
+      None => Err("get DefKind EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for DefSafety {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Unsafe => buf.push(0),
+      Self::Safe => buf.push(1),
+      Self::Partial => buf.push(2),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Unsafe),
+          1 => Ok(Self::Safe),
+          2 => Ok(Self::Partial),
+          x => Err(format!("get DefSafety invalid {x}")),
+        }
+      },
+      None => Err("get DefSafety EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for Definition {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.mode.put(buf);
+    self.value.put(buf);
+    self.safety.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    let mode = DefKind::get(buf)?;
+    let value = Address::get(buf)?;
+    let safety = DefSafety::get(buf)?;
+    Ok(Definition { lvls, typ, mode, value, safety })
+  }
+}
+
+impl Serialize for Constructor {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.cidx.put(buf);
+    self.params.put(buf);
+    self.fields.put(buf);
+    self.is_unsafe.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    let cidx = Nat::get(buf)?;
+    let params = Nat::get(buf)?;
+    let fields = Nat::get(buf)?;
+    let is_unsafe = bool::get(buf)?;
+    Ok(Constructor { lvls, typ, cidx, params, fields, is_unsafe })
+  }
+}
+
+impl Serialize for RecursorRule {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.fields.put(buf);
+    self.rhs.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let fields = Nat::get(buf)?;
+    let rhs = Address::get(buf)?;
+    Ok(RecursorRule { fields, rhs })
+  }
+}
+
+impl Serialize for Recursor {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.params.put(buf);
+    self.indices.put(buf);
+    self.motives.put(buf);
+    self.minors.put(buf);
+    self.rules.put(buf);
+    Ixon::pack_bools(vec![self.k, self.is_unsafe]).put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Serialize::get(buf)?;
+    let params = Nat::get(buf)?;
+    let indices = Nat::get(buf)?;
+    let motives = Nat::get(buf)?;
+    let minors = Nat::get(buf)?;
+    let rules = Serialize::get(buf)?;
+    let bools = Ixon::unpack_bools(2, u8::get(buf)?);
+    Ok(Recursor {
+      lvls,
+      typ,
+      params,
+      indices,
+      motives,
+      minors,
+      rules,
+      k: bools[0],
+      is_unsafe: bools[1],
+    })
+  }
+}
+
+impl Serialize for Inductive {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.params.put(buf);
+    self.indices.put(buf);
+    Serialize::put(&self.ctors, buf);
+    Serialize::put(&self.recrs, buf);
+    self.nested.put(buf);
+    Ixon::pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    let params = Nat::get(buf)?;
+    let indices = Nat::get(buf)?;
+    let ctors = Serialize::get(buf)?;
+    let recrs = Serialize::get(buf)?;
+    let nested = Nat::get(buf)?;
+    let bools = Ixon::unpack_bools(3, u8::get(buf)?);
+    Ok(Inductive {
+      lvls,
+      typ,
+      params,
+      indices,
+      ctors,
+      recrs,
+      nested,
+      recr: bools[0],
+      refl: bools[1],
+      is_unsafe: bools[2],
+    })
+  }
+}
+
+impl Serialize for InductiveProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.block.put(buf);
+    self.idx.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let block = Address::get(buf)?;
+    let idx = Nat::get(buf)?;
+    Ok(InductiveProj { block, idx })
+  }
+}
+
+impl Serialize for ConstructorProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.block.put(buf);
+    self.idx.put(buf);
+    self.cidx.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let block = Address::get(buf)?;
+    let idx = Nat::get(buf)?;
+    let cidx = Nat::get(buf)?;
+    Ok(ConstructorProj { block, idx, cidx })
+  }
+}
+
+impl Serialize for RecursorProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.block.put(buf);
+    self.idx.put(buf);
+    self.ridx.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let block = Address::get(buf)?;
+    let idx = Nat::get(buf)?;
+    let ridx = Nat::get(buf)?;
+    Ok(RecursorProj { block, idx, ridx })
+  }
+}
+
+impl Serialize for DefinitionProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.block.put(buf);
+    self.idx.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let block = Address::get(buf)?;
+    let idx = Nat::get(buf)?;
+    Ok(DefinitionProj { block, idx })
+  }
+}
+
+impl Serialize for Comm {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.secret.put(buf);
+    self.payload.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let secret = Address::get(buf)?;
+    let payload = Address::get(buf)?;
+    Ok(Comm { secret, payload })
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::ixon::tests::gen_range;
+  use quickcheck::{Arbitrary, Gen};
+
+  use std::ptr;
+
+  impl Arbitrary for QuotKind {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..3);
+      match x {
+        0 => Self::Type,
+        1 => Self::Ctor,
+        2 => Self::Lift,
+        _ => Self::Ind,
+      }
+    }
+  }
+
+  impl Arbitrary for Quotient {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        kind: QuotKind::arbitrary(g),
+      }
+    }
+  }
+
+  impl Arbitrary for Axiom {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        is_unsafe: bool::arbitrary(g),
+      }
+    }
+  }
+
+  impl Arbitrary for DefKind {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..2);
+      match x {
+        0 => Self::Definition,
+        1 => Self::Opaque,
+        _ => Self::Theorem,
+      }
+    }
+  }
+
+  impl Arbitrary for DefSafety {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..2);
+      match x {
+        0 => Self::Unsafe,
+        1 => Self::Safe,
+        _ => Self::Partial,
+      }
+    }
+  }
+
+  impl Arbitrary for Definition {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        mode: DefKind::arbitrary(g),
+        value: Address::arbitrary(g),
+        safety: DefSafety::arbitrary(g),
+      }
+    }
+  }
+
+  impl Arbitrary for Constructor {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        cidx: Nat::arbitrary(g),
+        params: Nat::arbitrary(g),
+        fields: Nat::arbitrary(g),
+        is_unsafe: bool::arbitrary(g),
+      }
+    }
+  }
+
+  impl Arbitrary for RecursorRule {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self { fields: Nat::arbitrary(g), rhs: Address::arbitrary(g) }
+    }
+  }
+
+  impl Arbitrary for Recursor {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..9);
+      let mut rules = vec![];
+      for _ in 0..x {
+        rules.push(RecursorRule::arbitrary(g));
+      }
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        params: Nat::arbitrary(g),
+        indices: Nat::arbitrary(g),
+        motives: Nat::arbitrary(g),
+        minors: Nat::arbitrary(g),
+        rules,
+        k: bool::arbitrary(g),
+        is_unsafe: bool::arbitrary(g),
+      }
+    }
+  }
+
+  impl Arbitrary for Inductive {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..9);
+      let y = gen_range(g, 0..9);
+      let mut ctors = vec![];
+      let mut recrs = vec![];
+      for _ in 0..x {
+        ctors.push(Constructor::arbitrary(g));
+      }
+      for _ in 0..y {
+        recrs.push(Recursor::arbitrary(g));
+      }
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        params: Nat::arbitrary(g),
+        indices: Nat::arbitrary(g),
+        ctors,
+        recrs,
+        nested: Nat::arbitrary(g),
+        recr: bool::arbitrary(g),
+        refl: bool::arbitrary(g),
+        is_unsafe: bool::arbitrary(g),
+      }
+    }
+  }
+
+  impl Arbitrary for InductiveProj {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self { block: Address::arbitrary(g), idx: Nat::arbitrary(g) }
+    }
+  }
+
+  impl Arbitrary for ConstructorProj {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        block: Address::arbitrary(g),
+        idx: Nat::arbitrary(g),
+        cidx: Nat::arbitrary(g),
+      }
+    }
+  }
+
+  impl Arbitrary for RecursorProj {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        block: Address::arbitrary(g),
+        idx: Nat::arbitrary(g),
+        ridx: Nat::arbitrary(g),
+      }
+    }
+  }
+
+  impl Arbitrary for DefinitionProj {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self { block: Address::arbitrary(g), idx: Nat::arbitrary(g) }
+    }
+  }
+
+  impl Arbitrary for Comm {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self { secret: Address::arbitrary(g), payload: Address::arbitrary(g) }
+    }
+  }
+}
diff --git a/src/ixon/expr.rs b/src/ixon/expr.rs
index f706ceae..a98ba70c 100644
--- a/src/ixon/expr.rs
+++ b/src/ixon/expr.rs
@@ -8,7 +8,6 @@ use num_bigint::BigUint;
 
 // 0xTTTT_LXXX
 #[derive(Debug, Clone, PartialEq, Eq)]
-#[repr(C)]
 pub enum Expr {
   // 0x0, ^1
   Vari(u64),
@@ -61,6 +60,31 @@ impl Expr {
       Ok(small as u64)
     }
   }
+
+  pub fn put_array<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
+    Self::put_tag(0xB, xs.len() as u64, buf);
+    for x in xs {
+      x.put(buf)
+    }
+  }
+  pub fn get_array<S: Serialize>(buf: &mut &[u8]) -> Result<Vec<S>, String> {
+    let tag_byte = u8::get(buf)?;
+    let tag = tag_byte >> 4;
+    let small_size = tag_byte & 0b111;
+    let is_large = tag_byte & 0b1000 != 0;
+    match tag {
+      0xB => {
+        let len = Self::get_tag(is_large, small_size, buf)?;
+        let mut vec = vec![];
+        for _ in 0..len {
+          let s = S::get(buf)?;
+          vec.push(s);
+        }
+        Ok(vec)
+      },
+      x => Err(format!("get array invalid tag {x}")),
+    }
+  }
 }
 
 impl Serialize for Expr {
@@ -243,7 +267,7 @@ impl Serialize for Expr {
 }
 
 #[cfg(test)]
-mod tests {
+pub mod tests {
   use super::*;
   use crate::ixon::common::tests::{gen_range, next_case};
   use crate::ixon::nat::tests::*;
diff --git a/src/ixon/meta.rs b/src/ixon/meta.rs
index 59740b53..c3f6ef72 100644
--- a/src/ixon/meta.rs
+++ b/src/ixon/meta.rs
@@ -1,9 +1,25 @@
 use crate::ixon::address::Address;
-use crate::ixon::common::{BinderInfo, ReducibilityHints};
 use crate::ixon::name::Name;
 use crate::ixon::nat::Nat;
-use std::collections::BTreeMap;
+use crate::ixon::serialize::Serialize;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BinderInfo {
+  Default,
+  Implicit,
+  StrictImplicit,
+  InstImplicit,
+  AuxDecl,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ReducibilityHints {
+  Opaque,
+  Abbrev,
+  Regular,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Metadatum {
   Name(Name),
   Info(BinderInfo),
@@ -13,6 +29,201 @@ pub enum Metadatum {
   MutCtx(Vec<Vec<Name>>),
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Metadata {
-  pub map: BTreeMap<Nat, Metadatum>,
+  pub map: Vec<(Nat, Vec<Metadatum>)>,
+}
+
+impl Serialize for BinderInfo {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Default => buf.push(0),
+      Self::Implicit => buf.push(1),
+      Self::StrictImplicit => buf.push(2),
+      Self::InstImplicit => buf.push(3),
+      Self::AuxDecl => buf.push(3),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Default),
+          1 => Ok(Self::Implicit),
+          2 => Ok(Self::StrictImplicit),
+          3 => Ok(Self::InstImplicit),
+          4 => Ok(Self::AuxDecl),
+          x => Err(format!("get BinderInfo invalid {x}")),
+        }
+      },
+      None => Err("get BinderInfo EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for ReducibilityHints {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Opaque => buf.push(0),
+      Self::Abbrev => buf.push(1),
+      Self::Regular => buf.push(2),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Opaque),
+          1 => Ok(Self::Abbrev),
+          2 => Ok(Self::Regular),
+          x => Err(format!("get ReducibilityHints invalid {x}")),
+        }
+      },
+      None => Err("get ReducibilityHints EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for Metadatum {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Name(x) => {
+        buf.push(0);
+        x.put(buf);
+      },
+      Self::Info(x) => {
+        buf.push(1);
+        x.put(buf);
+      },
+      Self::Link(x) => {
+        buf.push(2);
+        x.put(buf);
+      },
+      Self::Hints(x) => {
+        buf.push(3);
+        x.put(buf);
+      },
+      Self::All(x) => {
+        buf.push(4);
+        x.put(buf);
+      },
+      Self::MutCtx(x) => {
+        buf.push(5);
+        x.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => {
+            let x = Name::get(buf)?;
+            Ok(Self::Name(x))
+          },
+          1 => {
+            let x = BinderInfo::get(buf)?;
+            Ok(Self::Info(x))
+          },
+          2 => {
+            let x = Address::get(buf)?;
+            Ok(Self::Link(x))
+          },
+          3 => {
+            let x = ReducibilityHints::get(buf)?;
+            Ok(Self::Hints(x))
+          },
+          4 => {
+            let x = Serialize::get(buf)?;
+            Ok(Self::All(x))
+          },
+          5 => {
+            let x = Serialize::get(buf)?;
+            Ok(Self::MutCtx(x))
+          },
+          x => Err(format!("get Metadata invalid {x}")),
+        }
+      },
+      None => Err("get Metadata EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for Metadata {
+  fn put(&self, buf: &mut Vec<u8>) {
+    Serialize::put(&self.map, buf)
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    Ok(Metadata { map: Serialize::get(buf)? })
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::ixon::tests::{gen_range, gen_vec};
+  use quickcheck::{Arbitrary, Gen};
+
+  impl Arbitrary for BinderInfo {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..4);
+      match x {
+        0 => Self::Default,
+        1 => Self::Implicit,
+        2 => Self::StrictImplicit,
+        3 => Self::InstImplicit,
+        _ => Self::AuxDecl,
+      }
+    }
+  }
+
+  impl Arbitrary for ReducibilityHints {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..2);
+      match x {
+        0 => Self::Opaque,
+        1 => Self::Abbrev,
+        _ => Self::Regular,
+      }
+    }
+  }
+
+  impl Arbitrary for Metadatum {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..5);
+      match x {
+        0 => Self::Name(Name::arbitrary(g)),
+        1 => Self::Info(BinderInfo::arbitrary(g)),
+        2 => Self::Link(Address::arbitrary(g)),
+        3 => Self::Hints(ReducibilityHints::arbitrary(g)),
+        4 => Self::All(gen_vec(g, 9, Arbitrary::arbitrary)),
+        _ => {
+          let x = gen_range(g, 0..9);
+          let mut res = vec![];
+          for _ in 0..x {
+            res.push(gen_vec(g, 9, Arbitrary::arbitrary))
+          }
+          Self::MutCtx(res)
+        },
+      }
+    }
+  }
+
+  impl Arbitrary for Metadata {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..9);
+      let mut map = Vec::new();
+      for _ in 0..x {
+        map.push((Nat::arbitrary(g), gen_vec(g, 9, Metadatum::arbitrary)));
+      }
+      Metadata { map }
+    }
+  }
 }
diff --git a/src/ixon/name.rs b/src/ixon/name.rs
index 9e9b6450..82768729 100644
--- a/src/ixon/name.rs
+++ b/src/ixon/name.rs
@@ -1,10 +1,68 @@
 use crate::ixon::nat::Nat;
+use crate::ixon::serialize::Serialize;
+use crate::ixon::*;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum NamePart {
   Str(String),
   Num(Nat),
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Name {
   pub parts: Vec<NamePart>,
 }
+
+impl Serialize for NamePart {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      // TODO: do we need to clone here?
+      Self::Str(x) => Ixon::Strl(x.clone()).put(buf),
+      Self::Num(x) => Ixon::Natl(x.clone()).put(buf),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match Ixon::get(buf)? {
+      Ixon::Strl(x) => Ok(Self::Str(x)),
+      Ixon::Natl(x) => Ok(Self::Num(x)),
+      x => Err(format!("get NamePart invalid {x:?}")),
+    }
+  }
+}
+
+impl Serialize for Name {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.parts.put(buf)
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    Ok(Name { parts: Serialize::get(buf)? })
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::ixon::nat::tests::arbitrary_nat;
+  use crate::ixon::tests::{arbitrary_string, gen_range, gen_vec};
+  use quickcheck::{Arbitrary, Gen};
+
+  impl Arbitrary for NamePart {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..1);
+      let len = gen_range(g, 0..9);
+      match x {
+        0 => Self::Str(arbitrary_string(g, len)),
+        _ => Self::Num(arbitrary_nat(g, len)),
+      }
+    }
+  }
+
+  impl Arbitrary for Name {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let parts = gen_vec(g, 9, NamePart::arbitrary);
+      Name { parts }
+    }
+  }
+}
diff --git a/src/ixon/nat.rs b/src/ixon/nat.rs
index 4e53bab2..86607447 100644
--- a/src/ixon/nat.rs
+++ b/src/ixon/nat.rs
@@ -1,14 +1,29 @@
+use crate::ixon::serialize::Serialize;
+use crate::ixon::*;
 use num_bigint::BigUint;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Nat(pub BigUint);
 
-//impl Nat {}
+impl Nat {}
+
+impl Serialize for Nat {
+  fn put(&self, buf: &mut Vec<u8>) {
+    Ixon::Natl(self.clone()).put(buf)
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match Ixon::get(buf) {
+      Ok(Ixon::Natl(x)) => Ok(x),
+      Ok(x) => Err(format!("get Nat invalid {x:?}")),
+      Err(e) => Err(e),
+    }
+  }
+}
 
 #[cfg(test)]
 pub mod tests {
   use super::*;
-  use crate::ixon::common::tests::gen_range;
+  use crate::ixon::tests::gen_range;
   use quickcheck::{Arbitrary, Gen};
 
   pub fn arbitrary_nat(g: &mut Gen, size: usize) -> Nat {
diff --git a/src/ixon/serialize.rs b/src/ixon/serialize.rs
index 73a86a98..fa4052dc 100644
--- a/src/ixon/serialize.rs
+++ b/src/ixon/serialize.rs
@@ -1,3 +1,5 @@
+use crate::ixon::*;
+
 pub trait Serialize: Sized {
   fn put(&self, buf: &mut Vec<u8>);
   fn get(buf: &mut &[u8]) -> Result<Self, String>;
@@ -73,108 +75,44 @@ impl Serialize for u64 {
 impl Serialize for bool {
   fn put(&self, buf: &mut Vec<u8>) {
     match self {
-      false => Serialize::put(&0u8, buf),
-      true => Serialize::put(&1u8, buf),
+      false => buf.push(0),
+      true => buf.push(1),
     }
   }
   fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match <u8 as Serialize>::get(buf) {
-      Ok(0u8) => Ok(false),
-      Ok(1u8) => Ok(true),
-      Ok(x) => Err(format!("get bool invalid {x}")),
-      Err(e) => Err(e),
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(false),
+          1 => Ok(true),
+          x => Err(format!("get bool invalid {x}")),
+        }
+      },
+      None => Err("get bool EOF".to_string()),
     }
   }
 }
 
-pub fn u64_byte_count(x: u64) -> u8 {
-  match x {
-    0 => 0,
-    x if x < 0x0000000000000100 => 1,
-    x if x < 0x0000000000010000 => 2,
-    x if x < 0x0000000001000000 => 3,
-    x if x < 0x0000000100000000 => 4,
-    x if x < 0x0000010000000000 => 5,
-    x if x < 0x0001000000000000 => 6,
-    x if x < 0x0100000000000000 => 7,
-    _ => 8,
+impl<S: Serialize> Serialize for Vec<S> {
+  fn put(&self, buf: &mut Vec<u8>) {
+    Ixon::put_array(self, buf)
   }
-}
-
-pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
-  let n = u64_byte_count(x) as usize;
-  buf.extend_from_slice(&x.to_le_bytes()[..n])
-}
 
-pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
-  let mut res = [0u8; 8];
-  if len > 8 {
-    return Err("get trimmed_le_64 len > 8".to_string());
-  }
-  match buf.split_at_checked(len) {
-    Some((head, rest)) => {
-      *buf = rest;
-      res[..len].copy_from_slice(head);
-      Ok(u64::from_le_bytes(res))
-    },
-    None => Err("get trimmed_le_u64 EOF".to_string()),
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    Ixon::get_array(buf)
   }
 }
 
-#[cfg(test)]
-mod tests {
-  use super::*;
-  use quickcheck::{Arbitrary, Gen};
-
-  #[test]
-  fn unit_u64_trimmed() {
-    fn test(input: u64, expected: Vec<u8>) -> bool {
-      let mut tmp = Vec::new();
-      let n = u64_byte_count(input);
-      u64_put_trimmed_le(input, &mut tmp);
-      if tmp != expected {
-        return false;
-      }
-      match u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
-        Ok(out) => input == out,
-        Err(e) => {
-          println!("err: {e}");
-          false
-        },
-      }
-    }
-    assert!(test(0x0, vec![]));
-    assert!(test(0x01, vec![0x01]));
-    assert!(test(0x0000000000000100, vec![0x00, 0x01]));
-    assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
-    assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000010000000000, vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]));
-    assert!(test(
-      0x0001000000000000,
-      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-    ));
-    assert!(test(
-      0x0100000000000000,
-      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-    ));
-    assert!(test(
-      0x0102030405060708,
-      vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
-    ));
+impl<X: Serialize, Y: Serialize> Serialize for (X, Y) {
+  fn put(&self, buf: &mut Vec<u8>) {
+    Serialize::put(&self.0, buf);
+    Serialize::put(&self.1, buf);
   }
 
-  #[quickcheck]
-  fn prop_u64_trimmed_le_readback(x: u64) -> bool {
-    let mut buf = Vec::new();
-    let n = u64_byte_count(x);
-    u64_put_trimmed_le(x, &mut buf);
-    match u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
-      Ok(y) => x == y,
-      Err(e) => {
-        println!("err: {e}");
-        false
-      },
-    }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let x = Serialize::get(buf)?;
+    let y = Serialize::get(buf)?;
+    Ok((x, y))
   }
 }
diff --git a/src/ixon/univ.rs b/src/ixon/univ.rs
index 69b2bb79..1434f5d5 100644
--- a/src/ixon/univ.rs
+++ b/src/ixon/univ.rs
@@ -1,20 +1,19 @@
-use crate::ixon::serialize::{
-  u64_byte_count, u64_get_trimmed_le, u64_put_trimmed_le, Serialize,
-};
+use crate::ixon::serialize::Serialize;
+use crate::ixon::Ixon;
 
-// 0xTTTL_XXXX
+// 0xTTLX_XXXX
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[repr(C)]
 pub enum Univ {
-  // 0x0, 1
+  // 0x0X, 1
   Const(u64),
   // 0x1, ^1
   Var(u64),
   // 0x2, (+ x y)
   Add(u64, Box<Univ>),
-  // 0x3, (max x y)
+  // 0x3, size=0 (max x y)
   Max(Box<Univ>, Box<Univ>),
-  // 0x4, (imax x y)
+  // 0x3, size=1 (imax x y)
   IMax(Box<Univ>, Box<Univ>),
 }
 
@@ -26,11 +25,11 @@ impl Default for Univ {
 
 impl Univ {
   fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
-    if val < 16 {
-      buf.push((tag << 5) | (val as u8));
+    if val < 32 {
+      buf.push((tag << 6) | (val as u8));
     } else {
-      buf.push((tag << 5) | 0b1_0000 | (u64_byte_count(val) - 1));
-      u64_put_trimmed_le(val, buf);
+      buf.push((tag << 6) | 0b10_0000 | (Ixon::u64_byte_count(val) - 1));
+      Ixon::u64_put_trimmed_le(val, buf);
     }
   }
 
@@ -40,7 +39,7 @@ impl Univ {
     buf: &mut &[u8],
   ) -> Result<u64, String> {
     if is_large {
-      u64_get_trimmed_le((small + 1) as usize, buf)
+      Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
     } else {
       Ok(small as u64)
     }
@@ -62,7 +61,7 @@ impl Serialize for Univ {
         y.put(buf);
       },
       Self::IMax(x, y) => {
-        Univ::put_tag(0x4, 0, buf);
+        Univ::put_tag(0x3, 1, buf);
         x.put(buf);
         y.put(buf);
       },
@@ -71,9 +70,9 @@ impl Serialize for Univ {
 
   fn get(buf: &mut &[u8]) -> Result<Self, String> {
     let tag_byte = u8::get(buf)?;
-    let tag = tag_byte >> 5;
-    let small_size = tag_byte & 0b1111;
-    let is_large = tag_byte & 0b10000 != 0;
+    let tag = tag_byte >> 6;
+    let is_large = tag_byte & 0b10_0000 != 0;
+    let small_size = tag_byte & 0b1_1111;
     match tag {
       0x0 => {
         let x = Univ::get_tag(is_large, small_size, buf)?;
@@ -91,12 +90,11 @@ impl Serialize for Univ {
       0x3 => {
         let x = Univ::get(buf)?;
         let y = Univ::get(buf)?;
-        Ok(Self::Max(Box::new(x), Box::new(y)))
-      },
-      0x4 => {
-        let x = Univ::get(buf)?;
-        let y = Univ::get(buf)?;
-        Ok(Self::IMax(Box::new(x), Box::new(y)))
+        if small_size == 0 {
+          Ok(Self::Max(Box::new(x), Box::new(y)))
+        } else {
+          Ok(Self::IMax(Box::new(x), Box::new(y)))
+        }
       },
       x => Err(format!("get Univ invalid tag {x}")),
     }
@@ -106,7 +104,7 @@ impl Serialize for Univ {
 #[cfg(test)]
 pub mod tests {
   use super::*;
-  use crate::ixon::common::tests::{gen_range, next_case};
+  use crate::ixon::tests::{gen_range, next_case};
   use quickcheck::{Arbitrary, Gen};
 
   use std::ptr;

From a5ad9ea04028a4a70ea4a5c2ec79ece81aba4356 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 15 Aug 2025 17:24:32 -0400
Subject: [PATCH 36/74] remove old files

---
 src/ixon/cnst.rs | 611 -----------------------------------------------
 src/ixon/expr.rs | 474 ------------------------------------
 2 files changed, 1085 deletions(-)
 delete mode 100644 src/ixon/cnst.rs
 delete mode 100644 src/ixon/expr.rs

diff --git a/src/ixon/cnst.rs b/src/ixon/cnst.rs
deleted file mode 100644
index ec18735a..00000000
--- a/src/ixon/cnst.rs
+++ /dev/null
@@ -1,611 +0,0 @@
-use crate::ixon::address::Address;
-use crate::ixon::claim::{Claim, Claims, Proof};
-use crate::ixon::expr::Expr;
-use crate::ixon::meta::Metadata;
-use crate::ixon::nat::Nat;
-use crate::ixon::serialize::{pack_bools, unpack_bools, Serialize};
-
-pub enum QuotKind {
-  Type,
-  Ctor,
-  Lift,
-  Ind,
-}
-
-pub struct Quotient {
-  pub lvls: Nat,
-  pub typ: Box<Expr>,
-  pub kind: QuotKind,
-}
-
-pub struct Axiom {
-  pub lvls: Nat,
-  pub typ: Box<Expr>,
-  pub is_unsafe: bool,
-}
-
-pub enum DefKind {
-  Definition,
-  Opaque,
-  Theorem,
-}
-
-pub enum DefSafety {
-  Unsafe,
-  Safe,
-  Partial,
-}
-
-pub struct Definition {
-  pub lvls: Nat,
-  pub typ: Box<Expr>,
-  pub mode: DefKind,
-  pub value: Box<Expr>,
-  pub safety: DefSafety,
-}
-
-pub struct Constructor {
-  pub lvls: Nat,
-  pub typ: Box<Expr>,
-  pub cidx: Nat,
-  pub params: Nat,
-  pub fields: Nat,
-  pub is_unsafe: bool,
-}
-
-pub struct RecursorRule {
-  pub fields: Nat,
-  pub rhs: Box<Expr>,
-}
-
-pub struct Recursor {
-  pub lvls: Nat,
-  pub typ: Box<Expr>,
-  pub params: Nat,
-  pub indices: Nat,
-  pub motives: Nat,
-  pub minors: Nat,
-  pub rules: Vec<RecursorRule>,
-  pub k: bool,
-  pub is_unsafe: bool,
-}
-
-pub struct Inductive {
-  pub lvls: Nat,
-  pub typ: Box<Expr>,
-  pub params: Nat,
-  pub indices: Nat,
-  pub ctors: Vec<Constructor>,
-  pub recrs: Vec<Recursor>,
-  pub nested: Nat,
-  pub recr: bool,
-  pub refl: bool,
-  pub is_unsafe: bool,
-}
-
-pub struct InductiveProj {
-  pub block: Address,
-  pub idx: Nat,
-}
-
-pub struct ConstructorProj {
-  pub block: Address,
-  pub idx: Nat,
-  pub cidx: Nat,
-}
-
-pub struct RecursorProj {
-  pub block: Address,
-  pub idx: Nat,
-  pub ridx: Nat,
-}
-
-pub struct DefinitionProj {
-  pub block: Address,
-  pub idx: Nat,
-}
-
-pub struct Comm {
-  pub secret: Address,
-  pub payload: Address,
-}
-
-pub enum Const {
-  // 0xC0
-  Defn(Definition),
-  // 0xC1
-  Axio(Axiom),
-  // 0xC2
-  Quot(Quotient),
-  // 0xC3
-  CtorProj(ConstructorProj),
-  // 0xC4
-  RecrProj(RecursorProj),
-  // 0xC5
-  IndcProj(InductiveProj),
-  // 0xC6
-  DefnProj(DefinitionProj),
-  // 0xC7
-  MutDef(Vec<Definition>),
-  // 0xC8
-  MutInd(Vec<Inductive>),
-  // 0xC9
-  Meta(Metadata),
-  // 0xCA
-  Proof(Proof),
-  // 0xCB
-  Claim(Claim),
-  // 0xCC
-  Comm(Comm),
-  // 0xCD
-  Env(Claims),
-}
-
-pub enum Ixon {
-  // Expressions
-  EVar(u64),                              // 0x0X
-  ERef(Address, Vec<Ixon>),               // 0x1X
-  ERec(u64, Vec<Ixon>),                   // 0x2X
-  EApp(Box<Ixon>, Box<Ixon>, Vec<Ixon>),  // 0x3X
-  ELam(Vec<Ixon>, Box<Ixon>),             // 0x4X
-  EAll(Vec<Ixon>, Box<Ixon>),             // 0x5X
-  EPrj(Address, u64, Box<Ixon>),          // 0x6X
-  EStr(String),                           // 0x7X
-  ENat(Nat),                              // 0x8X
-  ELet(Box<Ixon>, Box<Ixon>, Box<Ixon>),  // 0xE0
-  ELetD(Box<Ixon>, Box<Ixon>, Box<Ixon>), // 0xE1
-  // Arrays
-  Array(Vec<Ixon>), //0xA
-  // Constants
-  Defn(Definition),          // 0xC0
-  Axio(Axiom),               // 0xC1
-  Quot(Quotient),            // 0xC2
-  CtorProj(ConstructorProj), // 0xC3
-  RecrProj(RecursorProj),    // 0xC4
-  IndcProj(InductiveProj),   // 0xC5
-  DefnProj(DefinitionProj),  // 0xC6
-  MutDef(Vec<Definition>),   // 0xC7
-  MutInd(Vec<Inductive>),    // 0xC8
-  Meta(Metadata),            // 0xC9
-  Proof(Proof),              // 0xCA
-  Claim(Claim),              // 0xCB
-  Comm(Comm),                // 0xCC
-  Env(Claims),               // 0xCD
-  // Universes
-  UVar(u64),                   // 0x9X
-  UConst(u64),                 // 0xBX
-  UAdd(u64, Box<Ixon>),        // 0xDX
-  UMax(Box<Ixon>, Box<Ixon>),  // 0xE2
-  UIMax(Box<Ixon>, Box<Ixon>), // 0xE3
-}
-
-impl Const {}
-
-impl Serialize for Const {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Defn(x) => {
-        u8::put(&0xC0, buf);
-        x.put(buf);
-      },
-      Self::Axio(x) => {
-        u8::put(&0xC1, buf);
-        x.put(buf);
-      },
-      Self::Quot(x) => {
-        u8::put(&0xC2, buf);
-        x.put(buf);
-      },
-      Self::CtorProj(x) => {
-        u8::put(&0xC3, buf);
-        x.put(buf);
-      },
-      Self::RecrProj(x) => {
-        u8::put(&0xC4, buf);
-        x.put(buf);
-      },
-      Self::IndcProj(x) => {
-        u8::put(&0xC5, buf);
-        x.put(buf);
-      },
-      Self::DefnProj(x) => {
-        u8::put(&0xC6, buf);
-        x.put(buf);
-      },
-      Self::MutDef(x) => {
-        u8::put(&0xC7, buf);
-        Expr::put_array(x, buf);
-      },
-      Self::MutInd(x) => {
-        u8::put(&0xC8, buf);
-        Expr::put_array(x, buf);
-      },
-      Self::Meta(x) => {
-        u8::put(&0xC9, buf);
-        x.put(buf);
-      },
-      Self::Proof(x) => {
-        u8::put(&0xCA, buf);
-        x.put(buf);
-      },
-      Self::Claim(x) => {
-        u8::put(&0xCB, buf);
-        x.put(buf);
-      },
-      Self::Comm(x) => {
-        u8::put(&0xCC, buf);
-        x.put(buf);
-      },
-      Self::Env(x) => {
-        u8::put(&0xCD, buf);
-        x.put(buf);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let tag = u8::get(buf)?;
-    match tag {
-      0xC0 => Ok(Self::Defn(Definition::get(buf)?)),
-      0xC1 => Ok(Self::Axio(Axiom::get(buf)?)),
-      0xC2 => Ok(Self::Quot(Quotient::get(buf)?)),
-      0xC3 => Ok(Self::CtorProj(ConstructorProj::get(buf)?)),
-      0xC4 => Ok(Self::RecrProj(RecursorProj::get(buf)?)),
-      0xC5 => Ok(Self::IndcProj(InductiveProj::get(buf)?)),
-      0xC6 => Ok(Self::DefnProj(DefinitionProj::get(buf)?)),
-      0xC7 => Ok(Self::MutDef(Expr::get_array(buf)?)),
-      0xC8 => Ok(Self::MutInd(Expr::get_array(buf)?)),
-      0xC9 => Ok(Self::Meta(Metadata::get(buf)?)),
-      0xCA => Ok(Self::Proof(Proof::get(buf)?)),
-      0xCB => Ok(Self::Claim(Claim::get(buf)?)),
-      0xCC => Ok(Self::Comm(Comm::get(buf)?)),
-      0xCD => Ok(Self::Env(Claims::get(buf)?)),
-      x => Err(format!("get Expr invalid tag {x}")),
-    }
-  }
-}
-
-impl Serialize for QuotKind {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Type => buf.push(0),
-      Self::Ctor => buf.push(1),
-      Self::Lift => buf.push(2),
-      Self::Ind => buf.push(3),
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Type),
-          1 => Ok(Self::Ctor),
-          2 => Ok(Self::Lift),
-          3 => Ok(Self::Ind),
-          x => Err(format!("get QuotKind invalid {x}")),
-        }
-      },
-      None => Err("get QuotKind EOF".to_string()),
-    }
-  }
-}
-
-impl Serialize for Quotient {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.kind.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Expr::get(buf)?;
-    let kind = QuotKind::get(buf)?;
-    Ok(Quotient { lvls, typ: Box::new(typ), kind })
-  }
-}
-
-impl Serialize for Axiom {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.is_unsafe.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Expr::get(buf)?;
-    let is_unsafe = bool::get(buf)?;
-    Ok(Axiom { lvls, typ: Box::new(typ), is_unsafe })
-  }
-}
-
-impl Serialize for DefKind {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Definition => buf.push(0),
-      Self::Opaque => buf.push(1),
-      Self::Theorem => buf.push(2),
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Definition),
-          1 => Ok(Self::Opaque),
-          2 => Ok(Self::Theorem),
-          x => Err(format!("get DefKind invalid {x}")),
-        }
-      },
-      None => Err("get DefKind EOF".to_string()),
-    }
-  }
-}
-
-impl Serialize for DefSafety {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Unsafe => buf.push(0),
-      Self::Safe => buf.push(1),
-      Self::Partial => buf.push(2),
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Unsafe),
-          1 => Ok(Self::Safe),
-          2 => Ok(Self::Partial),
-          x => Err(format!("get DefSafety invalid {x}")),
-        }
-      },
-      None => Err("get DefSafety EOF".to_string()),
-    }
-  }
-}
-
-impl Serialize for Definition {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.mode.put(buf);
-    self.value.put(buf);
-    self.safety.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Expr::get(buf)?;
-    let mode = DefKind::get(buf)?;
-    let value = Expr::get(buf)?;
-    let safety = DefSafety::get(buf)?;
-    Ok(Definition {
-      lvls,
-      typ: Box::new(typ),
-      mode,
-      value: Box::new(value),
-      safety,
-    })
-  }
-}
-
-impl Serialize for Constructor {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.cidx.put(buf);
-    self.params.put(buf);
-    self.fields.put(buf);
-    self.is_unsafe.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Expr::get(buf)?;
-    let cidx = Nat::get(buf)?;
-    let params = Nat::get(buf)?;
-    let fields = Nat::get(buf)?;
-    let is_unsafe = bool::get(buf)?;
-    Ok(Constructor {
-      lvls,
-      typ: Box::new(typ),
-      cidx,
-      params,
-      fields,
-      is_unsafe,
-    })
-  }
-}
-
-impl Serialize for RecursorRule {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.fields.put(buf);
-    self.rhs.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let fields = Nat::get(buf)?;
-    let rhs = Expr::get(buf)?;
-    Ok(RecursorRule { fields, rhs: Box::new(rhs) })
-  }
-}
-
-impl Serialize for Recursor {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.params.put(buf);
-    self.indices.put(buf);
-    self.motives.put(buf);
-    self.minors.put(buf);
-    Expr::put_array(&self.rules, buf);
-    pack_bools(vec![self.k, self.is_unsafe]).put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Expr::get(buf)?;
-    let params = Nat::get(buf)?;
-    let indices = Nat::get(buf)?;
-    let motives = Nat::get(buf)?;
-    let minors = Nat::get(buf)?;
-    let rules = Expr::get_array(buf)?;
-    let bools = unpack_bools(2, u8::get(buf)?);
-    Ok(Recursor {
-      lvls,
-      typ: Box::new(typ),
-      params,
-      indices,
-      motives,
-      minors,
-      rules,
-      k: bools[0],
-      is_unsafe: bools[1],
-    })
-  }
-}
-
-impl Serialize for Inductive {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.params.put(buf);
-    self.indices.put(buf);
-    Expr::put_array(&self.ctors, buf);
-    Expr::put_array(&self.recrs, buf);
-    self.nested.put(buf);
-    pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Expr::get(buf)?;
-    let params = Nat::get(buf)?;
-    let indices = Nat::get(buf)?;
-    let ctors = Expr::get_array(buf)?;
-    let recrs = Expr::get_array(buf)?;
-    let nested = Nat::get(buf)?;
-    let bools = unpack_bools(3, u8::get(buf)?);
-    Ok(Inductive {
-      lvls,
-      typ: Box::new(typ),
-      params,
-      indices,
-      ctors,
-      recrs,
-      nested,
-      recr: bools[0],
-      refl: bools[1],
-      is_unsafe: bools[2],
-    })
-  }
-}
-
-impl Serialize for InductiveProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.block.put(buf);
-    self.idx.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let block = Address::get(buf)?;
-    let idx = Nat::get(buf)?;
-    Ok(InductiveProj { block, idx })
-  }
-}
-
-impl Serialize for ConstructorProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.block.put(buf);
-    self.idx.put(buf);
-    self.cidx.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let block = Address::get(buf)?;
-    let idx = Nat::get(buf)?;
-    let cidx = Nat::get(buf)?;
-    Ok(ConstructorProj { block, idx, cidx })
-  }
-}
-
-impl Serialize for RecursorProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.block.put(buf);
-    self.idx.put(buf);
-    self.ridx.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let block = Address::get(buf)?;
-    let idx = Nat::get(buf)?;
-    let ridx = Nat::get(buf)?;
-    Ok(RecursorProj { block, idx, ridx })
-  }
-}
-
-impl Serialize for DefinitionProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.block.put(buf);
-    self.idx.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let block = Address::get(buf)?;
-    let idx = Nat::get(buf)?;
-    Ok(DefinitionProj { block, idx })
-  }
-}
-
-impl Serialize for Comm {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.secret.put(buf);
-    self.payload.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let secret = Address::get(buf)?;
-    let payload = Address::get(buf)?;
-    Ok(Comm { secret, payload })
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-  use crate::ixon::common::tests::{gen_range, next_case};
-  use crate::ixon::expr::tests::*;
-  use crate::ixon::nat::tests::*;
-  use crate::ixon::univ::tests::*;
-  use quickcheck::{Arbitrary, Gen};
-
-  use std::ptr;
-
-  //impl Arbitrary for Expr {
-  //  fn arbitrary(g: &mut Gen) -> Self {
-  //    let ctx = gen_range(g, 0..4);
-  //    arbitrary_expr(g, ctx as u64)
-  //  }
-  //}
-
-  //#[quickcheck]
-  //fn prop_expr_readback(x: Expr) -> bool {
-  //  let mut buf = Vec::new();
-  //  Expr::put(&x, &mut buf);
-  //  match Expr::get(&mut buf.as_slice()) {
-  //    Ok(y) => x == y,
-  //    Err(e) => {
-  //      println!("err: {e}");
-  //      false
-  //    },
-  //  }
-  //}
-}
diff --git a/src/ixon/expr.rs b/src/ixon/expr.rs
deleted file mode 100644
index a98ba70c..00000000
--- a/src/ixon/expr.rs
+++ /dev/null
@@ -1,474 +0,0 @@
-use crate::ixon::address::Address;
-use crate::ixon::nat::Nat;
-use crate::ixon::serialize::{
-  u64_byte_count, u64_get_trimmed_le, u64_put_trimmed_le, Serialize,
-};
-use crate::ixon::univ::Univ;
-use num_bigint::BigUint;
-
-// 0xTTTT_LXXX
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Expr {
-  // 0x0, ^1
-  Vari(u64),
-  // 0x1, {max (add 1 2) (var 1)}
-  Sort(Box<Univ>),
-  // 0x2 #dead_beef_cafe_babe {u1, u2, ... }
-  Refr(Address, Vec<Univ>),
-  // 0x3 #1.{u1, u2, u3}
-  Recr(u64, Vec<Univ>),
-  // 0x4 (f x y z)
-  Apps(Box<Expr>, Box<Expr>, Vec<Expr>),
-  // 0x5 (λ A B C => body)
-  Lams(Vec<Expr>, Box<Expr>),
-  // 0x6 (∀ A B C -> body)
-  Alls(Vec<Expr>, Box<Expr>),
-  // 0x7 (let d : A in b)
-  Let(bool, Box<Expr>, Box<Expr>, Box<Expr>),
-  // 0x8 .1
-  Proj(Address, u64, Box<Expr>),
-  // 0x9 "foobar"
-  Strl(String),
-  // 0xA 0xdead_beef
-  Natl(Nat),
-}
-
-impl Default for Expr {
-  fn default() -> Self {
-    Self::Vari(0)
-  }
-}
-
-impl Expr {
-  fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
-    if val < 8 {
-      buf.push((tag << 4) | (val as u8));
-    } else {
-      buf.push((tag << 4) | 0b1000 | (u64_byte_count(val) - 1));
-      u64_put_trimmed_le(val, buf);
-    }
-  }
-
-  fn get_tag(
-    is_large: bool,
-    small: u8,
-    buf: &mut &[u8],
-  ) -> Result<u64, String> {
-    if is_large {
-      u64_get_trimmed_le((small + 1) as usize, buf)
-    } else {
-      Ok(small as u64)
-    }
-  }
-
-  pub fn put_array<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
-    Self::put_tag(0xB, xs.len() as u64, buf);
-    for x in xs {
-      x.put(buf)
-    }
-  }
-  pub fn get_array<S: Serialize>(buf: &mut &[u8]) -> Result<Vec<S>, String> {
-    let tag_byte = u8::get(buf)?;
-    let tag = tag_byte >> 4;
-    let small_size = tag_byte & 0b111;
-    let is_large = tag_byte & 0b1000 != 0;
-    match tag {
-      0xB => {
-        let len = Self::get_tag(is_large, small_size, buf)?;
-        let mut vec = vec![];
-        for _ in 0..len {
-          let s = S::get(buf)?;
-          vec.push(s);
-        }
-        Ok(vec)
-      },
-      x => Err(format!("get array invalid tag {x}")),
-    }
-  }
-}
-
-impl Serialize for Expr {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Vari(x) => Self::put_tag(0x0, *x, buf),
-      Self::Sort(x) => {
-        Self::put_tag(0x1, 0, buf);
-        x.put(buf);
-      },
-      Self::Refr(addr, lvls) => {
-        Self::put_tag(0x2, lvls.len() as u64, buf);
-        addr.put(buf);
-        for l in lvls {
-          l.put(buf);
-        }
-      },
-      Self::Recr(x, lvls) => {
-        Self::put_tag(0x3, lvls.len() as u64, buf);
-        x.put(buf);
-        for l in lvls {
-          l.put(buf);
-        }
-      },
-      Self::Apps(f, a, args) => {
-        Self::put_tag(0x4, args.len() as u64, buf);
-        f.put(buf);
-        a.put(buf);
-        for x in args {
-          x.put(buf);
-        }
-      },
-      Self::Lams(ts, b) => {
-        Self::put_tag(0x5, ts.len() as u64, buf);
-        for t in ts {
-          t.put(buf);
-        }
-        b.put(buf);
-      },
-      Self::Alls(ts, b) => {
-        Self::put_tag(0x6, ts.len() as u64, buf);
-        for t in ts {
-          t.put(buf);
-        }
-        b.put(buf);
-      },
-      Self::Let(nd, t, d, b) => {
-        if *nd {
-          Self::put_tag(0x7, 1, buf);
-        } else {
-          Self::put_tag(0x7, 0, buf);
-        }
-        t.put(buf);
-        d.put(buf);
-        b.put(buf);
-      },
-      Self::Proj(t, n, x) => {
-        Self::put_tag(0x8, *n, buf);
-        t.put(buf);
-        x.put(buf);
-      },
-      Self::Strl(s) => {
-        let bytes = s.as_bytes();
-        Self::put_tag(0x9, bytes.len() as u64, buf);
-        buf.extend_from_slice(bytes);
-      },
-      Self::Natl(n) => {
-        let bytes = n.0.to_bytes_le();
-        Self::put_tag(0xA, bytes.len() as u64, buf);
-        buf.extend_from_slice(&bytes);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let tag_byte = u8::get(buf)?;
-    let tag = tag_byte >> 4;
-    let small_size = tag_byte & 0b111;
-    let is_large = tag_byte & 0b1000 != 0;
-    match tag {
-      0x0 => {
-        let x = Expr::get_tag(is_large, small_size, buf)?;
-        Ok(Self::Vari(x))
-      },
-      0x1 => {
-        let u = Univ::get(buf)?;
-        Ok(Self::Sort(Box::new(u)))
-      },
-      0x2 => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        let a = Address::get(buf)?;
-        let mut lvls = Vec::new();
-        for _ in 0..n {
-          let l = Univ::get(buf)?;
-          lvls.push(l);
-        }
-        Ok(Self::Refr(a, lvls))
-      },
-      0x3 => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        let x = u64::get(buf)?;
-        let mut lvls = Vec::new();
-        for _ in 0..n {
-          let l = Univ::get(buf)?;
-          lvls.push(l);
-        }
-        Ok(Self::Recr(x, lvls))
-      },
-      0x4 => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        let f = Expr::get(buf)?;
-        let a = Expr::get(buf)?;
-        let mut args = Vec::new();
-        for _ in 0..n {
-          let x = Expr::get(buf)?;
-          args.push(x);
-        }
-        Ok(Self::Apps(Box::new(f), Box::new(a), args))
-      },
-      0x5 => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        let mut ts = Vec::new();
-        for _ in 0..n {
-          let x = Expr::get(buf)?;
-          ts.push(x);
-        }
-        let b = Expr::get(buf)?;
-        Ok(Self::Lams(ts, Box::new(b)))
-      },
-      0x6 => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        let mut ts = Vec::new();
-        for _ in 0..n {
-          let x = Expr::get(buf)?;
-          ts.push(x);
-        }
-        let b = Expr::get(buf)?;
-        Ok(Self::Alls(ts, Box::new(b)))
-      },
-      0x7 => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        let nd = n == 1;
-        let t = Expr::get(buf)?;
-        let d = Expr::get(buf)?;
-        let b = Expr::get(buf)?;
-        Ok(Self::Let(nd, Box::new(t), Box::new(d), Box::new(b)))
-      },
-      0x8 => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        let t = Address::get(buf)?;
-        let x = Expr::get(buf)?;
-        Ok(Self::Proj(t, n, Box::new(x)))
-      },
-      0x9 => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        match buf.split_at_checked(n as usize) {
-          Some((head, rest)) => {
-            *buf = rest;
-            match String::from_utf8(head.to_owned()) {
-              Ok(s) => Ok(Expr::Strl(s)),
-              Err(e) => Err(format!("UTF8 Error: {e}")),
-            }
-          },
-          None => Err("get Expr Strl EOF".to_string()),
-        }
-      },
-      0xA => {
-        let n = Expr::get_tag(is_large, small_size, buf)?;
-        match buf.split_at_checked(n as usize) {
-          Some((head, rest)) => {
-            *buf = rest;
-            Ok(Expr::Natl(Nat(BigUint::from_bytes_le(head))))
-          },
-          None => Err("get Expr Natl EOF".to_string()),
-        }
-      },
-      x => Err(format!("get Expr invalid tag {x}")),
-    }
-  }
-}
-
-#[cfg(test)]
-pub mod tests {
-  use super::*;
-  use crate::ixon::common::tests::{gen_range, next_case};
-  use crate::ixon::nat::tests::*;
-  use crate::ixon::univ::tests::*;
-  use quickcheck::{Arbitrary, Gen};
-
-  use std::ptr;
-
-  #[derive(Debug, Clone, Copy)]
-  pub enum ExprCase {
-    Vari,
-    Sort,
-    Refr,
-    Recr,
-    Apps,
-    Lams,
-    Alls,
-    Let,
-    Proj,
-    Strl,
-    Natl,
-  }
-
-  // incremental tree generation without recursion stack overflows
-  pub fn arbitrary_expr(g: &mut Gen, ctx: u64) -> Expr {
-    let mut root = Expr::default();
-    let mut stack = vec![&mut root as *mut Expr];
-
-    while let Some(ptr) = stack.pop() {
-      let gens: Vec<(usize, ExprCase)> = vec![
-        (100, ExprCase::Vari),
-        (100, ExprCase::Sort),
-        (75, ExprCase::Refr),
-        (50, ExprCase::Recr),
-        (25, ExprCase::Apps),
-        (25, ExprCase::Lams),
-        (50, ExprCase::Alls),
-        (50, ExprCase::Let),
-        (50, ExprCase::Proj),
-        (100, ExprCase::Strl),
-        (100, ExprCase::Natl),
-      ];
-
-      match next_case(g, &gens) {
-        ExprCase::Vari => {
-          let x: u64 = Arbitrary::arbitrary(g);
-          unsafe {
-            ptr::replace(ptr, Expr::Vari(x));
-          }
-        },
-        ExprCase::Sort => {
-          let u = arbitrary_univ(g, ctx);
-          unsafe {
-            ptr::replace(ptr, Expr::Sort(Box::new(u)));
-          }
-        },
-        ExprCase::Refr => {
-          let addr = Address::arbitrary(g);
-          let mut lvls = vec![];
-          for _ in 0..gen_range(g, 0..4) {
-            lvls.push(arbitrary_univ(g, ctx));
-          }
-          unsafe {
-            ptr::replace(ptr, Expr::Refr(addr, lvls));
-          }
-        },
-        ExprCase::Recr => {
-          let n = u64::arbitrary(g);
-          let mut lvls = vec![];
-          for _ in 0..gen_range(g, 0..4) {
-            lvls.push(arbitrary_univ(g, ctx));
-          }
-          unsafe {
-            ptr::replace(ptr, Expr::Recr(n, lvls));
-          }
-        },
-        ExprCase::Apps => {
-          let mut f_box = Box::new(Expr::default());
-          let f_ptr: *mut Expr = &mut *f_box;
-          stack.push(f_ptr);
-
-          let mut a_box = Box::new(Expr::default());
-          let a_ptr: *mut Expr = &mut *a_box;
-          stack.push(a_ptr);
-
-          let n = gen_range(g, 0..4);
-          let mut xs: Vec<Expr> = Vec::with_capacity(n);
-          xs.resize(n, Expr::Vari(0));
-          for i in 0..n {
-            let p = unsafe { xs.as_mut_ptr().add(i) };
-            stack.push(p);
-          }
-
-          unsafe {
-            std::ptr::replace(ptr, Expr::Apps(f_box, a_box, xs));
-          }
-        },
-        ExprCase::Lams => {
-          let n = gen_range(g, 0..4);
-          let mut ts: Vec<Expr> = Vec::with_capacity(n);
-          ts.resize(n, Expr::Vari(0));
-          for i in 0..n {
-            let p = unsafe { ts.as_mut_ptr().add(i) };
-            stack.push(p);
-          }
-
-          let mut b_box = Box::new(Expr::default());
-          let b_ptr: *mut Expr = &mut *b_box;
-          stack.push(b_ptr);
-
-          unsafe {
-            std::ptr::replace(ptr, Expr::Lams(ts, b_box));
-          }
-        },
-        ExprCase::Alls => {
-          let n = gen_range(g, 0..4);
-          let mut ts: Vec<Expr> = Vec::with_capacity(n);
-          ts.resize(n, Expr::Vari(0));
-          for i in 0..n {
-            let p = unsafe { ts.as_mut_ptr().add(i) };
-            stack.push(p);
-          }
-
-          let mut b_box = Box::new(Expr::default());
-          let b_ptr: *mut Expr = &mut *b_box;
-          stack.push(b_ptr);
-
-          unsafe {
-            std::ptr::replace(ptr, Expr::Alls(ts, b_box));
-          }
-        },
-        ExprCase::Let => {
-          let nd = bool::arbitrary(g);
-
-          let mut t_box = Box::new(Expr::default());
-          let t_ptr: *mut Expr = &mut *t_box;
-          stack.push(t_ptr);
-
-          let mut d_box = Box::new(Expr::default());
-          let d_ptr: *mut Expr = &mut *d_box;
-          stack.push(d_ptr);
-
-          let mut b_box = Box::new(Expr::default());
-          let b_ptr: *mut Expr = &mut *b_box;
-          stack.push(b_ptr);
-
-          unsafe {
-            ptr::replace(ptr, Expr::Let(nd, t_box, d_box, b_box));
-          }
-        },
-        ExprCase::Proj => {
-          let addr = Address::arbitrary(g);
-          let n = u64::arbitrary(g);
-
-          let mut t_box = Box::new(Expr::default());
-          let t_ptr: *mut Expr = &mut *t_box;
-          stack.push(t_ptr);
-
-          unsafe {
-            ptr::replace(ptr, Expr::Proj(addr, n, t_box));
-          }
-        },
-        ExprCase::Strl => {
-          let cs = gen_range(g, 0..4);
-          let mut s = String::new();
-          for _ in 0..cs {
-            s.push(char::arbitrary(g));
-          }
-
-          unsafe {
-            ptr::replace(ptr, Expr::Strl(s));
-          }
-        },
-        ExprCase::Natl => {
-          let size = gen_range(g, 0..4);
-          unsafe {
-            ptr::replace(ptr, Expr::Natl(arbitrary_nat(g, size)));
-          }
-        },
-      }
-    }
-    root
-  }
-
-  impl Arbitrary for Expr {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let ctx = gen_range(g, 0..4);
-      arbitrary_expr(g, ctx as u64)
-    }
-  }
-
-  #[quickcheck]
-  fn prop_expr_readback(x: Expr) -> bool {
-    let mut buf = Vec::new();
-    Expr::put(&x, &mut buf);
-    match Expr::get(&mut buf.as_slice()) {
-      Ok(y) => x == y,
-      Err(e) => {
-        println!("err: {e}");
-        false
-      },
-    }
-  }
-}

From 6da9f7ade4d281b86cd69c112c2c730b1ed75534 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 22 Aug 2025 11:16:49 -0400
Subject: [PATCH 37/74] implement Ixon v2 in Lean

---
 Ix/Claim.lean          |  30 +++-
 Ix/Common.lean         |   2 +-
 Ix/CompileM.lean       |  13 +-
 Ix/DecompileM.lean     |   7 +-
 Ix/IR.lean             |   9 +-
 Ix/Ixon.lean           | 121 ++++++++++++++-
 Ix/Ixon/Const.lean     | 305 ++++++++++++++++--------------------
 Ix/Ixon/Expr.lean      | 341 ++++++++++++++++++++---------------------
 Ix/Ixon/Metadata.lean  |  61 +++++---
 Ix/Ixon/Serialize.lean | 339 +++++++++++++++++++++++++++++++---------
 Ix/Ixon/Tag.lean       |  83 ++++++++++
 Ix/Ixon/Univ.lean      |  59 +++----
 Ix/Prove.lean          |   1 -
 Ix/Store.lean          |  13 +-
 Ix/TransportM.lean     | 133 +++++++++-------
 Tests/Ix.lean          |  17 +-
 Tests/Ix/Common.lean   |   3 +-
 Tests/Ix/IR.lean       |   2 +-
 Tests/Ix/Ixon.lean     | 114 ++++++++++----
 19 files changed, 1047 insertions(+), 606 deletions(-)
 create mode 100644 Ix/Ixon/Tag.lean

diff --git a/Ix/Claim.lean b/Ix/Claim.lean
index 19b43b00..5b02a610 100644
--- a/Ix/Claim.lean
+++ b/Ix/Claim.lean
@@ -1,13 +1,33 @@
 import Ix.Address
 
+structure EvalClaim where
+  lvls : Address
+  input: Address
+  output: Address
+  type : Address
+deriving BEq, Repr, Inhabited
+
+structure CheckClaim where
+  lvls : Address
+  type : Address
+  value : Address
+deriving BEq, Repr, Inhabited
+
 inductive Claim where
-| checks (lvls type value: Address) : Claim
-| evals (lvls input output type: Address) : Claim
-deriving Inhabited, BEq
+| checks : CheckClaim -> Claim
+| evals : EvalClaim -> Claim
+deriving BEq, Repr, Inhabited
+
+instance : ToString CheckClaim where
+  toString x := s!"#{x.value} : #{x.type} @ #{x.lvls}"
+
+instance : ToString EvalClaim where
+  toString x := s!"#{x.input} ~> #{x.output} : #{x.type} @ #{x.lvls}"
 
 instance : ToString Claim where
   toString
-  | .checks lvls type value => s!"#{value} : #{type} @ #{lvls}"
-  | .evals lvls inp out type => s!"#{inp} ~> #{out} : #{type} @ #{lvls}"
+  | .checks x => toString x
+  | .evals x => toString x
+
 
 
diff --git a/Ix/Common.lean b/Ix/Common.lean
index 5b741e50..9416ba8b 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -56,7 +56,7 @@ def UInt32.MAX : UInt64 := 0xFFFFFFFF
 def UInt64.MAX : UInt64 := 0xFFFFFFFFFFFFFFFF
 
 /-- Distinguish different kinds of Ix definitions --/
-inductive Ix.DefMode where
+inductive Ix.DefKind where
 | «definition»
 | «opaque»
 | «theorem»
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 8f0d8f17..352a41c9 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -1,6 +1,7 @@
 import Batteries.Data.RBMap
 import Ix.TransportM
 import Ix.Ixon.Metadata
+import Ix.Ixon
 import Ix.Ixon.Const
 import Ix.Ixon.Serialize
 import Ix.Common
@@ -68,11 +69,13 @@ structure CompileEnv where
 def CompileEnv.init (maxHeartBeats: USize): CompileEnv :=
   ⟨default, default, default, maxHeartBeats, default⟩
 
+open Ixon
+
 structure CompileState where
   env: Lean.Environment
   prng: StdGen
   names: RBMap Lean.Name (Address × Address) compare
-  store: RBMap Address Ixon.Const compare
+  store: RBMap Address Ixon compare
   cache: RBMap Ix.Const (Address × Address) compare
   comms: RBMap Lean.Name (Address × Address) compare
   axioms: RBMap Lean.Name (Address × Address) compare
@@ -87,8 +90,8 @@ def CompileM.run (env: CompileEnv) (stt: CompileState) (c : CompileM α)
   : EStateM.Result CompileError CompileState α
   := EStateM.run (ReaderT.run c env) stt
 
-def storeConst (const: Ixon.Const): CompileM Address := do
-  let addr := Address.blake3 (Ixon.Serialize.put const)
+def storeConst (const: Ixon): CompileM Address := do
+  let addr := Address.blake3 (runPut (Serialize.put const))
   modifyGet fun stt => (addr, { stt with
     store := stt.store.insert addr const
   })
@@ -907,7 +910,7 @@ partial def checkClaim
   let (value, valMeta) <- compileConst leanConst >>= comm
   let (type, typeMeta) <- addDef lvls sort type >>= comm
   let lvls <- packLevel lvls.length commit
-  return (Claim.checks lvls type value, typeMeta, valMeta)
+  return (Claim.checks (CheckClaim.mk lvls type value), typeMeta, valMeta)
   where
     comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
 
@@ -923,7 +926,7 @@ partial def evalClaim
   let (output, outputMeta) <- addDef lvls type output >>= comm
   let (type, typeMeta) <- addDef lvls sort type >>= comm
   let lvlsAddr <- packLevel lvls.length commit
-  return (Claim.evals lvlsAddr input output type, inputMeta, outputMeta, typeMeta)
+  return (Claim.evals (EvalClaim.mk lvlsAddr input output type), inputMeta, outputMeta, typeMeta)
   where
     comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
 
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index 38cf8c59..d8be21cd 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -11,6 +11,7 @@ open Batteries (RBMap)
 open Batteries (RBSet)
 open Ix.TransportM
 open Ix.Compile
+open Ixon
 
 namespace Ix.Decompile
 
@@ -27,7 +28,7 @@ instance : ToString Named where
 /- The local environment for the Ix -> Lean4 decompiler -/
 structure DecompileEnv where
   names : RBMap Lean.Name (Address × Address) compare
-  store : RBMap Address Ixon.Const compare
+  store : RBMap Address Ixon compare
   univCtx : List Lean.Name
   bindCtx : List Lean.Name
   mutCtx  : RBMap Lean.Name Nat compare
@@ -37,7 +38,7 @@ structure DecompileEnv where
 /- initialize from an Ixon store and a name-index to the store -/
 def DecompileEnv.init
   (names : RBMap Lean.Name (Address × Address) compare)
-  (store : RBMap Address Ixon.Const compare)
+  (store : RBMap Address Ixon compare)
   : DecompileEnv
   := ⟨names, store, default, default, default, default⟩
 
@@ -116,7 +117,7 @@ inductive DecompileError
 | transport (curr: Named) (err: TransportError) (cont meta: Address)
 | unknownName (curr: Named) (name: Lean.Name)
 | unknownStoreAddress (curr: Named) (exp: Address)
-| expectedIxonMetadata (curr: Named) (exp: Address) (got: Ixon.Const)
+| expectedIxonMetadata (curr: Named) (exp: Address) (got: Ixon)
 | badProjection
   (curr: Named) (name: Lean.Name) (cont meta: Address) (msg: String)
 | nonCongruentInductives (curr: Named) (x y: Ix.Inductive)
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 3e7d93fb..4e85a503 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -131,7 +131,7 @@ structure PreDefinition where
   name: Lean.Name
   levelParams : List Lean.Name
   type : Lean.Expr
-  mode : DefMode
+  mode : DefKind
   value : Lean.Expr
   hints : Lean.ReducibilityHints
   safety : Lean.DefinitionSafety
@@ -148,13 +148,12 @@ def mkPreOpaque (x: Lean.OpaqueVal) : PreDefinition :=
   ⟨x.name, x.levelParams, x.type, .opaque, x.value, .opaque,
     if x.isUnsafe then .unsafe else .safe, x.all⟩
 
-
 /--
 Ix.Definition definitions combine Lean.DefinitionVal, Lean.OpaqueVal and
 Lean.TheoremVal into a single structure in order to enable content-addressing of
-mutually recursive blocks. These cases are disambiguated via the Ix.DefMode
+mutually recursive blocks. These cases are disambiguated via the Ix.DefKind
 inductive. ReducibilityHints are preserved only as metadata, and are set to
-`ReducibilityHints.opaque` and ignored if the DefMode is either .opaque or
+`ReducibilityHints.opaque` and ignored if the DefKind is either .opaque or
 .theorem. The `safety : Lean.DefinitionSafety` parameter from DefinitionVal is
 replaced with a boolean for partial definitions, as Ix definitions are
 restricted to exclude unsafe constants.
@@ -163,7 +162,7 @@ structure Definition where
   name: Lean.Name
   levelParams : List Lean.Name
   type : Expr
-  mode: DefMode
+  mode: DefKind
   value : Expr
   hints : Lean.ReducibilityHints
   safety: Lean.DefinitionSafety
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 345d56cf..6df34954 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -1,6 +1,125 @@
 import Ix.Address
 import Ix.Ixon.Serialize
 import Ix.Ixon.Univ
-import Ix.Ixon.Expr
+import Ix.Claim
+import Ix.Ixon.Tag
 import Ix.Ixon.Const
 import Ix.Ixon.Metadata
+
+namespace Ixon
+
+inductive Ixon where
+| vari : UInt64 -> Ixon                       -- 0x0X, variables
+| sort : Univ -> Ixon                         -- 0x90, universes
+| refr : Address -> List Univ -> Ixon         -- 0x1X, global reference
+| recr : UInt64 -> List Univ -> Ixon          -- 0x2X, local recursion
+| apps : Ixon -> Ixon -> List Ixon -> Ixon    -- 0x3X, funciton application
+| lams : List Ixon -> Ixon -> Ixon            -- 0x4X, lambda abstraction
+| alls : List Ixon -> Ixon -> Ixon            -- 0x5X, universal quantification
+| letE : Bool -> Ixon -> Ixon -> Ixon -> Ixon -- 0x91, 0x92 let expression
+| proj : Address -> UInt64 -> Ixon -> Ixon    -- 0x6X, structure projection
+| strl : String -> Ixon                       -- 0x7X, utf8 string
+| natl : Nat -> Ixon                          -- 0x8X, natural number
+| list : List Ixon -> Ixon                    -- 0xAX, list
+| defn : Definition -> Ixon                   -- 0xB0, definition
+| axio : Axiom -> Ixon                        -- 0xB1, axiom
+| quot : Quotient -> Ixon                     -- 0xB2, quotient
+| cprj : ConstructorProj -> Ixon              -- 0xB3, ctor projection
+| rprj : RecursorProj -> Ixon                 -- 0xB4, recr projection
+| iprj : InductiveProj -> Ixon                -- 0xB5, indc projection
+| dprj : DefinitionProj -> Ixon               -- 0xB6, defn projection
+| inds : List Inductive -> Ixon               -- 0xCX, mutual inductive types
+| defs : List Definition -> Ixon              -- 0xDX, mutual definitions
+| meta : Metadata -> Ixon                     -- 0xE0, Lean4 metadata
+| prof : Proof -> Ixon                        -- 0xE1, zero-knowledge proof
+| eval : EvalClaim -> Ixon                    -- 0xE2, cryptographic claim
+| chck : CheckClaim -> Ixon                   -- 0xE3, cryptographic claim
+| comm : Comm -> Ixon                         -- 0xE4, cryptographic commitment
+| envn : Unit -> Ixon                         -- 0xE5, Lean4 environment
+deriving BEq, Repr, Inhabited
+
+open Serialize
+
+partial def putIxon : Ixon -> PutM Unit
+| .vari i => put (Tag4.mk 0x0 i)
+| .sort u => put (Tag4.mk 0x9 0x0) *> put u
+| .refr a lvls => do
+  put (Tag4.mk 0x1 lvls.length.toUInt64) *> put a *> putMany putUniv lvls
+| .recr i lvls => put (Tag4.mk 0x2 i) *> putList lvls
+| .apps f a as => do
+  put (Tag4.mk 0x3 as.length.toUInt64)
+  putIxon f *> putIxon a *> putMany putIxon as
+| .lams ts b => do
+  put (Tag4.mk 0x4 ts.length.toUInt64) *> putMany putIxon ts *> putIxon b
+| .alls ts b => do
+  put (Tag4.mk 0x5 ts.length.toUInt64) *> putMany putIxon ts *> putIxon b
+| .letE nD t d b => do
+  if nD then put (Tag4.mk 0x9 0x1) else put (Tag4.mk 0x9 0x2)
+  putIxon t *> putIxon d *> putIxon b
+| .proj t n x => put (Tag4.mk 0x6 n) *> putBytes t.hash *> putIxon x
+| .strl s => putString s -- 0x7
+| .natl n => putNat n -- 0x8
+| .list xs => do
+  put (Tag4.mk 0xA xs.length.toUInt64)
+  List.forM xs putIxon
+| .defn x => put (Tag4.mk 0xB 0x0) *> put x
+| .axio x => put (Tag4.mk 0xB 0x1) *> put x
+| .quot x => put (Tag4.mk 0xB 0x2) *> put x
+| .cprj x => put (Tag4.mk 0xB 0x3) *> put x
+| .rprj x => put (Tag4.mk 0xB 0x4) *> put x
+| .iprj x => put (Tag4.mk 0xB 0x5) *> put x
+| .dprj x => put (Tag4.mk 0xB 0x6) *> put x
+| .inds xs => put (Tag4.mk 0xC xs.length.toUInt64) *> putMany put xs
+| .defs xs => put (Tag4.mk 0xD xs.length.toUInt64) *> putMany put xs
+| .meta x => put (Tag4.mk 0xE 0x0) *> put x
+| .prof x => put (Tag4.mk 0xE 0x1) *> put x
+| .eval x => put (Tag4.mk 0xE 0x2) *> put x
+| .chck x => put (Tag4.mk 0xE 0x3) *> put x
+| .comm x => put (Tag4.mk 0xE 0x4) *> put x
+| .envn x => put (Tag4.mk 0xE 0x5) *> put x
+
+def getIxon : GetM Ixon := do
+  let st ← MonadState.get
+  go (st.bytes.size - st.idx)
+  where
+    go : Nat → GetM Ixon
+    | 0 => throw "Out of fuel"
+    | Nat.succ f => do
+      let tag <- getTag4
+      match tag with
+      | ⟨0x0, x⟩ => pure <| .vari x
+      | ⟨0x9, 0⟩ => .sort <$> getUniv
+      | ⟨0x1, x⟩ => .refr <$> get <*> getMany x getUniv
+      | ⟨0x2, x⟩ => .recr <$> pure x <*> get
+      | ⟨0x3, x⟩ => .apps <$> go f <*> go f <*> getMany x (go f)
+      | ⟨0x4, x⟩ => .lams <$> getMany x (go f) <*> go f
+      | ⟨0x5, x⟩ => .alls <$> getMany x (go f) <*> go f
+      | ⟨0x9, 1⟩ => .letE true <$> go f <*> go f <*> go f
+      | ⟨0x9, 2⟩ => .letE false <$> go f <*> go f <*> go f
+      | ⟨0x6, x⟩ => .proj <$> get <*> pure x <*> go f
+      | ⟨0x7, _⟩ => .strl <$> getString' tag
+      | ⟨0x8, _⟩ => .natl <$> getNat' tag
+      | ⟨0xA, x⟩ => .list <$> getMany x (go f)
+      | ⟨0xB, 0x0⟩ => .defn <$> get
+      | ⟨0xB, 0x1⟩ => .axio <$> get
+      | ⟨0xB, 0x2⟩ => .quot <$> get
+      | ⟨0xB, 0x3⟩ => .cprj <$> get
+      | ⟨0xB, 0x4⟩ => .rprj <$> get
+      | ⟨0xB, 0x5⟩ => .iprj <$> get
+      | ⟨0xB, 0x6⟩ => .dprj <$> get
+      | ⟨0xC, x⟩ => .inds <$> getMany x get
+      | ⟨0xD, x⟩ => .defs <$> getMany x get
+      | ⟨0xE, 0x0⟩ => .meta <$> get
+      | ⟨0xE, 0x1⟩ => .prof <$> get
+      | ⟨0xE, 0x2⟩ => .eval <$> get
+      | ⟨0xE, 0x3⟩ => .chck <$> get
+      | ⟨0xE, 0x4⟩ => .comm <$> get
+      | ⟨0xE, 0x5⟩ => .envn <$> get
+      | x => throw s!"Unknown Ixon tag {repr x}"
+
+instance : Serialize Ixon where
+  put := putIxon
+  get := getIxon
+
+end Ixon
+
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index 9fb24f48..4f8d536d 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -1,6 +1,7 @@
 import Ix.Common
 import Ix.Address
 import Ix.Prove
+import Ix.Claim
 import Lean.Declaration
 import Ix.Ixon.Serialize
 import Ix.Ixon.Metadata
@@ -10,41 +11,79 @@ namespace Ixon
 
 structure Quotient where
   lvls : Nat
-  type : Expr
+  type : Address
   kind : Lean.QuotKind
   deriving BEq, Repr
 
+instance : Serialize Quotient where
+  put := fun x => Serialize.put (x.lvls, x.type, x.kind)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
 structure Axiom where
   lvls : Nat
-  type : Expr
+  type : Address
   isUnsafe: Bool
   deriving BEq, Repr
 
+instance : Serialize Axiom where
+  put := fun x => Serialize.put (x.lvls, x.type, x.isUnsafe)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
 structure Definition where
   lvls : Nat
-  type : Expr
-  mode : Ix.DefMode
-  value : Expr
+  type : Address
+  mode : Ix.DefKind
+  value : Address
   safety : Lean.DefinitionSafety
   deriving BEq, Repr
 
+instance : Serialize Definition where
+  put := fun x => Serialize.put (x.lvls, x.type, x.mode, x.value, x.safety)
+  get := (fun (a,b,c,d,e) => .mk a b c d e) <$> Serialize.get
+
 structure Constructor where
   lvls : Nat
-  type : Expr
+  type : Address
   cidx : Nat
   params : Nat
   fields : Nat
   isUnsafe: Bool
   deriving BEq, Repr
 
+instance : Serialize Constructor where
+  put x := do
+    Serialize.put x.lvls
+    Serialize.put x.type
+    Serialize.put x.cidx
+    Serialize.put x.params
+    Serialize.put x.fields
+    Serialize.put x.isUnsafe
+  get := do
+    let lvls <- Serialize.get
+    let type <- Serialize.get
+    let cidx <- Serialize.get
+    let params <- Serialize.get
+    let fields <- Serialize.get
+    let isUnsafe <- Serialize.get
+    return .mk lvls type cidx params fields isUnsafe
+
 structure RecursorRule where
   fields : Nat
-  rhs : Expr
+  rhs : Address
   deriving BEq, Repr
 
+instance : Serialize RecursorRule where
+  put x := do
+    Serialize.put x.fields
+    Serialize.put x.rhs
+  get := do
+    let fields <- Serialize.get
+    let rhs <- Serialize.get
+    return .mk fields rhs
+
 structure Recursor where
   lvls : Nat
-  type : Expr
+  type : Address
   params : Nat
   indices : Nat
   motives : Nat
@@ -54,9 +93,30 @@ structure Recursor where
   isUnsafe: Bool
   deriving BEq, Repr
 
+instance : Serialize Recursor where
+  put x := do
+    Serialize.put x.lvls
+    Serialize.put x.type
+    Serialize.put x.params
+    Serialize.put x.indices
+    Serialize.put x.motives
+    Serialize.put x.minors
+    Serialize.put x.rules
+    Serialize.put (x.k, x.isUnsafe)
+  get := do
+    let lvls <- Serialize.get
+    let type <- Serialize.get
+    let params <- Serialize.get
+    let indices <- Serialize.get
+    let motives <- Serialize.get
+    let minors <- Serialize.get
+    let rules <- Serialize.get
+    let (k, isUnsafe) := <- Serialize.get
+    return .mk lvls type params indices motives minors rules k isUnsafe
+
 structure Inductive where
   lvls : Nat
-  type : Expr
+  type : Address
   params : Nat
   indices : Nat
   ctors : List Constructor
@@ -67,198 +127,93 @@ structure Inductive where
   isUnsafe: Bool
   deriving BEq, Repr
 
+instance : Serialize Inductive where
+  put x := do
+    Serialize.put x.lvls
+    Serialize.put x.type
+    Serialize.put x.params
+    Serialize.put x.indices
+    Serialize.put x.ctors
+    Serialize.put x.recrs
+    Serialize.put x.nested
+    Serialize.put (x.recr, x.refl, x.isUnsafe)
+  get := do
+    let lvls : Nat <- Serialize.get
+    let type : Address <- Serialize.get
+    let params : Nat <- Serialize.get
+    let indices : Nat <- Serialize.get
+    let ctors : List Constructor <- Serialize.get
+    let recrs : List Recursor <- Serialize.get
+    let nested: Nat <- Serialize.get
+    let (recr, refl, isUnsafe) : (Bool × Bool × Bool) := <- Serialize.get
+    return .mk lvls type params indices ctors recrs nested recr refl isUnsafe
+
 structure InductiveProj where
   block : Address
   idx : Nat
   deriving BEq, Repr
 
+instance : Serialize InductiveProj where
+  put := fun x => Serialize.put (x.block, x.idx)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
+
 structure ConstructorProj where
   block : Address
   idx : Nat
   cidx : Nat
   deriving BEq, Repr
 
+instance : Serialize ConstructorProj where
+  put := fun x => Serialize.put (x.block, x.idx, x.cidx)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
 structure RecursorProj where
   block : Address
   idx : Nat
   ridx : Nat
   deriving BEq, Repr
 
+instance : Serialize RecursorProj where
+  put := fun x => Serialize.put (x.block, x.idx, x.ridx)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
 structure DefinitionProj where
   block : Address
   idx : Nat
   deriving BEq, Repr
 
+instance : Serialize DefinitionProj where
+  put := fun x => Serialize.put (x.block, x.idx)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
+
 structure Comm where
   secret : Address
   payload : Address
   deriving BEq, Repr
 
-inductive Const where
-  -- 0xC0
-  | defn : Definition -> Const
-  -- 0xC1
-  | axio : Axiom -> Const
-  -- 0xC2
-  | quot : Quotient -> Const
-  -- 0xC3
-  | ctorProj : ConstructorProj -> Const
-  -- 0xC4
-  | recrProj : RecursorProj -> Const
-  -- 0xC5
-  | indcProj : InductiveProj -> Const
-  -- 0xC6
-  | defnProj : DefinitionProj -> Const
-  -- 0xC7
-  | mutDef : List Definition -> Const
-  -- 0xC8
-  | mutInd : List Inductive -> Const
-  -- 0xC9
-  | meta   : Metadata -> Const
-  -- 0xCA
-  | proof : Proof -> Const
-  -- 0xCC
-  | comm: Comm -> Const
-  deriving BEq, Repr, Inhabited
-
-def putConst : Const → PutM
-| .defn x => putUInt8 0xC0 *> putDefn x
-| .axio x => putUInt8 0xC1 *> putNatl x.lvls *> putExpr x.type *> putBool x.isUnsafe
-| .quot x => putUInt8 0xC2 *> putNatl x.lvls *> putExpr x.type *> putQuotKind x.kind
-| .ctorProj x => putUInt8 0xC3 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.cidx
-| .recrProj x => putUInt8 0xC4 *> putBytes x.block.hash *> putNatl x.idx *> putNatl x.ridx
-| .indcProj x => putUInt8 0xC5 *> putBytes x.block.hash *> putNatl x.idx
-| .defnProj x => putUInt8 0xC6 *> putBytes x.block.hash *> putNatl x.idx
-| .mutDef xs => putUInt8 0xC7 *> putArray putDefn xs
-| .mutInd xs => putUInt8 0xC8 *> putArray putIndc xs
-| .meta m => putUInt8 0xC9 *> putMetadata m
-| .proof p => putUInt8 0xCA *> putProof p
-| .comm c => putUInt8 0xCC *> putComm c
-  where
-    putDefn (x: Definition) := do
-      putNatl x.lvls
-      putExpr x.type
-      putDefMode x.mode
-      putExpr x.value
-      putDefinitionSafety x.safety
-    putRecrRule (x: RecursorRule) : PutM := putNatl x.fields *> putExpr x.rhs
-    putCtor (x: Constructor) : PutM := do
-      putNatl x.lvls
-      putExpr x.type
-      putNatl x.cidx
-      putNatl x.params
-      putNatl x.fields
-      putBool x.isUnsafe
-    putRecr (x: Recursor) : PutM := do
-      putNatl x.lvls
-      putExpr x.type
-      putNatl x.params
-      putNatl x.indices
-      putNatl x.motives
-      putNatl x.minors
-      putArray putRecrRule x.rules
-      putBool x.k
-      putBool x.isUnsafe
-    putIndc (x: Inductive) : PutM := do
-      putNatl x.lvls
-      putExpr x.type
-      putNatl x.params
-      putNatl x.indices
-      putArray putCtor x.ctors
-      putArray putRecr x.recrs
-      putNatl x.nested
-      putBools [x.recr, x.refl, x.isUnsafe]
-    putProof (p: Proof) : PutM :=
-      match p.claim with
-      | .checks lvls type value => do
-        putUInt8 0
-        putBytes lvls.hash
-        putBytes type.hash
-        putBytes value.hash
-        putByteArray p.bin
-      | .evals lvls inp out type => do
-        putUInt8 1
-        putBytes lvls.hash
-        putBytes inp.hash
-        putBytes out.hash
-        putBytes type.hash
-        putByteArray p.bin
-    putComm (c: Comm) : PutM :=
-      putBytes c.secret.hash *> putBytes c.payload.hash
-
-def getConst : GetM Const := do
-  let tag ← getUInt8
-  match tag with
-  | 0xC0 => .defn <$> getDefn
-  | 0xC1 => .axio <$> (.mk <$> getNatl <*> getExpr <*> getBool)
-  | 0xC2 => .quot <$> (.mk <$> getNatl <*> getExpr <*> getQuotKind)
-  | 0xC3 => .ctorProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
-  | 0xC4 => .recrProj <$> (.mk <$> getAddr <*> getNatl <*> getNatl)
-  | 0xC5 => .indcProj <$> (.mk <$> getAddr <*> getNatl)
-  | 0xC6 => .defnProj <$> (.mk <$> getAddr <*> getNatl)
-  | 0xC7 => .mutDef <$> getArray getDefn
-  | 0xC8 => .mutInd <$> getArray getIndc
-  | 0xC9 => .meta <$> getMetadata
-  | 0xCA => .proof <$> getProof
-  | 0xCC => .comm <$> getComm
-  | e => throw s!"expected Const tag, got {e}"
-  where
-    getDefn : GetM Definition := do
-      let lvls <- getNatl
-      let type <- getExpr
-      let mode <- getDefMode
-      let value <- getExpr
-      let safety <- getDefinitionSafety
-      return ⟨lvls, type, mode, value, safety⟩
-    getCtor : GetM Constructor := do
-      let lvls <- getNatl
-      let type <- getExpr
-      let cidx <- getNatl
-      let params <- getNatl
-      let fields <- getNatl
-      let safety <- getBool
-      return ⟨lvls, type, cidx, params, fields, safety⟩
-    getRecrRule : GetM RecursorRule := RecursorRule.mk <$> getNatl <*> getExpr
-    getRecr : GetM Recursor := do
-      let lvls <- getNatl
-      let type <- getExpr
-      let params <- getNatl
-      let indices <- getNatl
-      let motives <- getNatl
-      let minors <- getNatl
-      let rules <- getArray getRecrRule
-      let k <- getBool
-      let safety <- getBool
-      return ⟨lvls, type, params, indices, motives, minors, rules, k, safety⟩
-    getIndc : GetM Inductive := do
-      let lvls <- getNatl
-      let type <- getExpr
-      let params <- getNatl
-      let indices <- getNatl
-      let ctors <- getArray getCtor
-      let recrs <- getArray getRecr
-      let nested <- getNatl
-      let (recr, refl, safety) <- match ← getBools 3 with
-        | [x, y, z] => pure (x, y, z)
-        | _ => throw s!"unreachable"
-      return ⟨lvls, type, params, indices, ctors, recrs, nested, recr, refl, safety⟩
-    getAddr : GetM Address := .mk <$> getBytes 32
-    getProof : GetM Proof := do
-      match (<- getUInt8) with
-      | 0 => do
-        let claim <- .checks <$> getAddr <*> getAddr <*> getAddr
-        let proof <- getByteArray
-        return ⟨claim, proof⟩
-      | 1 => do
-        let claim <- .evals <$> getAddr <*> getAddr <*> getAddr <*> getAddr
-        let proof <- getByteArray
-        return ⟨claim, proof⟩
-      | e => throw s!"expect proof variant tag, got {e}"
-    getComm : GetM Comm :=
-      .mk <$> getAddr <*> getAddr
-
-instance : Serialize Const where
-  put := runPut ∘ putConst
-  get := runGet getConst
+instance : Serialize Comm where
+  put := fun x => Serialize.put (x.secret, x.payload)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
+
+instance : Serialize CheckClaim where
+  put x := Serialize.put (x.lvls, x.type, x.value)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
+instance : Serialize EvalClaim where
+  put x := Serialize.put (x.lvls, x.input, x.output, x.type)
+  get := (fun (w,x,y,z) => .mk w x y z) <$> Serialize.get
+
+instance : Serialize Claim where
+  put
+  | .checks x => putTag4 ⟨0xE, 2⟩ *> Serialize.put x
+  | .evals x => putTag4 ⟨0xE, 3⟩ *> Serialize.put x
+  get := do match <- getTag4 with
+  | ⟨0xE,2⟩ => .checks <$> Serialize.get
+  | ⟨0xE,3⟩ => .checks <$> Serialize.get
+  | e => throw s!"expected Claim with tag 0xE2 or 0xE3, got {repr e}"
+
+instance : Serialize Proof where
+  put := fun x => Serialize.put (x.claim, x.bin)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
 
 end Ixon
diff --git a/Ix/Ixon/Expr.lean b/Ix/Ixon/Expr.lean
index 24d5ea40..28feb8b7 100644
--- a/Ix/Ixon/Expr.lean
+++ b/Ix/Ixon/Expr.lean
@@ -4,180 +4,171 @@ import Ix.Ixon.Univ
 
 namespace Ixon
 
--- 0xTTTT_LXXX
-inductive Expr where
-  -- 0x0, ^1
-  | vari (idx: UInt64) : Expr
-  -- 0x1, {max (add 1 2) (var 1)}
-  | sort (univ: Univ) : Expr
-  -- 0x2 #dead_beef_cafe_babe {u1, u2, ... }
-  | cnst (adr: Address) (lvls: List Univ) : Expr
-  -- 0x3 #1.{u1, u2, u3}
-  | rec_ (idx: UInt64) (lvls: List Univ) : Expr
-  -- 0x4 (f x y z)
-  | apps (func: Expr) (arg: Expr) (args: List Expr) : Expr
-  -- 0x5 (λ A B C => body)
-  | lams (types: List Expr) (body: Expr) : Expr
-  -- 0x6 (∀ A B C -> body)
-  | alls (types: List Expr) (body: Expr) : Expr
-  -- 0x7 (let d : A in b)
-  | let_ (nonDep: Bool) (type: Expr) (defn: Expr) (body: Expr) : Expr
-  -- 0x8 .1
-  | proj (type: Address) (idx: UInt64) (struct: Expr): Expr
-  -- 0x9 "foobar"
-  | strl (lit: String) : Expr
-  -- 0xA 0xdead_beef
-  | natl (lit: Nat): Expr
-  deriving Inhabited, Repr, BEq
--- array: 0xB
--- const: 0xC
-
-
-def putExprTag (tag: UInt8) (val: UInt64) : PutM :=
-  let t := UInt8.shiftLeft tag 4
-  if val < 8
-  then putUInt8 (UInt8.lor t (UInt64.toUInt8 val)) *> pure ()
-  else do
-    putUInt8 (UInt8.lor (UInt8.lor t 0b1000) (byteCount val - 1))
-    putTrimmedLE val
-
-partial def putExpr : Expr -> PutM
-| .vari i => putExprTag 0x0 i
-| .sort u => putExprTag 0x1 0 *> putUniv u
-| .cnst a lvls => do
-  putExprTag 0x2 (Nat.toUInt64 lvls.length)
-  putBytes a.hash *> putList putUniv lvls
-| .rec_ i lvls => do
-  putExprTag 0x3 (Nat.toUInt64 lvls.length)
-  putUInt64LE i *> putList putUniv lvls
-| .apps f a as => do
-  putExprTag 0x4 (Nat.toUInt64 as.length)
-  putExpr f *> putExpr a *> putList putExpr as
-| .lams ts b => do
-  putExprTag 0x5 (Nat.toUInt64 ts.length)
-  putList putExpr ts *> putExpr b
-| .alls ts b => do
-  putExprTag 0x6 (Nat.toUInt64 ts.length) *>
-  putList putExpr ts *> putExpr b
-| .let_ nD t d b => do
-  if nD then putExprTag 0x7 1 else putExprTag 0x7 0
-  putExpr t *> putExpr d *> putExpr b
-| .proj t n x => do
-  putExprTag 0x8 n
-  putBytes t.hash
-  putExpr x
-| .strl l => do
-  let bytes := l.toUTF8
-  putExprTag 0x9 (UInt64.ofNat bytes.size)
-  putBytes bytes
-| .natl l => do
-  let bytes := natToBytesLE l
-  putExprTag 0xA (UInt64.ofNat bytes.size)
-  putBytes { data := bytes }
-
-def getExprTag (isLarge: Bool) (small: UInt8) : GetM UInt64 := do
-  if isLarge then (fromTrimmedLE ·.data) <$> getBytes (UInt8.toNat small + 1)
-  else return Nat.toUInt64 (UInt8.toNat small)
-
-def getExpr : GetM Expr := do
-  let st ← get
-  go (st.bytes.size - st.index)
-  where
-    go : Nat → GetM Expr
-    | 0 => throw "Out of fuel"
-    | Nat.succ f => do
-      let tagByte ← getUInt8
-      let tag := UInt8.shiftRight tagByte 4
-      let small := UInt8.land tagByte 0b111
-      let isLarge := UInt8.land tagByte 0b1000 != 0
-      match tag with
-      | 0x0 => .vari <$> getExprTag isLarge small
-      | 0x1 => .sort <$> getUniv
-      | 0x2 => do
-        let n ← getExprTag isLarge small
-        .cnst <$> (Address.mk <$> getBytes 32) <*> getList n getUniv
-      | 0x3 => do
-        let n ← getExprTag isLarge small
-        .rec_ <$> getUInt64LE <*> getList n getUniv
-      | 0x4 => do
-        let n ← getExprTag isLarge small
-        .apps <$> go f <*> go f <*> getList n (go f)
-      | 0x5 => do
-        let n ← getExprTag isLarge small
-        .lams <$> getList n (go f) <*> go f
-      | 0x6 => do
-        let n ← getExprTag isLarge small
-        .alls <$> getList n (go f) <*> go f
-      | 0x7 => do
-        let n ← getExprTag isLarge small
-        if n == 0 then
-          .let_ .false <$> go f <*> go f <*> go f
-        else
-          .let_ .true <$> go f <*> go f <*> go f
-      | 0x8 => do
-        let n ← getExprTag isLarge small
-        .proj <$> (Address.mk <$> getBytes 32) <*> pure n <*> go f
-      | 0x9 => do
-        let n ← getExprTag isLarge small
-        let bs ← getBytes n.toNat
-        match String.fromUTF8? bs with
-        | .some s => return .strl s
-        | .none => throw s!"invalid UTF8 bytes {bs}"
-      | 0xA => do
-        let n ← getExprTag isLarge small
-        let bs ← getBytes n.toNat
-        return .natl (natFromBytesLE bs.data)
-      | x => throw s!"Unknown Ixon Expr tag {x}"
-
-instance : Serialize Expr where
-  put := runPut ∘ putExpr
-  get := runGet getExpr
-
-
-def putArray {A: Type} (putM : A -> PutM) (xs : List A) : PutM := do
-  putExprTag 0xB (UInt64.ofNat xs.length)
-  List.forM xs putM
-
--- useful for arrays of non-uniform type, such as encoding tuples, although that
--- requires a custom getArray equivalent
-def putArray' (xs : List PutM) : PutM := do
-  putExprTag 0xB (UInt64.ofNat xs.length)
-  List.forM xs id
-
-def putByteArray (x: ByteArray) : PutM := do
-  putExprTag 0xB (UInt64.ofNat x.size)
-  x.toList.forM putUInt8
-
-def getArray (getM: GetM A) : GetM (List A) := do
-  let tagByte ← getUInt8
-  let tag := UInt8.shiftRight tagByte 4
-  let small := UInt8.land tagByte 0b111
-  let isLarge := (UInt8.land tagByte 0b1000 != 0)
-  match tag with
-  | 0xB => do
-    let len <- UInt64.toNat <$> getExprTag isLarge small
-    List.mapM (λ _ => getM) (List.range len)
-  | e => throw s!"expected Array with tag 0xB, got {e}"
-
-def getByteArray : GetM ByteArray := do
-  let xs <- getArray getUInt8
-  return ⟨xs.toArray⟩
-
-
-def putOption (putM: A -> PutM): Option A → PutM
-| .none => putArray putM []
-| .some x => putArray putM [x]
-
-def getOption [Repr A] (getM: GetM A): GetM (Option A) := do
-  match ← getArray getM with
-  | [] => return .none
-  | [x] => return .some x
-  | e => throw s!"Expected Option, got {repr e}"
-
-def putNatl (x: Nat) : PutM := putExpr (.natl x)
-def getNatl : GetM Nat := do
-  match (← getExpr) with
-  | .natl n => return n
-  | x => throw s!"expected Expr.Nat, got {repr x}"
+---- 0xTTTT_LXXX
+--inductive Expr where
+--  -- 0x0, ^1
+--  | vari (idx: UInt64) : Expr
+--  -- 0x1, {max (add 1 2) (var 1)}
+--  | sort (univ: Univ) : Expr
+--  -- 0x2 #dead_beef_cafe_babe {u1, u2, ... }
+--  | cnst (adr: Address) (lvls: List Univ) : Expr
+--  -- 0x3 #1.{u1, u2, u3}
+--  | rec_ (idx: UInt64) (lvls: List Univ) : Expr
+--  -- 0x4 (f x y z)
+--  | apps (func: Expr) (arg: Expr) (args: List Expr) : Expr
+--  -- 0x5 (λ A B C => body)
+--  | lams (types: List Expr) (body: Expr) : Expr
+--  -- 0x6 (∀ A B C -> body)
+--  | alls (types: List Expr) (body: Expr) : Expr
+--  -- 0x7 (let d : A in b)
+--  | let_ (nonDep: Bool) (type: Expr) (defn: Expr) (body: Expr) : Expr
+--  -- 0x8 .1
+--  | proj (type: Address) (idx: UInt64) (struct: Expr): Expr
+--  -- 0x9 "foobar"
+--  | strl (lit: String) : Expr
+--  -- 0xA 0xdead_beef
+--  | natl (lit: Nat): Expr
+--  deriving Inhabited, Repr, BEq
+---- array: 0xB
+---- const: 0xC
+--
+--
+--def putExprTag (tag: UInt8) (val: UInt64) : PutM :=
+--  let t := UInt8.shiftLeft tag 4
+--  if val < 8
+--  then putUInt8 (UInt8.lor t (UInt64.toUInt8 val)) *> pure ()
+--  else do
+--    putUInt8 (UInt8.lor (UInt8.lor t 0b1000) (byteCount val - 1))
+--    putTrimmedLE val
+--
+--partial def putExpr : Expr -> PutM
+--| .vari i => putExprTag 0x0 i
+--| .sort u => putExprTag 0x1 0 *> putUniv u
+--| .cnst a lvls => do
+--  putExprTag 0x2 (Nat.toUInt64 lvls.length)
+--  putBytes a.hash *> putList putUniv lvls
+--| .rec_ i lvls => do
+--  putExprTag 0x3 (Nat.toUInt64 lvls.length)
+--  putUInt64LE i *> putList putUniv lvls
+--| .apps f a as => do
+--  putExprTag 0x4 (Nat.toUInt64 as.length)
+--  putExpr f *> putExpr a *> putList putExpr as
+--| .lams ts b => do
+--  putExprTag 0x5 (Nat.toUInt64 ts.length)
+--  putList putExpr ts *> putExpr b
+--| .alls ts b => do
+--  putExprTag 0x6 (Nat.toUInt64 ts.length) *>
+--  putList putExpr ts *> putExpr b
+--| .let_ nD t d b => do
+--  if nD then putExprTag 0x7 1 else putExprTag 0x7 0
+--  putExpr t *> putExpr d *> putExpr b
+--| .proj t n x => do
+--  putExprTag 0x8 n
+--  putBytes t.hash
+--  putExpr x
+--| .strl l => do
+--  let bytes := l.toUTF8
+--  putExprTag 0x9 (UInt64.ofNat bytes.size)
+--  putBytes bytes
+--| .natl l => do
+--  let bytes := natToBytesLE l
+--  putExprTag 0xA (UInt64.ofNat bytes.size)
+--  putBytes { data := bytes }
+--
+--def getExprTag (isLarge: Bool) (small: UInt8) : GetM UInt64 := do
+--  if isLarge then (fromTrimmedLE ·.data) <$> getBytes (UInt8.toNat small + 1)
+--  else return Nat.toUInt64 (UInt8.toNat small)
+--
+--def getExpr : GetM Expr := do
+--  let st ← get
+--  go (st.bytes.size - st.index)
+--  where
+--    go : Nat → GetM Expr
+--    | 0 => throw "Out of fuel"
+--    | Nat.succ f => do
+--      let tagByte ← getUInt8
+--      let tag := UInt8.shiftRight tagByte 4
+--      let small := UInt8.land tagByte 0b111
+--      let isLarge := UInt8.land tagByte 0b1000 != 0
+--      match tag with
+--      | 0x0 => .vari <$> getExprTag isLarge small
+--      | 0x1 => .sort <$> getUniv
+--      | 0x2 => do
+--        let n ← getExprTag isLarge small
+--        .cnst <$> (Address.mk <$> getBytes 32) <*> getList n getUniv
+--      | 0x3 => do
+--        let n ← getExprTag isLarge small
+--        .rec_ <$> getUInt64LE <*> getList n getUniv
+--      | 0x4 => do
+--        let n ← getExprTag isLarge small
+--        .apps <$> go f <*> go f <*> getList n (go f)
+--      | 0x5 => do
+--        let n ← getExprTag isLarge small
+--        .lams <$> getList n (go f) <*> go f
+--      | 0x6 => do
+--        let n ← getExprTag isLarge small
+--        .alls <$> getList n (go f) <*> go f
+--      | 0x7 => do
+--        let n ← getExprTag isLarge small
+--        if n == 0 then
+--          .let_ .false <$> go f <*> go f <*> go f
+--        else
+--          .let_ .true <$> go f <*> go f <*> go f
+--      | 0x8 => do
+--        let n ← getExprTag isLarge small
+--        .proj <$> (Address.mk <$> getBytes 32) <*> pure n <*> go f
+--      | 0x9 => do
+--        let n ← getExprTag isLarge small
+--        let bs ← getBytes n.toNat
+--        match String.fromUTF8? bs with
+--        | .some s => return .strl s
+--        | .none => throw s!"invalid UTF8 bytes {bs}"
+--      | 0xA => do
+--        let n ← getExprTag isLarge small
+--        let bs ← getBytes n.toNat
+--        return .natl (natFromBytesLE bs.data)
+--      | x => throw s!"Unknown Ixon Expr tag {x}"
+--
+--instance : Serialize Expr where
+--  put := runPut ∘ putExpr
+--  get := runGet getExpr
+--
+--
+--def putArray {A: Type} (putM : A -> PutM) (xs : List A) : PutM := do
+--  putExprTag 0xB (UInt64.ofNat xs.length)
+--  List.forM xs putM
+--
+---- useful for arrays of non-uniform type, such as encoding tuples, although that
+---- requires a custom getArray equivalent
+--def putArray' (xs : List PutM) : PutM := do
+--  putExprTag 0xB (UInt64.ofNat xs.length)
+--  List.forM xs id
+--
+--def putByteArray (x: ByteArray) : PutM := do
+--  putExprTag 0xB (UInt64.ofNat x.size)
+--  x.toList.forM putUInt8
+--
+--def getArray (getM: GetM A) : GetM (List A) := do
+--  let tagByte ← getUInt8
+--  let tag := UInt8.shiftRight tagByte 4
+--  let small := UInt8.land tagByte 0b111
+--  let isLarge := (UInt8.land tagByte 0b1000 != 0)
+--  match tag with
+--  | 0xB => do
+--    let len <- UInt64.toNat <$> getExprTag isLarge small
+--    List.mapM (λ _ => getM) (List.range len)
+--  | e => throw s!"expected Array with tag 0xB, got {e}"
+--
+--def getByteArray : GetM ByteArray := do
+--  let xs <- getArray getUInt8
+--  return ⟨xs.toArray⟩
+--
+--
+--
+--def putNatl (x: Nat) : PutM := putExpr (.natl x)
+--def getNatl : GetM Nat := do
+--  match (← getExpr) with
+--  | .natl n => return n
+--  | x => throw s!"expected Expr.Nat, got {repr x}"
 
 end Ixon
diff --git a/Ix/Ixon/Metadata.lean b/Ix/Ixon/Metadata.lean
index b917cb1e..36e59fd0 100644
--- a/Ix/Ixon/Metadata.lean
+++ b/Ix/Ixon/Metadata.lean
@@ -1,6 +1,5 @@
 import Ix.Common
 import Ix.Ixon.Serialize
-import Ix.Ixon.Expr
 import Ix.Address
 import Batteries.Data.RBMap
 
@@ -34,47 +33,59 @@ def nameFromParts: List NamePart → Lean.Name
 | (.str n)::ns => .str (nameFromParts ns) n
 | (.num i)::ns => .num (nameFromParts ns) i
 
-def putNamePart : NamePart → PutM
-| .str s => putExpr (.strl s)
-| .num i => putExpr (.natl i)
+open Serialize
+
+def putNamePart : NamePart → PutM Unit
+| .str s => put s
+| .num i => put i
 
 def getNamePart : GetM NamePart := do
-  match (← getExpr) with
-  | .strl s => return (.str s)
-  | .natl s => return (.num s)
-  | e => throw s!"expected NamePart from .strl or .natl, got {repr e}"
+  match (← getTag4) with
+  | ⟨0x7, x⟩ => .str <$> getString' ⟨0x7, x⟩
+  | ⟨0x8, x⟩ => .num <$> getNat' ⟨0x8, x⟩
+  | e => throw s!"expected NamePart from 0x7 or 0x8 got {repr e}"
+
+instance : Serialize NamePart where
+  put := putNamePart
+  get := getNamePart
+
+def putName (n: Lean.Name): PutM Unit := put (nameToParts n)
+def getName: GetM Lean.Name := nameFromParts <$> get
 
-def putName (n: Lean.Name): PutM := putArray putNamePart (nameToParts n)
-def getName: GetM Lean.Name := nameFromParts <$> getArray getNamePart
+instance : Serialize Lean.Name where
+  put := putName
+  get := getName
 
-def putMetadatum : Metadatum → PutM
+def putMetadatum : Metadatum → PutM Unit
 | .name n => putUInt8 0 *> putName n
 | .info i => putUInt8 1 *> putBinderInfo i
 | .link l => putUInt8 2 *> putBytes l.hash
 | .hints h => putUInt8 3 *> putReducibilityHints h
-| .all ns => putUInt8 4 *> putArray putName ns
-| .mutCtx ctx => putUInt8 5 *> (putArray (putArray putName) ctx)
+| .all ns => putUInt8 4 *> put ns
+| .mutCtx ctx => putUInt8 5 *> put ctx
 
 def getMetadatum : GetM Metadatum := do
   match (<- getUInt8) with
-  | 0 => .name <$> getName
-  | 1 => .info <$> getBinderInfo
+  | 0 => .name <$> get
+  | 1 => .info <$> get
   | 2 => .link <$> (.mk <$> getBytes 32)
-  | 3 => .hints <$> getReducibilityHints
-  | 4 => .all <$> getArray getName
-  | 5 => .mutCtx <$> getArray (getArray getName)
+  | 3 => .hints <$> get
+  | 4 => .all <$> get
+  | 5 => .mutCtx <$> get
   | e => throw s!"expected Metadatum encoding between 0 and 4, got {e}"
 
-def putMetadata (m: Metadata) : PutM := putArray putEntry m.map.toList
-  where
-    putEntry e := putNatl e.fst *> putArray putMetadatum e.snd
+instance : Serialize Metadatum where
+  put := putMetadatum
+  get := getMetadatum
+
+def putMetadata (m: Metadata) : PutM Unit := put m.map.toList
 
 def getMetadata : GetM Metadata := do
-  let xs <- getArray (Prod.mk <$> getNatl <*> getArray getMetadatum)
+  let xs <- Serialize.get
   return Metadata.mk (Batteries.RBMap.ofList xs compare)
 
-instance : Serialize Metadatum where
-  put := runPut ∘ putMetadatum
-  get := runGet getMetadatum
+instance : Serialize Metadata where
+  put := putMetadata
+  get := getMetadata
 
 end Ixon
diff --git a/Ix/Ixon/Serialize.lean b/Ix/Ixon/Serialize.lean
index 598fb83f..9aa4bbd9 100644
--- a/Ix/Ixon/Serialize.lean
+++ b/Ix/Ixon/Serialize.lean
@@ -1,55 +1,67 @@
 import Ix.Common
 import Lean.Declaration
 import Ix.Address
+import Ix.Ixon.Tag
 
 namespace Ixon
 
--- TODO: move to `Ix`
-class Serialize (α : Type) where
-  put : α → ByteArray
-  get : ByteArray → Except String α
-
-abbrev PutM := StateM ByteArray Unit
+abbrev PutM := StateM ByteArray
 
 structure GetState where
-  index : Nat
-  bytes : ByteArray
+  idx : Nat := 0
+  bytes : ByteArray := .empty
+
+abbrev GetM := EStateM String GetState
+
+class Serialize (α : Type) where
+  put : α → PutM Unit
+  get : GetM α
 
-abbrev GetM A := EStateM String GetState A
+def runPut (p: PutM Unit) : ByteArray := (p.run ByteArray.empty).2
 
 def runGet (getm: GetM A) (bytes: ByteArray) : Except String A :=
-  match EStateM.run getm { index := 0, bytes } with
+  match getm.run { idx := 0, bytes } with
   | .ok a _ => .ok a
   | .error e _ => .error e
 
-def runPut (putm: PutM) : ByteArray :=
-  (·.2) <$> StateT.run putm ByteArray.empty
+def putUInt8 (x: UInt8) : PutM Unit :=
+  StateT.modifyGet (fun s => ((), s.push x))
 
-def putUInt8 (x: UInt8) : PutM := StateT.modifyGet (fun s => ((), s.push x))
+def getUInt8 : GetM UInt8 := do
+  let st ← get
+  if st.idx < st.bytes.size then
+    let b := st.bytes[st.idx]!
+    set { st with idx := st.idx + 1 }
+    return b
+  else
+    throw "EOF"
 
-def putUInt32LE (x: UInt32) : PutM := do
-  List.forM (List.range 4) fun i =>
-    let b := UInt32.toUInt8 (x >>> (i.toUInt32 * 8))
-    putUInt8 b
-  pure ()
+instance : Serialize UInt8 where
+  put := putUInt8
+  get := getUInt8
 
-def putUInt64LE (x: UInt64) : PutM := do
-  List.forM (List.range 8) fun i =>
-    let b := UInt64.toUInt8 (x >>> (i.toUInt64 * 8))
+def putUInt16LE (x: UInt16) : PutM Unit := do
+  List.forM (List.range 2) fun i =>
+    let b := UInt16.toUInt8 (x >>> (i.toUInt16 * 8))
     putUInt8 b
   pure ()
 
-def putBytes (x: ByteArray) : PutM :=
-  StateT.modifyGet (fun s => ((), s.append x))
+def getUInt16LE : GetM UInt16 := do
+  let mut x : UInt16 := 0
+  for i in List.range 2 do
+    let b ← getUInt8
+    x := x + (UInt8.toUInt16 b) <<< ((UInt16.ofNat i) * 8)
+  pure x
 
-def getUInt8 : GetM UInt8 := do
-  let st ← get
-  if st.index < st.bytes.size then
-    let b := st.bytes[st.index]!
-    set { st with index := st.index + 1 }
-    return b
-  else
-    throw "EOF"
+instance : Serialize UInt16 where
+  put := putUInt16LE
+  get := getUInt16LE
+
+def putUInt32LE (x: UInt32) : PutM Unit := do
+  List.forM (List.range 4) fun i =>
+    let b := UInt32.toUInt8 (x >>> (i.toUInt32 * 8))
+    putUInt8 b
+  pure ()
 
 def getUInt32LE : GetM UInt32 := do
   let mut x : UInt32 := 0
@@ -58,6 +70,16 @@ def getUInt32LE : GetM UInt32 := do
     x := x + (UInt8.toUInt32 b) <<< ((UInt32.ofNat i) * 8)
   pure x
 
+instance : Serialize UInt32 where
+  put := putUInt32LE
+  get := getUInt32LE
+
+def putUInt64LE (x: UInt64) : PutM Unit := do
+  List.forM (List.range 8) fun i =>
+    let b := UInt64.toUInt8 (x >>> (i.toUInt64 * 8))
+    putUInt8 b
+  pure ()
+
 def getUInt64LE : GetM UInt64 := do
   let mut x : UInt64 := 0
   for i in List.range 8 do
@@ -65,32 +87,99 @@ def getUInt64LE : GetM UInt64 := do
     x := x + (UInt8.toUInt64 b) <<< ((UInt64.ofNat i) * 8)
   pure x
 
+instance : Serialize UInt64 where
+  put := putUInt64LE
+  get := getUInt64LE
+
+def putBytes (x: ByteArray) : PutM Unit :=
+  StateT.modifyGet (fun s => ((), s.append x))
+
 def getBytes (len: Nat) : GetM ByteArray := do
   let st ← get
-  if st.index + len <= st.bytes.size then
-    let chunk := st.bytes.extract st.index (st.index + len)
-    set { st with index := st.index + len }
+  if st.idx + len <= st.bytes.size then
+    let chunk := st.bytes.extract st.idx (st.idx + len)
+    set { st with idx := st.idx + len }
     return chunk
-  else throw s!"EOF: need {len} bytes at index {st.index}, but size is {st.bytes.size}"
-
-def byteCount (x: UInt64) : UInt8 :=
-  if      x < 0x0000000000000100 then 1
-  else if x < 0x0000000000010000 then 2
-  else if x < 0x0000000001000000 then 3
-  else if x < 0x0000000100000000 then 4
-  else if x < 0x0000010000000000 then 5
-  else if x < 0x0001000000000000 then 6
-  else if x < 0x0100000000000000 then 7
-  else 8
-
-def trimmedLE (x: UInt64) : Array UInt8 :=
-  if x == 0 then Array.mkArray1 0 else List.toArray (go 8 x)
-  where
-    go : Nat → UInt64 → List UInt8
-    | _, 0 => []
-    | 0, _ => []
-    | Nat.succ f, x =>
-      Nat.toUInt8 (UInt64.toNat x) :: go f (UInt64.shiftRight x 8)
+  else throw s!"EOF: need {len} bytes at index {st.idx}, but size is {st.bytes.size}"
+
+def putTag2 (tag: Tag2) : PutM Unit := do
+  putUInt8 (encodeTag2Head tag)
+  if tag.size < 8
+  then pure ()
+  else putBytes (.mk (trimmedLE tag.size))
+
+def getTagSize (large: Bool) (small: UInt8) : GetM UInt64 := do
+  if large then (fromTrimmedLE ·.data) <$> getBytes (small.toNat + 1)
+  else return small.toNat.toUInt64
+
+def getTag2 : GetM Tag2 := do
+  let (flag, largeBit, small) <- decodeTag2Head <$> getUInt8
+  let size <- getTagSize largeBit small
+  pure (Tag2.mk flag size)
+
+instance : Serialize Tag2 where
+  put := putTag2
+  get := getTag2
+
+def putTag4 (tag: Tag4) : PutM Unit := do
+  putUInt8 (encodeTag4Head tag)
+  if tag.size < 8
+  then pure ()
+  else putBytes (.mk (trimmedLE tag.size))
+
+def getTag4 : GetM Tag4 := do
+  let (flag, largeBit, small) <- decodeTag4Head <$> getUInt8
+  let size <- getTagSize largeBit small
+  pure (Tag4.mk flag size)
+
+instance : Serialize Tag4 where
+  put := putTag4
+  get := getTag4
+
+def putList [Serialize A] (xs : List A) : PutM Unit := do
+  Serialize.put (Tag4.mk 0xA (UInt64.ofNat xs.length))
+  List.forM xs Serialize.put
+
+def getList [Serialize A] : GetM (List A) := do
+  let tag : Tag4 <- Serialize.get
+  match tag with
+  | ⟨0xA, size⟩ => do
+    List.mapM (λ _ => Serialize.get) (List.range size.toNat)
+  | e => throw s!"expected List with tag 0xA, got {repr e}"
+
+instance [Serialize A] : Serialize (List A) where
+  put := putList
+  get := getList
+
+instance : Serialize ByteArray where
+  put x := putList x.toList
+  get := ByteArray.mk <$> Array.mk <$> getList
+
+def putMany {A: Type} (put : A -> PutM Unit) (xs: List A) : PutM Unit := 
+  List.forM xs put
+
+def getMany {A: Type} (x: UInt64) (getm : GetM A) : GetM (List A) :=
+  (List.range x.toNat).mapM (fun _ => getm)
+
+def putString (x: String) : PutM Unit := do
+  let bytes := x.toUTF8
+  Serialize.put (Tag4.mk 0x7 bytes.size.toUInt64)
+  putBytes bytes
+
+def getString' (tag: Tag4) : GetM String := do
+  match tag with
+  | ⟨0x7, size⟩ => do
+    let bs ← getBytes size.toNat
+    match String.fromUTF8? bs with
+    | .some s => return s
+    | .none => throw s!"invalid UTF8 bytes {bs}"
+  | e => throw s!"expected String with tag 0x7, got {repr e}"
+
+def getString : GetM String := getTag4 >>= getString'
+
+instance : Serialize String where
+  put := putString
+  get := getString
 
 def natToBytesLE (x: Nat) : Array UInt8 :=
   if x == 0 then Array.mkArray1 0 else List.toArray (go x x)
@@ -103,6 +192,24 @@ def natToBytesLE (x: Nat) : Array UInt8 :=
 def natFromBytesLE (xs: Array UInt8) : Nat :=
   (xs.toList.zipIdx 0).foldl (fun acc (b, i) => acc + (UInt8.toNat b) * 256 ^ i) 0
 
+def putNat (x: Nat) : PutM Unit := do
+  let bytes := natToBytesLE x
+  putTag4 (Tag4.mk 0x8 bytes.size.toUInt64)
+  putBytes { data := bytes }
+
+def getNat' (tag: Tag4) : GetM Nat := do
+  match tag with
+  | ⟨0x8, size⟩ => do
+    let bs ← getBytes size.toNat
+    return natFromBytesLE bs.data
+  | e => throw s!"expected Nat with tag 0x8, got {repr e}"
+
+def getNat : GetM Nat := getTag4 >>= getNat'
+
+instance : Serialize Nat where
+  put := putNat
+  get := getNat
+
 def natPackAsAddress (x: Nat) : Option Address := 
   let bytes := natToBytesLE x
   if bytes.size > 32 then .none
@@ -111,18 +218,7 @@ def natPackAsAddress (x: Nat) : Option Address :=
 def natUnpackFromAddress (x: Address) : Nat := 
   natFromBytesLE x.hash.data
 
-def fromTrimmedLE (xs: Array UInt8) : UInt64 := List.foldr step 0 xs.toList
-  where
-    step byte acc := UInt64.shiftLeft acc 8 + (UInt8.toUInt64 byte)
-
-def putTrimmedLE (x: UInt64) : PutM := List.forM (trimmedLE x).toList putUInt8
-
-def putList {A: Type} (put : A -> PutM) (xs: List A) : PutM := List.forM xs put
-
-def getList {A: Type} (x: UInt64) (getm : GetM A) : GetM (List A) :=
-  (List.range x.toNat).mapM (fun _ => getm)
-
-def putBool : Bool → PutM
+def putBool : Bool → PutM Unit
 | .false => putUInt8 0
 | .true => putUInt8 1
 
@@ -132,6 +228,10 @@ def getBool : GetM Bool := do
   | 1 => return .true
   | e => throw s!"expected Bool encoding between 0 and 1, got {e}"
 
+instance : Serialize Bool where
+  put := putBool
+  get := getBool
+
 def packBools (bools : List Bool) : UInt8 :=
   List.foldl
     (λ acc (b, i) => acc ||| (if b then 1 <<< UInt8.ofNat i else 0))
@@ -141,10 +241,55 @@ def packBools (bools : List Bool) : UInt8 :=
 def unpackBools (n: Nat) (b: UInt8) : List Bool :=
   ((List.range 8).map (λ i => (b &&& (1 <<< UInt8.ofNat i)) != 0)).take n
 
-def putBools: List Bool → PutM := putUInt8 ∘ packBools
+def putBools: List Bool → PutM Unit := putUInt8 ∘ packBools
 def getBools (n: Nat): GetM (List Bool) := unpackBools n <$> getUInt8
 
-def putQuotKind : Lean.QuotKind → PutM
+instance (priority := default + 100) : Serialize (Bool × Bool) where
+  put := fun (a, b) => putBools [a, b]
+  get := do match (<- getBools 2) with
+    | [a, b] => pure (a, b)
+    | e => throw s!"expected packed (Bool × Bool), got {e}" 
+
+instance (priority := default + 101): Serialize (Bool × Bool × Bool) where
+  put := fun (a, b, c) => putBools [a, b, c]
+  get := do match (<- getBools 3) with
+    | [a, b, c] => pure (a, b, c)
+    | e => throw s!"expected packed (Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 102): Serialize (Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c,d) => putBools [a, b, c, d]
+  get := do match (<- getBools 4) with
+    | [a, b, c, d] => pure (a, b, c, d)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 103): Serialize (Bool × Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c, d, e) => putBools [a, b, c, d, e]
+  get := do match (<- getBools 5) with
+    | [a, b, c, d, e] => pure (a, b, c, d, e)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 104)
+  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c, d, e, f) => putBools [a, b, c, d, e, f]
+  get := do match (<- getBools 6) with
+    | [a, b, c, d, e, f] => pure (a, b, c, d, e, f)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 106)
+  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c, d, e, f, g) => putBools [a, b, c, d, e, f, g]
+  get := do match (<- getBools 7) with
+    | [a, b, c, d, e, f, g] => pure (a, b, c, d, e, f, g)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 105)
+  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c, d, e, f, g, h) => putBools [a, b, c, d, e, f, g, h]
+  get := do match (<- getBools 8) with
+    | [a, b, c, d, e, f, g, h] => pure (a, b, c, d, e, f, g, h)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+
+def putQuotKind : Lean.QuotKind → PutM Unit
 | .type => putUInt8 0
 | .ctor => putUInt8 1
 | .lift => putUInt8 2
@@ -158,19 +303,27 @@ def getQuotKind : GetM Lean.QuotKind := do
   | 3 => return .ind
   | e => throw s!"expected QuotKind encoding between 0 and 3, got {e}"
 
-def putDefMode : Ix.DefMode → PutM
+instance : Serialize Lean.QuotKind where
+  put := putQuotKind
+  get := getQuotKind
+
+def putDefKind : Ix.DefKind → PutM Unit
 | .«definition» => putUInt8 0
 | .«opaque» => putUInt8 1
 | .«theorem» => putUInt8 2
 
-def getDefMode : GetM Ix.DefMode := do
+def getDefKind : GetM Ix.DefKind := do
   match (← getUInt8) with
   | 0 => return .definition
   | 1 => return .opaque
   | 2 => return .theorem
-  | e => throw s!"expected DefMode encoding between 0 and 3, got {e}"
+  | e => throw s!"expected DefKind encoding between 0 and 3, got {e}"
 
-def putBinderInfo : Lean.BinderInfo → PutM
+instance : Serialize Ix.DefKind where
+  put := putDefKind
+  get := getDefKind
+
+def putBinderInfo : Lean.BinderInfo → PutM Unit
 | .default => putUInt8 0
 | .implicit => putUInt8 1
 | .strictImplicit => putUInt8 2
@@ -184,7 +337,11 @@ def getBinderInfo : GetM Lean.BinderInfo := do
   | 3 => return .instImplicit
   | e => throw s!"expected BinderInfo encoding between 0 and 3, got {e}"
 
-def putReducibilityHints : Lean.ReducibilityHints → PutM
+instance : Serialize Lean.BinderInfo where
+  put := putBinderInfo
+  get := getBinderInfo
+
+def putReducibilityHints : Lean.ReducibilityHints → PutM Unit
 | .«opaque» => putUInt8 0
 | .«abbrev» => putUInt8 1
 | .regular x => putUInt8 2 *> putUInt32LE x
@@ -196,7 +353,11 @@ def getReducibilityHints : GetM Lean.ReducibilityHints := do
   | 2 => .regular <$> getUInt32LE
   | e => throw s!"expected ReducibilityHints encoding between 0 and 2, got {e}"
 
-def putDefinitionSafety : Lean.DefinitionSafety → PutM
+instance : Serialize Lean.ReducibilityHints where
+  put := putReducibilityHints
+  get := getReducibilityHints
+
+def putDefinitionSafety : Lean.DefinitionSafety → PutM Unit
 | .«unsafe» => putUInt8 0
 | .«safe» => putUInt8 1
 | .«partial» => putUInt8 2
@@ -208,4 +369,34 @@ def getDefinitionSafety : GetM Lean.DefinitionSafety := do
   | 2 => return .«partial» 
   | e => throw s!"expected DefinitionSafety encoding between 0 and 2, got {e}"
 
+instance : Serialize Lean.DefinitionSafety where
+  put := putDefinitionSafety
+  get := getDefinitionSafety
+
+instance [Serialize A] [Serialize B] : Serialize (A × B) where
+  put := fun (a, b) => Serialize.put a *> Serialize.put b
+  get := (·,·) <$> Serialize.get <*> Serialize.get
+
+def putOption [Serialize A]: Option A → PutM Unit
+| .none => Serialize.put ([] : List A)
+| .some x => Serialize.put [x]
+
+def getOption [Serialize A] : GetM (Option A) := do
+  match ← Serialize.get with
+  | [] => return .none
+  | [x] => return .some x
+  | _ => throw s!"Expected Option"
+
+instance [Serialize A] : Serialize (Option A) where
+  put := putOption
+  get := getOption
+
+instance: Serialize Unit where
+  put _ := pure ()
+  get := pure ()
+
+instance : Serialize Address where
+  put x := putBytes x.hash
+  get := Address.mk <$> getBytes 32
+
 end Ixon
diff --git a/Ix/Ixon/Tag.lean b/Ix/Ixon/Tag.lean
new file mode 100644
index 00000000..89783550
--- /dev/null
+++ b/Ix/Ixon/Tag.lean
@@ -0,0 +1,83 @@
+namespace Ixon
+
+def byteCount (x: UInt64) : UInt8 :=
+  if      x < 0x0000000000000100 then 1
+  else if x < 0x0000000000010000 then 2
+  else if x < 0x0000000001000000 then 3
+  else if x < 0x0000000100000000 then 4
+  else if x < 0x0000010000000000 then 5
+  else if x < 0x0001000000000000 then 6
+  else if x < 0x0100000000000000 then 7
+  else 8
+
+def trimmedLE (x: UInt64) : Array UInt8 :=
+  if x == 0 then Array.mkArray1 0 else List.toArray (go 8 x)
+  where
+    go : Nat → UInt64 → List UInt8
+    | _, 0 => []
+    | 0, _ => []
+    | Nat.succ f, x =>
+      Nat.toUInt8 (UInt64.toNat x) :: go f (UInt64.shiftRight x 8)
+
+def fromTrimmedLE (xs: Array UInt8) : UInt64 := List.foldr step 0 xs.toList
+  where
+    step byte acc := UInt64.shiftLeft acc 8 + (UInt8.toUInt64 byte)
+
+--  F := flag, L := large-bit, X := small-field, A := large_field
+-- 0xFFLX_XXXX {AAAA_AAAA, ...}
+structure Tag2 where
+  flag: Fin 4
+  size: UInt64
+  deriving Inhabited, Repr, BEq, Hashable
+
+def encodeTag2Head (tag: Tag2) : UInt8 := 
+  let t := UInt8.shiftLeft (UInt8.ofNat tag.flag.val) 6
+  if tag.size < 32
+  then t + (UInt64.toUInt8 tag.size)
+  else t + 0b10_0000 + (byteCount tag.size - 1)
+
+def flag2_to_Fin4 (x: UInt8) : Fin 4 :=
+  ⟨ x.toNat / 64, by
+      have h256 : x.toNat < 256 := UInt8.toNat_lt x
+      have h : x.toNat < 64 * 4 := by simpa using h256
+      exact (Nat.div_lt_iff_lt_mul (by decide)).mpr h
+  ⟩
+
+def decodeTag2Head (head: UInt8) : (Fin 4 × Bool × UInt8) :=
+  let flag : Fin 4 := flag2_to_Fin4 head
+  let largeBit := (UInt8.land head 0b10_0000 != 0)
+  let small := head % 0b10_0000
+  (flag, largeBit, small)
+
+--  F := flag, L := large-bit, X := small-field, A := large_field
+-- 0xFFFF_LXXX {AAAA_AAAA, ...}
+-- "Tag" means the whole thing
+-- "Head" means the first byte of the tag
+-- "Flag" means the first nibble of the head
+structure Tag4 where
+  flag: Fin 16
+  size: UInt64
+  deriving Inhabited, Repr, BEq, Hashable
+
+-- 0xC is a hardcoded exception without small size
+def encodeTag4Head (tag: Tag4): UInt8 :=
+  let t := UInt8.shiftLeft (UInt8.ofNat tag.flag.val) 4
+  if tag.size < 8
+  then t + tag.size.toUInt8
+  else t + 0b1000 + (byteCount tag.size - 1)
+
+def flag4_to_Fin16 (x: UInt8) : Fin 16 :=
+  ⟨ x.toNat / 16, by
+      have h256 : x.toNat < 256 := UInt8.toNat_lt x
+      have h : x.toNat < 16 * 16 := by simpa using h256
+      exact (Nat.div_lt_iff_lt_mul (by decide)).mpr h
+  ⟩
+
+-- 0xC is a hardcoded exception without small size
+def decodeTag4Head (head: UInt8) : (Fin 16 × Bool × UInt8) :=
+  let flag : Fin 16 := flag4_to_Fin16 head
+  let largeBit := UInt8.land head 0b1000 != 0
+  let small := if flag == 0xC then head % 0b10000 else head % 0b1000
+  (flag, largeBit, small)
+
+end Ixon
diff --git a/Ix/Ixon/Univ.lean b/Ix/Ixon/Univ.lean
index 0310cb62..d00b9272 100644
--- a/Ix/Ixon/Univ.lean
+++ b/Ix/Ixon/Univ.lean
@@ -2,60 +2,47 @@ import Ix.Ixon.Serialize
 
 namespace Ixon
 
--- 0xTTTL_XXXX
+-- 0xTTLX_XXXX
 inductive Univ where
-  -- 0x0 1
+  -- 0x0X 1
   | const : UInt64 -> Univ
-  -- 0x1 ^1
+  -- 0x1X ^1
   | var : UInt64 -> Univ
-  -- 0x2 (+ x y)
+  -- 0x2X (+ x y)
   | add : UInt64 -> Univ -> Univ
-  -- 0x3 (max x y)
+  -- 0x30 (max x y)
   | max : Univ -> Univ -> Univ
-  -- 0x4 (imax x y)
+  -- 0x31 (imax x y)
   | imax : Univ -> Univ -> Univ
   deriving Repr, Inhabited, BEq
 
-def putUnivTag (tag: UInt8) (val: UInt64) : PutM :=
-  let t := UInt8.shiftLeft tag 5
-  if val < 16
-  then putUInt8 (UInt8.lor t (Nat.toUInt8 (UInt64.toNat val))) *> pure ()
-  else do
-    putUInt8 (UInt8.lor (UInt8.lor t 0b10000) (byteCount val - 1))
-    putTrimmedLE val
+open Serialize
 
-def putUniv : Univ -> PutM
-  | .const i => putUnivTag 0x0 i
-  | .var i => putUnivTag 0x1 i
-  | .add i x => putUnivTag 0x2 i *> putUniv x
-  | .max x y => putUnivTag 0x3 0 *> putUniv x *> putUniv y
-  | .imax x y => putUnivTag 0x4 0 *> putUniv x *> putUniv y
-
-def getUnivTag (isLarge: Bool) (small: UInt8) : GetM UInt64 := do
-  if isLarge then (fromTrimmedLE ·.data) <$> getBytes (UInt8.toNat small + 1)
-  else return Nat.toUInt64 (UInt8.toNat small)
+def putUniv : Univ -> PutM Unit
+  | .const i => put (Tag2.mk 0x0 i)
+  | .var i => put (Tag2.mk 0x1 i)
+  | .add i x => put (Tag2.mk 0x2 i) *> putUniv x
+  | .max x y => put (Tag2.mk 0x3 0) *> putUniv x *> putUniv y
+  | .imax x y => put (Tag2.mk 0x3 1) *> putUniv x *> putUniv y
 
 def getUniv : GetM Univ := do
   let st ← get
-  go (st.bytes.size - st.index)
+  go (st.bytes.size - st.idx)
   where
     go : Nat → GetM Univ
     | 0 => throw "Out of fuel"
     | Nat.succ f => do
-      let tagByte ← getUInt8
-      let tag := UInt8.shiftRight tagByte 5
-      let smallSize := UInt8.land tagByte 0b1111
-      let isLarge := UInt8.land tagByte 0b10000 != 0
+      let tag ← getTag2
       match tag with
-      | 0x0 => .const <$> getUnivTag isLarge smallSize
-      | 0x1 => .var <$> getUnivTag isLarge smallSize
-      | 0x2 => .add <$> getUnivTag isLarge smallSize <*> go f
-      | 0x3 => .max <$> go f <*> go f
-      | 0x4 => .imax <$> go f <*> go f
-      | x => throw s!"Unknown Ixon Universe tag {x}"
+      | ⟨0x0, x⟩ => pure (.const x)
+      | ⟨0x1, x⟩ => pure (.var x)
+      | ⟨0x2, x⟩ => .add x <$> go f
+      | ⟨0x3, 0⟩ => .max <$> go f <*> go f
+      | ⟨0x3, 1⟩ => .imax <$> go f <*> go f
+      | x => throw s!"Unknown Ixon Universe tag {repr x}"
 
 instance : Serialize Univ where
-  put := runPut ∘ putUniv
-  get := runGet getUniv
+  put := putUniv
+  get := getUniv
 
 end Ixon
diff --git a/Ix/Prove.lean b/Ix/Prove.lean
index 423d1d95..bb45d038 100644
--- a/Ix/Prove.lean
+++ b/Ix/Prove.lean
@@ -10,7 +10,6 @@ import Ix.Common
 --
 --abbrev ProveM := ExceptT ProveError IO
 
-
 structure Proof where
   claim: Claim
   /-- Bytes of the Binius proof -/
diff --git a/Ix/Store.lean b/Ix/Store.lean
index 75da1dc4..cb11c5fd 100644
--- a/Ix/Store.lean
+++ b/Ix/Store.lean
@@ -7,6 +7,7 @@ import Init.System.IO
 import Init.System.IOError
 
 open System
+open Ixon
 
 inductive StoreError
 | unknownAddress (a: Address)
@@ -40,8 +41,8 @@ def ensureStoreDir : StoreIO Unit := do
   let store ← storeDir
   IO.toEIO .ioError (IO.FS.createDirAll store)
 
-def writeConst (x: Ixon.Const) : StoreIO Address := do
-  let bytes := Ixon.Serialize.put x
+def writeConst (x: Ixon) : StoreIO Address := do
+  let bytes := runPut (Serialize.put x)
   let addr  := Address.blake3 bytes
   let store ← storeDir
   let path := store / hexOfBytes addr.hash
@@ -49,18 +50,18 @@ def writeConst (x: Ixon.Const) : StoreIO Address := do
   return addr
 
 -- unsafe, can corrupt store if called with bad address
-def forceWriteConst (addr: Address) (x: Ixon.Const) : StoreIO Address := do
-  let bytes := Ixon.Serialize.put x
+def forceWriteConst (addr: Address) (x: Ixon) : StoreIO Address := do
+  let bytes := runPut (Serialize.put x)
   let store ← storeDir
   let path := store / hexOfBytes addr.hash
   let _ <- IO.toEIO .ioError (IO.FS.writeBinFile path bytes)
   return addr
 
-def readConst (a: Address) : StoreIO Ixon.Const := do
+def readConst (a: Address) : StoreIO Ixon := do
   let store ← storeDir
   let path := store / hexOfBytes a.hash
   let bytes ← IO.toEIO .ioError (IO.FS.readBinFile path)
-  match Ixon.Serialize.get bytes with
+  match runGet Serialize.get bytes with
   | .ok c => return c
   | .error e => throw (.ixonError e)
 
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index d9f48336..16453ba4 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -1,7 +1,6 @@
 import Ix.IR
 import Ix.Ixon.Univ
-import Ix.Ixon.Expr
-import Ix.Ixon.Const
+import Ix.Ixon
 import Ix.Common
 import Ix.Address
 import Ix.Ixon.Metadata
@@ -11,20 +10,26 @@ import Batteries.Data.RBMap
 
 namespace Ix.TransportM
 
+open Ixon
+
 structure DematState where
   idx: Nat
+  store: Batteries.RBMap Address Ixon compare
   meta: Ixon.Metadata
   deriving Repr
 
 def emptyDematState : DematState := 
-  { idx := 0, meta := { map := Batteries.RBMap.empty }}
+  { idx := 0, store := .empty, meta := { map := .empty }}
 
 inductive TransportError
 | natTooBig (idx: Nat) (x: Nat)
 | unknownIndex (idx: Nat) (m: Ixon.Metadata)
+| unknownAddress (adr: Address)
 | unexpectedNode (idx: Nat) (m: Ixon.Metadata)
+| nonExprIxon (x: Ixon) (m: Ixon.Metadata)
+| nonConstIxon (x: Ixon) (m: Ixon.Metadata)
 | rawMetadata (m: Ixon.Metadata)
-| expectedMetadata (m: Ixon.Const)
+| expectedMetadata (m: Ixon.Ixon)
 | rawProof (m: Proof)
 | rawComm (m: Ixon.Comm)
 | emptyEquivalenceClass
@@ -33,6 +38,9 @@ deriving BEq, Repr
 instance : ToString TransportError where toString
 | .natTooBig idx x => s!"At index {idx}, natural number {x} too big to fit in UInt64"
 | .unknownIndex idx x => s!"Unknown index {idx} with metadata {repr x}"
+| .unknownAddress x => s!"Unknown address {x}"
+| .nonExprIxon x m => s!"Tried to rematerialize {repr x} with metadata {repr m} as expression"
+| .nonConstIxon x m => s!"Tried to rematerialize {repr x} with metadata {repr m} as constant"
 | .unexpectedNode idx x => s!"Unexpected node at {idx} with metadata {repr x}"
 | .rawMetadata x => s!"Can't rematerialize raw metadata {repr x}"
 | .expectedMetadata x => s!"Expected metadata, got {repr x}"
@@ -44,15 +52,18 @@ abbrev DematM := EStateM TransportError DematState
 
 structure RematState where
   idx: Nat
+  store: Batteries.RBMap Address Ixon compare
+
+def emptyRematState : RematState := { idx := 0, store := .empty }
 
-def emptyRematState : RematState := { idx := 0 }
+def rematStateWithStore (store: Batteries.RBMap Address Ixon compare) : RematState := 
+  { idx := 0, store }
 
 structure RematCtx where
   meta: Ixon.Metadata
 
 abbrev RematM := ReaderT RematCtx (EStateM TransportError RematState)
 
-
 def countSucc : Ix.Level -> Nat -> (Nat × Ix.Level)
 | .succ x, i => countSucc x (.succ i)
 | n, i => (i, n)
@@ -151,24 +162,24 @@ def rematUniv : Ixon.Univ -> RematM Ix.Level
   | [.name name] => return .param name (UInt64.toNat x)
   | _ => rematThrowUnexpected
 
-partial def dematExpr : Ix.Expr -> DematM Ixon.Expr
+partial def dematExpr : Ix.Expr -> DematM Ixon
 | .var i => dematIncr *> .vari <$> dematNat i
 | .sort u => dematIncr *> .sort <$> dematUniv u
 | .const n r m us => do
   let _ <- dematIncr
   dematMeta [.name n, .link m ]
-  .cnst r <$> (us.mapM dematUniv)
+  .refr r <$> (us.mapM dematUniv)
 | .rec_ n i us => do
   let _ <- dematIncr
   dematMeta [.name n]
-  .rec_ <$> dematNat i <*> (us.mapM dematUniv)
+  .recr <$> dematNat i <*> (us.mapM dematUniv)
 | .app f a => apps f a []
 | .lam n i t b => lams (.lam n i t b) []
 | .pi n i t b => alls (.pi n i t b) []
 | .letE n t v b nD => do
   let _ <- dematIncr
   dematMeta [.name n]
-  .let_ nD <$> dematExpr t <*> dematExpr v <*> dematExpr b
+  .letE nD <$> dematExpr t <*> dematExpr v <*> dematExpr b
 | .lit l => dematIncr *> match l with
   | .strVal s => return .strl s
   | .natVal n => return .natl n
@@ -177,19 +188,19 @@ partial def dematExpr : Ix.Expr -> DematM Ixon.Expr
   dematMeta [.name n, .link tM ]
   .proj t <$> dematNat i <*> dematExpr s
   where
-    apps : Ix.Expr -> Ix.Expr -> List Ix.Expr -> DematM Ixon.Expr
+    apps : Ix.Expr -> Ix.Expr -> List Ix.Expr -> DematM Ixon
     | .app ff fa, a, as => apps ff fa (a::as)
     | f, a, as => do
       let as' <- as.reverse.mapM (fun a => dematIncr *> dematExpr a)
       .apps <$> dematExpr f <*> dematExpr a <*> pure (as'.reverse)
-    lams : Ix.Expr -> List Ixon.Expr -> DematM Ixon.Expr
+    lams : Ix.Expr -> List Ixon -> DematM Ixon
     | .lam n i t b, ts => do
       let _ <- dematIncr
       dematMeta [.name n, .info i]
       let t' <- dematExpr t
       lams b (t'::ts)
     | x, ts => .lams ts.reverse <$> dematExpr x
-    alls : Ix.Expr -> List Ixon.Expr -> DematM Ixon.Expr
+    alls : Ix.Expr -> List Ixon -> DematM Ixon
     | .pi n i t b, ts => do
       let _ <- dematIncr
       dematMeta [.name n, .info i]
@@ -197,17 +208,17 @@ partial def dematExpr : Ix.Expr -> DematM Ixon.Expr
       alls b (t'::ts)
     | x, ts => .alls ts.reverse <$> dematExpr x
 
-partial def rematExpr : Ixon.Expr -> RematM Ix.Expr
+partial def rematExpr : Ixon -> RematM Ix.Expr
 | .vari i => rematIncr *> pure (.var i.toNat)
 | .sort u => rematIncr *> .sort <$> rematUniv u
-| .cnst adr us => do
+| .refr adr us => do
   let _ <- rematIncr
   let node <- rematMeta
   let us' <- us.mapM rematUniv
   match node with
   | [.name name, .link link] => return (.const name adr link us')
   | _ => rematThrowUnexpected
-| .rec_ i us => do 
+| .recr i us => do 
   let _ <- rematIncr
   let node <- rematMeta
   let us' <- us.mapM rematUniv
@@ -229,7 +240,7 @@ partial def rematExpr : Ixon.Expr -> RematM Ix.Expr
     (fun e => rematIncr *> Prod.mk <$> rematBindMeta <*> rematExpr e)
   let b' <- rematExpr b
   return ts'.foldr (fun (m, t) b => Expr.pi m.fst m.snd t b) b'
-| .let_ nD t d b => do
+| .letE nD t d b => do
   let _ <- rematIncr
   let node <- rematMeta
   let name <- match node with
@@ -245,69 +256,76 @@ partial def rematExpr : Ixon.Expr -> RematM Ix.Expr
   .proj name t link i.toNat <$> rematExpr s
 | .strl s => rematIncr *> return .lit (.strVal s)
 | .natl n => rematIncr *> return .lit (.natVal n)
+| e => do throw (.nonExprIxon e (<- read).meta)
 
-partial def dematConst : Ix.Const -> DematM Ixon.Const
+def dematStore (ixon: Ixon): DematM Address :=
+  let addr := Address.blake3 (Ixon.runPut (Ixon.Serialize.put ixon))
+  modifyGet fun stt => (addr, { stt with
+    store := stt.store.insert addr ixon
+  })
+
+partial def dematConst : Ix.Const -> DematM Ixon
 | .«axiom» x => do
   dematMeta [.name x.name]
   let lvls <- dematLevels x.levelParams
-  let type <- dematExpr x.type
+  let type <- dematExpr x.type >>= dematStore
   return .axio (.mk lvls type x.isUnsafe)
 | .«definition» x => .defn <$> dematDefn x
 | .quotient x => do
   dematMeta [.name x.name]
   let lvls <- dematLevels x.levelParams
-  let type <- dematExpr x.type
+  let type <- dematExpr x.type >>= dematStore
   return .quot (.mk lvls type x.kind)
 | .inductiveProj x => do
   dematMeta [.name x.name, .link x.blockMeta]
-  return .indcProj (.mk x.blockCont x.idx)
+  return .iprj (.mk x.blockCont x.idx)
 | .constructorProj x => do
   dematMeta [.name x.name, .link x.blockMeta, .name x.induct]
-  return .ctorProj (.mk x.blockCont x.idx x.cidx)
+  return .cprj (.mk x.blockCont x.idx x.cidx)
 | .recursorProj x => do
   dematMeta [.name x.name, .link x.blockMeta, .name x.induct]
-  return .recrProj (.mk x.blockCont x.idx x.ridx)
+  return .rprj (.mk x.blockCont x.idx x.ridx)
 | .definitionProj x => do
   dematMeta [.name x.name, .link x.blockMeta]
-  return .defnProj (.mk x.blockCont x.idx)
+  return .dprj (.mk x.blockCont x.idx)
 | .mutual x => do
   dematMeta [.mutCtx x.ctx]
   let defs <- x.defs.mapM fun ds => ds.mapM dematDefn
   let ds <- defs.mapM fun d => match d.head? with
     | .some a => pure a
     | .none => throw .emptyEquivalenceClass
-  return .mutDef ds
+  return .defs ds
 | .inductive x => do
   dematMeta [.mutCtx x.ctx]
   let inds <- x.inds.mapM fun is => is.mapM dematIndc
   let is <- inds.mapM fun i => match i.head? with
     | .some a => pure a
     | .none => throw .emptyEquivalenceClass
-  return .mutInd is
+  return .inds is
   where
     dematDefn (x: Ix.Definition): DematM Ixon.Definition := do
       let _ <- dematIncr
       dematMeta [.name x.name, .hints x.hints, .all x.all]
       let lvls <- dematLevels x.levelParams
-      let type <- dematExpr x.type
-      let value <- dematExpr x.value
+      let type <- dematExpr x.type >>= dematStore
+      let value <- dematExpr x.value >>= dematStore
       return .mk lvls type x.mode value x.safety
     dematCtor (x: Ix.Constructor): DematM Ixon.Constructor := do
       let _ <- dematIncr
       dematMeta [.name x.name]
       let lvls <- dematLevels x.levelParams
-      let t <- dematExpr x.type
+      let t <- dematExpr x.type >>= dematStore
       return .mk lvls t x.cidx x.numParams x.numFields x.isUnsafe
     dematRecrRule (x: Ix.RecursorRule): DematM Ixon.RecursorRule := do
       let _ <- dematIncr
       dematMeta [.name x.ctor]
-      let rhs <- dematExpr x.rhs
+      let rhs <- dematExpr x.rhs >>= dematStore
       return ⟨x.nfields, rhs⟩
     dematRecr (x: Ix.Recursor): DematM Ixon.Recursor := do
       let _ <- dematIncr
       dematMeta [.name x.name]
       let lvls <- dematLevels x.levelParams
-      let t <- dematExpr x.type
+      let t <- dematExpr x.type >>= dematStore
       let rrs <- x.rules.mapM dematRecrRule
       return ⟨lvls, t, x.numParams, x.numIndices, x.numMotives, x.numMinors, 
         rrs, x.k, x.isUnsafe⟩
@@ -315,62 +333,72 @@ partial def dematConst : Ix.Const -> DematM Ixon.Const
       let _ <- dematIncr
       dematMeta [.name x.name, .all x.all]
       let lvls <- dematLevels x.levelParams
-      let type <- dematExpr x.type
+      let type <- dematExpr x.type >>= dematStore
       let ctors <- x.ctors.mapM dematCtor
       let recrs <- x.recrs.mapM dematRecr
       return ⟨lvls, type, x.numParams, x.numIndices, ctors, recrs, x.numNested,
         x.isRec, x.isReflexive, x.isUnsafe⟩
 
-def constToIxon (x: Ix.Const) : Except TransportError (Ixon.Const × Ixon.Const) := 
+def constToIxon (x: Ix.Const) : Except TransportError (Ixon × Ixon) := 
   match EStateM.run (dematConst x) emptyDematState with
-  | .ok ix stt => .ok (ix, Ixon.Const.meta stt.meta)
+  | .ok ix stt => .ok (ix, Ixon.meta stt.meta)
   | .error e _ => .error e
 
 def constToBytes (x: Ix.Const) : Except TransportError ByteArray := do
   let (ix, _) <- constToIxon x
-  return Ixon.Serialize.put ix
+  return runPut (Serialize.put ix)
 
 def constAddress (x: Ix.Const) : Except TransportError Address := do
   let bs <- constToBytes x
   return Address.blake3 bs
 
-partial def rematConst : Ixon.Const -> RematM Ix.Const
+def rematAddress (adr: Address): RematM Ixon := do
+  match (<- get).store.find? adr with
+  | .some x => return x
+  | .none => throw (.unknownAddress adr)
+
+def rematExprAddress (adr: Address): RematM Ix.Expr := do
+  match (<- get).store.find? adr with
+  | .some x => rematExpr x
+  | .none => throw (.unknownAddress adr)
+
+partial def rematConst : Ixon -> RematM Ix.Const
 | .defn x => .«definition» <$> rematDefn x
 | .axio x => do
   let name <- match (<- rematMeta) with
     | [.name x] => pure x
     | _ => rematThrowUnexpected
   let lvls <- rematLevels x.lvls
-  let type <- rematExpr x.type
+  let type <- rematExprAddress x.type
   return .«axiom» ⟨name, lvls, type, x.isUnsafe⟩
 | .quot x => do
   let name <- match (<- rematMeta) with
     | [.name x] => pure x
     | _ => rematThrowUnexpected
   let lvls <- rematLevels x.lvls
-  let type <- rematExpr x.type
+  let type <- rematExprAddress x.type
   return .quotient ⟨name, lvls, type, x.kind⟩
-| .indcProj x => do
+| .iprj x => do
   let (name, link) <- match (<- rematMeta) with
     | [.name n, .link x] => pure (n, x)
     | _ => rematThrowUnexpected
   return .inductiveProj ⟨name, x.block, link, x.idx⟩
-| .ctorProj x => do
+| .cprj x => do
   let (name, link, induct) <- match (<- rematMeta) with
     | [.name n, .link x, .name i] => pure (n, x, i)
     | _ => rematThrowUnexpected
   return .constructorProj ⟨name, x.block, link, x.idx, induct, x.cidx⟩
-| .recrProj x => do
+| .rprj x => do
   let (name, link, induct) <- match (<- rematMeta) with
     | [.name n, .link x, .name i] => pure (n, x, i)
     | _ => rematThrowUnexpected
   return .recursorProj ⟨name, x.block, link, x.idx, induct, x.ridx⟩
-| .defnProj x => do
+| .dprj x => do
   let (name, link) <- match (<- rematMeta) with
     | [.name n, .link x] => pure (n, x)
     | _ => rematThrowUnexpected
   return .definitionProj ⟨name, x.block, link, x.idx⟩
-| .mutDef xs => do
+| .defs xs => do
   let ctx <- match (<- rematMeta) with
     | [.mutCtx x] => pure x
     | _ => rematThrowUnexpected
@@ -382,7 +410,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
       ds := ds.push d
     defs := defs.push ds.toList
   return .mutual ⟨defs.toList⟩
-| .mutInd xs => do
+| .inds xs => do
   let ctx <- match (<- rematMeta) with
     | [.mutCtx x] => pure x
     | _ => rematThrowUnexpected
@@ -396,8 +424,9 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
   return .inductive ⟨inds.toList⟩
 | .meta m => throw (.rawMetadata m)
 -- TODO: This could return a Proof inductive, since proofs have no metadata
-| .proof p => throw (.rawProof p)
+| .prof p => throw (.rawProof p)
 | .comm p => throw (.rawComm p)
+| e => do throw (.nonConstIxon e (<- read).meta)
   where
     rematDefn (x: Ixon.Definition) : RematM Ix.Definition := do
       let _ <- rematIncr
@@ -405,8 +434,8 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
         | [.name n, .hints h, .all as] => pure (n, h, as)
         | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
-      let type <- rematExpr x.type
-      let value <- rematExpr x.value
+      let type <- rematExprAddress x.type
+      let value <- rematExprAddress x.value
       return .mk name lvls type x.mode value hints x.safety all
     rematCtor (x: Ixon.Constructor) : RematM Ix.Constructor := do
       let _ <- rematIncr
@@ -414,14 +443,14 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
         | [.name n] => pure n
         | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
-      let t <- rematExpr x.type
+      let t <- rematExprAddress x.type
       return .mk name lvls t x.cidx x.params x.fields x.isUnsafe
     rematRecrRule (x: Ixon.RecursorRule) : RematM Ix.RecursorRule := do
       let _ <- rematIncr
       let ctor <- match (<- rematMeta) with
         | [.name n] => pure n
         | _ => rematThrowUnexpected
-      let rhs <- rematExpr x.rhs
+      let rhs <- rematExprAddress x.rhs
       return ⟨ctor, x.fields, rhs⟩
     rematRecr (x: Ixon.Recursor) : RematM Ix.Recursor := do
       let _ <- rematIncr
@@ -429,7 +458,7 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
         | [.name n] => pure n
         | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
-      let t <- rematExpr x.type
+      let t <- rematExprAddress x.type
       let rs <- x.rules.mapM rematRecrRule
       return ⟨name, lvls, t, x.params, x.indices, x.motives, x.minors, rs, x.k, x.isUnsafe⟩
     rematIndc (x: Ixon.Inductive) : RematM Ix.Inductive := do
@@ -438,13 +467,13 @@ partial def rematConst : Ixon.Const -> RematM Ix.Const
         | [.name n, .all as] => pure (n, as)
         | _ => rematThrowUnexpected
       let lvls <- rematLevels x.lvls
-      let t <- rematExpr x.type
+      let t <- rematExprAddress x.type
       let cs <- x.ctors.mapM rematCtor
       let rs <- x.recrs.mapM rematRecr
       return ⟨name, lvls, t, x.params, x.indices, all, cs, rs, x.nested, x.recr,
         x.refl, x.isUnsafe⟩
 
-def rematerialize (c m: Ixon.Const) : Except TransportError Ix.Const := do
+def rematerialize (c m: Ixon) : Except TransportError Ix.Const := do
   let m <- match m with
   | .meta m => pure m
   | x => throw <| .expectedMetadata x
diff --git a/Tests/Ix.lean b/Tests/Ix.lean
index 774abf88..a89d72c9 100644
--- a/Tests/Ix.lean
+++ b/Tests/Ix.lean
@@ -19,7 +19,7 @@ open SlimCheck
 open SlimCheck.Gen
 
 def serde [Ixon.Serialize A] [BEq A] (x: A) : Bool :=
-  match Ixon.Serialize.get (Ixon.Serialize.put x) with
+  match Ixon.runGet Ixon.Serialize.get (Ixon.runPut <| Ixon.Serialize.put x) with
   | .ok (y : A) => x == y
   | _ => false
 
@@ -29,7 +29,7 @@ def transportUniv (univ: Ix.Level): Bool :=
   match EStateM.run (dematUniv univ) emptyDematState with
   | .ok ixon stt =>
     let remat := (ReaderT.run (rematUniv ixon) { meta := stt.meta})
-    match EStateM.run remat emptyRematState with
+    match EStateM.run remat (rematStateWithStore stt.store) with
     | .ok ix _ => univ == ix
     | .error _ _ => .false
   | .error _ _ => .false
@@ -38,7 +38,7 @@ def transportExpr (x: Ix.Expr): Bool :=
   match EStateM.run (dematExpr x) emptyDematState with
   | .ok ixon stt =>
     let remat := (ReaderT.run (rematExpr ixon) { meta := stt.meta})
-    match EStateM.run remat emptyRematState with
+    match EStateM.run remat (rematStateWithStore stt.store) with
     | .ok ix _ => x == ix
     | .error _ _ => .false
   | .error _ _ => .false
@@ -47,7 +47,7 @@ def transportConst (x: Ix.Const): Bool :=
   match EStateM.run (dematConst x) emptyDematState with
   | .ok ixon stt =>
     let remat := (ReaderT.run (rematConst ixon) { meta := stt.meta})
-    match EStateM.run remat emptyRematState with
+    match EStateM.run remat (rematStateWithStore stt.store) with
     | .ok ix _ => x == ix
     | .error _ _ => .false
   | .error _ _ => .false
@@ -83,8 +83,13 @@ def Tests.Ix.suite : List LSpec.TestSeq :=
     check "metadatum serde" (∀ x : Ixon.Metadatum, serde x),
     check "universe serde" (∀ x : Ixon.Univ, serde x),
     check "universe transport" (∀ x : Ix.Level, transportUniv x),
-    check "expr serde" (∀ x : Ixon.Expr, serde x),
+    check "expr serde" (∀ x : Ixon.IxonExpr, serde x),
     check "expr transport" (∀ x : Ix.Expr, transportExpr x),
-    check "const serde" (∀ x : Ixon.Const, serde x),
+    --check "axiom serde" (∀ x : Ixon.Axiom, serde x),
+    --check "recursor rule serde" (∀ x : Ixon.RecursorRule, serde x),
+    --check "recursor serde" (∀ x : Ixon.Recursor, serde x),
+    --check "constructor serde" (∀ x : Ixon.Constructor, serde x),
+    --check "inductive serde" (∀ x : Ixon.Inductive, serde x),
+    check "const serde" (∀ x : Ixon.IxonConst, serde x),
     check "const transport" (∀ x : Ix.Const, transportConst x),
   ]
diff --git a/Tests/Ix/Common.lean b/Tests/Ix/Common.lean
index 1b37f51c..ef35f41e 100644
--- a/Tests/Ix/Common.lean
+++ b/Tests/Ix/Common.lean
@@ -13,6 +13,7 @@ import Tests.Common
 open LSpec
 open SlimCheck
 open SlimCheck.Gen
+open Ixon
 
 def genAddress : SlimCheck.Gen Address := 
   pure (Address.mk (Blake3.hash "foobar".toUTF8).val)
@@ -70,7 +71,7 @@ def genBinderInfo : Gen Lean.BinderInfo := oneOf'
    , pure .instImplicit
    ]
 
-def genDefMode : Gen Ix.DefMode := oneOf'
+def genDefKind : Gen Ix.DefKind := oneOf'
    [ pure .opaque
    , pure .theorem
    , pure .definition
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index 60fa726b..20fdd96c 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -63,7 +63,7 @@ def genConst : Gen Ix.Const := getSize >>= go
       let n <- genName
       let lvls <- genNames
       let type <- genExpr
-      let mode <- genDefMode
+      let mode <- genDefKind
       let value <- genExpr
       let hints <- genReducibilityHints
       let safety <- oneOf #[pure .safe, pure .partial, pure .unsafe]
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index ec508370..244be4cb 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -36,35 +36,42 @@ instance : SampleableExt Univ := SampleableExt.mkSelfContained genUniv
 
 -- Expr
 
-def genExpr : SlimCheck.Gen Ixon.Expr := getSize >>= go
+def genExpr : SlimCheck.Gen Ixon := getSize >>= go
   where
-    go : Nat -> SlimCheck.Gen Ixon.Expr
+    go : Nat -> SlimCheck.Gen Ixon
     | 0 => return .vari 0
     | Nat.succ f =>
       frequency [
         (100, .vari <$> genUInt64),
         (100, .sort <$> genUniv),
-        (100, .cnst <$> genAddress <*> resizeListOf genUniv),
-        (100, .rec_ <$> genUInt64 <*> resizeListOf genUniv),
+        (100, .refr <$> genAddress <*> resizeListOf genUniv),
+        (100, .recr <$> genUInt64 <*> resizeListOf genUniv),
         (30, .apps <$> go f <*> go f <*> resizeListOf (go f)),
         (30, .lams <$> resizeListOf (go f) <*> go f),
         (30, .alls <$> resizeListOf (go f) <*> go f),
-        (15, .let_ .true <$> go f <*> go f <*> go f),
-        (15, .let_ .false <$> go f <*> go f <*> go f),
+        (15, .letE .true <$> go f <*> go f <*> go f),
+        (15, .letE .false <$> go f <*> go f <*> go f),
         (50, .proj <$> genAddress <*> genUInt64 <*> go f),
         (100, .strl <$> genString),
         (100, .natl <$> chooseAny Nat)
       ]
 
+structure IxonExpr where
+  ixon : Ixon
+deriving BEq, Repr
+
+instance : Serialize IxonExpr where
+  put x := Serialize.put x.ixon
+  get := .mk <$> Serialize.get
+
 -- TODO: useful shrinking
-instance : Shrinkable Expr where
+instance : Shrinkable IxonExpr where
   shrink _ := []
 
-instance : SampleableExt Expr := SampleableExt.mkSelfContained genExpr
+instance : SampleableExt IxonExpr := 
+  SampleableExt.mkSelfContained (IxonExpr.mk <$> genExpr)
 
 -- Metadata
-
-
 def genMetadatum : Gen Ixon.Metadatum := 
   frequency [
     (100, .name <$> genName),
@@ -87,33 +94,66 @@ def genMetadata : Gen Metadata := do
   let xs ← genList' genMetaNode
   return .mk (Batteries.RBMap.ofList ((List.range xs.length).zip xs) compare)
 
-
 -- Const
+def genAxiom : Gen Axiom := .mk <$> genNat' <*> genAddress <*> genBool
+
+-- TODO: useful shrinking
+instance : Shrinkable Axiom where
+  shrink _ := []
 
-def genAxiom : Gen Axiom := .mk <$> genNat' <*> genExpr <*> genBool
+instance : SampleableExt Axiom 
+  := SampleableExt.mkSelfContained genAxiom
 
 def genDefinition : Gen Definition := do
   let lvls <- genNat'
-  let type <- genExpr
-  let mode <- genDefMode
-  let value <- genExpr
+  let type <- genAddress
+  let mode <- genDefKind
+  let value <- genAddress
   let safety <- oneOf #[pure .safe, pure .unsafe, pure .partial]
   return .mk lvls type mode value safety
 
 def genConstructor : Gen Constructor :=
-  .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat' <*> genBool
+  .mk <$> genNat' <*> genAddress <*> genNat' <*> genNat' <*> genNat' <*> genBool
+
+-- TODO: useful shrinking
+instance : Shrinkable Constructor where
+  shrink _ := []
+
+instance : SampleableExt Constructor
+  := SampleableExt.mkSelfContained genConstructor
+
+def genRecursorRule : Gen RecursorRule := .mk <$> genNat' <*> genAddress
+
+-- TODO: useful shrinking
+instance : Shrinkable RecursorRule where
+  shrink _ := []
 
-def genRecursorRule : Gen RecursorRule := .mk <$> genNat' <*> genExpr
+instance : SampleableExt RecursorRule
+  := SampleableExt.mkSelfContained genRecursorRule
 
 def genRecursor : Gen Recursor :=
-  .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat' <*> genNat'
+  .mk <$> genNat' <*> genAddress <*> genNat' <*> genNat' <*> genNat'
     <*> genNat' <*> genList' genRecursorRule <*> genBool <*> genBool
 
+-- TODO: useful shrinking
+instance : Shrinkable Recursor where
+  shrink _ := []
+
+instance : SampleableExt Recursor
+  := SampleableExt.mkSelfContained genRecursor
+
 def genInductive : Gen Inductive :=
-  .mk <$> genNat' <*> genExpr <*> genNat' <*> genNat'
+  .mk <$> genNat' <*> genAddress <*> genNat' <*> genNat'
     <*> genList' genConstructor <*> genList' genRecursor <*> genNat'
     <*> genBool <*> genBool <*> genBool
 
+-- TODO: useful shrinking
+instance : Shrinkable Inductive where
+  shrink _ := []
+
+instance : SampleableExt Inductive
+  := SampleableExt.mkSelfContained genInductive
+
 def genConstructorProj : Gen ConstructorProj :=
   .mk <$> genAddress <*> genNat' <*> genNat'
 
@@ -126,30 +166,36 @@ def genDefinitionProj : Gen DefinitionProj :=
 def genInductiveProj : Gen InductiveProj :=
   .mk <$> genAddress <*> genNat'
 
-
-def genConst : Gen Ixon.Const := getSize >>= go
+def genConst : Gen Ixon := getSize >>= go
   where
-    go : Nat -> Gen Ixon.Const
-    | 0 => return .axio ⟨0, .vari 0, false⟩
+    go : Nat -> Gen Ixon
+    | 0 => .axio <$> genAxiom
     | Nat.succ _ =>
       frequency [
         (100, .axio <$> genAxiom),
         (100, .defn <$> genDefinition),
-        --(100, .ctor <$> genConstructor),
-        --(100, .recr <$> genRecursor),
-        --(100, .indc <$> genInductive),
-        (100, .ctorProj <$> genConstructorProj),
-        (100, .recrProj <$> genRecursorProj),
-        (100, .indcProj <$> genInductiveProj),
-        (100, .defnProj <$> genDefinitionProj),
-        (100, .mutDef <$> genList' genDefinition),
-        (100, .mutInd <$> genList' genInductive),
+        (100, .cprj <$> genConstructorProj),
+        (100, .rprj <$> genRecursorProj),
+        (100, .iprj <$> genInductiveProj),
+        (100, .dprj <$> genDefinitionProj),
+        (100, .defs <$> genList' genDefinition),
+        (100, .inds <$> genList' genInductive),
         (100, .meta <$> genMetadata),
       ]
 
+structure IxonConst where
+  ixon : Ixon
+deriving BEq, Repr
+
+instance : Serialize IxonConst where
+  put x := Serialize.put x.ixon
+  get := .mk <$> Serialize.get
+
 -- TODO: useful shrinking
-instance : Shrinkable Const where
+instance : Shrinkable IxonConst where
   shrink _ := []
 
-instance : SampleableExt Const := SampleableExt.mkSelfContained genConst
+instance : SampleableExt IxonConst 
+  := SampleableExt.mkSelfContained (IxonConst.mk <$> genConst)
+
 end Ixon

From da561e50819fcafeabbc90f7ef5c6fc5def591a9 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Wed, 27 Aug 2025 15:44:42 -0300
Subject: [PATCH 38/74] Ixon reconstruction in Rust from Lean pointers

---
 Ix/Ixon.lean         | 214 ++++++++++++++++++++-
 Tests/Ix/Ixon.lean   |  17 +-
 src/lean/ffi/ixon.rs | 448 +++++++++++++++++++++++++++++++++++++++++++
 src/lean/ffi/mod.rs  |   1 +
 4 files changed, 674 insertions(+), 6 deletions(-)
 create mode 100644 src/lean/ffi/ixon.rs

diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 6df34954..df161b76 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -121,5 +121,217 @@ instance : Serialize Ixon where
   put := putIxon
   get := getIxon
 
-end Ixon
+section FFI
+
+/--
+# Ixon FFI types
+
+This section defines FFI-friendly versions of the original Ixon datatypes by
+* Replacing `Nat` by `ByteArray` containing the corresponding bytes in LE
+* Replacing `List` by `Array`
+* Replacing maps by `Array`s of pairs
+-/
+
+@[inline] def nat2Bytes (n : Nat) : ByteArray :=
+  ⟨natToBytesLE n⟩
+
+structure DefinitionFFI where
+  lvls : ByteArray
+  type : Address
+  mode : Ix.DefKind
+  value : Address
+  safety : Lean.DefinitionSafety
+
+def Definition.toFFI : Definition → DefinitionFFI
+  | ⟨lvls, type, mode, value, safety⟩ =>
+    ⟨nat2Bytes lvls, type, mode, value, safety⟩
+
+structure AxiomFFI where
+  lvls : ByteArray
+  type : Address
+  isUnsafe: Bool
+
+def Axiom.toFFI : Axiom → AxiomFFI
+  | ⟨lvls, type, isUnsafe⟩ => ⟨nat2Bytes lvls, type, isUnsafe⟩
+
+structure QuotientFFI where
+  lvls : ByteArray
+  type : Address
+  kind : Lean.QuotKind
+
+def Quotient.toFFI : Quotient → QuotientFFI
+  | ⟨lvls, type, kind⟩ => ⟨nat2Bytes lvls, type, kind⟩
+
+structure ConstructorProjFFI where
+  block : Address
+  idx : ByteArray
+  cidx : ByteArray
+
+def ConstructorProj.toFFI : ConstructorProj → ConstructorProjFFI
+  | ⟨block, idx, cidx⟩ => ⟨block, nat2Bytes idx, nat2Bytes cidx⟩
+
+structure RecursorProjFFI where
+  block : Address
+  idx : ByteArray
+  ridx : ByteArray
+
+def RecursorProj.toFFI : RecursorProj → RecursorProjFFI
+  | ⟨block, idx, ridx⟩ => ⟨block, nat2Bytes idx, nat2Bytes ridx⟩
+
+structure InductiveProjFFI where
+  block : Address
+  idx : ByteArray
+
+def InductiveProj.toFFI : InductiveProj → InductiveProjFFI
+  | ⟨block, idx⟩ => ⟨block, nat2Bytes idx⟩
+
+structure DefinitionProjFFI where
+  block : Address
+  idx : ByteArray
 
+def DefinitionProj.toFFI : DefinitionProj → DefinitionProjFFI
+  | ⟨block, idx⟩ => ⟨block, nat2Bytes idx⟩
+
+structure RecursorRuleFFI where
+  fields : ByteArray
+  rhs : Address
+
+def RecursorRule.toFFI : RecursorRule → RecursorRuleFFI
+  | ⟨fields, rhs⟩ => ⟨nat2Bytes fields, rhs⟩
+
+structure RecursorFFI where
+  lvls : ByteArray
+  type : Address
+  params : ByteArray
+  indices : ByteArray
+  motives : ByteArray
+  minors : ByteArray
+  rules : Array RecursorRuleFFI
+  k : Bool
+  isUnsafe: Bool
+
+def Recursor.toFFI : Recursor → RecursorFFI
+  | ⟨lvls, type, params, indices, motives, minors, rules, k, isUnsafe⟩ =>
+    ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
+      nat2Bytes motives, nat2Bytes minors, rules.toArray.map RecursorRule.toFFI,
+      k, isUnsafe⟩
+
+structure ConstructorFFI where
+  lvls : ByteArray
+  type : Address
+  cidx : ByteArray
+  params : ByteArray
+  fields : ByteArray
+  isUnsafe: Bool
+
+def Constructor.toFFI : Constructor → ConstructorFFI
+  | ⟨lvls, type, cidx, params, fields, isUnsafe⟩ =>
+    ⟨nat2Bytes lvls, type, nat2Bytes cidx, nat2Bytes params, nat2Bytes fields, isUnsafe⟩
+
+structure InductiveFFI where
+  lvls : ByteArray
+  type : Address
+  params : ByteArray
+  indices : ByteArray
+  ctors : Array ConstructorFFI
+  recrs : Array RecursorFFI
+  nested : ByteArray
+  recr : Bool
+  refl : Bool
+  isUnsafe: Bool
+
+def Inductive.toFFI : Inductive → InductiveFFI
+  | ⟨lvls, type, params, indices, ctors, recrs, nested, recr, refl, isUnsafe⟩ =>
+    ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
+      ctors.toArray.map Constructor.toFFI, recrs.toArray.map Recursor.toFFI,
+      nat2Bytes nested, recr, refl, isUnsafe⟩
+
+inductive NameFFI
+  | anonymous
+  | str : NameFFI → String → NameFFI
+  | num : NameFFI → ByteArray → NameFFI
+
+def _root_.Lean.Name.toFFI : Lean.Name → NameFFI
+  | .anonymous => .anonymous
+  | .str name s => .str name.toFFI s
+  | .num name n => .num name.toFFI (nat2Bytes n)
+
+inductive MetadatumFFI where
+| name : NameFFI -> MetadatumFFI
+| info : Lean.BinderInfo -> MetadatumFFI
+| link : Address -> MetadatumFFI
+| hints : Lean.ReducibilityHints -> MetadatumFFI
+| all : Array NameFFI -> MetadatumFFI
+| mutCtx : Array (Array NameFFI) -> MetadatumFFI
+
+def Metadatum.toFFI : Metadatum → MetadatumFFI
+  | .name n => .name n.toFFI
+  | .info i => .info i
+  | .link addr => .link addr
+  | .hints h => .hints h
+  | .all ns => .all (ns.toArray.map Lean.Name.toFFI)
+  | .mutCtx ctx => .mutCtx $ ctx.toArray.map (·.toArray.map Lean.Name.toFFI)
+
+inductive IxonFFI where
+| vari : UInt64 -> IxonFFI
+| sort : Univ -> IxonFFI
+| refr : Address -> Array Univ -> IxonFFI
+| recr : UInt64 -> Array Univ -> IxonFFI
+| apps : IxonFFI -> IxonFFI -> Array IxonFFI -> IxonFFI
+| lams : Array IxonFFI -> IxonFFI -> IxonFFI
+| alls : Array IxonFFI -> IxonFFI -> IxonFFI
+| letE : Bool -> IxonFFI -> IxonFFI -> IxonFFI -> IxonFFI
+| proj : Address -> UInt64 -> IxonFFI -> IxonFFI
+| strl : String -> IxonFFI
+| natl : ByteArray -> IxonFFI
+| list : Array IxonFFI -> IxonFFI
+| defn : DefinitionFFI -> IxonFFI
+| axio : AxiomFFI -> IxonFFI
+| quot : QuotientFFI -> IxonFFI
+| cprj : ConstructorProjFFI -> IxonFFI
+| rprj : RecursorProjFFI -> IxonFFI
+| iprj : InductiveProjFFI -> IxonFFI
+| dprj : DefinitionProjFFI -> IxonFFI
+| inds : Array InductiveFFI -> IxonFFI
+| defs : Array DefinitionFFI -> IxonFFI
+| meta : Array (ByteArray × (Array MetadatumFFI)) -> IxonFFI
+| prof : Proof -> IxonFFI
+| eval : EvalClaim -> IxonFFI
+| chck : CheckClaim -> IxonFFI
+| comm : Comm -> IxonFFI
+| envn : Unit -> IxonFFI
+
+def Ixon.toFFI : Ixon → IxonFFI
+  | .vari i => .vari i
+  | .sort u => .sort u
+  | .refr addr univs => .refr addr univs.toArray
+  | .recr i us => .recr i us.toArray
+  | .apps f a as => .apps f.toFFI a.toFFI (as.map Ixon.toFFI).toArray
+  | .lams xs b => .lams (xs.map Ixon.toFFI).toArray b.toFFI
+  | .alls xs x => .alls (xs.map Ixon.toFFI).toArray x.toFFI
+  | .letE x v t b => .letE x v.toFFI t.toFFI b.toFFI
+  | .proj addr i x => .proj addr i x.toFFI
+  | .strl s => .strl s
+  | .natl n => .natl (nat2Bytes n)
+  | .list xs => .list (xs.map Ixon.toFFI).toArray
+  | .defn d => .defn d.toFFI
+  | .axio a => .axio a.toFFI
+  | .quot q => .quot q.toFFI
+  | .cprj c => .cprj c.toFFI
+  | .rprj r => .rprj r.toFFI
+  | .iprj i => .iprj i.toFFI
+  | .dprj d => .dprj d.toFFI
+  | .inds is => .inds (is.map Inductive.toFFI).toArray
+  | .defs d => .defs (d.map Definition.toFFI).toArray
+  | .meta ⟨map⟩ =>
+    .meta $ map.toList.toArray.map
+      fun (x, y) => (nat2Bytes x, y.toArray.map Metadatum.toFFI)
+  | .prof p => .prof p
+  | .eval x => .eval x
+  | .chck x => .chck x
+  | .comm x => .comm x
+  | .envn x => .envn x
+
+end FFI
+
+end Ixon
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 244be4cb..40f366cc 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -68,11 +68,11 @@ instance : Serialize IxonExpr where
 instance : Shrinkable IxonExpr where
   shrink _ := []
 
-instance : SampleableExt IxonExpr := 
+instance : SampleableExt IxonExpr :=
   SampleableExt.mkSelfContained (IxonExpr.mk <$> genExpr)
 
 -- Metadata
-def genMetadatum : Gen Ixon.Metadatum := 
+def genMetadatum : Gen Ixon.Metadatum :=
   frequency [
     (100, .name <$> genName),
     (100, .info <$> genBinderInfo),
@@ -87,7 +87,7 @@ instance : Shrinkable Metadatum where
 instance : SampleableExt Metadatum :=
   SampleableExt.mkSelfContained genMetadatum
 
-def genMetaNode : Gen (List Metadatum) := 
+def genMetaNode : Gen (List Metadatum) :=
   genList' genMetadatum
 
 def genMetadata : Gen Metadata := do
@@ -101,7 +101,7 @@ def genAxiom : Gen Axiom := .mk <$> genNat' <*> genAddress <*> genBool
 instance : Shrinkable Axiom where
   shrink _ := []
 
-instance : SampleableExt Axiom 
+instance : SampleableExt Axiom
   := SampleableExt.mkSelfContained genAxiom
 
 def genDefinition : Gen Definition := do
@@ -195,7 +195,14 @@ instance : Serialize IxonConst where
 instance : Shrinkable IxonConst where
   shrink _ := []
 
-instance : SampleableExt IxonConst 
+instance : SampleableExt IxonConst
   := SampleableExt.mkSelfContained (IxonConst.mk <$> genConst)
 
+/--
+Whether the provided IxonFFI term, reconstructed and serialized in Rust, matches
+the provided bytes.
+-/
+@[extern "rs_eq_lean_rust_serialization"]
+opaque eqLeanRustSerialization : @& IxonFFI -> @& ByteArray -> Bool
+
 end Ixon
diff --git a/src/lean/ffi/ixon.rs b/src/lean/ffi/ixon.rs
new file mode 100644
index 00000000..ee09f230
--- /dev/null
+++ b/src/lean/ffi/ixon.rs
@@ -0,0 +1,448 @@
+use blake3::Hash;
+use num_bigint::BigUint;
+use std::ffi::c_void;
+
+use crate::{
+    ixon::{
+        address::Address, claim::{Claim, Proof}, constant::{
+            Axiom, Comm, Constructor, ConstructorProj, DefKind, DefSafety, Definition, DefinitionProj, Inductive, InductiveProj, QuotKind, Quotient, Recursor, RecursorProj, RecursorRule
+        }, meta::{BinderInfo, Metadata, Metadatum, ReducibilityHints}, name::{Name, NamePart}, nat::Nat, serialize::Serialize, univ::Univ, Ixon
+    },
+    lean::{
+        array::LeanArrayObject, as_ref_unsafe, ctor::LeanCtorObject, lean_is_scalar,
+        sarray::LeanSArrayObject, string::LeanStringObject
+    },
+    lean_unbox,
+};
+
+fn lean_ctor_to_univ(ctor: &LeanCtorObject) -> Univ {
+    match ctor.tag() {
+        0 => {
+            let [val] = ctor.objs();
+            Univ::Const(val as u64)
+        }
+        1 => {
+            let [idx] = ctor.objs();
+            Univ::Var(idx as u64)
+        }
+        2 => {
+            let [b_ptr, a_idx] = ctor.objs();
+            let a_idx = a_idx as u64;
+            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
+            Univ::Add(a_idx, b.into())
+        }
+        3 => {
+            let [a_ptr, b_ptr] = ctor.objs();
+            let a = lean_ctor_to_univ(as_ref_unsafe(a_ptr.cast()));
+            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
+            Univ::Max(a.into(), b.into())
+        }
+        4 => {
+            let [a_ptr, b_ptr] = ctor.objs();
+            let a = lean_ctor_to_univ(as_ref_unsafe(a_ptr.cast()));
+            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
+            Univ::IMax(a.into(), b.into())
+        }
+        _ => unreachable!(),
+    }
+}
+
+fn lean_ptr_to_address(ptr: *const c_void) -> Address {
+    let sarray: &LeanSArrayObject = as_ref_unsafe(ptr.cast());
+    let hash = Hash::from_slice(sarray.data()).unwrap();
+    Address { hash }
+}
+
+fn lean_ptr_to_univs(ptr: *const c_void) -> Vec<Univ> {
+    let univs: &LeanArrayObject = as_ref_unsafe(ptr.cast());
+    univs.to_vec(|ptr| lean_ctor_to_univ(as_ref_unsafe(ptr.cast())))
+}
+
+fn lean_ptr_to_nat(ptr: *const c_void) -> Nat {
+    let nat_bytes: &LeanSArrayObject = as_ref_unsafe(ptr.cast());
+    Nat(BigUint::from_bytes_le(nat_bytes.data()))
+}
+
+fn lean_ptr_to_definition(ptr: *const c_void) -> Definition {
+    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [lvls, typ, value, mode_safety] = ctor.objs();
+    let lvls = lean_ptr_to_nat(lvls);
+    let typ = lean_ptr_to_address(typ);
+    let value = lean_ptr_to_address(value);
+    let [mode, safety, ..] = (mode_safety as usize).to_le_bytes();
+    let mode = match mode {
+        0 => DefKind::Definition,
+        1 => DefKind::Opaque,
+        2 => DefKind::Theorem,
+        _ => unreachable!(),
+    };
+    let safety = match safety {
+        0 => DefSafety::Unsafe,
+        1 => DefSafety::Safe,
+        2 => DefSafety::Partial,
+        _ => unreachable!(),
+    };
+    Definition {lvls, typ, mode: mode, value, safety}
+}
+
+fn lean_ptr_to_constructor(ptr: *const c_void) -> Constructor {
+    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [lvls, typ, cidx, params, fields, is_unsafe] = ctor.objs();
+    let lvls = lean_ptr_to_nat(lvls);
+    let typ = lean_ptr_to_address(typ);
+    let cidx = lean_ptr_to_nat(cidx);
+    let params = lean_ptr_to_nat(params);
+    let fields = lean_ptr_to_nat(fields);
+    let is_unsafe = is_unsafe as usize == 1;
+    Constructor { lvls, typ, cidx, params, fields, is_unsafe }
+}
+
+fn lean_ptr_to_recursor_rule(ptr: *const c_void) -> RecursorRule {
+    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [fields, rhs] = ctor.objs();
+    let fields = lean_ptr_to_nat(fields);
+    let rhs = lean_ptr_to_address(rhs);
+    RecursorRule { fields, rhs }
+}
+
+fn lean_ptr_to_recursor(ptr: *const c_void) -> Recursor {
+    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [lvls, typ, params, indices, motives, minors, rules, k_isunsafe] = ctor.objs();
+    let lvls = lean_ptr_to_nat(lvls);
+    let typ = lean_ptr_to_address(typ);
+    let params = lean_ptr_to_nat(params);
+    let indices = lean_ptr_to_nat(indices);
+    let motives = lean_ptr_to_nat(motives);
+    let minors = lean_ptr_to_nat(minors);
+    let rules: &LeanArrayObject = as_ref_unsafe(rules.cast());
+    let rules = rules.to_vec(lean_ptr_to_recursor_rule);
+    let [k, is_unsafe, ..] = (k_isunsafe as usize).to_le_bytes();
+    let k = k == 1;
+    let is_unsafe = is_unsafe == 1;
+    Recursor { lvls, typ, params, indices, motives, minors, rules, k, is_unsafe }
+}
+
+fn lean_ptr_to_inductive(ptr: *const c_void) -> Inductive {
+    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [lvls, typ, params, indices, ctors, recrs, nested, recr_refl_isunsafe] = ctor.objs();
+    let lvls = lean_ptr_to_nat(lvls);
+    let typ = lean_ptr_to_address(typ);
+    let params = lean_ptr_to_nat(params);
+    let indices = lean_ptr_to_nat(indices);
+    let ctors: &LeanArrayObject = as_ref_unsafe(ctors.cast());
+    let ctors = ctors.to_vec(lean_ptr_to_constructor);
+    let recrs: &LeanArrayObject = as_ref_unsafe(recrs.cast());
+    let recrs = recrs.to_vec(lean_ptr_to_recursor);
+    let nested = lean_ptr_to_nat(nested);
+    let [recr, refl, is_unsafe, ..] = (recr_refl_isunsafe as usize).to_le_bytes();
+    let recr = recr == 1;
+    let refl = refl == 1;
+    let is_unsafe = is_unsafe == 1;
+    Inductive { lvls, typ, params, indices, ctors, recrs, nested, recr, refl, is_unsafe }
+}
+
+fn lean_ptr_to_name_parts(ptr: *const c_void) -> Vec<NamePart> {
+    if lean_is_scalar(ptr) {
+        Vec::new()
+    } else {
+        let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+        match ctor.tag() {
+            1 => {
+                let [prefix_ptr, str_ptr] = ctor.objs();
+                let mut parts = lean_ptr_to_name_parts(prefix_ptr);
+                let str_obj: &LeanStringObject = as_ref_unsafe(str_ptr.cast());
+                parts.push(NamePart::Str(str_obj.as_string()));
+                parts
+            }
+            2 => {
+                let [prefix_ptr, num_ptr] = ctor.objs();
+                let mut parts = lean_ptr_to_name_parts(prefix_ptr);
+                parts.push(NamePart::Num(lean_ptr_to_nat(num_ptr)));
+                parts
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+fn lean_ptr_to_name(ptr: *const c_void) -> Name {
+    let parts = lean_ptr_to_name_parts(ptr);
+    // Is `parts` reversed?
+    Name { parts }
+}
+
+fn lean_ptr_to_metadatum(ptr: *const c_void) -> Metadatum {
+    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    match ctor.tag() {
+        0 => {
+            let [name] = ctor.objs();
+            let name = lean_ptr_to_name(name);
+            Metadatum::Name(name)
+        },
+        1 => {
+            let [info] = ctor.objs();
+            let info = match info as usize {
+                0 => BinderInfo::Default,
+                1 => BinderInfo::Implicit,
+                2 => BinderInfo::StrictImplicit,
+                3 => BinderInfo::InstImplicit,
+                _ => unreachable!(),
+            };
+            Metadatum::Info(info)
+        }
+        2 => {
+            let [addr] = ctor.objs();
+            let addr = lean_ptr_to_address(addr);
+            Metadatum::Link(addr)
+        }
+        3 => {
+            let [hints] = ctor.objs();
+            let hints = if lean_is_scalar(hints) {
+                match lean_unbox!(usize, hints) {
+                    0 => ReducibilityHints::Opaque,
+                    1 => ReducibilityHints::Abbrev,
+                    _ => unreachable!(),
+                }
+            } else {
+                ReducibilityHints::Regular
+            };
+            Metadatum::Hints(hints)
+        }
+        4 => {
+            let [all] = ctor.objs();
+            let all: &LeanArrayObject = as_ref_unsafe(all.cast());
+            let all = all.to_vec(lean_ptr_to_name);
+            Metadatum::All(all)
+        }
+        5 => {
+            let [mut_ctx] = ctor.objs();
+            let mut_ctx: &LeanArrayObject = as_ref_unsafe(mut_ctx.cast());
+            let mut_ctx = mut_ctx.to_vec(|names| {
+                let names: &LeanArrayObject = as_ref_unsafe(names.cast());
+                names.to_vec(lean_ptr_to_name)
+            });
+            Metadatum::MutCtx(mut_ctx)
+        }
+        _ => unreachable!(),
+    }
+}
+
+fn lean_ptr_to_metadata_entry(ptr: *const c_void) -> (Nat, Vec<Metadatum>) {
+    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [fst, snd] = ctor.objs();
+    let fst = lean_ptr_to_nat(fst);
+    let snd: &LeanArrayObject = as_ref_unsafe(snd.cast());
+    let snd = snd.to_vec(lean_ptr_to_metadatum);
+    (fst, snd)
+}
+
+fn lean_ptr_to_eval_claim(ptr: *const c_void) -> Claim {
+    let evals: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [lvls, input, output, typ] = evals.objs().map(lean_ptr_to_address);
+    Claim::Evals { lvls, typ, input, output }
+}
+
+fn lean_ptr_to_check_claim(ptr: *const c_void) -> Claim {
+    let checks: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [lvls, typ, value] = checks.objs().map(lean_ptr_to_address);
+    Claim::Checks { lvls, typ, value }
+}
+
+fn lean_ptr_to_ixon(ptr: *const c_void) -> Ixon {
+    lean_ctor_to_ixon(as_ref_unsafe(ptr.cast()))
+}
+
+fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
+    match ctor.tag() {
+        0 => {
+            let [idx] = ctor.objs();
+            Ixon::Var(idx as u64)
+        }
+        1 => {
+            let [univ_ptr] = ctor.objs();
+            let univ_ctor = as_ref_unsafe(univ_ptr.cast());
+            Ixon::Sort(lean_ctor_to_univ(univ_ctor).into())
+        }
+        2 => {
+            let [addr_ptr, univs_ptr] = ctor.objs();
+            let addr = lean_ptr_to_address(addr_ptr);
+            Ixon::Ref(addr, lean_ptr_to_univs(univs_ptr))
+        }
+        3 => {
+            let [univs_ptr, idx] = ctor.objs();
+            Ixon::Rec(idx as u64, lean_ptr_to_univs(univs_ptr))
+        }
+        4 => {
+            let [f, x, xs] = ctor.objs();
+            let f = lean_ptr_to_ixon(f).into();
+            let x = lean_ptr_to_ixon(x).into();
+            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
+            let xs = xs_array.to_vec(lean_ptr_to_ixon);
+            Ixon::App(f, x, xs)
+        }
+        5 => {
+            let [xs, x] = ctor.objs();
+            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
+            let xs = xs_array.to_vec(lean_ptr_to_ixon);
+            let x = lean_ptr_to_ixon(x);
+            Ixon::Lam(xs, x.into())
+        }
+        6 => {
+            let [xs, x] = ctor.objs();
+            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
+            let xs = xs_array.to_vec(lean_ptr_to_ixon);
+            let x = lean_ptr_to_ixon(x).into();
+            Ixon::All(xs, x)
+        }
+        7 => {
+            let [v, t, b, x] = ctor.objs();
+            let v = lean_ptr_to_ixon(v).into();
+            let t = lean_ptr_to_ixon(t).into();
+            let b = lean_ptr_to_ixon(b).into();
+            Ixon::Let(x as usize == 1, v, t, b)
+        }
+        8 => {
+            let [addr_ptr, ptr, idx] = ctor.objs();
+            let addr = lean_ptr_to_address(addr_ptr);
+            let term = lean_ptr_to_ixon(ptr).into();
+            Ixon::Proj(addr, idx as u64, term)
+        }
+        9 => {
+            let [str_ptr] = ctor.objs();
+            let str: &LeanStringObject = as_ref_unsafe(str_ptr.cast());
+            Ixon::Strl(str.as_string())
+        }
+        10 => {
+            let [nat_bytes_ptr] = ctor.objs();
+            Ixon::Natl(lean_ptr_to_nat(nat_bytes_ptr))
+        }
+        11 => {
+            let [xs] = ctor.objs();
+            let xs: &LeanArrayObject = as_ref_unsafe(xs.cast());
+            Ixon::Array(xs.to_vec(lean_ptr_to_ixon))
+        }
+        12 => {
+            let [defn_ptr] = ctor.objs();
+            Ixon::Defn(lean_ptr_to_definition(defn_ptr))
+        }
+        13 => {
+            let [axio_ptr] = ctor.objs();
+            let axio_ctor: &LeanCtorObject = as_ref_unsafe(axio_ptr.cast());
+            let [lvls, typ, is_unsafe] = axio_ctor.objs();
+            let lvls = lean_ptr_to_nat(lvls);
+            let typ = lean_ptr_to_address(typ);
+            let is_unsafe = is_unsafe as usize == 1;
+            Ixon::Axio(Axiom { lvls, typ, is_unsafe })
+        }
+        14 => {
+            let [quot_ptr] = ctor.objs();
+            let quot_ctor: &LeanCtorObject = as_ref_unsafe(quot_ptr.cast());
+            let [lvls, typ, kind] = quot_ctor.objs();
+            let lvls = lean_ptr_to_nat(lvls);
+            let typ = lean_ptr_to_address(typ);
+            let kind = match kind as usize {
+                0 => QuotKind::Type,
+                1 => QuotKind::Ctor,
+                2 => QuotKind::Lift,
+                3 => QuotKind::Ind,
+                _ => unreachable!(),
+            };
+            Ixon::Quot(Quotient {lvls, typ, kind})
+        }
+        15 => {
+            let [cprj_ptr] = ctor.objs();
+            let cprj_ctor: &LeanCtorObject = as_ref_unsafe(cprj_ptr.cast());
+            let [block, idx, cidx] = cprj_ctor.objs();
+            let block = lean_ptr_to_address(block);
+            let idx = lean_ptr_to_nat(idx);
+            let cidx = lean_ptr_to_nat(cidx);
+            Ixon::CtorProj(ConstructorProj { block, idx, cidx })
+        }
+        16 => {
+            let [rprj_ptr] = ctor.objs();
+            let rprj_ctor: &LeanCtorObject = as_ref_unsafe(rprj_ptr.cast());
+            let [block, idx, ridx] = rprj_ctor.objs();
+            let block = lean_ptr_to_address(block);
+            let idx = lean_ptr_to_nat(idx);
+            let ridx = lean_ptr_to_nat(ridx);
+            Ixon::RecrProj(RecursorProj { block, idx, ridx })
+        }
+        17 => {
+            let [iprj_ptr] = ctor.objs();
+            let iprj_ctor: &LeanCtorObject = as_ref_unsafe(iprj_ptr.cast());
+            let [block, idx] = iprj_ctor.objs();
+            let block = lean_ptr_to_address(block);
+            let idx = lean_ptr_to_nat(idx);
+            Ixon::IndcProj(InductiveProj {block, idx})
+        }
+        18 => {
+            let [dprj_ptr] = ctor.objs();
+            let dprj_ctor: &LeanCtorObject = as_ref_unsafe(dprj_ptr.cast());
+            let [block, idx] = dprj_ctor.objs();
+            let block = lean_ptr_to_address(block);
+            let idx = lean_ptr_to_nat(idx);
+            Ixon::DefnProj(DefinitionProj {block, idx})
+        }
+        19 => {
+            let [inds_ptr] = ctor.objs();
+            let inds: &LeanArrayObject = as_ref_unsafe(inds_ptr.cast());
+            let inds = inds.to_vec(lean_ptr_to_inductive);
+            Ixon::MutInd(inds)
+        }
+        20 => {
+            let [defs_ptr] = ctor.objs();
+            let defs: &LeanArrayObject = as_ref_unsafe(defs_ptr.cast());
+            let defs = defs.to_vec(lean_ptr_to_definition);
+            Ixon::MutDef(defs)
+        }
+        21 => {
+            let [pairs_ptr] = ctor.objs();
+            let pairs: &LeanArrayObject = as_ref_unsafe(pairs_ptr.cast());
+            let map = pairs.to_vec(lean_ptr_to_metadata_entry);
+            Ixon::Meta(Metadata { map })
+        }
+        22 => {
+            let [proof] = ctor.objs();
+            let proof: &LeanCtorObject = as_ref_unsafe(proof.cast());
+            let [claim, bin] = proof.objs();
+            let claim: &LeanCtorObject = as_ref_unsafe(claim.cast());
+            let claim = match claim.tag() {
+                0 => {
+                    let [checks] = claim.objs();
+                    lean_ptr_to_check_claim(checks)
+                }
+                1 => {
+                    let [evals] = claim.objs();
+                    lean_ptr_to_eval_claim(evals)
+                }
+                _ => unreachable!(),
+            };
+            let bin: &LeanSArrayObject = as_ref_unsafe(bin.cast());
+            Ixon::Proof(Proof {claim, proof: bin.data().to_vec()})
+        }
+        23 => {
+            let [evals] = ctor.objs();
+            Ixon::Claim(lean_ptr_to_eval_claim(evals))
+        }
+        24 => {
+            let [checks] = ctor.objs();
+            Ixon::Claim(lean_ptr_to_check_claim(checks))
+        }
+        25 => {
+            let [comm] = ctor.objs();
+            let comm: &LeanCtorObject = as_ref_unsafe(comm.cast());
+            let [secret, payload] = comm.objs().map(lean_ptr_to_address);
+            Ixon::Comm(Comm { secret, payload })
+        }
+        26 => todo!("Env"),
+        _ => unreachable!(),
+    }
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rs_eq_lean_rust_serialization(ixon: &LeanCtorObject, bytes: &LeanSArrayObject) -> bool {
+    let mut buf = Vec::new();
+    println!("{:?}", lean_ctor_to_ixon(ixon));
+    lean_ctor_to_ixon(ixon).put(&mut buf);
+    buf == bytes.data()
+}
\ No newline at end of file
diff --git a/src/lean/ffi/mod.rs b/src/lean/ffi/mod.rs
index e0ac59f7..13610bba 100644
--- a/src/lean/ffi/mod.rs
+++ b/src/lean/ffi/mod.rs
@@ -10,6 +10,7 @@ pub mod byte_array;
   not(all(target_os = "macos", target_arch = "aarch64"))
 ))]
 pub mod iroh;
+pub mod ixon;
 pub mod keccak;
 
 use std::ffi::{c_char, c_void, CStr, CString};

From 42f882c099b588e4c7f21fe1a5e9fb9aa4c16234 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Wed, 3 Sep 2025 09:49:32 -0300
Subject: [PATCH 39/74] use standard formatting

---
 rustfmt.toml => _rustfmt.toml |    0
 src/aiur/constraints.rs       |  543 ++++++------
 src/aiur/memory.rs            |  190 +++--
 src/aiur/synthesis.rs         |  226 ++---
 src/ixon.rs                   | 1463 ++++++++++++++++-----------------
 src/ixon/address.rs           |   60 +-
 src/ixon/claim.rs             |  216 ++---
 src/ixon/constant.rs          |  999 +++++++++++-----------
 src/ixon/meta.rs              |  360 ++++----
 src/ixon/name.rs              |   80 +-
 src/ixon/nat.rs               |   60 +-
 src/ixon/serialize.rs         |  159 ++--
 src/ixon/univ.rs              |  328 ++++----
 src/lean/ffi/aiur/protocol.rs |  179 ++--
 src/lean/ffi/ixon.rs          |  115 ++-
 src/lean/ffi/mod.rs           |   91 +-
 src/lib.rs                    |    8 +-
 17 files changed, 2603 insertions(+), 2474 deletions(-)
 rename rustfmt.toml => _rustfmt.toml (100%)

diff --git a/rustfmt.toml b/_rustfmt.toml
similarity index 100%
rename from rustfmt.toml
rename to _rustfmt.toml
diff --git a/src/aiur/constraints.rs b/src/aiur/constraints.rs
index 7c43539d..1789c526 100644
--- a/src/aiur/constraints.rs
+++ b/src/aiur/constraints.rs
@@ -1,22 +1,21 @@
 use multi_stark::{
-  builder::symbolic::SymbolicExpression, lookup::Lookup,
-  p3_field::PrimeCharacteristicRing,
+    builder::symbolic::SymbolicExpression, lookup::Lookup, p3_field::PrimeCharacteristicRing,
 };
 use std::ops::Range;
 
 use super::{
-  bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel},
-  trace::Channel,
-  G,
+    G,
+    bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel},
+    trace::Channel,
 };
 
 #[macro_export]
 macro_rules! sym_var {
-  ($a:expr) => {{
-    use multi_stark::builder::symbolic::*;
-    let entry = Entry::Main { offset: 0 };
-    SymbolicExpression::Variable(SymbolicVariable::new(entry, $a))
-  }};
+    ($a:expr) => {{
+        use multi_stark::builder::symbolic::*;
+        let entry = Entry::Main { offset: 0 };
+        SymbolicExpression::Variable(SymbolicVariable::new(entry, $a))
+    }};
 }
 
 type Expr = SymbolicExpression<G>;
@@ -24,301 +23,299 @@ type Degree = u8;
 
 /// Holds data for a function circuit.
 pub struct Constraints {
-  pub zeros: Vec<Expr>,
-  pub selectors: Range<usize>,
-  pub width: usize,
+    pub zeros: Vec<Expr>,
+    pub selectors: Range<usize>,
+    pub width: usize,
 }
 
 struct ConstraintState {
-  function_index: G,
-  layout: FunctionLayout,
-  column: usize,
-  lookup: usize,
-  lookups: Vec<Lookup<Expr>>,
-  map: Vec<(Expr, Degree)>,
-  constraints: Constraints,
+    function_index: G,
+    layout: FunctionLayout,
+    column: usize,
+    lookup: usize,
+    lookups: Vec<Lookup<Expr>>,
+    map: Vec<(Expr, Degree)>,
+    constraints: Constraints,
 }
 
 struct SharedState {
-  column: usize,
-  lookup: usize,
-  map_len: usize,
+    column: usize,
+    lookup: usize,
+    map_len: usize,
 }
 
 impl ConstraintState {
-  fn selector_index(&self, sel: usize) -> usize {
-    sel + self.layout.input_size
-  }
+    fn selector_index(&self, sel: usize) -> usize {
+        sel + self.layout.input_size
+    }
 
-  fn next_lookup(&mut self) -> &mut Lookup<Expr> {
-    let lookup = &mut self.lookups[self.lookup];
-    self.lookup += 1;
-    lookup
-  }
+    fn next_lookup(&mut self) -> &mut Lookup<Expr> {
+        let lookup = &mut self.lookups[self.lookup];
+        self.lookup += 1;
+        lookup
+    }
 
-  fn next_auxiliary(&mut self) -> Expr {
-    self.column += 1;
-    sym_var!(self.column - 1)
-  }
+    fn next_auxiliary(&mut self) -> Expr {
+        self.column += 1;
+        sym_var!(self.column - 1)
+    }
 
-  fn save(&mut self) -> SharedState {
-    SharedState {
-      column: self.column,
-      lookup: self.lookup,
-      map_len: self.map.len(),
+    fn save(&mut self) -> SharedState {
+        SharedState {
+            column: self.column,
+            lookup: self.lookup,
+            map_len: self.map.len(),
+        }
     }
-  }
 
-  #[allow(clippy::needless_pass_by_value)]
-  fn restore(&mut self, init: SharedState) {
-    self.column = init.column;
-    self.lookup = init.lookup;
-    self.map.truncate(init.map_len);
-  }
+    #[allow(clippy::needless_pass_by_value)]
+    fn restore(&mut self, init: SharedState) {
+        self.column = init.column;
+        self.lookup = init.lookup;
+        self.map.truncate(init.map_len);
+    }
 }
 
 impl Toplevel {
-  pub fn build_constraints(
-    &self,
-    function_index: usize,
-  ) -> (Constraints, Vec<Lookup<Expr>>) {
-    let function = &self.functions[function_index];
-    let constraints = Constraints {
-      zeros: vec![],
-      selectors: 0..0,
-      width: function.layout.width(),
-    };
-    let mut state = ConstraintState {
-      function_index: G::from_usize(function_index),
-      layout: function.layout,
-      column: 0,
-      lookup: 0,
-      map: vec![],
-      lookups: vec![Lookup::empty(); function.layout.lookups],
-      constraints,
-    };
-    function.build_constraints(&mut state, self);
-    (state.constraints, state.lookups)
-  }
+    pub fn build_constraints(&self, function_index: usize) -> (Constraints, Vec<Lookup<Expr>>) {
+        let function = &self.functions[function_index];
+        let constraints = Constraints {
+            zeros: vec![],
+            selectors: 0..0,
+            width: function.layout.width(),
+        };
+        let mut state = ConstraintState {
+            function_index: G::from_usize(function_index),
+            layout: function.layout,
+            column: 0,
+            lookup: 0,
+            map: vec![],
+            lookups: vec![Lookup::empty(); function.layout.lookups],
+            constraints,
+        };
+        function.build_constraints(&mut state, self);
+        (state.constraints, state.lookups)
+    }
 }
 
 impl Function {
-  fn build_constraints(
-    &self,
-    state: &mut ConstraintState,
-    toplevel: &Toplevel,
-  ) {
-    // 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((sym_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 = sym_var!(state.column);
-    state.column += 1;
-    // the return lookup occupies the first lookup slot
-    state.lookups[0].multiplicity = -multiplicity.clone();
-    state.lookup += 1;
-    // the multiplicity can only be set if one and only one selector is set
-    let sel = self.body.get_block_selector(state);
-    state
-      .constraints
-      .zeros
-      .push(multiplicity * (Expr::from(G::ONE) - sel.clone()));
-    self.body.collect_constraints(sel, state, toplevel);
-  }
+    fn build_constraints(&self, state: &mut ConstraintState, toplevel: &Toplevel) {
+        // 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((sym_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 = sym_var!(state.column);
+        state.column += 1;
+        // the return lookup occupies the first lookup slot
+        state.lookups[0].multiplicity = -multiplicity.clone();
+        state.lookup += 1;
+        // the multiplicity can only be set if one and only one selector is set
+        let sel = self.body.get_block_selector(state);
+        state
+            .constraints
+            .zeros
+            .push(multiplicity * (Expr::from(G::ONE) - sel.clone()));
+        self.body.collect_constraints(sel, state, toplevel);
+    }
 }
 
 impl Block {
-  fn collect_constraints(
-    &self,
-    sel: Expr,
-    state: &mut ConstraintState,
-    toplevel: &Toplevel,
-  ) {
-    self.ops.iter().for_each(|op| op.collect_constraints(&sel, state));
-    self.ctrl.collect_constraints(sel, state, toplevel);
-  }
+    fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState, toplevel: &Toplevel) {
+        self.ops
+            .iter()
+            .for_each(|op| op.collect_constraints(&sel, state));
+        self.ctrl.collect_constraints(sel, state, toplevel);
+    }
 
-  fn get_block_selector(&self, state: &mut ConstraintState) -> Expr {
-    (self.min_sel_included..self.max_sel_excluded)
-      .map(|i| sym_var!(state.selector_index(i)))
-      .fold(Expr::Constant(G::ZERO), |var, acc| var + acc)
-  }
+    fn get_block_selector(&self, state: &mut ConstraintState) -> Expr {
+        (self.min_sel_included..self.max_sel_excluded)
+            .map(|i| sym_var!(state.selector_index(i)))
+            .fold(Expr::Constant(G::ZERO), |var, acc| var + acc)
+    }
 }
 
 impl Ctrl {
-  #[allow(clippy::needless_pass_by_value)]
-  fn collect_constraints(
-    &self,
-    sel: Expr,
-    state: &mut ConstraintState,
-    toplevel: &Toplevel,
-  ) {
-    match self {
-      Ctrl::Return(_, values) => {
-        // channel and function index
-        let mut vector = vec![
-          sel.clone() * Channel::Function.to_field(),
-          sel.clone() * state.function_index,
-        ];
-        // input
-        vector.extend(
-          (0..state.layout.input_size)
-            .map(|arg| sel.clone() * state.map[arg].0.clone()),
-        );
-        // output
-        vector.extend(
-          values.iter().map(|arg| sel.clone() * state.map[*arg].0.clone()),
-        );
-        let mut values_iter = vector.into_iter();
-        let lookup = &mut state.lookups[0];
-        lookup.args.iter_mut().zip(values_iter.by_ref()).for_each(
-          |(arg, value)| {
-            *arg += value;
-          },
-        );
-        lookup.args.extend(values_iter);
-        // multiplicity is already set
-      },
-      Ctrl::Match(var, cases, def) => {
-        let (var, _) = state.map[*var].clone();
-        for (&value, branch) in cases.iter() {
-          let init = state.save();
-          let branch_sel = branch.get_block_selector(state);
-          state
-            .constraints
-            .zeros
-            .push(branch_sel.clone() * (var.clone() - Expr::from(value)));
-          branch.collect_constraints(branch_sel, state, toplevel);
-          state.restore(init);
+    #[allow(clippy::needless_pass_by_value)]
+    fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState, toplevel: &Toplevel) {
+        match self {
+            Ctrl::Return(_, values) => {
+                // channel and function index
+                let mut vector = vec![
+                    sel.clone() * Channel::Function.to_field(),
+                    sel.clone() * state.function_index,
+                ];
+                // input
+                vector.extend(
+                    (0..state.layout.input_size).map(|arg| sel.clone() * state.map[arg].0.clone()),
+                );
+                // output
+                vector.extend(
+                    values
+                        .iter()
+                        .map(|arg| sel.clone() * state.map[*arg].0.clone()),
+                );
+                let mut values_iter = vector.into_iter();
+                let lookup = &mut state.lookups[0];
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                // multiplicity is already set
+            }
+            Ctrl::Match(var, cases, def) => {
+                let (var, _) = state.map[*var].clone();
+                for (&value, branch) in cases.iter() {
+                    let init = state.save();
+                    let branch_sel = branch.get_block_selector(state);
+                    state
+                        .constraints
+                        .zeros
+                        .push(branch_sel.clone() * (var.clone() - Expr::from(value)));
+                    branch.collect_constraints(branch_sel, state, toplevel);
+                    state.restore(init);
+                }
+                def.iter().for_each(|branch| {
+                    let init = state.save();
+                    let branch_sel = branch.get_block_selector(state);
+                    for &value in cases.keys() {
+                        let inverse = state.next_auxiliary();
+                        state.constraints.zeros.push(
+                            branch_sel.clone()
+                                * ((var.clone() - Expr::from(value)) * inverse
+                                    - Expr::from(G::ONE)),
+                        );
+                    }
+                    branch.collect_constraints(branch_sel, state, toplevel);
+                    state.restore(init);
+                })
+            }
         }
-        def.iter().for_each(|branch| {
-          let init = state.save();
-          let branch_sel = branch.get_block_selector(state);
-          for &value in cases.keys() {
-            let inverse = state.next_auxiliary();
-            state.constraints.zeros.push(
-              branch_sel.clone()
-                * ((var.clone() - Expr::from(value)) * inverse
-                  - Expr::from(G::ONE)),
-            );
-          }
-          branch.collect_constraints(branch_sel, state, toplevel);
-          state.restore(init);
-        })
-      },
     }
-  }
 }
 
 impl Op {
-  fn collect_constraints(&self, sel: &Expr, state: &mut ConstraintState) {
-    match self {
-      Op::Const(f) => state.map.push(((*f).into(), 0)),
-      Op::Add(a, b) => {
-        let (a, a_deg) = &state.map[*a];
-        let (b, b_deg) = &state.map[*b];
-        let deg = a_deg.max(b_deg);
-        state.map.push((a.clone() + b.clone(), *deg));
-      },
-      Op::Sub(a, b) => {
-        let (a, a_deg) = &state.map[*a];
-        let (b, b_deg) = &state.map[*b];
-        let deg = a_deg.max(b_deg);
-        state.map.push((a.clone() - b.clone(), *deg));
-      },
-      Op::Mul(a, b) => {
-        let (a, a_deg) = &state.map[*a];
-        let (b, b_deg) = &state.map[*b];
-        let deg = a_deg + b_deg;
-        let mul = a.clone() * b.clone();
-        if deg < 2 {
-          state.map.push((mul, deg));
-        } else {
-          let col = state.next_auxiliary();
-          state.map.push((col.clone(), 1));
-          state.constraints.zeros.push(sel.clone() * (col - mul));
+    fn collect_constraints(&self, sel: &Expr, state: &mut ConstraintState) {
+        match self {
+            Op::Const(f) => state.map.push(((*f).into(), 0)),
+            Op::Add(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg.max(b_deg);
+                state.map.push((a.clone() + b.clone(), *deg));
+            }
+            Op::Sub(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg.max(b_deg);
+                state.map.push((a.clone() - b.clone(), *deg));
+            }
+            Op::Mul(a, b) => {
+                let (a, a_deg) = &state.map[*a];
+                let (b, b_deg) = &state.map[*b];
+                let deg = a_deg + b_deg;
+                let mul = a.clone() * b.clone();
+                if deg < 2 {
+                    state.map.push((mul, deg));
+                } else {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    state.constraints.zeros.push(sel.clone() * (col - mul));
+                }
+            }
+            Op::Call(function_index, inputs, output_size) => {
+                // channel and function index
+                let mut vector = vec![
+                    sel.clone() * Channel::Function.to_field(),
+                    sel.clone() * G::from_usize(*function_index),
+                ];
+                // input
+                vector.extend(
+                    inputs
+                        .iter()
+                        .map(|arg| sel.clone() * state.map[*arg].0.clone()),
+                );
+                // output
+                let output = (0..*output_size).map(|_| {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    col
+                });
+                vector.extend(output);
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
+            Op::Store(values) => {
+                let size = values.len();
+                // channel, function index and pointer
+                let ptr = state.next_auxiliary();
+                state.map.push((ptr.clone(), 1));
+                let mut vector = vec![
+                    sel.clone() * Channel::Memory.to_field(),
+                    sel.clone() * G::from_usize(size),
+                    sel.clone() * ptr.clone(),
+                ];
+                // stored values
+                vector.extend(
+                    values
+                        .iter()
+                        .map(|value| sel.clone() * state.map[*value].0.clone()),
+                );
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
+            Op::Load(size, ptr) => {
+                // channel, size and pointer
+                let mut vector = vec![
+                    sel.clone() * Channel::Memory.to_field(),
+                    sel.clone() * G::from_usize(*size),
+                    sel.clone() * state.map[*ptr].0.clone(),
+                ];
+                // loaded values
+                let values = (0..*size).map(|_| {
+                    let col = state.next_auxiliary();
+                    state.map.push((col.clone(), 1));
+                    col
+                });
+                vector.extend(values);
+                let mut values_iter = vector.into_iter();
+                let lookup = state.next_lookup();
+                lookup
+                    .args
+                    .iter_mut()
+                    .zip(values_iter.by_ref())
+                    .for_each(|(arg, value)| {
+                        *arg += value;
+                    });
+                lookup.args.extend(values_iter);
+                lookup.multiplicity += sel.clone();
+            }
         }
-      },
-      Op::Call(function_index, inputs, output_size) => {
-        // channel and function index
-        let mut vector = vec![
-          sel.clone() * Channel::Function.to_field(),
-          sel.clone() * G::from_usize(*function_index),
-        ];
-        // input
-        vector.extend(
-          inputs.iter().map(|arg| sel.clone() * state.map[*arg].0.clone()),
-        );
-        // output
-        let output = (0..*output_size).map(|_| {
-          let col = state.next_auxiliary();
-          state.map.push((col.clone(), 1));
-          col
-        });
-        vector.extend(output);
-        let mut values_iter = vector.into_iter();
-        let lookup = state.next_lookup();
-        lookup.args.iter_mut().zip(values_iter.by_ref()).for_each(
-          |(arg, value)| {
-            *arg += value;
-          },
-        );
-        lookup.args.extend(values_iter);
-        lookup.multiplicity += sel.clone();
-      },
-      Op::Store(values) => {
-        let size = values.len();
-        // channel, function index and pointer
-        let ptr = state.next_auxiliary();
-        state.map.push((ptr.clone(), 1));
-        let mut vector = vec![
-          sel.clone() * Channel::Memory.to_field(),
-          sel.clone() * G::from_usize(size),
-          sel.clone() * ptr.clone(),
-        ];
-        // stored values
-        vector.extend(
-          values.iter().map(|value| sel.clone() * state.map[*value].0.clone()),
-        );
-        let mut values_iter = vector.into_iter();
-        let lookup = state.next_lookup();
-        lookup.args.iter_mut().zip(values_iter.by_ref()).for_each(
-          |(arg, value)| {
-            *arg += value;
-          },
-        );
-        lookup.args.extend(values_iter);
-        lookup.multiplicity += sel.clone();
-      },
-      Op::Load(size, ptr) => {
-        // channel, size and pointer
-        let mut vector = vec![
-          sel.clone() * Channel::Memory.to_field(),
-          sel.clone() * G::from_usize(*size),
-          sel.clone() * state.map[*ptr].0.clone(),
-        ];
-        // loaded values
-        let values = (0..*size).map(|_| {
-          let col = state.next_auxiliary();
-          state.map.push((col.clone(), 1));
-          col
-        });
-        vector.extend(values);
-        let mut values_iter = vector.into_iter();
-        let lookup = state.next_lookup();
-        lookup.args.iter_mut().zip(values_iter.by_ref()).for_each(
-          |(arg, value)| {
-            *arg += value;
-          },
-        );
-        lookup.args.extend(values_iter);
-        lookup.multiplicity += sel.clone();
-      },
     }
-  }
 }
diff --git a/src/aiur/memory.rs b/src/aiur/memory.rs
index d007e6fc..e418c1de 100644
--- a/src/aiur/memory.rs
+++ b/src/aiur/memory.rs
@@ -1,125 +1,121 @@
 use multi_stark::{
-  builder::symbolic::SymbolicExpression,
-  lookup::Lookup,
-  p3_air::{Air, AirBuilder, BaseAir},
-  p3_field::PrimeCharacteristicRing,
-  p3_matrix::{dense::RowMajorMatrix, Matrix},
+    builder::symbolic::SymbolicExpression,
+    lookup::Lookup,
+    p3_air::{Air, AirBuilder, BaseAir},
+    p3_field::PrimeCharacteristicRing,
+    p3_matrix::{Matrix, dense::RowMajorMatrix},
 };
 use rayon::{
-  iter::{
-    IndexedParallelIterator, IntoParallelRefIterator,
-    IntoParallelRefMutIterator, ParallelIterator,
-  },
-  slice::ParallelSliceMut,
+    iter::{
+        IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator,
+        ParallelIterator,
+    },
+    slice::ParallelSliceMut,
 };
 
 use crate::{
-  aiur::{execute::QueryRecord, trace::Channel, G},
-  sym_var,
+    aiur::{G, execute::QueryRecord, trace::Channel},
+    sym_var,
 };
 
 pub struct Memory {
-  width: usize,
+    width: usize,
 }
 
 impl Memory {
-  pub(super) fn lookup(
-    multiplicity: G,
-    size: G,
-    ptr: G,
-    values: &[G],
-  ) -> Lookup<G> {
-    let mut args = Vec::with_capacity(3 + values.len());
-    args.extend([Channel::Memory.to_field(), size, ptr]);
-    args.extend(values);
-    Lookup { multiplicity, args }
-  }
-
-  fn width(size: usize) -> usize {
-    // Multiplicity, selector, pointer and values.
-    3 + size
-  }
-
-  pub fn build(size: usize) -> (Self, Lookup<SymbolicExpression<G>>) {
-    let multiplicity = sym_var!(0);
-    let selector = sym_var!(1);
-    let pointer = sym_var!(2);
-    let mut args = Vec::with_capacity(3 + size);
-    args.push(selector.clone() * Channel::Memory.to_field());
-    args.push(selector.clone() * G::from_usize(size));
-    args.push(selector.clone() * pointer);
-    for val_idx in 0..size {
-      args.push(selector.clone() * sym_var!(3 + val_idx));
+    pub(super) fn lookup(multiplicity: G, size: G, ptr: G, values: &[G]) -> Lookup<G> {
+        let mut args = Vec::with_capacity(3 + values.len());
+        args.extend([Channel::Memory.to_field(), size, ptr]);
+        args.extend(values);
+        Lookup { multiplicity, args }
+    }
+
+    fn width(size: usize) -> usize {
+        // Multiplicity, selector, pointer and values.
+        3 + size
+    }
+
+    pub fn build(size: usize) -> (Self, Lookup<SymbolicExpression<G>>) {
+        let multiplicity = sym_var!(0);
+        let selector = sym_var!(1);
+        let pointer = sym_var!(2);
+        let mut args = Vec::with_capacity(3 + size);
+        args.push(selector.clone() * Channel::Memory.to_field());
+        args.push(selector.clone() * G::from_usize(size));
+        args.push(selector.clone() * pointer);
+        for val_idx in 0..size {
+            args.push(selector.clone() * sym_var!(3 + val_idx));
+        }
+        let width = Self::width(size);
+        (Self { width }, Lookup::pull(multiplicity, args))
+    }
+
+    pub fn generate_trace(
+        size: usize,
+        record: &QueryRecord,
+    ) -> (RowMajorMatrix<G>, Vec<Vec<Lookup<G>>>) {
+        let queries = record.memory_queries.get(&size).expect("Invalid size");
+        let width = Self::width(size);
+        let height_no_padding = queries.len();
+        let height = height_no_padding.next_power_of_two();
+
+        let mut rows = vec![G::ZERO; height * width];
+        let rows_no_padding = &mut rows[0..height_no_padding * width];
+
+        let mut lookups = vec![vec![Lookup::empty()]; height];
+        let lookups_no_padding = &mut lookups[0..height_no_padding];
+
+        rows_no_padding
+            .par_chunks_mut(width)
+            .zip(queries.par_iter())
+            .zip(lookups_no_padding.par_iter_mut())
+            .enumerate()
+            .for_each(|(i, ((row, (values, result)), row_lookups))| {
+                row[0] = result.multiplicity;
+                row[1] = G::ONE;
+                row[2] = G::from_usize(i);
+                row[3..].copy_from_slice(values);
+
+                row_lookups[0] = Self::lookup(-row[0], G::from_usize(size), row[2], &row[3..]);
+            });
+
+        let trace = RowMajorMatrix::new(rows, width);
+        (trace, lookups)
     }
-    let width = Self::width(size);
-    (Self { width }, Lookup::pull(multiplicity, args))
-  }
-
-  pub fn generate_trace(
-    size: usize,
-    record: &QueryRecord,
-  ) -> (RowMajorMatrix<G>, Vec<Vec<Lookup<G>>>) {
-    let queries = record.memory_queries.get(&size).expect("Invalid size");
-    let width = Self::width(size);
-    let height_no_padding = queries.len();
-    let height = height_no_padding.next_power_of_two();
-
-    let mut rows = vec![G::ZERO; height * width];
-    let rows_no_padding = &mut rows[0..height_no_padding * width];
-
-    let mut lookups = vec![vec![Lookup::empty()]; height];
-    let lookups_no_padding = &mut lookups[0..height_no_padding];
-
-    rows_no_padding
-      .par_chunks_mut(width)
-      .zip(queries.par_iter())
-      .zip(lookups_no_padding.par_iter_mut())
-      .enumerate()
-      .for_each(|(i, ((row, (values, result)), row_lookups))| {
-        row[0] = result.multiplicity;
-        row[1] = G::ONE;
-        row[2] = G::from_usize(i);
-        row[3..].copy_from_slice(values);
-
-        row_lookups[0] =
-          Self::lookup(-row[0], G::from_usize(size), row[2], &row[3..]);
-      });
-
-    let trace = RowMajorMatrix::new(rows, width);
-    (trace, lookups)
-  }
 }
 
 impl BaseAir<G> for Memory {
-  fn width(&self) -> usize {
-    self.width
-  }
+    fn width(&self) -> usize {
+        self.width
+    }
 }
 
 impl<AB> Air<AB> for Memory
 where
-  AB: AirBuilder<F = G>,
+    AB: AirBuilder<F = G>,
 {
-  fn eval(&self, builder: &mut AB) {
-    let main = builder.main();
-    let local: &[AB::Var] = &main.row_slice(0).unwrap();
-    let next: &[AB::Var] = &main.row_slice(1).unwrap();
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local: &[AB::Var] = &main.row_slice(0).unwrap();
+        let next: &[AB::Var] = &main.row_slice(1).unwrap();
 
-    let (is_real, ptr) = (local[1].clone(), local[2].clone());
-    let (is_real_next, ptr_next) = (next[1].clone(), next[2].clone());
+        let (is_real, ptr) = (local[1].clone(), local[2].clone());
+        let (is_real_next, ptr_next) = (next[1].clone(), next[2].clone());
 
-    builder.assert_bool(is_real.clone());
+        builder.assert_bool(is_real.clone());
 
-    // Whether the next row is real.
-    let is_real_transition = is_real_next * builder.is_transition();
+        // Whether the next row is real.
+        let is_real_transition = is_real_next * builder.is_transition();
 
-    // If the next row is real, the current row is real.
-    builder.when(is_real_transition.clone()).assert_one(is_real);
+        // If the next row is real, the current row is real.
+        builder.when(is_real_transition.clone()).assert_one(is_real);
 
-    // Is this necessary?
-    // builder.when_first_row().when(is_real).assert_zero(ptr);
+        // Is this necessary?
+        // builder.when_first_row().when(is_real).assert_zero(ptr);
 
-    // Pointer increases by one
-    builder.when(is_real_transition).assert_eq(ptr + AB::Expr::ONE, ptr_next);
-  }
+        // Pointer increases by one
+        builder
+            .when(is_real_transition)
+            .assert_eq(ptr + AB::Expr::ONE, ptr_next);
+    }
 }
diff --git a/src/aiur/synthesis.rs b/src/aiur/synthesis.rs
index 074f792f..09dbc547 100644
--- a/src/aiur/synthesis.rs
+++ b/src/aiur/synthesis.rs
@@ -1,152 +1,152 @@
 use multi_stark::{
-  lookup::LookupAir,
-  p3_air::{Air, AirBuilder, BaseAir},
-  p3_field::PrimeCharacteristicRing,
-  p3_matrix::Matrix,
-  prover::Proof,
-  system::{ProverKey, System, SystemWitness},
-  types::{CommitmentParameters, FriParameters, PcsError},
-  verifier::VerificationError,
-};
-use rayon::iter::{
-  IntoParallelIterator, IntoParallelRefIterator, ParallelIterator,
+    lookup::LookupAir,
+    p3_air::{Air, AirBuilder, BaseAir},
+    p3_field::PrimeCharacteristicRing,
+    p3_matrix::Matrix,
+    prover::Proof,
+    system::{ProverKey, System, SystemWitness},
+    types::{CommitmentParameters, FriParameters, PcsError},
+    verifier::VerificationError,
 };
+use rayon::iter::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
 
 use crate::aiur::{
-  bytecode::{FunIdx, Toplevel},
-  constraints::Constraints,
-  memory::Memory,
-  trace::Channel,
-  G,
+    G,
+    bytecode::{FunIdx, Toplevel},
+    constraints::Constraints,
+    memory::Memory,
+    trace::Channel,
 };
 
 pub struct AiurSystem {
-  toplevel: Toplevel,
-  // perhaps remove the key from the system in verifier only mode?
-  key: ProverKey,
-  system: System<AiurCircuit>,
+    toplevel: Toplevel,
+    // perhaps remove the key from the system in verifier only mode?
+    key: ProverKey,
+    system: System<AiurCircuit>,
 }
 
 enum AiurCircuit {
-  Function(Constraints),
-  Memory(Memory),
+    Function(Constraints),
+    Memory(Memory),
 }
 
 impl BaseAir<G> for AiurCircuit {
-  fn width(&self) -> usize {
-    // Even though the inner types might have `width` attributes, we dispatch
-    // to their trait implementations for correctness.
-    match self {
-      Self::Function(constraints) => constraints.width(),
-      Self::Memory(memory) => memory.width(),
+    fn width(&self) -> usize {
+        // Even though the inner types might have `width` attributes, we dispatch
+        // to their trait implementations for correctness.
+        match self {
+            Self::Function(constraints) => constraints.width(),
+            Self::Memory(memory) => memory.width(),
+        }
     }
-  }
 }
 
 impl<AB> Air<AB> for AiurCircuit
 where
-  AB: AirBuilder<F = G>,
+    AB: AirBuilder<F = G>,
 {
-  fn eval(&self, builder: &mut AB) {
-    match self {
-      Self::Function(constraints) => constraints.eval(builder),
-      Self::Memory(memory) => memory.eval(builder),
+    fn eval(&self, builder: &mut AB) {
+        match self {
+            Self::Function(constraints) => constraints.eval(builder),
+            Self::Memory(memory) => memory.eval(builder),
+        }
     }
-  }
 }
 
 impl BaseAir<G> for Constraints {
-  fn width(&self) -> usize {
-    self.width
-  }
+    fn width(&self) -> usize {
+        self.width
+    }
 }
 
 impl<AB> Air<AB> for Constraints
 where
-  AB: AirBuilder<F = G>,
+    AB: AirBuilder<F = G>,
 {
-  fn eval(&self, builder: &mut AB) {
-    let main = builder.main();
-    let row = main.row_slice(0).unwrap();
-    for zero in self.zeros.iter() {
-      builder.assert_zero(zero.interpret(&row, None));
-    }
-    for sel in self.selectors.clone() {
-      builder.assert_bool(row[sel].clone());
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let row = main.row_slice(0).unwrap();
+        for zero in self.zeros.iter() {
+            builder.assert_zero(zero.interpret(&row, None));
+        }
+        for sel in self.selectors.clone() {
+            builder.assert_bool(row[sel].clone());
+        }
     }
-  }
 }
 
 enum CircuitType {
-  Function { idx: usize },
-  Memory { width: usize },
+    Function { idx: usize },
+    Memory { width: usize },
 }
 
 impl AiurSystem {
-  pub fn build(
-    toplevel: Toplevel,
-    commitment_parameters: CommitmentParameters,
-  ) -> Self {
-    let function_circuits = (0..toplevel.functions.len()).map(|i| {
-      let (constraints, lookups) = toplevel.build_constraints(i);
-      LookupAir::new(AiurCircuit::Function(constraints), lookups)
-    });
-    let memory_circuits = toplevel.memory_sizes.iter().map(|&width| {
-      let (memory, lookup) = Memory::build(width);
-      LookupAir::new(AiurCircuit::Memory(memory), vec![lookup])
-    });
-    let (system, key) = System::new(
-      commitment_parameters,
-      function_circuits.chain(memory_circuits),
-    );
-    AiurSystem { system, key, toplevel }
-  }
+    pub fn build(toplevel: Toplevel, commitment_parameters: CommitmentParameters) -> Self {
+        let function_circuits = (0..toplevel.functions.len()).map(|i| {
+            let (constraints, lookups) = toplevel.build_constraints(i);
+            LookupAir::new(AiurCircuit::Function(constraints), lookups)
+        });
+        let memory_circuits = toplevel.memory_sizes.iter().map(|&width| {
+            let (memory, lookup) = Memory::build(width);
+            LookupAir::new(AiurCircuit::Memory(memory), vec![lookup])
+        });
+        let (system, key) = System::new(
+            commitment_parameters,
+            function_circuits.chain(memory_circuits),
+        );
+        AiurSystem {
+            system,
+            key,
+            toplevel,
+        }
+    }
 
-  pub fn prove(
-    &self,
-    fri_parameters: FriParameters,
-    fun_idx: FunIdx,
-    input: &[G],
-  ) -> (Vec<G>, Proof) {
-    let (query_record, output) = self.toplevel.execute(fun_idx, input.to_vec());
-    let mut witness = SystemWitness { traces: vec![], lookups: vec![] };
-    let functions = (0..self.toplevel.functions.len())
-      .into_par_iter()
-      .map(|idx| CircuitType::Function { idx });
-    let memories = self
-      .toplevel
-      .memory_sizes
-      .par_iter()
-      .map(|&width| CircuitType::Memory { width });
-    let witness_data = functions
-      .chain(memories)
-      .map(|circuit_type| match circuit_type {
-        CircuitType::Function { idx } => {
-          self.toplevel.generate_trace(idx, &query_record)
-        },
-        CircuitType::Memory { width } => {
-          Memory::generate_trace(width, &query_record)
-        },
-      })
-      .collect::<Vec<_>>();
-    for (trace, lookups) in witness_data {
-      witness.traces.push(trace);
-      witness.lookups.push(lookups);
+    pub fn prove(
+        &self,
+        fri_parameters: FriParameters,
+        fun_idx: FunIdx,
+        input: &[G],
+    ) -> (Vec<G>, Proof) {
+        let (query_record, output) = self.toplevel.execute(fun_idx, input.to_vec());
+        let mut witness = SystemWitness {
+            traces: vec![],
+            lookups: vec![],
+        };
+        let functions = (0..self.toplevel.functions.len())
+            .into_par_iter()
+            .map(|idx| CircuitType::Function { idx });
+        let memories = self
+            .toplevel
+            .memory_sizes
+            .par_iter()
+            .map(|&width| CircuitType::Memory { width });
+        let witness_data = functions
+            .chain(memories)
+            .map(|circuit_type| match circuit_type {
+                CircuitType::Function { idx } => self.toplevel.generate_trace(idx, &query_record),
+                CircuitType::Memory { width } => Memory::generate_trace(width, &query_record),
+            })
+            .collect::<Vec<_>>();
+        for (trace, lookups) in witness_data {
+            witness.traces.push(trace);
+            witness.lookups.push(lookups);
+        }
+        let mut claim = vec![Channel::Function.to_field(), G::from_usize(fun_idx)];
+        claim.extend(input);
+        claim.extend(output);
+        let proof = self
+            .system
+            .prove(fri_parameters, &self.key, &claim, witness);
+        (claim, proof)
     }
-    let mut claim = vec![Channel::Function.to_field(), G::from_usize(fun_idx)];
-    claim.extend(input);
-    claim.extend(output);
-    let proof = self.system.prove(fri_parameters, &self.key, &claim, witness);
-    (claim, proof)
-  }
 
-  #[inline]
-  pub fn verify(
-    &self,
-    fri_parameters: FriParameters,
-    claim: &[G],
-    proof: &Proof,
-  ) -> Result<(), VerificationError<PcsError>> {
-    self.system.verify(fri_parameters, claim, proof)
-  }
+    #[inline]
+    pub fn verify(
+        &self,
+        fri_parameters: FriParameters,
+        claim: &[G],
+        proof: &Proof,
+    ) -> Result<(), VerificationError<PcsError>> {
+        self.system.verify(fri_parameters, claim, proof)
+    }
 }
diff --git a/src/ixon.rs b/src/ixon.rs
index 6d0a16bc..5baaef0f 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -21,796 +21,795 @@ use univ::*;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Ixon {
-  Var(u64),                                   // 0x0X, variables
-  Sort(Box<Univ>),                            // 0xB0, universes
-  Ref(Address, Vec<Univ>),                    // 0x1X, global reference
-  Rec(u64, Vec<Univ>),                        // 0x2X, local const recursion
-  App(Box<Ixon>, Box<Ixon>, Vec<Ixon>),       // 0x3X, applications
-  Lam(Vec<Ixon>, Box<Ixon>),                  // 0x4X, lambdas
-  All(Vec<Ixon>, Box<Ixon>),                  // 0x5X, foralls
-  Proj(Address, u64, Box<Ixon>),              // 0x6X, structure projection
-  Strl(String),                               // 0x7X, unicode string
-  Natl(Nat),                                  // 0x8X, natural numbers
-  Let(bool, Box<Ixon>, Box<Ixon>, Box<Ixon>), // 0xB1, 0xB2, local binder
-  Array(Vec<Ixon>),                           // 0xA, array
-  Defn(Definition),                           // 0xC0, definition
-  Axio(Axiom),                                // 0xC1, axiom
-  Quot(Quotient),                             // 0xC2, quotient
-  CtorProj(ConstructorProj),                  // 0xC3, constructor projection
-  RecrProj(RecursorProj),                     // 0xC4, recursor projection
-  IndcProj(InductiveProj),                    // 0xC5, inductive projection
-  DefnProj(DefinitionProj),                   // 0xC6, definition projection
-  Meta(Metadata),                             // 0xC7, metadata
-  Proof(Proof),                               // 0xC8, zero-knowledge proof
-  Claim(Claim),                               // 0xC9, cryptographic claim
-  Comm(Comm),                                 // 0xCA, cryptographic commitment
-  Env(Env),                                   // 0xCB, multi-claim environment
-  MutDef(Vec<Definition>),                    // 0xDX, mutual definition
-  MutInd(Vec<Inductive>),                     // 0xEX, mutual inductive data
-                                              // unused: 0x9, 0xB3..0xBF, 0xFX
+    Var(u64),                                   // 0x0X, variables
+    Sort(Box<Univ>),                            // 0xB0, universes
+    Ref(Address, Vec<Univ>),                    // 0x1X, global reference
+    Rec(u64, Vec<Univ>),                        // 0x2X, local const recursion
+    App(Box<Ixon>, Box<Ixon>, Vec<Ixon>),       // 0x3X, applications
+    Lam(Vec<Ixon>, Box<Ixon>),                  // 0x4X, lambdas
+    All(Vec<Ixon>, Box<Ixon>),                  // 0x5X, foralls
+    Proj(Address, u64, Box<Ixon>),              // 0x6X, structure projection
+    Strl(String),                               // 0x7X, unicode string
+    Natl(Nat),                                  // 0x8X, natural numbers
+    Let(bool, Box<Ixon>, Box<Ixon>, Box<Ixon>), // 0xB1, 0xB2, local binder
+    Array(Vec<Ixon>),                           // 0xA, array
+    Defn(Definition),                           // 0xC0, definition
+    Axio(Axiom),                                // 0xC1, axiom
+    Quot(Quotient),                             // 0xC2, quotient
+    CtorProj(ConstructorProj),                  // 0xC3, constructor projection
+    RecrProj(RecursorProj),                     // 0xC4, recursor projection
+    IndcProj(InductiveProj),                    // 0xC5, inductive projection
+    DefnProj(DefinitionProj),                   // 0xC6, definition projection
+    Meta(Metadata),                             // 0xC7, metadata
+    Proof(Proof),                               // 0xC8, zero-knowledge proof
+    Claim(Claim),                               // 0xC9, cryptographic claim
+    Comm(Comm),                                 // 0xCA, cryptographic commitment
+    Env(Env),                                   // 0xCB, multi-claim environment
+    MutDef(Vec<Definition>),                    // 0xDX, mutual definition
+    MutInd(Vec<Inductive>),                     // 0xEX, mutual inductive data
+                                                // unused: 0x9, 0xB3..0xBF, 0xFX
 }
 
 impl Default for Ixon {
-  fn default() -> Self {
-    Self::Var(0)
-  }
+    fn default() -> Self {
+        Self::Var(0)
+    }
 }
 
 impl Ixon {
-  pub fn u64_byte_count(x: u64) -> u8 {
-    match x {
-      0 => 0,
-      x if x < 0x0000000000000100 => 1,
-      x if x < 0x0000000000010000 => 2,
-      x if x < 0x0000000001000000 => 3,
-      x if x < 0x0000000100000000 => 4,
-      x if x < 0x0000010000000000 => 5,
-      x if x < 0x0001000000000000 => 6,
-      x if x < 0x0100000000000000 => 7,
-      _ => 8,
+    pub fn u64_byte_count(x: u64) -> u8 {
+        match x {
+            0 => 0,
+            x if x < 0x0000000000000100 => 1,
+            x if x < 0x0000000000010000 => 2,
+            x if x < 0x0000000001000000 => 3,
+            x if x < 0x0000000100000000 => 4,
+            x if x < 0x0000010000000000 => 5,
+            x if x < 0x0001000000000000 => 6,
+            x if x < 0x0100000000000000 => 7,
+            _ => 8,
+        }
     }
-  }
-
-  pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
-    let n = Ixon::u64_byte_count(x) as usize;
-    buf.extend_from_slice(&x.to_le_bytes()[..n])
-  }
 
-  pub fn u64_get_trimmed_le(
-    len: usize,
-    buf: &mut &[u8],
-  ) -> Result<u64, String> {
-    let mut res = [0u8; 8];
-    if len > 8 {
-      return Err("get trimmed_le_64 len > 8".to_string());
+    pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
+        let n = Ixon::u64_byte_count(x) as usize;
+        buf.extend_from_slice(&x.to_le_bytes()[..n])
     }
-    match buf.split_at_checked(len) {
-      Some((head, rest)) => {
-        *buf = rest;
-        res[..len].copy_from_slice(head);
-        Ok(u64::from_le_bytes(res))
-      },
-      None => Err("get trimmed_le_u64 EOF".to_string()),
+
+    pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
+        let mut res = [0u8; 8];
+        if len > 8 {
+            return Err("get trimmed_le_64 len > 8".to_string());
+        }
+        match buf.split_at_checked(len) {
+            Some((head, rest)) => {
+                *buf = rest;
+                res[..len].copy_from_slice(head);
+                Ok(u64::from_le_bytes(res))
+            }
+            None => Err("get trimmed_le_u64 EOF".to_string()),
+        }
     }
-  }
 
-  pub fn pack_bools<I>(bools: I) -> u8
-  where
-    I: IntoIterator<Item = bool>,
-  {
-    let mut acc: u8 = 0;
-    for (i, b) in bools.into_iter().take(8).enumerate() {
-      if b {
-        acc |= 1u8 << (i as u32);
-      }
+    pub fn pack_bools<I>(bools: I) -> u8
+    where
+        I: IntoIterator<Item = bool>,
+    {
+        let mut acc: u8 = 0;
+        for (i, b) in bools.into_iter().take(8).enumerate() {
+            if b {
+                acc |= 1u8 << (i as u32);
+            }
+        }
+        acc
     }
-    acc
-  }
 
-  pub fn unpack_bools(n: usize, b: u8) -> Vec<bool> {
-    (0..8).map(|i| (b & (1u8 << (i as u32))) != 0).take(n.min(8)).collect()
-  }
+    pub fn unpack_bools(n: usize, b: u8) -> Vec<bool> {
+        (0..8)
+            .map(|i| (b & (1u8 << (i as u32))) != 0)
+            .take(n.min(8))
+            .collect()
+    }
 
-  fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
-    if val < 8 {
-      buf.push((tag << 4) | (val as u8));
-    } else {
-      buf.push((tag << 4) | 0b1000 | (Ixon::u64_byte_count(val) - 1));
-      Ixon::u64_put_trimmed_le(val, buf);
+    fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
+        if val < 8 {
+            buf.push((tag << 4) | (val as u8));
+        } else {
+            buf.push((tag << 4) | 0b1000 | (Ixon::u64_byte_count(val) - 1));
+            Ixon::u64_put_trimmed_le(val, buf);
+        }
     }
-  }
 
-  fn get_size(
-    is_large: bool,
-    small: u8,
-    buf: &mut &[u8],
-  ) -> Result<u64, String> {
-    if is_large {
-      Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
-    } else {
-      Ok(small as u64)
+    fn get_size(is_large: bool, small: u8, buf: &mut &[u8]) -> Result<u64, String> {
+        if is_large {
+            Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
+        } else {
+            Ok(small as u64)
+        }
     }
-  }
 
-  // put_array and get_array are separated from Ixon's serialize implementation
-  // in order to create a generic Serialize impl for Vec<S>
-  pub fn put_array<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
-    Self::put_tag(0xA, xs.len() as u64, buf);
-    for x in xs {
-      x.put(buf)
+    // put_array and get_array are separated from Ixon's serialize implementation
+    // in order to create a generic Serialize impl for Vec<S>
+    pub fn put_array<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
+        Self::put_tag(0xA, xs.len() as u64, buf);
+        for x in xs {
+            x.put(buf)
+        }
     }
-  }
 
-  pub fn get_array<S: Serialize>(buf: &mut &[u8]) -> Result<Vec<S>, String> {
-    let tag_byte = u8::get(buf)?;
-    let tag = tag_byte >> 4;
-    let small_size = tag_byte & 0b111;
-    let is_large = tag_byte & 0b1000 != 0;
-    match tag {
-      0xA => {
-        let len = Self::get_size(is_large, small_size, buf)?;
-        let mut vec = vec![];
-        for _ in 0..len {
-          let s = S::get(buf)?;
-          vec.push(s);
+    pub fn get_array<S: Serialize>(buf: &mut &[u8]) -> Result<Vec<S>, String> {
+        let tag_byte = u8::get(buf)?;
+        let tag = tag_byte >> 4;
+        let small_size = tag_byte & 0b111;
+        let is_large = tag_byte & 0b1000 != 0;
+        match tag {
+            0xA => {
+                let len = Self::get_size(is_large, small_size, buf)?;
+                let mut vec = vec![];
+                for _ in 0..len {
+                    let s = S::get(buf)?;
+                    vec.push(s);
+                }
+                Ok(vec)
+            }
+            x => Err(format!("get array invalid tag {x}")),
         }
-        Ok(vec)
-      },
-      x => Err(format!("get array invalid tag {x}")),
     }
-  }
 }
 
 impl Serialize for Ixon {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Var(x) => Self::put_tag(0x0, *x, buf),
-      Self::Sort(x) => {
-        u8::put(&0xB0, buf);
-        x.put(buf);
-      },
-      Self::Ref(addr, lvls) => {
-        Self::put_tag(0x1, lvls.len() as u64, buf);
-        addr.put(buf);
-        for l in lvls {
-          l.put(buf);
-        }
-      },
-      Self::Rec(x, lvls) => {
-        Self::put_tag(0x2, lvls.len() as u64, buf);
-        x.put(buf);
-        for l in lvls {
-          l.put(buf);
-        }
-      },
-      Self::App(f, a, args) => {
-        Self::put_tag(0x3, args.len() as u64, buf);
-        f.put(buf);
-        a.put(buf);
-        for x in args {
-          x.put(buf);
-        }
-      },
-      Self::Lam(ts, b) => {
-        Self::put_tag(0x4, ts.len() as u64, buf);
-        for t in ts {
-          t.put(buf);
-        }
-        b.put(buf);
-      },
-      Self::All(ts, b) => {
-        Self::put_tag(0x5, ts.len() as u64, buf);
-        for t in ts {
-          t.put(buf);
-        }
-        b.put(buf);
-      },
-      Self::Proj(t, n, x) => {
-        Self::put_tag(0x6, *n, buf);
-        t.put(buf);
-        x.put(buf);
-      },
-      Self::Strl(s) => {
-        let bytes = s.as_bytes();
-        Self::put_tag(0x7, bytes.len() as u64, buf);
-        buf.extend_from_slice(bytes);
-      },
-      Self::Natl(n) => {
-        let bytes = n.0.to_bytes_le();
-        Self::put_tag(0x8, bytes.len() as u64, buf);
-        buf.extend_from_slice(&bytes);
-      },
-      Self::Let(nd, t, d, b) => {
-        if *nd {
-          u8::put(&0xB2, buf);
-        } else {
-          u8::put(&0xB1, buf);
-        }
-        t.put(buf);
-        d.put(buf);
-        b.put(buf);
-      },
-      Self::Array(xs) => Ixon::put_array(xs, buf),
-      Self::Defn(x) => {
-        u8::put(&0xC0, buf);
-        x.put(buf);
-      },
-      Self::Axio(x) => {
-        u8::put(&0xC1, buf);
-        x.put(buf);
-      },
-      Self::Quot(x) => {
-        u8::put(&0xC2, buf);
-        x.put(buf);
-      },
-      Self::CtorProj(x) => {
-        u8::put(&0xC3, buf);
-        x.put(buf);
-      },
-      Self::RecrProj(x) => {
-        u8::put(&0xC4, buf);
-        x.put(buf);
-      },
-      Self::IndcProj(x) => {
-        u8::put(&0xC5, buf);
-        x.put(buf);
-      },
-      Self::DefnProj(x) => {
-        u8::put(&0xC6, buf);
-        x.put(buf);
-      },
-      Self::Meta(x) => {
-        u8::put(&0xC7, buf);
-        x.put(buf);
-      },
-      Self::Proof(x) => {
-        u8::put(&0xC8, buf);
-        x.put(buf);
-      },
-      Self::Claim(x) => {
-        u8::put(&0xC9, buf);
-        x.put(buf);
-      },
-      Self::Comm(x) => {
-        u8::put(&0xCA, buf);
-        x.put(buf);
-      },
-      Self::Env(x) => {
-        u8::put(&0xCB, buf);
-        x.put(buf);
-      },
-      Self::MutDef(xs) => {
-        Self::put_tag(0xD, xs.len() as u64, buf);
-        for x in xs {
-          x.put(buf);
-        }
-      },
-      Self::MutInd(xs) => {
-        Self::put_tag(0xE, xs.len() as u64, buf);
-        for x in xs {
-          x.put(buf);
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Var(x) => Self::put_tag(0x0, *x, buf),
+            Self::Sort(x) => {
+                u8::put(&0xB0, buf);
+                x.put(buf);
+            }
+            Self::Ref(addr, lvls) => {
+                Self::put_tag(0x1, lvls.len() as u64, buf);
+                addr.put(buf);
+                for l in lvls {
+                    l.put(buf);
+                }
+            }
+            Self::Rec(x, lvls) => {
+                Self::put_tag(0x2, lvls.len() as u64, buf);
+                x.put(buf);
+                for l in lvls {
+                    l.put(buf);
+                }
+            }
+            Self::App(f, a, args) => {
+                Self::put_tag(0x3, args.len() as u64, buf);
+                f.put(buf);
+                a.put(buf);
+                for x in args {
+                    x.put(buf);
+                }
+            }
+            Self::Lam(ts, b) => {
+                Self::put_tag(0x4, ts.len() as u64, buf);
+                for t in ts {
+                    t.put(buf);
+                }
+                b.put(buf);
+            }
+            Self::All(ts, b) => {
+                Self::put_tag(0x5, ts.len() as u64, buf);
+                for t in ts {
+                    t.put(buf);
+                }
+                b.put(buf);
+            }
+            Self::Proj(t, n, x) => {
+                Self::put_tag(0x6, *n, buf);
+                t.put(buf);
+                x.put(buf);
+            }
+            Self::Strl(s) => {
+                let bytes = s.as_bytes();
+                Self::put_tag(0x7, bytes.len() as u64, buf);
+                buf.extend_from_slice(bytes);
+            }
+            Self::Natl(n) => {
+                let bytes = n.0.to_bytes_le();
+                Self::put_tag(0x8, bytes.len() as u64, buf);
+                buf.extend_from_slice(&bytes);
+            }
+            Self::Let(nd, t, d, b) => {
+                if *nd {
+                    u8::put(&0xB2, buf);
+                } else {
+                    u8::put(&0xB1, buf);
+                }
+                t.put(buf);
+                d.put(buf);
+                b.put(buf);
+            }
+            Self::Array(xs) => Ixon::put_array(xs, buf),
+            Self::Defn(x) => {
+                u8::put(&0xC0, buf);
+                x.put(buf);
+            }
+            Self::Axio(x) => {
+                u8::put(&0xC1, buf);
+                x.put(buf);
+            }
+            Self::Quot(x) => {
+                u8::put(&0xC2, buf);
+                x.put(buf);
+            }
+            Self::CtorProj(x) => {
+                u8::put(&0xC3, buf);
+                x.put(buf);
+            }
+            Self::RecrProj(x) => {
+                u8::put(&0xC4, buf);
+                x.put(buf);
+            }
+            Self::IndcProj(x) => {
+                u8::put(&0xC5, buf);
+                x.put(buf);
+            }
+            Self::DefnProj(x) => {
+                u8::put(&0xC6, buf);
+                x.put(buf);
+            }
+            Self::Meta(x) => {
+                u8::put(&0xC7, buf);
+                x.put(buf);
+            }
+            Self::Proof(x) => {
+                u8::put(&0xC8, buf);
+                x.put(buf);
+            }
+            Self::Claim(x) => {
+                u8::put(&0xC9, buf);
+                x.put(buf);
+            }
+            Self::Comm(x) => {
+                u8::put(&0xCA, buf);
+                x.put(buf);
+            }
+            Self::Env(x) => {
+                u8::put(&0xCB, buf);
+                x.put(buf);
+            }
+            Self::MutDef(xs) => {
+                Self::put_tag(0xD, xs.len() as u64, buf);
+                for x in xs {
+                    x.put(buf);
+                }
+            }
+            Self::MutInd(xs) => {
+                Self::put_tag(0xE, xs.len() as u64, buf);
+                for x in xs {
+                    x.put(buf);
+                }
+            }
         }
-      },
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let tag_byte = u8::get(buf)?;
-    let small_size = tag_byte & 0b111;
-    let is_large = tag_byte & 0b1000 != 0;
-    match tag_byte {
-      0x00..=0x0F => {
-        let x = Ixon::get_size(is_large, small_size, buf)?;
-        Ok(Self::Var(x))
-      },
-      0xB0 => {
-        let u = Univ::get(buf)?;
-        Ok(Self::Sort(Box::new(u)))
-      },
-      0x10..=0x1F => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        let a = Address::get(buf)?;
-        let mut lvls = Vec::new();
-        for _ in 0..n {
-          let l = Univ::get(buf)?;
-          lvls.push(l);
-        }
-        Ok(Self::Ref(a, lvls))
-      },
-      0x20..=0x2F => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        let x = u64::get(buf)?;
-        let mut lvls = Vec::new();
-        for _ in 0..n {
-          let l = Univ::get(buf)?;
-          lvls.push(l);
-        }
-        Ok(Self::Rec(x, lvls))
-      },
-      0x30..=0x3F => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        let f = Ixon::get(buf)?;
-        let a = Ixon::get(buf)?;
-        let mut args = Vec::new();
-        for _ in 0..n {
-          let x = Ixon::get(buf)?;
-          args.push(x);
-        }
-        Ok(Self::App(Box::new(f), Box::new(a), args))
-      },
-      0x40..=0x4F => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        let mut ts = Vec::new();
-        for _ in 0..n {
-          let x = Ixon::get(buf)?;
-          ts.push(x);
-        }
-        let b = Ixon::get(buf)?;
-        Ok(Self::Lam(ts, Box::new(b)))
-      },
-      0x50..=0x5F => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        let mut ts = Vec::new();
-        for _ in 0..n {
-          let x = Ixon::get(buf)?;
-          ts.push(x);
-        }
-        let b = Ixon::get(buf)?;
-        Ok(Self::All(ts, Box::new(b)))
-      },
-      0x60..=0x6F => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        let t = Address::get(buf)?;
-        let x = Ixon::get(buf)?;
-        Ok(Self::Proj(t, n, Box::new(x)))
-      },
-      0x70..=0x7F => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        match buf.split_at_checked(n as usize) {
-          Some((head, rest)) => {
-            *buf = rest;
-            match String::from_utf8(head.to_owned()) {
-              Ok(s) => Ok(Ixon::Strl(s)),
-              Err(e) => Err(format!("UTF8 Error: {e}")),
-            }
-          },
-          None => Err("get Ixon Strl EOF".to_string()),
-        }
-      },
-      0x80..=0x8F => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        match buf.split_at_checked(n as usize) {
-          Some((head, rest)) => {
-            *buf = rest;
-            Ok(Ixon::Natl(Nat(BigUint::from_bytes_le(head))))
-          },
-          None => Err("get Expr Natl EOF".to_string()),
-        }
-      },
-      0xB1..=0xB2 => {
-        let nd = tag_byte == 0xB2;
-        let t = Ixon::get(buf)?;
-        let d = Ixon::get(buf)?;
-        let b = Ixon::get(buf)?;
-        Ok(Self::Let(nd, Box::new(t), Box::new(d), Box::new(b)))
-      },
-      0xA0..=0xAF => {
-        let len = Self::get_size(is_large, small_size, buf)?;
-        let mut vec = vec![];
-        for _ in 0..len {
-          let s = Ixon::get(buf)?;
-          vec.push(s);
-        }
-        Ok(Self::Array(vec))
-      },
-      0xC0 => Ok(Self::Defn(Definition::get(buf)?)),
-      0xC1 => Ok(Self::Axio(Axiom::get(buf)?)),
-      0xC2 => Ok(Self::Quot(Quotient::get(buf)?)),
-      0xC3 => Ok(Self::CtorProj(ConstructorProj::get(buf)?)),
-      0xC4 => Ok(Self::RecrProj(RecursorProj::get(buf)?)),
-      0xC5 => Ok(Self::IndcProj(InductiveProj::get(buf)?)),
-      0xC6 => Ok(Self::DefnProj(DefinitionProj::get(buf)?)),
-      0xC7 => Ok(Self::Meta(Metadata::get(buf)?)),
-      0xC8 => Ok(Self::Proof(Proof::get(buf)?)),
-      0xC9 => Ok(Self::Claim(Claim::get(buf)?)),
-      0xCA => Ok(Self::Comm(Comm::get(buf)?)),
-      0xCB => Ok(Self::Env(Env::get(buf)?)),
-      0xD0..=0xDF => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        let mut defs = Vec::new();
-        for _ in 0..n {
-          let x = Definition::get(buf)?;
-          defs.push(x);
-        }
-        Ok(Self::MutDef(defs))
-      },
-      0xE0..=0xEF => {
-        let n = Ixon::get_size(is_large, small_size, buf)?;
-        let mut inds = Vec::new();
-        for _ in 0..n {
-          let x = Inductive::get(buf)?;
-          inds.push(x);
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let tag_byte = u8::get(buf)?;
+        let small_size = tag_byte & 0b111;
+        let is_large = tag_byte & 0b1000 != 0;
+        match tag_byte {
+            0x00..=0x0F => {
+                let x = Ixon::get_size(is_large, small_size, buf)?;
+                Ok(Self::Var(x))
+            }
+            0xB0 => {
+                let u = Univ::get(buf)?;
+                Ok(Self::Sort(Box::new(u)))
+            }
+            0x10..=0x1F => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let a = Address::get(buf)?;
+                let mut lvls = Vec::new();
+                for _ in 0..n {
+                    let l = Univ::get(buf)?;
+                    lvls.push(l);
+                }
+                Ok(Self::Ref(a, lvls))
+            }
+            0x20..=0x2F => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let x = u64::get(buf)?;
+                let mut lvls = Vec::new();
+                for _ in 0..n {
+                    let l = Univ::get(buf)?;
+                    lvls.push(l);
+                }
+                Ok(Self::Rec(x, lvls))
+            }
+            0x30..=0x3F => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let f = Ixon::get(buf)?;
+                let a = Ixon::get(buf)?;
+                let mut args = Vec::new();
+                for _ in 0..n {
+                    let x = Ixon::get(buf)?;
+                    args.push(x);
+                }
+                Ok(Self::App(Box::new(f), Box::new(a), args))
+            }
+            0x40..=0x4F => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let mut ts = Vec::new();
+                for _ in 0..n {
+                    let x = Ixon::get(buf)?;
+                    ts.push(x);
+                }
+                let b = Ixon::get(buf)?;
+                Ok(Self::Lam(ts, Box::new(b)))
+            }
+            0x50..=0x5F => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let mut ts = Vec::new();
+                for _ in 0..n {
+                    let x = Ixon::get(buf)?;
+                    ts.push(x);
+                }
+                let b = Ixon::get(buf)?;
+                Ok(Self::All(ts, Box::new(b)))
+            }
+            0x60..=0x6F => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let t = Address::get(buf)?;
+                let x = Ixon::get(buf)?;
+                Ok(Self::Proj(t, n, Box::new(x)))
+            }
+            0x70..=0x7F => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                match buf.split_at_checked(n as usize) {
+                    Some((head, rest)) => {
+                        *buf = rest;
+                        match String::from_utf8(head.to_owned()) {
+                            Ok(s) => Ok(Ixon::Strl(s)),
+                            Err(e) => Err(format!("UTF8 Error: {e}")),
+                        }
+                    }
+                    None => Err("get Ixon Strl EOF".to_string()),
+                }
+            }
+            0x80..=0x8F => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                match buf.split_at_checked(n as usize) {
+                    Some((head, rest)) => {
+                        *buf = rest;
+                        Ok(Ixon::Natl(Nat(BigUint::from_bytes_le(head))))
+                    }
+                    None => Err("get Expr Natl EOF".to_string()),
+                }
+            }
+            0xB1..=0xB2 => {
+                let nd = tag_byte == 0xB2;
+                let t = Ixon::get(buf)?;
+                let d = Ixon::get(buf)?;
+                let b = Ixon::get(buf)?;
+                Ok(Self::Let(nd, Box::new(t), Box::new(d), Box::new(b)))
+            }
+            0xA0..=0xAF => {
+                let len = Self::get_size(is_large, small_size, buf)?;
+                let mut vec = vec![];
+                for _ in 0..len {
+                    let s = Ixon::get(buf)?;
+                    vec.push(s);
+                }
+                Ok(Self::Array(vec))
+            }
+            0xC0 => Ok(Self::Defn(Definition::get(buf)?)),
+            0xC1 => Ok(Self::Axio(Axiom::get(buf)?)),
+            0xC2 => Ok(Self::Quot(Quotient::get(buf)?)),
+            0xC3 => Ok(Self::CtorProj(ConstructorProj::get(buf)?)),
+            0xC4 => Ok(Self::RecrProj(RecursorProj::get(buf)?)),
+            0xC5 => Ok(Self::IndcProj(InductiveProj::get(buf)?)),
+            0xC6 => Ok(Self::DefnProj(DefinitionProj::get(buf)?)),
+            0xC7 => Ok(Self::Meta(Metadata::get(buf)?)),
+            0xC8 => Ok(Self::Proof(Proof::get(buf)?)),
+            0xC9 => Ok(Self::Claim(Claim::get(buf)?)),
+            0xCA => Ok(Self::Comm(Comm::get(buf)?)),
+            0xCB => Ok(Self::Env(Env::get(buf)?)),
+            0xD0..=0xDF => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let mut defs = Vec::new();
+                for _ in 0..n {
+                    let x = Definition::get(buf)?;
+                    defs.push(x);
+                }
+                Ok(Self::MutDef(defs))
+            }
+            0xE0..=0xEF => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let mut inds = Vec::new();
+                for _ in 0..n {
+                    let x = Inductive::get(buf)?;
+                    inds.push(x);
+                }
+                Ok(Self::MutInd(inds))
+            }
+            x => Err(format!("get Ixon invalid tag {x}")),
         }
-        Ok(Self::MutInd(inds))
-      },
-      x => Err(format!("get Ixon invalid tag {x}")),
     }
-  }
 }
 
 #[cfg(test)]
 pub mod tests {
-  use super::*;
-  use crate::ixon::nat::tests::arbitrary_nat;
-  use crate::ixon::univ::tests::arbitrary_univ;
-  use quickcheck::{Arbitrary, Gen};
-  use std::ops::Range;
-  use std::ptr;
+    use super::*;
+    use crate::ixon::nat::tests::arbitrary_nat;
+    use crate::ixon::univ::tests::arbitrary_univ;
+    use quickcheck::{Arbitrary, Gen};
+    use std::ops::Range;
+    use std::ptr;
 
-  pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
-    let res: usize = Arbitrary::arbitrary(g);
-    if range.is_empty() {
-      0
-    } else {
-      (res % (range.end - range.start)) + range.start
+    pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
+        let res: usize = Arbitrary::arbitrary(g);
+        if range.is_empty() {
+            0
+        } else {
+            (res % (range.end - range.start)) + range.start
+        }
     }
-  }
 
-  pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
-  where
-    F: FnMut(&mut Gen) -> A,
-  {
-    let len = gen_range(g, 0..size);
-    let mut vec = Vec::with_capacity(len);
-    for _ in 0..len {
-      vec.push(f(g));
+    pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
+    where
+        F: FnMut(&mut Gen) -> A,
+    {
+        let len = gen_range(g, 0..size);
+        let mut vec = Vec::with_capacity(len);
+        for _ in 0..len {
+            vec.push(f(g));
+        }
+        vec
     }
-    vec
-  }
 
-  pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
-    let sum: usize = gens.iter().map(|x| x.0).sum();
-    let mut weight: usize = gen_range(g, 1..sum);
-    for (n, case) in gens {
-      if *n == 0 {
-        continue;
-      } else {
-        match weight.checked_sub(*n) {
-          None | Some(0) => {
-            return *case;
-          },
-          _ => {
-            weight -= *n;
-          },
+    pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
+        let sum: usize = gens.iter().map(|x| x.0).sum();
+        let mut weight: usize = gen_range(g, 1..sum);
+        for (n, case) in gens {
+            if *n == 0 {
+                continue;
+            } else {
+                match weight.checked_sub(*n) {
+                    None | Some(0) => {
+                        return *case;
+                    }
+                    _ => {
+                        weight -= *n;
+                    }
+                }
+            }
         }
-      }
+        unreachable!()
     }
-    unreachable!()
-  }
 
-  #[test]
-  fn unit_u64_trimmed() {
-    fn test(input: u64, expected: Vec<u8>) -> bool {
-      let mut tmp = Vec::new();
-      let n = Ixon::u64_byte_count(input);
-      Ixon::u64_put_trimmed_le(input, &mut tmp);
-      if tmp != expected {
-        return false;
-      }
-      match Ixon::u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
-        Ok(out) => input == out,
-        Err(e) => {
-          println!("err: {e}");
-          false
-        },
-      }
+    #[test]
+    fn unit_u64_trimmed() {
+        fn test(input: u64, expected: Vec<u8>) -> bool {
+            let mut tmp = Vec::new();
+            let n = Ixon::u64_byte_count(input);
+            Ixon::u64_put_trimmed_le(input, &mut tmp);
+            if tmp != expected {
+                return false;
+            }
+            match Ixon::u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
+                Ok(out) => input == out,
+                Err(e) => {
+                    println!("err: {e}");
+                    false
+                }
+            }
+        }
+        assert!(test(0x0, vec![]));
+        assert!(test(0x01, vec![0x01]));
+        assert!(test(0x0000000000000100, vec![0x00, 0x01]));
+        assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
+        assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
+        assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
+        assert!(test(
+            0x0000010000000000,
+            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+        ));
+        assert!(test(
+            0x0001000000000000,
+            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+        ));
+        assert!(test(
+            0x0100000000000000,
+            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+        ));
+        assert!(test(
+            0x0102030405060708,
+            vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+        ));
     }
-    assert!(test(0x0, vec![]));
-    assert!(test(0x01, vec![0x01]));
-    assert!(test(0x0000000000000100, vec![0x00, 0x01]));
-    assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
-    assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000010000000000, vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]));
-    assert!(test(
-      0x0001000000000000,
-      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-    ));
-    assert!(test(
-      0x0100000000000000,
-      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-    ));
-    assert!(test(
-      0x0102030405060708,
-      vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
-    ));
-  }
 
-  #[quickcheck]
-  fn prop_u64_trimmed_le_readback(x: u64) -> bool {
-    let mut buf = Vec::new();
-    let n = Ixon::u64_byte_count(x);
-    Ixon::u64_put_trimmed_le(x, &mut buf);
-    match Ixon::u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
-      Ok(y) => x == y,
-      Err(e) => {
-        println!("err: {e}");
-        false
-      },
+    #[quickcheck]
+    fn prop_u64_trimmed_le_readback(x: u64) -> bool {
+        let mut buf = Vec::new();
+        let n = Ixon::u64_byte_count(x);
+        Ixon::u64_put_trimmed_le(x, &mut buf);
+        match Ixon::u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
+            Ok(y) => x == y,
+            Err(e) => {
+                println!("err: {e}");
+                false
+            }
+        }
     }
-  }
 
-  #[derive(Debug, Clone, Copy)]
-  pub enum IxonCase {
-    Var,
-    Sort,
-    Ref,
-    Rec,
-    App,
-    Lam,
-    All,
-    Proj,
-    Strl,
-    Natl,
-    Let,
-    Array,
-    Defn,
-    Axio,
-    Quot,
-    CtorProj,
-    RecrProj,
-    IndcProj,
-    DefnProj,
-    Meta,
-    Proof,
-    Claim,
-    Comm,
-    Env,
-    MutDef,
-    MutInd,
-  }
+    #[derive(Debug, Clone, Copy)]
+    pub enum IxonCase {
+        Var,
+        Sort,
+        Ref,
+        Rec,
+        App,
+        Lam,
+        All,
+        Proj,
+        Strl,
+        Natl,
+        Let,
+        Array,
+        Defn,
+        Axio,
+        Quot,
+        CtorProj,
+        RecrProj,
+        IndcProj,
+        DefnProj,
+        Meta,
+        Proof,
+        Claim,
+        Comm,
+        Env,
+        MutDef,
+        MutInd,
+    }
 
-  pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
-    let mut s = String::new();
-    for _ in 0..cs {
-      s.push(char::arbitrary(g));
+    pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
+        let mut s = String::new();
+        for _ in 0..cs {
+            s.push(char::arbitrary(g));
+        }
+        s
     }
-    s
-  }
 
-  // incremental tree generation without recursion stack overflows
-  pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
-    let mut root = Ixon::Var(0);
-    let mut stack = vec![&mut root as *mut Ixon];
+    // incremental tree generation without recursion stack overflows
+    pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
+        let mut root = Ixon::Var(0);
+        let mut stack = vec![&mut root as *mut Ixon];
 
-    while let Some(ptr) = stack.pop() {
-      let gens: Vec<(usize, IxonCase)> = vec![
-        (100, IxonCase::Var),
-        (100, IxonCase::Sort),
-        (15, IxonCase::Ref),
-        (15, IxonCase::Rec),
-        (15, IxonCase::App),
-        (15, IxonCase::Lam),
-        (15, IxonCase::All),
-        (50, IxonCase::Let),
-        (50, IxonCase::Proj),
-        (100, IxonCase::Strl),
-        (100, IxonCase::Natl),
-        (10, IxonCase::Array),
-        (100, IxonCase::Defn),
-        (100, IxonCase::Axio),
-        (100, IxonCase::Quot),
-        (100, IxonCase::CtorProj),
-        (100, IxonCase::RecrProj),
-        (100, IxonCase::IndcProj),
-        (100, IxonCase::DefnProj),
-        (100, IxonCase::Meta),
-        (100, IxonCase::Proof),
-        (100, IxonCase::Claim),
-        (100, IxonCase::Comm),
-        (100, IxonCase::Env),
-        (15, IxonCase::MutDef),
-        (15, IxonCase::MutInd),
-      ];
+        while let Some(ptr) = stack.pop() {
+            let gens: Vec<(usize, IxonCase)> = vec![
+                (100, IxonCase::Var),
+                (100, IxonCase::Sort),
+                (15, IxonCase::Ref),
+                (15, IxonCase::Rec),
+                (15, IxonCase::App),
+                (15, IxonCase::Lam),
+                (15, IxonCase::All),
+                (50, IxonCase::Let),
+                (50, IxonCase::Proj),
+                (100, IxonCase::Strl),
+                (100, IxonCase::Natl),
+                (10, IxonCase::Array),
+                (100, IxonCase::Defn),
+                (100, IxonCase::Axio),
+                (100, IxonCase::Quot),
+                (100, IxonCase::CtorProj),
+                (100, IxonCase::RecrProj),
+                (100, IxonCase::IndcProj),
+                (100, IxonCase::DefnProj),
+                (100, IxonCase::Meta),
+                (100, IxonCase::Proof),
+                (100, IxonCase::Claim),
+                (100, IxonCase::Comm),
+                (100, IxonCase::Env),
+                (15, IxonCase::MutDef),
+                (15, IxonCase::MutInd),
+            ];
 
-      match next_case(g, &gens) {
-        IxonCase::Var => {
-          let x: u64 = Arbitrary::arbitrary(g);
-          unsafe {
-            ptr::replace(ptr, Ixon::Var(x));
-          }
-        },
-        IxonCase::Sort => {
-          let u = arbitrary_univ(g, ctx);
-          unsafe {
-            ptr::replace(ptr, Ixon::Sort(Box::new(u)));
-          }
-        },
-        IxonCase::Ref => {
-          let addr = Address::arbitrary(g);
-          let mut lvls = vec![];
-          for _ in 0..gen_range(g, 0..9) {
-            lvls.push(arbitrary_univ(g, ctx));
-          }
-          unsafe {
-            ptr::replace(ptr, Ixon::Ref(addr, lvls));
-          }
-        },
-        IxonCase::Rec => {
-          let n = u64::arbitrary(g);
-          let mut lvls = vec![];
-          for _ in 0..gen_range(g, 0..9) {
-            lvls.push(arbitrary_univ(g, ctx));
-          }
-          unsafe {
-            ptr::replace(ptr, Ixon::Rec(n, lvls));
-          }
-        },
-        IxonCase::App => {
-          let mut f_box = Box::new(Ixon::default());
-          let f_ptr: *mut Ixon = &mut *f_box;
-          stack.push(f_ptr);
+            match next_case(g, &gens) {
+                IxonCase::Var => {
+                    let x: u64 = Arbitrary::arbitrary(g);
+                    unsafe {
+                        ptr::replace(ptr, Ixon::Var(x));
+                    }
+                }
+                IxonCase::Sort => {
+                    let u = arbitrary_univ(g, ctx);
+                    unsafe {
+                        ptr::replace(ptr, Ixon::Sort(Box::new(u)));
+                    }
+                }
+                IxonCase::Ref => {
+                    let addr = Address::arbitrary(g);
+                    let mut lvls = vec![];
+                    for _ in 0..gen_range(g, 0..9) {
+                        lvls.push(arbitrary_univ(g, ctx));
+                    }
+                    unsafe {
+                        ptr::replace(ptr, Ixon::Ref(addr, lvls));
+                    }
+                }
+                IxonCase::Rec => {
+                    let n = u64::arbitrary(g);
+                    let mut lvls = vec![];
+                    for _ in 0..gen_range(g, 0..9) {
+                        lvls.push(arbitrary_univ(g, ctx));
+                    }
+                    unsafe {
+                        ptr::replace(ptr, Ixon::Rec(n, lvls));
+                    }
+                }
+                IxonCase::App => {
+                    let mut f_box = Box::new(Ixon::default());
+                    let f_ptr: *mut Ixon = &mut *f_box;
+                    stack.push(f_ptr);
 
-          let mut a_box = Box::new(Ixon::default());
-          let a_ptr: *mut Ixon = &mut *a_box;
-          stack.push(a_ptr);
+                    let mut a_box = Box::new(Ixon::default());
+                    let a_ptr: *mut Ixon = &mut *a_box;
+                    stack.push(a_ptr);
 
-          let n = gen_range(g, 0..9);
-          let mut xs: Vec<Ixon> = Vec::with_capacity(n);
-          xs.resize(n, Ixon::Var(0));
-          for i in 0..n {
-            let p = unsafe { xs.as_mut_ptr().add(i) };
-            stack.push(p);
-          }
-          unsafe {
-            std::ptr::replace(ptr, Ixon::App(f_box, a_box, xs));
-          }
-        },
-        IxonCase::Lam => {
-          let n = gen_range(g, 0..9);
-          let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-          ts.resize(n, Ixon::Var(0));
-          for i in 0..n {
-            let p = unsafe { ts.as_mut_ptr().add(i) };
-            stack.push(p);
-          }
-          let mut b_box = Box::new(Ixon::default());
-          let b_ptr: *mut Ixon = &mut *b_box;
-          stack.push(b_ptr);
-          unsafe {
-            std::ptr::replace(ptr, Ixon::Lam(ts, b_box));
-          }
-        },
-        IxonCase::All => {
-          let n = gen_range(g, 0..9);
-          let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-          ts.resize(n, Ixon::Var(0));
-          for i in 0..n {
-            let p = unsafe { ts.as_mut_ptr().add(i) };
-            stack.push(p);
-          }
-          let mut b_box = Box::new(Ixon::default());
-          let b_ptr: *mut Ixon = &mut *b_box;
-          stack.push(b_ptr);
-          unsafe {
-            std::ptr::replace(ptr, Ixon::All(ts, b_box));
-          }
-        },
-        IxonCase::Let => {
-          let nd = bool::arbitrary(g);
-          let mut t_box = Box::new(Ixon::default());
-          let t_ptr: *mut Ixon = &mut *t_box;
-          stack.push(t_ptr);
-          let mut d_box = Box::new(Ixon::default());
-          let d_ptr: *mut Ixon = &mut *d_box;
-          stack.push(d_ptr);
-          let mut b_box = Box::new(Ixon::default());
-          let b_ptr: *mut Ixon = &mut *b_box;
-          stack.push(b_ptr);
-          unsafe {
-            ptr::replace(ptr, Ixon::Let(nd, t_box, d_box, b_box));
-          }
-        },
-        IxonCase::Proj => {
-          let addr = Address::arbitrary(g);
-          let n = u64::arbitrary(g);
-          let mut t_box = Box::new(Ixon::default());
-          let t_ptr: *mut Ixon = &mut *t_box;
-          stack.push(t_ptr);
-          unsafe {
-            ptr::replace(ptr, Ixon::Proj(addr, n, t_box));
-          }
-        },
-        IxonCase::Strl => unsafe {
-          let size = gen_range(g, 0..9);
-          ptr::replace(ptr, Ixon::Strl(arbitrary_string(g, size)));
-        },
-        IxonCase::Natl => {
-          let size = gen_range(g, 0..9);
-          unsafe {
-            ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
-          }
-        },
-        IxonCase::Array => {
-          let n = gen_range(g, 0..9);
-          let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-          ts.resize(n, Ixon::Var(0));
-          for i in 0..n {
-            let p = unsafe { ts.as_mut_ptr().add(i) };
-            stack.push(p);
-          }
-          unsafe {
-            std::ptr::replace(ptr, Ixon::Array(ts));
-          }
-        },
-        IxonCase::Quot => unsafe {
-          std::ptr::replace(ptr, Ixon::Quot(Quotient::arbitrary(g)));
-        },
-        IxonCase::Axio => unsafe {
-          std::ptr::replace(ptr, Ixon::Axio(Axiom::arbitrary(g)));
-        },
-        IxonCase::Defn => unsafe {
-          std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
-        },
-        IxonCase::CtorProj => unsafe {
-          std::ptr::replace(ptr, Ixon::CtorProj(ConstructorProj::arbitrary(g)));
-        },
-        IxonCase::RecrProj => unsafe {
-          std::ptr::replace(ptr, Ixon::RecrProj(RecursorProj::arbitrary(g)));
-        },
-        IxonCase::DefnProj => unsafe {
-          std::ptr::replace(ptr, Ixon::DefnProj(DefinitionProj::arbitrary(g)));
-        },
-        IxonCase::IndcProj => unsafe {
-          std::ptr::replace(ptr, Ixon::IndcProj(InductiveProj::arbitrary(g)));
-        },
-        IxonCase::Meta => unsafe {
-          std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
-        },
-        IxonCase::Proof => unsafe {
-          std::ptr::replace(ptr, Ixon::Proof(Proof::arbitrary(g)));
-        },
-        IxonCase::Claim => unsafe {
-          std::ptr::replace(ptr, Ixon::Claim(Claim::arbitrary(g)));
-        },
-        IxonCase::Comm => unsafe {
-          std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
-        },
-        IxonCase::Env => unsafe {
-          std::ptr::replace(ptr, Ixon::Env(Env::arbitrary(g)));
-        },
-        IxonCase::MutDef => unsafe {
-          let defs = gen_vec(g, 9, Definition::arbitrary);
-          std::ptr::replace(ptr, Ixon::MutDef(defs));
-        },
-        IxonCase::MutInd => unsafe {
-          let inds = gen_vec(g, 9, Inductive::arbitrary);
-          std::ptr::replace(ptr, Ixon::MutInd(inds));
-        },
-      }
+                    let n = gen_range(g, 0..9);
+                    let mut xs: Vec<Ixon> = Vec::with_capacity(n);
+                    xs.resize(n, Ixon::Var(0));
+                    for i in 0..n {
+                        let p = unsafe { xs.as_mut_ptr().add(i) };
+                        stack.push(p);
+                    }
+                    unsafe {
+                        std::ptr::replace(ptr, Ixon::App(f_box, a_box, xs));
+                    }
+                }
+                IxonCase::Lam => {
+                    let n = gen_range(g, 0..9);
+                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+                    ts.resize(n, Ixon::Var(0));
+                    for i in 0..n {
+                        let p = unsafe { ts.as_mut_ptr().add(i) };
+                        stack.push(p);
+                    }
+                    let mut b_box = Box::new(Ixon::default());
+                    let b_ptr: *mut Ixon = &mut *b_box;
+                    stack.push(b_ptr);
+                    unsafe {
+                        std::ptr::replace(ptr, Ixon::Lam(ts, b_box));
+                    }
+                }
+                IxonCase::All => {
+                    let n = gen_range(g, 0..9);
+                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+                    ts.resize(n, Ixon::Var(0));
+                    for i in 0..n {
+                        let p = unsafe { ts.as_mut_ptr().add(i) };
+                        stack.push(p);
+                    }
+                    let mut b_box = Box::new(Ixon::default());
+                    let b_ptr: *mut Ixon = &mut *b_box;
+                    stack.push(b_ptr);
+                    unsafe {
+                        std::ptr::replace(ptr, Ixon::All(ts, b_box));
+                    }
+                }
+                IxonCase::Let => {
+                    let nd = bool::arbitrary(g);
+                    let mut t_box = Box::new(Ixon::default());
+                    let t_ptr: *mut Ixon = &mut *t_box;
+                    stack.push(t_ptr);
+                    let mut d_box = Box::new(Ixon::default());
+                    let d_ptr: *mut Ixon = &mut *d_box;
+                    stack.push(d_ptr);
+                    let mut b_box = Box::new(Ixon::default());
+                    let b_ptr: *mut Ixon = &mut *b_box;
+                    stack.push(b_ptr);
+                    unsafe {
+                        ptr::replace(ptr, Ixon::Let(nd, t_box, d_box, b_box));
+                    }
+                }
+                IxonCase::Proj => {
+                    let addr = Address::arbitrary(g);
+                    let n = u64::arbitrary(g);
+                    let mut t_box = Box::new(Ixon::default());
+                    let t_ptr: *mut Ixon = &mut *t_box;
+                    stack.push(t_ptr);
+                    unsafe {
+                        ptr::replace(ptr, Ixon::Proj(addr, n, t_box));
+                    }
+                }
+                IxonCase::Strl => unsafe {
+                    let size = gen_range(g, 0..9);
+                    ptr::replace(ptr, Ixon::Strl(arbitrary_string(g, size)));
+                },
+                IxonCase::Natl => {
+                    let size = gen_range(g, 0..9);
+                    unsafe {
+                        ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
+                    }
+                }
+                IxonCase::Array => {
+                    let n = gen_range(g, 0..9);
+                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+                    ts.resize(n, Ixon::Var(0));
+                    for i in 0..n {
+                        let p = unsafe { ts.as_mut_ptr().add(i) };
+                        stack.push(p);
+                    }
+                    unsafe {
+                        std::ptr::replace(ptr, Ixon::Array(ts));
+                    }
+                }
+                IxonCase::Quot => unsafe {
+                    std::ptr::replace(ptr, Ixon::Quot(Quotient::arbitrary(g)));
+                },
+                IxonCase::Axio => unsafe {
+                    std::ptr::replace(ptr, Ixon::Axio(Axiom::arbitrary(g)));
+                },
+                IxonCase::Defn => unsafe {
+                    std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
+                },
+                IxonCase::CtorProj => unsafe {
+                    std::ptr::replace(ptr, Ixon::CtorProj(ConstructorProj::arbitrary(g)));
+                },
+                IxonCase::RecrProj => unsafe {
+                    std::ptr::replace(ptr, Ixon::RecrProj(RecursorProj::arbitrary(g)));
+                },
+                IxonCase::DefnProj => unsafe {
+                    std::ptr::replace(ptr, Ixon::DefnProj(DefinitionProj::arbitrary(g)));
+                },
+                IxonCase::IndcProj => unsafe {
+                    std::ptr::replace(ptr, Ixon::IndcProj(InductiveProj::arbitrary(g)));
+                },
+                IxonCase::Meta => unsafe {
+                    std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
+                },
+                IxonCase::Proof => unsafe {
+                    std::ptr::replace(ptr, Ixon::Proof(Proof::arbitrary(g)));
+                },
+                IxonCase::Claim => unsafe {
+                    std::ptr::replace(ptr, Ixon::Claim(Claim::arbitrary(g)));
+                },
+                IxonCase::Comm => unsafe {
+                    std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
+                },
+                IxonCase::Env => unsafe {
+                    std::ptr::replace(ptr, Ixon::Env(Env::arbitrary(g)));
+                },
+                IxonCase::MutDef => unsafe {
+                    let defs = gen_vec(g, 9, Definition::arbitrary);
+                    std::ptr::replace(ptr, Ixon::MutDef(defs));
+                },
+                IxonCase::MutInd => unsafe {
+                    let inds = gen_vec(g, 9, Inductive::arbitrary);
+                    std::ptr::replace(ptr, Ixon::MutInd(inds));
+                },
+            }
+        }
+        root
     }
-    root
-  }
 
-  impl Arbitrary for Ixon {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let ctx: u64 = Arbitrary::arbitrary(g);
-      arbitrary_ixon(g, ctx)
+    impl Arbitrary for Ixon {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let ctx: u64 = Arbitrary::arbitrary(g);
+            arbitrary_ixon(g, ctx)
+        }
     }
-  }
 
-  #[quickcheck]
-  fn prop_ixon_readback(x: Ixon) -> bool {
-    let mut buf = Vec::new();
-    Ixon::put(&x, &mut buf);
-    match Ixon::get(&mut buf.as_slice()) {
-      Ok(y) => x == y,
-      Err(e) => {
-        println!("err: {e}");
-        false
-      },
+    #[quickcheck]
+    fn prop_ixon_readback(x: Ixon) -> bool {
+        let mut buf = Vec::new();
+        Ixon::put(&x, &mut buf);
+        match Ixon::get(&mut buf.as_slice()) {
+            Ok(y) => x == y,
+            Err(e) => {
+                println!("err: {e}");
+                false
+            }
+        }
     }
-  }
 }
 
 //}
diff --git a/src/ixon/address.rs b/src/ixon/address.rs
index 744b7676..d2d43049 100644
--- a/src/ixon/address.rs
+++ b/src/ixon/address.rs
@@ -4,49 +4,53 @@ use std::cmp::{Ordering, PartialOrd};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Address {
-  pub hash: Hash,
+    pub hash: Hash,
 }
 
 impl Serialize for Address {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.extend_from_slice(self.hash.as_bytes())
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(self.hash.as_bytes())
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(32) {
-      Some((head, rest)) => {
-        *buf = rest;
-        Ok(Address { hash: Hash::from_slice(head).unwrap() })
-      },
-      None => Err("get Address out of input".to_string()),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(32) {
+            Some((head, rest)) => {
+                *buf = rest;
+                Ok(Address {
+                    hash: Hash::from_slice(head).unwrap(),
+                })
+            }
+            None => Err("get Address out of input".to_string()),
+        }
     }
-  }
 }
 
 impl Ord for Address {
-  fn cmp(&self, other: &Address) -> Ordering {
-    self.hash.as_bytes().cmp(other.hash.as_bytes())
-  }
+    fn cmp(&self, other: &Address) -> Ordering {
+        self.hash.as_bytes().cmp(other.hash.as_bytes())
+    }
 }
 
 impl PartialOrd for Address {
-  fn partial_cmp(&self, other: &Address) -> Option<Ordering> {
-    Some(self.cmp(other))
-  }
+    fn partial_cmp(&self, other: &Address) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
 }
 
 #[cfg(test)]
 pub mod tests {
-  use super::*;
-  use quickcheck::{Arbitrary, Gen};
+    use super::*;
+    use quickcheck::{Arbitrary, Gen};
 
-  impl Arbitrary for Address {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let mut bytes = [0u8; 32];
-      for b in &mut bytes {
-        *b = u8::arbitrary(g);
-      }
-      Address { hash: Hash::from_slice(&bytes).unwrap() }
+    impl Arbitrary for Address {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let mut bytes = [0u8; 32];
+            for b in &mut bytes {
+                *b = u8::arbitrary(g);
+            }
+            Address {
+                hash: Hash::from_slice(&bytes).unwrap(),
+            }
+        }
     }
-  }
 }
diff --git a/src/ixon/claim.rs b/src/ixon/claim.rs
index 87d54e16..0e90b1d6 100644
--- a/src/ixon/claim.rs
+++ b/src/ixon/claim.rs
@@ -3,133 +3,157 @@ use crate::ixon::serialize::Serialize;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Claim {
-  Checks { lvls: Address, typ: Address, value: Address },
-  Evals { lvls: Address, typ: Address, input: Address, output: Address },
+    Checks {
+        lvls: Address,
+        typ: Address,
+        value: Address,
+    },
+    Evals {
+        lvls: Address,
+        typ: Address,
+        input: Address,
+        output: Address,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Proof {
-  pub claim: Claim,
-  pub proof: Vec<u8>,
+    pub claim: Claim,
+    pub proof: Vec<u8>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Env {
-  env: Vec<(Address, Address)>,
+    env: Vec<(Address, Address)>,
 }
 
 impl Serialize for Claim {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Checks { lvls, typ, value } => {
-        buf.push(0);
-        lvls.put(buf);
-        typ.put(buf);
-        value.put(buf);
-      },
-      Self::Evals { lvls, typ, input, output } => {
-        buf.push(1);
-        lvls.put(buf);
-        typ.put(buf);
-        input.put(buf);
-        output.put(buf);
-      },
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Checks { lvls, typ, value } => {
+                buf.push(0);
+                lvls.put(buf);
+                typ.put(buf);
+                value.put(buf);
+            }
+            Self::Evals {
+                lvls,
+                typ,
+                input,
+                output,
+            } => {
+                buf.push(1);
+                lvls.put(buf);
+                typ.put(buf);
+                input.put(buf);
+                output.put(buf);
+            }
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => {
-            let lvls = Address::get(buf)?;
-            let typ = Address::get(buf)?;
-            let value = Address::get(buf)?;
-            Ok(Self::Checks { lvls, typ, value })
-          },
-          1 => {
-            let lvls = Address::get(buf)?;
-            let typ = Address::get(buf)?;
-            let input = Address::get(buf)?;
-            let output = Address::get(buf)?;
-            Ok(Self::Evals { lvls, typ, input, output })
-          },
-          x => Err(format!("get Claim invalid {x}")),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => {
+                        let lvls = Address::get(buf)?;
+                        let typ = Address::get(buf)?;
+                        let value = Address::get(buf)?;
+                        Ok(Self::Checks { lvls, typ, value })
+                    }
+                    1 => {
+                        let lvls = Address::get(buf)?;
+                        let typ = Address::get(buf)?;
+                        let input = Address::get(buf)?;
+                        let output = Address::get(buf)?;
+                        Ok(Self::Evals {
+                            lvls,
+                            typ,
+                            input,
+                            output,
+                        })
+                    }
+                    x => Err(format!("get Claim invalid {x}")),
+                }
+            }
+            None => Err("get Claim EOF".to_string()),
         }
-      },
-      None => Err("get Claim EOF".to_string()),
     }
-  }
 }
 
 impl Serialize for Proof {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.claim.put(buf);
-    self.proof.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.claim.put(buf);
+        self.proof.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let claim = Claim::get(buf)?;
-    let proof = Serialize::get(buf)?;
-    Ok(Proof { claim, proof })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let claim = Claim::get(buf)?;
+        let proof = Serialize::get(buf)?;
+        Ok(Proof { claim, proof })
+    }
 }
 
 impl Serialize for Env {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.env.put(buf)
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.env.put(buf)
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    Ok(Env { env: Serialize::get(buf)? })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        Ok(Env {
+            env: Serialize::get(buf)?,
+        })
+    }
 }
 
 #[cfg(test)]
 mod tests {
-  use super::*;
-  use crate::ixon::tests::gen_range;
-  use quickcheck::{Arbitrary, Gen};
+    use super::*;
+    use crate::ixon::tests::gen_range;
+    use quickcheck::{Arbitrary, Gen};
 
-  impl Arbitrary for Claim {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..1);
-      match x {
-        0 => Self::Checks {
-          lvls: Address::arbitrary(g),
-          typ: Address::arbitrary(g),
-          value: Address::arbitrary(g),
-        },
-        _ => Self::Evals {
-          lvls: Address::arbitrary(g),
-          typ: Address::arbitrary(g),
-          input: Address::arbitrary(g),
-          output: Address::arbitrary(g),
-        },
-      }
+    impl Arbitrary for Claim {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..1);
+            match x {
+                0 => Self::Checks {
+                    lvls: Address::arbitrary(g),
+                    typ: Address::arbitrary(g),
+                    value: Address::arbitrary(g),
+                },
+                _ => Self::Evals {
+                    lvls: Address::arbitrary(g),
+                    typ: Address::arbitrary(g),
+                    input: Address::arbitrary(g),
+                    output: Address::arbitrary(g),
+                },
+            }
+        }
     }
-  }
 
-  impl Arbitrary for Proof {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..32);
-      let mut bytes = vec![];
-      for _ in 0..x {
-        bytes.push(u8::arbitrary(g));
-      }
-      Proof { claim: Claim::arbitrary(g), proof: bytes }
+    impl Arbitrary for Proof {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..32);
+            let mut bytes = vec![];
+            for _ in 0..x {
+                bytes.push(u8::arbitrary(g));
+            }
+            Proof {
+                claim: Claim::arbitrary(g),
+                proof: bytes,
+            }
+        }
     }
-  }
 
-  impl Arbitrary for Env {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..32);
-      let mut env = vec![];
-      for _ in 0..x {
-        env.push((Address::arbitrary(g), Address::arbitrary(g)));
-      }
-      Env { env }
+    impl Arbitrary for Env {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..32);
+            let mut env = vec![];
+            for _ in 0..x {
+                env.push((Address::arbitrary(g), Address::arbitrary(g)));
+            }
+            Env { env }
+        }
     }
-  }
 }
diff --git a/src/ixon/constant.rs b/src/ixon/constant.rs
index 3835530d..40ad6dd8 100644
--- a/src/ixon/constant.rs
+++ b/src/ixon/constant.rs
@@ -5,600 +5,629 @@ use crate::ixon::*;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum QuotKind {
-  Type,
-  Ctor,
-  Lift,
-  Ind,
+    Type,
+    Ctor,
+    Lift,
+    Ind,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Quotient {
-  pub lvls: Nat,
-  pub typ: Address,
-  pub kind: QuotKind,
+    pub lvls: Nat,
+    pub typ: Address,
+    pub kind: QuotKind,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Axiom {
-  pub lvls: Nat,
-  pub typ: Address,
-  pub is_unsafe: bool,
+    pub lvls: Nat,
+    pub typ: Address,
+    pub is_unsafe: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DefKind {
-  Definition,
-  Opaque,
-  Theorem,
+    Definition,
+    Opaque,
+    Theorem,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DefSafety {
-  Unsafe,
-  Safe,
-  Partial,
+    Unsafe,
+    Safe,
+    Partial,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Definition {
-  pub lvls: Nat,
-  pub typ: Address,
-  pub mode: DefKind,
-  pub value: Address,
-  pub safety: DefSafety,
+    pub lvls: Nat,
+    pub typ: Address,
+    pub mode: DefKind,
+    pub value: Address,
+    pub safety: DefSafety,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Constructor {
-  pub lvls: Nat,
-  pub typ: Address,
-  pub cidx: Nat,
-  pub params: Nat,
-  pub fields: Nat,
-  pub is_unsafe: bool,
+    pub lvls: Nat,
+    pub typ: Address,
+    pub cidx: Nat,
+    pub params: Nat,
+    pub fields: Nat,
+    pub is_unsafe: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RecursorRule {
-  pub fields: Nat,
-  pub rhs: Address,
+    pub fields: Nat,
+    pub rhs: Address,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Recursor {
-  pub lvls: Nat,
-  pub typ: Address,
-  pub params: Nat,
-  pub indices: Nat,
-  pub motives: Nat,
-  pub minors: Nat,
-  pub rules: Vec<RecursorRule>,
-  pub k: bool,
-  pub is_unsafe: bool,
+    pub lvls: Nat,
+    pub typ: Address,
+    pub params: Nat,
+    pub indices: Nat,
+    pub motives: Nat,
+    pub minors: Nat,
+    pub rules: Vec<RecursorRule>,
+    pub k: bool,
+    pub is_unsafe: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Inductive {
-  pub lvls: Nat,
-  pub typ: Address,
-  pub params: Nat,
-  pub indices: Nat,
-  pub ctors: Vec<Constructor>,
-  pub recrs: Vec<Recursor>,
-  pub nested: Nat,
-  pub recr: bool,
-  pub refl: bool,
-  pub is_unsafe: bool,
+    pub lvls: Nat,
+    pub typ: Address,
+    pub params: Nat,
+    pub indices: Nat,
+    pub ctors: Vec<Constructor>,
+    pub recrs: Vec<Recursor>,
+    pub nested: Nat,
+    pub recr: bool,
+    pub refl: bool,
+    pub is_unsafe: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct InductiveProj {
-  pub block: Address,
-  pub idx: Nat,
+    pub block: Address,
+    pub idx: Nat,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ConstructorProj {
-  pub block: Address,
-  pub idx: Nat,
-  pub cidx: Nat,
+    pub block: Address,
+    pub idx: Nat,
+    pub cidx: Nat,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RecursorProj {
-  pub block: Address,
-  pub idx: Nat,
-  pub ridx: Nat,
+    pub block: Address,
+    pub idx: Nat,
+    pub ridx: Nat,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DefinitionProj {
-  pub block: Address,
-  pub idx: Nat,
+    pub block: Address,
+    pub idx: Nat,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Comm {
-  pub secret: Address,
-  pub payload: Address,
+    pub secret: Address,
+    pub payload: Address,
 }
 
 impl Serialize for QuotKind {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Type => buf.push(0),
-      Self::Ctor => buf.push(1),
-      Self::Lift => buf.push(2),
-      Self::Ind => buf.push(3),
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Type),
-          1 => Ok(Self::Ctor),
-          2 => Ok(Self::Lift),
-          3 => Ok(Self::Ind),
-          x => Err(format!("get QuotKind invalid {x}")),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Type => buf.push(0),
+            Self::Ctor => buf.push(1),
+            Self::Lift => buf.push(2),
+            Self::Ind => buf.push(3),
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Type),
+                    1 => Ok(Self::Ctor),
+                    2 => Ok(Self::Lift),
+                    3 => Ok(Self::Ind),
+                    x => Err(format!("get QuotKind invalid {x}")),
+                }
+            }
+            None => Err("get QuotKind EOF".to_string()),
         }
-      },
-      None => Err("get QuotKind EOF".to_string()),
     }
-  }
 }
 
 impl Serialize for Quotient {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.kind.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    let kind = QuotKind::get(buf)?;
-    Ok(Quotient { lvls, typ, kind })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.kind.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        let kind = QuotKind::get(buf)?;
+        Ok(Quotient { lvls, typ, kind })
+    }
 }
 
 impl Serialize for Axiom {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.is_unsafe.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    let is_unsafe = bool::get(buf)?;
-    Ok(Axiom { lvls, typ, is_unsafe })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.is_unsafe.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        let is_unsafe = bool::get(buf)?;
+        Ok(Axiom {
+            lvls,
+            typ,
+            is_unsafe,
+        })
+    }
 }
 
 impl Serialize for DefKind {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Definition => buf.push(0),
-      Self::Opaque => buf.push(1),
-      Self::Theorem => buf.push(2),
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Definition),
-          1 => Ok(Self::Opaque),
-          2 => Ok(Self::Theorem),
-          x => Err(format!("get DefKind invalid {x}")),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Definition => buf.push(0),
+            Self::Opaque => buf.push(1),
+            Self::Theorem => buf.push(2),
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Definition),
+                    1 => Ok(Self::Opaque),
+                    2 => Ok(Self::Theorem),
+                    x => Err(format!("get DefKind invalid {x}")),
+                }
+            }
+            None => Err("get DefKind EOF".to_string()),
         }
-      },
-      None => Err("get DefKind EOF".to_string()),
     }
-  }
 }
 
 impl Serialize for DefSafety {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Unsafe => buf.push(0),
-      Self::Safe => buf.push(1),
-      Self::Partial => buf.push(2),
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Unsafe),
-          1 => Ok(Self::Safe),
-          2 => Ok(Self::Partial),
-          x => Err(format!("get DefSafety invalid {x}")),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Unsafe => buf.push(0),
+            Self::Safe => buf.push(1),
+            Self::Partial => buf.push(2),
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Unsafe),
+                    1 => Ok(Self::Safe),
+                    2 => Ok(Self::Partial),
+                    x => Err(format!("get DefSafety invalid {x}")),
+                }
+            }
+            None => Err("get DefSafety EOF".to_string()),
         }
-      },
-      None => Err("get DefSafety EOF".to_string()),
     }
-  }
 }
 
 impl Serialize for Definition {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.mode.put(buf);
-    self.value.put(buf);
-    self.safety.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    let mode = DefKind::get(buf)?;
-    let value = Address::get(buf)?;
-    let safety = DefSafety::get(buf)?;
-    Ok(Definition { lvls, typ, mode, value, safety })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.mode.put(buf);
+        self.value.put(buf);
+        self.safety.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        let mode = DefKind::get(buf)?;
+        let value = Address::get(buf)?;
+        let safety = DefSafety::get(buf)?;
+        Ok(Definition {
+            lvls,
+            typ,
+            mode,
+            value,
+            safety,
+        })
+    }
 }
 
 impl Serialize for Constructor {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.cidx.put(buf);
-    self.params.put(buf);
-    self.fields.put(buf);
-    self.is_unsafe.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    let cidx = Nat::get(buf)?;
-    let params = Nat::get(buf)?;
-    let fields = Nat::get(buf)?;
-    let is_unsafe = bool::get(buf)?;
-    Ok(Constructor { lvls, typ, cidx, params, fields, is_unsafe })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.cidx.put(buf);
+        self.params.put(buf);
+        self.fields.put(buf);
+        self.is_unsafe.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        let cidx = Nat::get(buf)?;
+        let params = Nat::get(buf)?;
+        let fields = Nat::get(buf)?;
+        let is_unsafe = bool::get(buf)?;
+        Ok(Constructor {
+            lvls,
+            typ,
+            cidx,
+            params,
+            fields,
+            is_unsafe,
+        })
+    }
 }
 
 impl Serialize for RecursorRule {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.fields.put(buf);
-    self.rhs.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let fields = Nat::get(buf)?;
-    let rhs = Address::get(buf)?;
-    Ok(RecursorRule { fields, rhs })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.fields.put(buf);
+        self.rhs.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let fields = Nat::get(buf)?;
+        let rhs = Address::get(buf)?;
+        Ok(RecursorRule { fields, rhs })
+    }
 }
 
 impl Serialize for Recursor {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.params.put(buf);
-    self.indices.put(buf);
-    self.motives.put(buf);
-    self.minors.put(buf);
-    self.rules.put(buf);
-    Ixon::pack_bools(vec![self.k, self.is_unsafe]).put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Serialize::get(buf)?;
-    let params = Nat::get(buf)?;
-    let indices = Nat::get(buf)?;
-    let motives = Nat::get(buf)?;
-    let minors = Nat::get(buf)?;
-    let rules = Serialize::get(buf)?;
-    let bools = Ixon::unpack_bools(2, u8::get(buf)?);
-    Ok(Recursor {
-      lvls,
-      typ,
-      params,
-      indices,
-      motives,
-      minors,
-      rules,
-      k: bools[0],
-      is_unsafe: bools[1],
-    })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.params.put(buf);
+        self.indices.put(buf);
+        self.motives.put(buf);
+        self.minors.put(buf);
+        self.rules.put(buf);
+        Ixon::pack_bools(vec![self.k, self.is_unsafe]).put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Nat::get(buf)?;
+        let typ = Serialize::get(buf)?;
+        let params = Nat::get(buf)?;
+        let indices = Nat::get(buf)?;
+        let motives = Nat::get(buf)?;
+        let minors = Nat::get(buf)?;
+        let rules = Serialize::get(buf)?;
+        let bools = Ixon::unpack_bools(2, u8::get(buf)?);
+        Ok(Recursor {
+            lvls,
+            typ,
+            params,
+            indices,
+            motives,
+            minors,
+            rules,
+            k: bools[0],
+            is_unsafe: bools[1],
+        })
+    }
 }
 
 impl Serialize for Inductive {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.params.put(buf);
-    self.indices.put(buf);
-    Serialize::put(&self.ctors, buf);
-    Serialize::put(&self.recrs, buf);
-    self.nested.put(buf);
-    Ixon::pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    let params = Nat::get(buf)?;
-    let indices = Nat::get(buf)?;
-    let ctors = Serialize::get(buf)?;
-    let recrs = Serialize::get(buf)?;
-    let nested = Nat::get(buf)?;
-    let bools = Ixon::unpack_bools(3, u8::get(buf)?);
-    Ok(Inductive {
-      lvls,
-      typ,
-      params,
-      indices,
-      ctors,
-      recrs,
-      nested,
-      recr: bools[0],
-      refl: bools[1],
-      is_unsafe: bools[2],
-    })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.params.put(buf);
+        self.indices.put(buf);
+        Serialize::put(&self.ctors, buf);
+        Serialize::put(&self.recrs, buf);
+        self.nested.put(buf);
+        Ixon::pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        let params = Nat::get(buf)?;
+        let indices = Nat::get(buf)?;
+        let ctors = Serialize::get(buf)?;
+        let recrs = Serialize::get(buf)?;
+        let nested = Nat::get(buf)?;
+        let bools = Ixon::unpack_bools(3, u8::get(buf)?);
+        Ok(Inductive {
+            lvls,
+            typ,
+            params,
+            indices,
+            ctors,
+            recrs,
+            nested,
+            recr: bools[0],
+            refl: bools[1],
+            is_unsafe: bools[2],
+        })
+    }
 }
 
 impl Serialize for InductiveProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.block.put(buf);
-    self.idx.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let block = Address::get(buf)?;
-    let idx = Nat::get(buf)?;
-    Ok(InductiveProj { block, idx })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.block.put(buf);
+        self.idx.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let block = Address::get(buf)?;
+        let idx = Nat::get(buf)?;
+        Ok(InductiveProj { block, idx })
+    }
 }
 
 impl Serialize for ConstructorProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.block.put(buf);
-    self.idx.put(buf);
-    self.cidx.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let block = Address::get(buf)?;
-    let idx = Nat::get(buf)?;
-    let cidx = Nat::get(buf)?;
-    Ok(ConstructorProj { block, idx, cidx })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.block.put(buf);
+        self.idx.put(buf);
+        self.cidx.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let block = Address::get(buf)?;
+        let idx = Nat::get(buf)?;
+        let cidx = Nat::get(buf)?;
+        Ok(ConstructorProj { block, idx, cidx })
+    }
 }
 
 impl Serialize for RecursorProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.block.put(buf);
-    self.idx.put(buf);
-    self.ridx.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let block = Address::get(buf)?;
-    let idx = Nat::get(buf)?;
-    let ridx = Nat::get(buf)?;
-    Ok(RecursorProj { block, idx, ridx })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.block.put(buf);
+        self.idx.put(buf);
+        self.ridx.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let block = Address::get(buf)?;
+        let idx = Nat::get(buf)?;
+        let ridx = Nat::get(buf)?;
+        Ok(RecursorProj { block, idx, ridx })
+    }
 }
 
 impl Serialize for DefinitionProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.block.put(buf);
-    self.idx.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let block = Address::get(buf)?;
-    let idx = Nat::get(buf)?;
-    Ok(DefinitionProj { block, idx })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.block.put(buf);
+        self.idx.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let block = Address::get(buf)?;
+        let idx = Nat::get(buf)?;
+        Ok(DefinitionProj { block, idx })
+    }
 }
 
 impl Serialize for Comm {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.secret.put(buf);
-    self.payload.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let secret = Address::get(buf)?;
-    let payload = Address::get(buf)?;
-    Ok(Comm { secret, payload })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.secret.put(buf);
+        self.payload.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let secret = Address::get(buf)?;
+        let payload = Address::get(buf)?;
+        Ok(Comm { secret, payload })
+    }
 }
 
 #[cfg(test)]
 mod tests {
-  use super::*;
-  use crate::ixon::tests::gen_range;
-  use quickcheck::{Arbitrary, Gen};
-
-  use std::ptr;
-
-  impl Arbitrary for QuotKind {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..3);
-      match x {
-        0 => Self::Type,
-        1 => Self::Ctor,
-        2 => Self::Lift,
-        _ => Self::Ind,
-      }
-    }
-  }
-
-  impl Arbitrary for Quotient {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        kind: QuotKind::arbitrary(g),
-      }
-    }
-  }
-
-  impl Arbitrary for Axiom {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        is_unsafe: bool::arbitrary(g),
-      }
-    }
-  }
-
-  impl Arbitrary for DefKind {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..2);
-      match x {
-        0 => Self::Definition,
-        1 => Self::Opaque,
-        _ => Self::Theorem,
-      }
-    }
-  }
-
-  impl Arbitrary for DefSafety {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..2);
-      match x {
-        0 => Self::Unsafe,
-        1 => Self::Safe,
-        _ => Self::Partial,
-      }
-    }
-  }
-
-  impl Arbitrary for Definition {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        mode: DefKind::arbitrary(g),
-        value: Address::arbitrary(g),
-        safety: DefSafety::arbitrary(g),
-      }
-    }
-  }
-
-  impl Arbitrary for Constructor {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        cidx: Nat::arbitrary(g),
-        params: Nat::arbitrary(g),
-        fields: Nat::arbitrary(g),
-        is_unsafe: bool::arbitrary(g),
-      }
-    }
-  }
-
-  impl Arbitrary for RecursorRule {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self { fields: Nat::arbitrary(g), rhs: Address::arbitrary(g) }
-    }
-  }
-
-  impl Arbitrary for Recursor {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..9);
-      let mut rules = vec![];
-      for _ in 0..x {
-        rules.push(RecursorRule::arbitrary(g));
-      }
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        params: Nat::arbitrary(g),
-        indices: Nat::arbitrary(g),
-        motives: Nat::arbitrary(g),
-        minors: Nat::arbitrary(g),
-        rules,
-        k: bool::arbitrary(g),
-        is_unsafe: bool::arbitrary(g),
-      }
-    }
-  }
-
-  impl Arbitrary for Inductive {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..9);
-      let y = gen_range(g, 0..9);
-      let mut ctors = vec![];
-      let mut recrs = vec![];
-      for _ in 0..x {
-        ctors.push(Constructor::arbitrary(g));
-      }
-      for _ in 0..y {
-        recrs.push(Recursor::arbitrary(g));
-      }
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        params: Nat::arbitrary(g),
-        indices: Nat::arbitrary(g),
-        ctors,
-        recrs,
-        nested: Nat::arbitrary(g),
-        recr: bool::arbitrary(g),
-        refl: bool::arbitrary(g),
-        is_unsafe: bool::arbitrary(g),
-      }
-    }
-  }
-
-  impl Arbitrary for InductiveProj {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self { block: Address::arbitrary(g), idx: Nat::arbitrary(g) }
-    }
-  }
-
-  impl Arbitrary for ConstructorProj {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        block: Address::arbitrary(g),
-        idx: Nat::arbitrary(g),
-        cidx: Nat::arbitrary(g),
-      }
-    }
-  }
-
-  impl Arbitrary for RecursorProj {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        block: Address::arbitrary(g),
-        idx: Nat::arbitrary(g),
-        ridx: Nat::arbitrary(g),
-      }
-    }
-  }
-
-  impl Arbitrary for DefinitionProj {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self { block: Address::arbitrary(g), idx: Nat::arbitrary(g) }
-    }
-  }
-
-  impl Arbitrary for Comm {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self { secret: Address::arbitrary(g), payload: Address::arbitrary(g) }
-    }
-  }
+    use super::*;
+    use crate::ixon::tests::gen_range;
+    use quickcheck::{Arbitrary, Gen};
+
+    use std::ptr;
+
+    impl Arbitrary for QuotKind {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..3);
+            match x {
+                0 => Self::Type,
+                1 => Self::Ctor,
+                2 => Self::Lift,
+                _ => Self::Ind,
+            }
+        }
+    }
+
+    impl Arbitrary for Quotient {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                kind: QuotKind::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for Axiom {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                is_unsafe: bool::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for DefKind {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..2);
+            match x {
+                0 => Self::Definition,
+                1 => Self::Opaque,
+                _ => Self::Theorem,
+            }
+        }
+    }
+
+    impl Arbitrary for DefSafety {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..2);
+            match x {
+                0 => Self::Unsafe,
+                1 => Self::Safe,
+                _ => Self::Partial,
+            }
+        }
+    }
+
+    impl Arbitrary for Definition {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                mode: DefKind::arbitrary(g),
+                value: Address::arbitrary(g),
+                safety: DefSafety::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for Constructor {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                cidx: Nat::arbitrary(g),
+                params: Nat::arbitrary(g),
+                fields: Nat::arbitrary(g),
+                is_unsafe: bool::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for RecursorRule {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                fields: Nat::arbitrary(g),
+                rhs: Address::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for Recursor {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..9);
+            let mut rules = vec![];
+            for _ in 0..x {
+                rules.push(RecursorRule::arbitrary(g));
+            }
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                params: Nat::arbitrary(g),
+                indices: Nat::arbitrary(g),
+                motives: Nat::arbitrary(g),
+                minors: Nat::arbitrary(g),
+                rules,
+                k: bool::arbitrary(g),
+                is_unsafe: bool::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for Inductive {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..9);
+            let y = gen_range(g, 0..9);
+            let mut ctors = vec![];
+            let mut recrs = vec![];
+            for _ in 0..x {
+                ctors.push(Constructor::arbitrary(g));
+            }
+            for _ in 0..y {
+                recrs.push(Recursor::arbitrary(g));
+            }
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                params: Nat::arbitrary(g),
+                indices: Nat::arbitrary(g),
+                ctors,
+                recrs,
+                nested: Nat::arbitrary(g),
+                recr: bool::arbitrary(g),
+                refl: bool::arbitrary(g),
+                is_unsafe: bool::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for InductiveProj {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                block: Address::arbitrary(g),
+                idx: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for ConstructorProj {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                block: Address::arbitrary(g),
+                idx: Nat::arbitrary(g),
+                cidx: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for RecursorProj {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                block: Address::arbitrary(g),
+                idx: Nat::arbitrary(g),
+                ridx: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for DefinitionProj {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                block: Address::arbitrary(g),
+                idx: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for Comm {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                secret: Address::arbitrary(g),
+                payload: Address::arbitrary(g),
+            }
+        }
+    }
 }
diff --git a/src/ixon/meta.rs b/src/ixon/meta.rs
index c3f6ef72..3ecbfbfb 100644
--- a/src/ixon/meta.rs
+++ b/src/ixon/meta.rs
@@ -5,225 +5,227 @@ use crate::ixon::serialize::Serialize;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BinderInfo {
-  Default,
-  Implicit,
-  StrictImplicit,
-  InstImplicit,
-  AuxDecl,
+    Default,
+    Implicit,
+    StrictImplicit,
+    InstImplicit,
+    AuxDecl,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ReducibilityHints {
-  Opaque,
-  Abbrev,
-  Regular,
+    Opaque,
+    Abbrev,
+    Regular,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Metadatum {
-  Name(Name),
-  Info(BinderInfo),
-  Link(Address),
-  Hints(ReducibilityHints),
-  All(Vec<Name>),
-  MutCtx(Vec<Vec<Name>>),
+    Name(Name),
+    Info(BinderInfo),
+    Link(Address),
+    Hints(ReducibilityHints),
+    All(Vec<Name>),
+    MutCtx(Vec<Vec<Name>>),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Metadata {
-  pub map: Vec<(Nat, Vec<Metadatum>)>,
+    pub map: Vec<(Nat, Vec<Metadatum>)>,
 }
 
 impl Serialize for BinderInfo {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Default => buf.push(0),
-      Self::Implicit => buf.push(1),
-      Self::StrictImplicit => buf.push(2),
-      Self::InstImplicit => buf.push(3),
-      Self::AuxDecl => buf.push(3),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Default => buf.push(0),
+            Self::Implicit => buf.push(1),
+            Self::StrictImplicit => buf.push(2),
+            Self::InstImplicit => buf.push(3),
+            Self::AuxDecl => buf.push(3),
+        }
     }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Default),
-          1 => Ok(Self::Implicit),
-          2 => Ok(Self::StrictImplicit),
-          3 => Ok(Self::InstImplicit),
-          4 => Ok(Self::AuxDecl),
-          x => Err(format!("get BinderInfo invalid {x}")),
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Default),
+                    1 => Ok(Self::Implicit),
+                    2 => Ok(Self::StrictImplicit),
+                    3 => Ok(Self::InstImplicit),
+                    4 => Ok(Self::AuxDecl),
+                    x => Err(format!("get BinderInfo invalid {x}")),
+                }
+            }
+            None => Err("get BinderInfo EOF".to_string()),
         }
-      },
-      None => Err("get BinderInfo EOF".to_string()),
     }
-  }
 }
 
 impl Serialize for ReducibilityHints {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Opaque => buf.push(0),
-      Self::Abbrev => buf.push(1),
-      Self::Regular => buf.push(2),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Opaque => buf.push(0),
+            Self::Abbrev => buf.push(1),
+            Self::Regular => buf.push(2),
+        }
     }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Opaque),
-          1 => Ok(Self::Abbrev),
-          2 => Ok(Self::Regular),
-          x => Err(format!("get ReducibilityHints invalid {x}")),
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Opaque),
+                    1 => Ok(Self::Abbrev),
+                    2 => Ok(Self::Regular),
+                    x => Err(format!("get ReducibilityHints invalid {x}")),
+                }
+            }
+            None => Err("get ReducibilityHints EOF".to_string()),
         }
-      },
-      None => Err("get ReducibilityHints EOF".to_string()),
     }
-  }
 }
 
 impl Serialize for Metadatum {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Name(x) => {
-        buf.push(0);
-        x.put(buf);
-      },
-      Self::Info(x) => {
-        buf.push(1);
-        x.put(buf);
-      },
-      Self::Link(x) => {
-        buf.push(2);
-        x.put(buf);
-      },
-      Self::Hints(x) => {
-        buf.push(3);
-        x.put(buf);
-      },
-      Self::All(x) => {
-        buf.push(4);
-        x.put(buf);
-      },
-      Self::MutCtx(x) => {
-        buf.push(5);
-        x.put(buf);
-      },
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Name(x) => {
+                buf.push(0);
+                x.put(buf);
+            }
+            Self::Info(x) => {
+                buf.push(1);
+                x.put(buf);
+            }
+            Self::Link(x) => {
+                buf.push(2);
+                x.put(buf);
+            }
+            Self::Hints(x) => {
+                buf.push(3);
+                x.put(buf);
+            }
+            Self::All(x) => {
+                buf.push(4);
+                x.put(buf);
+            }
+            Self::MutCtx(x) => {
+                buf.push(5);
+                x.put(buf);
+            }
+        }
     }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => {
-            let x = Name::get(buf)?;
-            Ok(Self::Name(x))
-          },
-          1 => {
-            let x = BinderInfo::get(buf)?;
-            Ok(Self::Info(x))
-          },
-          2 => {
-            let x = Address::get(buf)?;
-            Ok(Self::Link(x))
-          },
-          3 => {
-            let x = ReducibilityHints::get(buf)?;
-            Ok(Self::Hints(x))
-          },
-          4 => {
-            let x = Serialize::get(buf)?;
-            Ok(Self::All(x))
-          },
-          5 => {
-            let x = Serialize::get(buf)?;
-            Ok(Self::MutCtx(x))
-          },
-          x => Err(format!("get Metadata invalid {x}")),
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => {
+                        let x = Name::get(buf)?;
+                        Ok(Self::Name(x))
+                    }
+                    1 => {
+                        let x = BinderInfo::get(buf)?;
+                        Ok(Self::Info(x))
+                    }
+                    2 => {
+                        let x = Address::get(buf)?;
+                        Ok(Self::Link(x))
+                    }
+                    3 => {
+                        let x = ReducibilityHints::get(buf)?;
+                        Ok(Self::Hints(x))
+                    }
+                    4 => {
+                        let x = Serialize::get(buf)?;
+                        Ok(Self::All(x))
+                    }
+                    5 => {
+                        let x = Serialize::get(buf)?;
+                        Ok(Self::MutCtx(x))
+                    }
+                    x => Err(format!("get Metadata invalid {x}")),
+                }
+            }
+            None => Err("get Metadata EOF".to_string()),
         }
-      },
-      None => Err("get Metadata EOF".to_string()),
     }
-  }
 }
 
 impl Serialize for Metadata {
-  fn put(&self, buf: &mut Vec<u8>) {
-    Serialize::put(&self.map, buf)
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        Serialize::put(&self.map, buf)
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    Ok(Metadata { map: Serialize::get(buf)? })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        Ok(Metadata {
+            map: Serialize::get(buf)?,
+        })
+    }
 }
 
 #[cfg(test)]
 mod tests {
-  use super::*;
-  use crate::ixon::tests::{gen_range, gen_vec};
-  use quickcheck::{Arbitrary, Gen};
-
-  impl Arbitrary for BinderInfo {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..4);
-      match x {
-        0 => Self::Default,
-        1 => Self::Implicit,
-        2 => Self::StrictImplicit,
-        3 => Self::InstImplicit,
-        _ => Self::AuxDecl,
-      }
+    use super::*;
+    use crate::ixon::tests::{gen_range, gen_vec};
+    use quickcheck::{Arbitrary, Gen};
+
+    impl Arbitrary for BinderInfo {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..4);
+            match x {
+                0 => Self::Default,
+                1 => Self::Implicit,
+                2 => Self::StrictImplicit,
+                3 => Self::InstImplicit,
+                _ => Self::AuxDecl,
+            }
+        }
     }
-  }
-
-  impl Arbitrary for ReducibilityHints {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..2);
-      match x {
-        0 => Self::Opaque,
-        1 => Self::Abbrev,
-        _ => Self::Regular,
-      }
+
+    impl Arbitrary for ReducibilityHints {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..2);
+            match x {
+                0 => Self::Opaque,
+                1 => Self::Abbrev,
+                _ => Self::Regular,
+            }
+        }
     }
-  }
-
-  impl Arbitrary for Metadatum {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..5);
-      match x {
-        0 => Self::Name(Name::arbitrary(g)),
-        1 => Self::Info(BinderInfo::arbitrary(g)),
-        2 => Self::Link(Address::arbitrary(g)),
-        3 => Self::Hints(ReducibilityHints::arbitrary(g)),
-        4 => Self::All(gen_vec(g, 9, Arbitrary::arbitrary)),
-        _ => {
-          let x = gen_range(g, 0..9);
-          let mut res = vec![];
-          for _ in 0..x {
-            res.push(gen_vec(g, 9, Arbitrary::arbitrary))
-          }
-          Self::MutCtx(res)
-        },
-      }
+
+    impl Arbitrary for Metadatum {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..5);
+            match x {
+                0 => Self::Name(Name::arbitrary(g)),
+                1 => Self::Info(BinderInfo::arbitrary(g)),
+                2 => Self::Link(Address::arbitrary(g)),
+                3 => Self::Hints(ReducibilityHints::arbitrary(g)),
+                4 => Self::All(gen_vec(g, 9, Arbitrary::arbitrary)),
+                _ => {
+                    let x = gen_range(g, 0..9);
+                    let mut res = vec![];
+                    for _ in 0..x {
+                        res.push(gen_vec(g, 9, Arbitrary::arbitrary))
+                    }
+                    Self::MutCtx(res)
+                }
+            }
+        }
     }
-  }
-
-  impl Arbitrary for Metadata {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..9);
-      let mut map = Vec::new();
-      for _ in 0..x {
-        map.push((Nat::arbitrary(g), gen_vec(g, 9, Metadatum::arbitrary)));
-      }
-      Metadata { map }
+
+    impl Arbitrary for Metadata {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..9);
+            let mut map = Vec::new();
+            for _ in 0..x {
+                map.push((Nat::arbitrary(g), gen_vec(g, 9, Metadatum::arbitrary)));
+            }
+            Metadata { map }
+        }
     }
-  }
 }
diff --git a/src/ixon/name.rs b/src/ixon/name.rs
index 82768729..203dc2c4 100644
--- a/src/ixon/name.rs
+++ b/src/ixon/name.rs
@@ -4,65 +4,67 @@ use crate::ixon::*;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum NamePart {
-  Str(String),
-  Num(Nat),
+    Str(String),
+    Num(Nat),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Name {
-  pub parts: Vec<NamePart>,
+    pub parts: Vec<NamePart>,
 }
 
 impl Serialize for NamePart {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      // TODO: do we need to clone here?
-      Self::Str(x) => Ixon::Strl(x.clone()).put(buf),
-      Self::Num(x) => Ixon::Natl(x.clone()).put(buf),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            // TODO: do we need to clone here?
+            Self::Str(x) => Ixon::Strl(x.clone()).put(buf),
+            Self::Num(x) => Ixon::Natl(x.clone()).put(buf),
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match Ixon::get(buf)? {
-      Ixon::Strl(x) => Ok(Self::Str(x)),
-      Ixon::Natl(x) => Ok(Self::Num(x)),
-      x => Err(format!("get NamePart invalid {x:?}")),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match Ixon::get(buf)? {
+            Ixon::Strl(x) => Ok(Self::Str(x)),
+            Ixon::Natl(x) => Ok(Self::Num(x)),
+            x => Err(format!("get NamePart invalid {x:?}")),
+        }
     }
-  }
 }
 
 impl Serialize for Name {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.parts.put(buf)
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.parts.put(buf)
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    Ok(Name { parts: Serialize::get(buf)? })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        Ok(Name {
+            parts: Serialize::get(buf)?,
+        })
+    }
 }
 
 #[cfg(test)]
 mod tests {
-  use super::*;
-  use crate::ixon::nat::tests::arbitrary_nat;
-  use crate::ixon::tests::{arbitrary_string, gen_range, gen_vec};
-  use quickcheck::{Arbitrary, Gen};
+    use super::*;
+    use crate::ixon::nat::tests::arbitrary_nat;
+    use crate::ixon::tests::{arbitrary_string, gen_range, gen_vec};
+    use quickcheck::{Arbitrary, Gen};
 
-  impl Arbitrary for NamePart {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..1);
-      let len = gen_range(g, 0..9);
-      match x {
-        0 => Self::Str(arbitrary_string(g, len)),
-        _ => Self::Num(arbitrary_nat(g, len)),
-      }
+    impl Arbitrary for NamePart {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..1);
+            let len = gen_range(g, 0..9);
+            match x {
+                0 => Self::Str(arbitrary_string(g, len)),
+                _ => Self::Num(arbitrary_nat(g, len)),
+            }
+        }
     }
-  }
 
-  impl Arbitrary for Name {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let parts = gen_vec(g, 9, NamePart::arbitrary);
-      Name { parts }
+    impl Arbitrary for Name {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let parts = gen_vec(g, 9, NamePart::arbitrary);
+            Name { parts }
+        }
     }
-  }
 }
diff --git a/src/ixon/nat.rs b/src/ixon/nat.rs
index 86607447..2c413339 100644
--- a/src/ixon/nat.rs
+++ b/src/ixon/nat.rs
@@ -8,46 +8,46 @@ pub struct Nat(pub BigUint);
 impl Nat {}
 
 impl Serialize for Nat {
-  fn put(&self, buf: &mut Vec<u8>) {
-    Ixon::Natl(self.clone()).put(buf)
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match Ixon::get(buf) {
-      Ok(Ixon::Natl(x)) => Ok(x),
-      Ok(x) => Err(format!("get Nat invalid {x:?}")),
-      Err(e) => Err(e),
+    fn put(&self, buf: &mut Vec<u8>) {
+        Ixon::Natl(self.clone()).put(buf)
+    }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match Ixon::get(buf) {
+            Ok(Ixon::Natl(x)) => Ok(x),
+            Ok(x) => Err(format!("get Nat invalid {x:?}")),
+            Err(e) => Err(e),
+        }
     }
-  }
 }
 
 #[cfg(test)]
 pub mod tests {
-  use super::*;
-  use crate::ixon::tests::gen_range;
-  use quickcheck::{Arbitrary, Gen};
+    use super::*;
+    use crate::ixon::tests::gen_range;
+    use quickcheck::{Arbitrary, Gen};
 
-  pub fn arbitrary_nat(g: &mut Gen, size: usize) -> Nat {
-    let mut bytes = vec![];
+    pub fn arbitrary_nat(g: &mut Gen, size: usize) -> Nat {
+        let mut bytes = vec![];
 
-    let b = u8::arbitrary(g);
+        let b = u8::arbitrary(g);
 
-    if b == 0 {
-      bytes.push(b + 1);
-    } else {
-      bytes.push(b);
-    }
+        if b == 0 {
+            bytes.push(b + 1);
+        } else {
+            bytes.push(b);
+        }
 
-    for _ in 0..size {
-      bytes.push(u8::arbitrary(g));
-    }
+        for _ in 0..size {
+            bytes.push(u8::arbitrary(g));
+        }
 
-    Nat(BigUint::from_bytes_be(&bytes))
-  }
+        Nat(BigUint::from_bytes_be(&bytes))
+    }
 
-  impl Arbitrary for Nat {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let size = gen_range(g, 0..4);
-      arbitrary_nat(g, size)
+    impl Arbitrary for Nat {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let size = gen_range(g, 0..4);
+            arbitrary_nat(g, size)
+        }
     }
-  }
 }
diff --git a/src/ixon/serialize.rs b/src/ixon/serialize.rs
index fa4052dc..12606528 100644
--- a/src/ixon/serialize.rs
+++ b/src/ixon/serialize.rs
@@ -1,118 +1,117 @@
 use crate::ixon::*;
 
 pub trait Serialize: Sized {
-  fn put(&self, buf: &mut Vec<u8>);
-  fn get(buf: &mut &[u8]) -> Result<Self, String>;
+    fn put(&self, buf: &mut Vec<u8>);
+    fn get(buf: &mut &[u8]) -> Result<Self, String>;
 }
 
 impl Serialize for u8 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.push(*self)
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.push(*self)
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_first() {
-      Some((&x, rest)) => {
-        *buf = rest;
-        Ok(x)
-      },
-      None => Err("get u8 EOF".to_string()),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_first() {
+            Some((&x, rest)) => {
+                *buf = rest;
+                Ok(x)
+            }
+            None => Err("get u8 EOF".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for u16 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.extend_from_slice(&self.to_le_bytes());
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(&self.to_le_bytes());
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(2) {
-      Some((head, rest)) => {
-        *buf = rest;
-        Ok(u16::from_le_bytes([head[0], head[1]]))
-      },
-      None => Err("get u16 EOF".to_string()),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(2) {
+            Some((head, rest)) => {
+                *buf = rest;
+                Ok(u16::from_le_bytes([head[0], head[1]]))
+            }
+            None => Err("get u16 EOF".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for u32 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.extend_from_slice(&self.to_le_bytes());
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(&self.to_le_bytes());
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(4) {
-      Some((head, rest)) => {
-        *buf = rest;
-        Ok(u32::from_le_bytes([head[0], head[1], head[2], head[3]]))
-      },
-      None => Err("get u32 EOF".to_string()),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(4) {
+            Some((head, rest)) => {
+                *buf = rest;
+                Ok(u32::from_le_bytes([head[0], head[1], head[2], head[3]]))
+            }
+            None => Err("get u32 EOF".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for u64 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.extend_from_slice(&self.to_le_bytes());
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(&self.to_le_bytes());
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(8) {
-      Some((head, rest)) => {
-        *buf = rest;
-        Ok(u64::from_le_bytes([
-          head[0], head[1], head[2], head[3], head[4], head[5], head[6],
-          head[7],
-        ]))
-      },
-      None => Err("get u64 EOF".to_string()),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(8) {
+            Some((head, rest)) => {
+                *buf = rest;
+                Ok(u64::from_le_bytes([
+                    head[0], head[1], head[2], head[3], head[4], head[5], head[6], head[7],
+                ]))
+            }
+            None => Err("get u64 EOF".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for bool {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      false => buf.push(0),
-      true => buf.push(1),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            false => buf.push(0),
+            true => buf.push(1),
+        }
     }
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(false),
-          1 => Ok(true),
-          x => Err(format!("get bool invalid {x}")),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(false),
+                    1 => Ok(true),
+                    x => Err(format!("get bool invalid {x}")),
+                }
+            }
+            None => Err("get bool EOF".to_string()),
         }
-      },
-      None => Err("get bool EOF".to_string()),
     }
-  }
 }
 
 impl<S: Serialize> Serialize for Vec<S> {
-  fn put(&self, buf: &mut Vec<u8>) {
-    Ixon::put_array(self, buf)
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        Ixon::put_array(self, buf)
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    Ixon::get_array(buf)
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        Ixon::get_array(buf)
+    }
 }
 
 impl<X: Serialize, Y: Serialize> Serialize for (X, Y) {
-  fn put(&self, buf: &mut Vec<u8>) {
-    Serialize::put(&self.0, buf);
-    Serialize::put(&self.1, buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        Serialize::put(&self.0, buf);
+        Serialize::put(&self.1, buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let x = Serialize::get(buf)?;
-    let y = Serialize::get(buf)?;
-    Ok((x, y))
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let x = Serialize::get(buf)?;
+        let y = Serialize::get(buf)?;
+        Ok((x, y))
+    }
 }
diff --git a/src/ixon/univ.rs b/src/ixon/univ.rs
index 1434f5d5..4d7050e4 100644
--- a/src/ixon/univ.rs
+++ b/src/ixon/univ.rs
@@ -1,203 +1,199 @@
-use crate::ixon::serialize::Serialize;
 use crate::ixon::Ixon;
+use crate::ixon::serialize::Serialize;
 
 // 0xTTLX_XXXX
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[repr(C)]
 pub enum Univ {
-  // 0x0X, 1
-  Const(u64),
-  // 0x1, ^1
-  Var(u64),
-  // 0x2, (+ x y)
-  Add(u64, Box<Univ>),
-  // 0x3, size=0 (max x y)
-  Max(Box<Univ>, Box<Univ>),
-  // 0x3, size=1 (imax x y)
-  IMax(Box<Univ>, Box<Univ>),
+    // 0x0X, 1
+    Const(u64),
+    // 0x1, ^1
+    Var(u64),
+    // 0x2, (+ x y)
+    Add(u64, Box<Univ>),
+    // 0x3, size=0 (max x y)
+    Max(Box<Univ>, Box<Univ>),
+    // 0x3, size=1 (imax x y)
+    IMax(Box<Univ>, Box<Univ>),
 }
 
 impl Default for Univ {
-  fn default() -> Self {
-    Self::Const(0)
-  }
+    fn default() -> Self {
+        Self::Const(0)
+    }
 }
 
 impl Univ {
-  fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
-    if val < 32 {
-      buf.push((tag << 6) | (val as u8));
-    } else {
-      buf.push((tag << 6) | 0b10_0000 | (Ixon::u64_byte_count(val) - 1));
-      Ixon::u64_put_trimmed_le(val, buf);
+    fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
+        if val < 32 {
+            buf.push((tag << 6) | (val as u8));
+        } else {
+            buf.push((tag << 6) | 0b10_0000 | (Ixon::u64_byte_count(val) - 1));
+            Ixon::u64_put_trimmed_le(val, buf);
+        }
     }
-  }
 
-  fn get_tag(
-    is_large: bool,
-    small: u8,
-    buf: &mut &[u8],
-  ) -> Result<u64, String> {
-    if is_large {
-      Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
-    } else {
-      Ok(small as u64)
+    fn get_tag(is_large: bool, small: u8, buf: &mut &[u8]) -> Result<u64, String> {
+        if is_large {
+            Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
+        } else {
+            Ok(small as u64)
+        }
     }
-  }
 }
 
 impl Serialize for Univ {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Const(x) => Univ::put_tag(0x0, *x, buf),
-      Self::Var(x) => Univ::put_tag(0x1, *x, buf),
-      Self::Add(x, y) => {
-        Univ::put_tag(0x2, *x, buf);
-        y.put(buf)
-      },
-      Self::Max(x, y) => {
-        Univ::put_tag(0x3, 0, buf);
-        x.put(buf);
-        y.put(buf);
-      },
-      Self::IMax(x, y) => {
-        Univ::put_tag(0x3, 1, buf);
-        x.put(buf);
-        y.put(buf);
-      },
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Const(x) => Univ::put_tag(0x0, *x, buf),
+            Self::Var(x) => Univ::put_tag(0x1, *x, buf),
+            Self::Add(x, y) => {
+                Univ::put_tag(0x2, *x, buf);
+                y.put(buf)
+            }
+            Self::Max(x, y) => {
+                Univ::put_tag(0x3, 0, buf);
+                x.put(buf);
+                y.put(buf);
+            }
+            Self::IMax(x, y) => {
+                Univ::put_tag(0x3, 1, buf);
+                x.put(buf);
+                y.put(buf);
+            }
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let tag_byte = u8::get(buf)?;
-    let tag = tag_byte >> 6;
-    let is_large = tag_byte & 0b10_0000 != 0;
-    let small_size = tag_byte & 0b1_1111;
-    match tag {
-      0x0 => {
-        let x = Univ::get_tag(is_large, small_size, buf)?;
-        Ok(Self::Const(x))
-      },
-      0x1 => {
-        let x = Univ::get_tag(is_large, small_size, buf)?;
-        Ok(Self::Var(x))
-      },
-      0x2 => {
-        let x = Univ::get_tag(is_large, small_size, buf)?;
-        let y = Univ::get(buf)?;
-        Ok(Self::Add(x, Box::new(y)))
-      },
-      0x3 => {
-        let x = Univ::get(buf)?;
-        let y = Univ::get(buf)?;
-        if small_size == 0 {
-          Ok(Self::Max(Box::new(x), Box::new(y)))
-        } else {
-          Ok(Self::IMax(Box::new(x), Box::new(y)))
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let tag_byte = u8::get(buf)?;
+        let tag = tag_byte >> 6;
+        let is_large = tag_byte & 0b10_0000 != 0;
+        let small_size = tag_byte & 0b1_1111;
+        match tag {
+            0x0 => {
+                let x = Univ::get_tag(is_large, small_size, buf)?;
+                Ok(Self::Const(x))
+            }
+            0x1 => {
+                let x = Univ::get_tag(is_large, small_size, buf)?;
+                Ok(Self::Var(x))
+            }
+            0x2 => {
+                let x = Univ::get_tag(is_large, small_size, buf)?;
+                let y = Univ::get(buf)?;
+                Ok(Self::Add(x, Box::new(y)))
+            }
+            0x3 => {
+                let x = Univ::get(buf)?;
+                let y = Univ::get(buf)?;
+                if small_size == 0 {
+                    Ok(Self::Max(Box::new(x), Box::new(y)))
+                } else {
+                    Ok(Self::IMax(Box::new(x), Box::new(y)))
+                }
+            }
+            x => Err(format!("get Univ invalid tag {x}")),
         }
-      },
-      x => Err(format!("get Univ invalid tag {x}")),
     }
-  }
 }
 
 #[cfg(test)]
 pub mod tests {
-  use super::*;
-  use crate::ixon::tests::{gen_range, next_case};
-  use quickcheck::{Arbitrary, Gen};
+    use super::*;
+    use crate::ixon::tests::{gen_range, next_case};
+    use quickcheck::{Arbitrary, Gen};
 
-  use std::ptr;
+    use std::ptr;
 
-  #[derive(Debug, Clone, Copy)]
-  pub enum UnivCase {
-    Const,
-    Var,
-    Add,
-    Max,
-    IMax,
-  }
+    #[derive(Debug, Clone, Copy)]
+    pub enum UnivCase {
+        Const,
+        Var,
+        Add,
+        Max,
+        IMax,
+    }
 
-  // incremental tree generation without recursion stack overflows
-  pub fn arbitrary_univ(g: &mut Gen, ctx: u64) -> Univ {
-    let mut root = Univ::Const(0);
-    let mut stack: Vec<*mut Univ> = vec![&mut root as *mut Univ];
+    // incremental tree generation without recursion stack overflows
+    pub fn arbitrary_univ(g: &mut Gen, ctx: u64) -> Univ {
+        let mut root = Univ::Const(0);
+        let mut stack: Vec<*mut Univ> = vec![&mut root as *mut Univ];
 
-    while let Some(ptr) = stack.pop() {
-      let gens: Vec<(usize, UnivCase)> = vec![
-        (100, UnivCase::Const),
-        (100, UnivCase::Var),
-        (75, UnivCase::Add),
-        (50, UnivCase::Max),
-        (50, UnivCase::IMax),
-      ];
+        while let Some(ptr) = stack.pop() {
+            let gens: Vec<(usize, UnivCase)> = vec![
+                (100, UnivCase::Const),
+                (100, UnivCase::Var),
+                (75, UnivCase::Add),
+                (50, UnivCase::Max),
+                (50, UnivCase::IMax),
+            ];
 
-      match next_case(g, &gens) {
-        UnivCase::Const => {
-          let x: u64 = Arbitrary::arbitrary(g);
-          unsafe {
-            ptr::replace(ptr, Univ::Const(x));
-          }
-        },
-        UnivCase::Var => {
-          let x: u64 = gen_range(g, 0..(ctx as usize)) as u64;
-          unsafe {
-            ptr::replace(ptr, Univ::Var(x));
-          }
-        },
-        UnivCase::Add => {
-          let x: u64 = Arbitrary::arbitrary(g);
-          let mut y_box = Box::new(Univ::Const(0));
-          let y_ptr: *mut Univ = &mut *y_box;
-          stack.push(y_ptr);
-          unsafe {
-            ptr::replace(ptr, Univ::Add(x, y_box));
-          }
-        },
-        UnivCase::Max => {
-          let mut x_box = Box::new(Univ::Const(0));
-          let x_ptr: *mut Univ = &mut *x_box;
-          stack.push(x_ptr);
-          let mut y_box = Box::new(Univ::Const(0));
-          let y_ptr: *mut Univ = &mut *y_box;
-          stack.push(y_ptr);
-          unsafe {
-            ptr::replace(ptr, Univ::Max(x_box, y_box));
-          }
-        },
-        UnivCase::IMax => {
-          let mut x_box = Box::new(Univ::Const(0));
-          let x_ptr: *mut Univ = &mut *x_box;
-          stack.push(x_ptr);
-          let mut y_box = Box::new(Univ::Const(0));
-          let y_ptr: *mut Univ = &mut *y_box;
-          stack.push(y_ptr);
-          unsafe {
-            ptr::replace(ptr, Univ::Max(x_box, y_box));
-          }
-        },
-      }
+            match next_case(g, &gens) {
+                UnivCase::Const => {
+                    let x: u64 = Arbitrary::arbitrary(g);
+                    unsafe {
+                        ptr::replace(ptr, Univ::Const(x));
+                    }
+                }
+                UnivCase::Var => {
+                    let x: u64 = gen_range(g, 0..(ctx as usize)) as u64;
+                    unsafe {
+                        ptr::replace(ptr, Univ::Var(x));
+                    }
+                }
+                UnivCase::Add => {
+                    let x: u64 = Arbitrary::arbitrary(g);
+                    let mut y_box = Box::new(Univ::Const(0));
+                    let y_ptr: *mut Univ = &mut *y_box;
+                    stack.push(y_ptr);
+                    unsafe {
+                        ptr::replace(ptr, Univ::Add(x, y_box));
+                    }
+                }
+                UnivCase::Max => {
+                    let mut x_box = Box::new(Univ::Const(0));
+                    let x_ptr: *mut Univ = &mut *x_box;
+                    stack.push(x_ptr);
+                    let mut y_box = Box::new(Univ::Const(0));
+                    let y_ptr: *mut Univ = &mut *y_box;
+                    stack.push(y_ptr);
+                    unsafe {
+                        ptr::replace(ptr, Univ::Max(x_box, y_box));
+                    }
+                }
+                UnivCase::IMax => {
+                    let mut x_box = Box::new(Univ::Const(0));
+                    let x_ptr: *mut Univ = &mut *x_box;
+                    stack.push(x_ptr);
+                    let mut y_box = Box::new(Univ::Const(0));
+                    let y_ptr: *mut Univ = &mut *y_box;
+                    stack.push(y_ptr);
+                    unsafe {
+                        ptr::replace(ptr, Univ::Max(x_box, y_box));
+                    }
+                }
+            }
+        }
+        root
     }
-    root
-  }
 
-  impl Arbitrary for Univ {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let ctx: u64 = Arbitrary::arbitrary(g);
-      arbitrary_univ(g, ctx)
+    impl Arbitrary for Univ {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let ctx: u64 = Arbitrary::arbitrary(g);
+            arbitrary_univ(g, ctx)
+        }
     }
-  }
 
-  #[quickcheck]
-  fn prop_univ_readback(x: Univ) -> bool {
-    let mut buf = Vec::new();
-    Univ::put(&x, &mut buf);
-    match Univ::get(&mut buf.as_slice()) {
-      Ok(y) => x == y,
-      Err(e) => {
-        println!("err: {e}");
-        false
-      },
+    #[quickcheck]
+    fn prop_univ_readback(x: Univ) -> bool {
+        let mut buf = Vec::new();
+        Univ::put(&x, &mut buf);
+        match Univ::get(&mut buf.as_slice()) {
+            Ok(y) => x == y,
+            Err(e) => {
+                println!("err: {e}");
+                false
+            }
+        }
     }
-  }
 }
diff --git a/src/lean/ffi/aiur/protocol.rs b/src/lean/ffi/aiur/protocol.rs
index a673cecc..debb04ce 100644
--- a/src/lean/ffi/aiur/protocol.rs
+++ b/src/lean/ffi/aiur/protocol.rs
@@ -1,145 +1,150 @@
 use multi_stark::{
-  p3_field::PrimeField64,
-  prover::Proof,
-  types::{CommitmentParameters, FriParameters},
+    p3_field::PrimeField64,
+    prover::Proof,
+    types::{CommitmentParameters, FriParameters},
 };
-use std::ffi::{c_void, CString};
+use std::ffi::{CString, c_void};
 
 use crate::{
-  aiur::{synthesis::AiurSystem, G},
-  lean::{
-    array::LeanArrayObject,
-    as_mut_unsafe,
-    boxed::BoxedU64,
-    ctor::LeanCtorObject,
-    ffi::{
-      aiur::{
-        lean_unbox_g, lean_unbox_nat_as_usize, toplevel::lean_ctor_to_toplevel,
-      },
-      drop_raw, to_raw, BytesData, CResult,
+    aiur::{G, synthesis::AiurSystem},
+    lean::{
+        array::LeanArrayObject,
+        as_mut_unsafe,
+        boxed::BoxedU64,
+        ctor::LeanCtorObject,
+        ffi::{
+            BytesData, CResult,
+            aiur::{lean_unbox_g, lean_unbox_nat_as_usize, toplevel::lean_ctor_to_toplevel},
+            drop_raw, to_raw,
+        },
+        sarray::LeanSArrayObject,
     },
-    sarray::LeanSArrayObject,
-  },
 };
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_proof_to_bytes(proof: &Proof) -> *const BytesData {
-  let bytes = proof.to_bytes().expect("Serialization error");
-  let bytes_data = BytesData::from_vec(bytes);
-  to_raw(bytes_data)
+    let bytes = proof.to_bytes().expect("Serialization error");
+    let bytes_data = BytesData::from_vec(bytes);
+    to_raw(bytes_data)
 }
 
 #[unsafe(no_mangle)]
-extern "C" fn rs_aiur_proof_of_bytes(
-  byte_array: &LeanSArrayObject,
-) -> *const Proof {
-  let proof =
-    Proof::from_bytes(byte_array.data()).expect("Deserialization error");
-  to_raw(proof)
+extern "C" fn rs_aiur_proof_of_bytes(byte_array: &LeanSArrayObject) -> *const Proof {
+    let proof = Proof::from_bytes(byte_array.data()).expect("Deserialization error");
+    to_raw(proof)
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_system_free(ptr: *mut AiurSystem) {
-  drop_raw(ptr);
+    drop_raw(ptr);
 }
 
 fn lean_ptr_to_commitment_parameters(
-  commitment_parameters_ptr: *const c_void,
+    commitment_parameters_ptr: *const c_void,
 ) -> CommitmentParameters {
-  // Single-attribute structure in Lean.
-  CommitmentParameters {
-    log_blowup: lean_unbox_nat_as_usize(commitment_parameters_ptr),
-  }
+    // Single-attribute structure in Lean.
+    CommitmentParameters {
+        log_blowup: lean_unbox_nat_as_usize(commitment_parameters_ptr),
+    }
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_system_build(
-  toplevel: &LeanCtorObject,
-  commitment_parameters: *const c_void,
+    toplevel: &LeanCtorObject,
+    commitment_parameters: *const c_void,
 ) -> *const AiurSystem {
-  to_raw(AiurSystem::build(
-    lean_ctor_to_toplevel(toplevel),
-    lean_ptr_to_commitment_parameters(commitment_parameters),
-  ))
+    to_raw(AiurSystem::build(
+        lean_ctor_to_toplevel(toplevel),
+        lean_ptr_to_commitment_parameters(commitment_parameters),
+    ))
 }
 
 fn lean_ctor_to_fri_parameters(ctor: &LeanCtorObject) -> FriParameters {
-  let [log_final_poly_len_ptr, num_queries_ptr, proof_of_work_bits_ptr] =
-    ctor.objs();
-  FriParameters {
-    log_final_poly_len: lean_unbox_nat_as_usize(log_final_poly_len_ptr),
-    num_queries: lean_unbox_nat_as_usize(num_queries_ptr),
-    proof_of_work_bits: lean_unbox_nat_as_usize(proof_of_work_bits_ptr),
-  }
+    let [
+        log_final_poly_len_ptr,
+        num_queries_ptr,
+        proof_of_work_bits_ptr,
+    ] = ctor.objs();
+    FriParameters {
+        log_final_poly_len: lean_unbox_nat_as_usize(log_final_poly_len_ptr),
+        num_queries: lean_unbox_nat_as_usize(num_queries_ptr),
+        proof_of_work_bits: lean_unbox_nat_as_usize(proof_of_work_bits_ptr),
+    }
 }
 
 #[repr(C)]
 struct ProveData {
-  claim_size: usize,
-  claim: *const Vec<G>,
-  proof: *const Proof,
+    claim_size: usize,
+    claim: *const Vec<G>,
+    proof: *const Proof,
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_claim_free(ptr: *mut Vec<G>) {
-  drop_raw(ptr);
+    drop_raw(ptr);
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_proof_free(ptr: *mut Proof) {
-  drop_raw(ptr);
+    drop_raw(ptr);
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_prove_data_free(ptr: *mut ProveData) {
-  drop_raw(ptr);
+    drop_raw(ptr);
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_system_prove(
-  aiur_system: &AiurSystem,
-  fri_parameters: &LeanCtorObject,
-  fun_idx: *const c_void,
-  args: &LeanArrayObject,
+    aiur_system: &AiurSystem,
+    fri_parameters: &LeanCtorObject,
+    fun_idx: *const c_void,
+    args: &LeanArrayObject,
 ) -> *const ProveData {
-  let fri_parameters = lean_ctor_to_fri_parameters(fri_parameters);
-  let fun_idx = lean_unbox_nat_as_usize(fun_idx);
-  let args = args.to_vec(lean_unbox_g);
-  let (claim, proof) = aiur_system.prove(fri_parameters, fun_idx, &args);
-  let claim_size = claim.len();
-  let prove_data =
-    ProveData { claim_size, claim: to_raw(claim), proof: to_raw(proof) };
-  to_raw(prove_data)
+    let fri_parameters = lean_ctor_to_fri_parameters(fri_parameters);
+    let fun_idx = lean_unbox_nat_as_usize(fun_idx);
+    let args = args.to_vec(lean_unbox_g);
+    let (claim, proof) = aiur_system.prove(fri_parameters, fun_idx, &args);
+    let claim_size = claim.len();
+    let prove_data = ProveData {
+        claim_size,
+        claim: to_raw(claim),
+        proof: to_raw(proof),
+    };
+    to_raw(prove_data)
 }
 
 #[unsafe(no_mangle)]
-extern "C" fn rs_set_aiur_claim_args(
-  claim_array: &mut LeanArrayObject,
-  claim: &Vec<G>,
-) {
-  let claim_data = claim_array.data();
-  assert_eq!(claim_data.len(), claim.len());
-  claim_data.iter().zip(claim).for_each(|(ptr, g)| {
-    let boxed_u64 = as_mut_unsafe(*ptr as *mut BoxedU64);
-    boxed_u64.value = g.as_canonical_u64();
-  });
+extern "C" fn rs_set_aiur_claim_args(claim_array: &mut LeanArrayObject, claim: &Vec<G>) {
+    let claim_data = claim_array.data();
+    assert_eq!(claim_data.len(), claim.len());
+    claim_data.iter().zip(claim).for_each(|(ptr, g)| {
+        let boxed_u64 = as_mut_unsafe(*ptr as *mut BoxedU64);
+        boxed_u64.value = g.as_canonical_u64();
+    });
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_system_verify(
-  aiur_system: &AiurSystem,
-  fri_parameters: &LeanCtorObject,
-  claim: &LeanArrayObject,
-  proof: &Proof,
+    aiur_system: &AiurSystem,
+    fri_parameters: &LeanCtorObject,
+    claim: &LeanArrayObject,
+    proof: &Proof,
 ) -> *const CResult {
-  let fri_parameters = lean_ctor_to_fri_parameters(fri_parameters);
-  let claim = claim.to_vec(lean_unbox_g);
-  let c_result = match aiur_system.verify(fri_parameters, &claim, proof) {
-    Ok(()) => CResult { is_ok: true, data: std::ptr::null() },
-    Err(err) => {
-      let msg = CString::new(format!("{err:?}")).expect("CString::new failure");
-      CResult { is_ok: false, data: msg.into_raw().cast() }
-    },
-  };
-  to_raw(c_result)
+    let fri_parameters = lean_ctor_to_fri_parameters(fri_parameters);
+    let claim = claim.to_vec(lean_unbox_g);
+    let c_result = match aiur_system.verify(fri_parameters, &claim, proof) {
+        Ok(()) => CResult {
+            is_ok: true,
+            data: std::ptr::null(),
+        },
+        Err(err) => {
+            let msg = CString::new(format!("{err:?}")).expect("CString::new failure");
+            CResult {
+                is_ok: false,
+                data: msg.into_raw().cast(),
+            }
+        }
+    };
+    to_raw(c_result)
 }
diff --git a/src/lean/ffi/ixon.rs b/src/lean/ffi/ixon.rs
index ee09f230..96acde67 100644
--- a/src/lean/ffi/ixon.rs
+++ b/src/lean/ffi/ixon.rs
@@ -4,13 +4,23 @@ use std::ffi::c_void;
 
 use crate::{
     ixon::{
-        address::Address, claim::{Claim, Proof}, constant::{
-            Axiom, Comm, Constructor, ConstructorProj, DefKind, DefSafety, Definition, DefinitionProj, Inductive, InductiveProj, QuotKind, Quotient, Recursor, RecursorProj, RecursorRule
-        }, meta::{BinderInfo, Metadata, Metadatum, ReducibilityHints}, name::{Name, NamePart}, nat::Nat, serialize::Serialize, univ::Univ, Ixon
+        Ixon,
+        address::Address,
+        claim::{Claim, Proof},
+        constant::{
+            Axiom, Comm, Constructor, ConstructorProj, DefKind, DefSafety, Definition,
+            DefinitionProj, Inductive, InductiveProj, QuotKind, Quotient, Recursor, RecursorProj,
+            RecursorRule,
+        },
+        meta::{BinderInfo, Metadata, Metadatum, ReducibilityHints},
+        name::{Name, NamePart},
+        nat::Nat,
+        serialize::Serialize,
+        univ::Univ,
     },
     lean::{
         array::LeanArrayObject, as_ref_unsafe, ctor::LeanCtorObject, lean_is_scalar,
-        sarray::LeanSArrayObject, string::LeanStringObject
+        sarray::LeanSArrayObject, string::LeanStringObject,
     },
     lean_unbox,
 };
@@ -82,7 +92,13 @@ fn lean_ptr_to_definition(ptr: *const c_void) -> Definition {
         2 => DefSafety::Partial,
         _ => unreachable!(),
     };
-    Definition {lvls, typ, mode: mode, value, safety}
+    Definition {
+        lvls,
+        typ,
+        mode: mode,
+        value,
+        safety,
+    }
 }
 
 fn lean_ptr_to_constructor(ptr: *const c_void) -> Constructor {
@@ -94,7 +110,14 @@ fn lean_ptr_to_constructor(ptr: *const c_void) -> Constructor {
     let params = lean_ptr_to_nat(params);
     let fields = lean_ptr_to_nat(fields);
     let is_unsafe = is_unsafe as usize == 1;
-    Constructor { lvls, typ, cidx, params, fields, is_unsafe }
+    Constructor {
+        lvls,
+        typ,
+        cidx,
+        params,
+        fields,
+        is_unsafe,
+    }
 }
 
 fn lean_ptr_to_recursor_rule(ptr: *const c_void) -> RecursorRule {
@@ -107,7 +130,16 @@ fn lean_ptr_to_recursor_rule(ptr: *const c_void) -> RecursorRule {
 
 fn lean_ptr_to_recursor(ptr: *const c_void) -> Recursor {
     let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [lvls, typ, params, indices, motives, minors, rules, k_isunsafe] = ctor.objs();
+    let [
+        lvls,
+        typ,
+        params,
+        indices,
+        motives,
+        minors,
+        rules,
+        k_isunsafe,
+    ] = ctor.objs();
     let lvls = lean_ptr_to_nat(lvls);
     let typ = lean_ptr_to_address(typ);
     let params = lean_ptr_to_nat(params);
@@ -119,12 +151,31 @@ fn lean_ptr_to_recursor(ptr: *const c_void) -> Recursor {
     let [k, is_unsafe, ..] = (k_isunsafe as usize).to_le_bytes();
     let k = k == 1;
     let is_unsafe = is_unsafe == 1;
-    Recursor { lvls, typ, params, indices, motives, minors, rules, k, is_unsafe }
+    Recursor {
+        lvls,
+        typ,
+        params,
+        indices,
+        motives,
+        minors,
+        rules,
+        k,
+        is_unsafe,
+    }
 }
 
 fn lean_ptr_to_inductive(ptr: *const c_void) -> Inductive {
     let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [lvls, typ, params, indices, ctors, recrs, nested, recr_refl_isunsafe] = ctor.objs();
+    let [
+        lvls,
+        typ,
+        params,
+        indices,
+        ctors,
+        recrs,
+        nested,
+        recr_refl_isunsafe,
+    ] = ctor.objs();
     let lvls = lean_ptr_to_nat(lvls);
     let typ = lean_ptr_to_address(typ);
     let params = lean_ptr_to_nat(params);
@@ -138,7 +189,18 @@ fn lean_ptr_to_inductive(ptr: *const c_void) -> Inductive {
     let recr = recr == 1;
     let refl = refl == 1;
     let is_unsafe = is_unsafe == 1;
-    Inductive { lvls, typ, params, indices, ctors, recrs, nested, recr, refl, is_unsafe }
+    Inductive {
+        lvls,
+        typ,
+        params,
+        indices,
+        ctors,
+        recrs,
+        nested,
+        recr,
+        refl,
+        is_unsafe,
+    }
 }
 
 fn lean_ptr_to_name_parts(ptr: *const c_void) -> Vec<NamePart> {
@@ -178,7 +240,7 @@ fn lean_ptr_to_metadatum(ptr: *const c_void) -> Metadatum {
             let [name] = ctor.objs();
             let name = lean_ptr_to_name(name);
             Metadatum::Name(name)
-        },
+        }
         1 => {
             let [info] = ctor.objs();
             let info = match info as usize {
@@ -239,7 +301,12 @@ fn lean_ptr_to_metadata_entry(ptr: *const c_void) -> (Nat, Vec<Metadatum>) {
 fn lean_ptr_to_eval_claim(ptr: *const c_void) -> Claim {
     let evals: &LeanCtorObject = as_ref_unsafe(ptr.cast());
     let [lvls, input, output, typ] = evals.objs().map(lean_ptr_to_address);
-    Claim::Evals { lvls, typ, input, output }
+    Claim::Evals {
+        lvls,
+        typ,
+        input,
+        output,
+    }
 }
 
 fn lean_ptr_to_check_claim(ptr: *const c_void) -> Claim {
@@ -332,7 +399,11 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let lvls = lean_ptr_to_nat(lvls);
             let typ = lean_ptr_to_address(typ);
             let is_unsafe = is_unsafe as usize == 1;
-            Ixon::Axio(Axiom { lvls, typ, is_unsafe })
+            Ixon::Axio(Axiom {
+                lvls,
+                typ,
+                is_unsafe,
+            })
         }
         14 => {
             let [quot_ptr] = ctor.objs();
@@ -347,7 +418,7 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
                 3 => QuotKind::Ind,
                 _ => unreachable!(),
             };
-            Ixon::Quot(Quotient {lvls, typ, kind})
+            Ixon::Quot(Quotient { lvls, typ, kind })
         }
         15 => {
             let [cprj_ptr] = ctor.objs();
@@ -373,7 +444,7 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let [block, idx] = iprj_ctor.objs();
             let block = lean_ptr_to_address(block);
             let idx = lean_ptr_to_nat(idx);
-            Ixon::IndcProj(InductiveProj {block, idx})
+            Ixon::IndcProj(InductiveProj { block, idx })
         }
         18 => {
             let [dprj_ptr] = ctor.objs();
@@ -381,7 +452,7 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let [block, idx] = dprj_ctor.objs();
             let block = lean_ptr_to_address(block);
             let idx = lean_ptr_to_nat(idx);
-            Ixon::DefnProj(DefinitionProj {block, idx})
+            Ixon::DefnProj(DefinitionProj { block, idx })
         }
         19 => {
             let [inds_ptr] = ctor.objs();
@@ -418,7 +489,10 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
                 _ => unreachable!(),
             };
             let bin: &LeanSArrayObject = as_ref_unsafe(bin.cast());
-            Ixon::Proof(Proof {claim, proof: bin.data().to_vec()})
+            Ixon::Proof(Proof {
+                claim,
+                proof: bin.data().to_vec(),
+            })
         }
         23 => {
             let [evals] = ctor.objs();
@@ -440,9 +514,12 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
 }
 
 #[unsafe(no_mangle)]
-extern "C" fn rs_eq_lean_rust_serialization(ixon: &LeanCtorObject, bytes: &LeanSArrayObject) -> bool {
+extern "C" fn rs_eq_lean_rust_serialization(
+    ixon: &LeanCtorObject,
+    bytes: &LeanSArrayObject,
+) -> bool {
     let mut buf = Vec::new();
     println!("{:?}", lean_ctor_to_ixon(ixon));
     lean_ctor_to_ixon(ixon).put(&mut buf);
     buf == bytes.data()
-}
\ No newline at end of file
+}
diff --git a/src/lean/ffi/mod.rs b/src/lean/ffi/mod.rs
index 13610bba..458eeb9b 100644
--- a/src/lean/ffi/mod.rs
+++ b/src/lean/ffi/mod.rs
@@ -1,23 +1,22 @@
 #[cfg(any(
-  not(feature = "net"),
-  all(target_os = "macos", target_arch = "aarch64")
+    not(feature = "net"),
+    all(target_os = "macos", target_arch = "aarch64")
 ))]
 pub mod _iroh;
 pub mod aiur;
 pub mod byte_array;
 #[cfg(all(
-  feature = "net",
-  not(all(target_os = "macos", target_arch = "aarch64"))
+    feature = "net",
+    not(all(target_os = "macos", target_arch = "aarch64"))
 ))]
 pub mod iroh;
 pub mod ixon;
 pub mod keccak;
 
-use std::ffi::{c_char, c_void, CStr, CString};
+use std::ffi::{CStr, CString, c_char, c_void};
 
 use crate::lean::{
-  array::LeanArrayObject, as_ref_unsafe, lean_unbox_u32,
-  sarray::LeanSArrayObject,
+    array::LeanArrayObject, as_ref_unsafe, lean_unbox_u32, sarray::LeanSArrayObject,
 };
 
 /// ```c
@@ -28,76 +27,76 @@ use crate::lean::{
 /// ```
 #[repr(C)]
 pub struct CResult {
-  pub is_ok: bool,
-  pub data: *const c_void,
+    pub is_ok: bool,
+    pub data: *const c_void,
 }
 
 // Free a `CResult` object that corresponds to the Rust type `Result<(), String>`
 #[unsafe(no_mangle)]
 extern "C" fn rs__c_result_unit_string_free(ptr: *mut CResult) {
-  let c_result = as_ref_unsafe(ptr);
-  // Free the string error message
-  if !c_result.is_ok {
-    let char_ptr = c_result.data as *mut c_char;
-    let c_string = unsafe { CString::from_raw(char_ptr) };
-    drop(c_string);
-  }
-  drop_raw(ptr);
+    let c_result = as_ref_unsafe(ptr);
+    // Free the string error message
+    if !c_result.is_ok {
+        let char_ptr = c_result.data as *mut c_char;
+        let c_string = unsafe { CString::from_raw(char_ptr) };
+        drop(c_string);
+    }
+    drop_raw(ptr);
 }
 
 #[inline]
 pub(super) fn to_raw<T>(t: T) -> *const T {
-  Box::into_raw(Box::new(t))
+    Box::into_raw(Box::new(t))
 }
 
 #[inline]
 pub(super) fn drop_raw<T>(ptr: *mut T) {
-  assert!(!ptr.is_null(), "Null pointer free attempt");
-  let t = unsafe { Box::from_raw(ptr) };
-  drop(t);
+    assert!(!ptr.is_null(), "Null pointer free attempt");
+    let t = unsafe { Box::from_raw(ptr) };
+    drop(t);
 }
 
 #[inline]
 #[allow(dead_code)]
 pub(super) fn raw_to_str<'a>(ptr: *const c_char) -> &'a str {
-  let c_str = unsafe { CStr::from_ptr(ptr) };
-  c_str.to_str().expect("Invalid UTF-8 string")
+    let c_str = unsafe { CStr::from_ptr(ptr) };
+    c_str.to_str().expect("Invalid UTF-8 string")
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn rs_boxed_u32s_are_equivalent_to_bytes(
-  u32s: &LeanArrayObject,
-  bytes: &LeanSArrayObject,
+    u32s: &LeanArrayObject,
+    bytes: &LeanSArrayObject,
 ) -> bool {
-  let u32s = u32s
-    .to_vec(lean_unbox_u32)
-    .into_iter()
-    .flat_map(u32::to_le_bytes)
-    .collect::<Vec<_>>();
-  u32s == bytes.data()
+    let u32s = u32s
+        .to_vec(lean_unbox_u32)
+        .into_iter()
+        .flat_map(u32::to_le_bytes)
+        .collect::<Vec<_>>();
+    u32s == bytes.data()
 }
 
 #[repr(C)]
 pub struct BytesData {
-  size: usize,
-  bytes_vec: *const Vec<u8>,
+    size: usize,
+    bytes_vec: *const Vec<u8>,
 }
 
 impl BytesData {
-  #[inline]
-  pub(super) fn from_vec(vec: Vec<u8>) -> Self {
-    Self { size: vec.len(), bytes_vec: to_raw(vec) }
-  }
+    #[inline]
+    pub(super) fn from_vec(vec: Vec<u8>) -> Self {
+        Self {
+            size: vec.len(),
+            bytes_vec: to_raw(vec),
+        }
+    }
 }
 
 #[unsafe(no_mangle)]
-extern "C" fn rs_move_bytes(
-  bytes_data: *mut BytesData,
-  byte_array: &mut LeanSArrayObject,
-) {
-  let bytes_data = unsafe { Box::from_raw(bytes_data) };
-  let bytes_vec = unsafe { Box::from_raw(bytes_data.bytes_vec as *mut Vec<_>) };
-  byte_array.set_data(&bytes_vec);
-  drop(bytes_vec);
-  drop(bytes_data);
+extern "C" fn rs_move_bytes(bytes_data: *mut BytesData, byte_array: &mut LeanSArrayObject) {
+    let bytes_data = unsafe { Box::from_raw(bytes_data) };
+    let bytes_vec = unsafe { Box::from_raw(bytes_data.bytes_vec as *mut Vec<_>) };
+    byte_array.set_data(&bytes_vec);
+    drop(bytes_vec);
+    drop(bytes_data);
 }
diff --git a/src/lib.rs b/src/lib.rs
index 1affea88..75792ddf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,8 +12,8 @@ pub mod lean;
 
 #[cfg(test)]
 mod tests {
-  #[test]
-  fn it_works() {
-    assert_eq!(2 + 2, 4);
-  }
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
 }

From c720d38826a44c71a972cef14bd71a6aefe6a2a6 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 3 Sep 2025 10:57:18 -0400
Subject: [PATCH 40/74] fix Ixon Lean serialization

---
 Cargo.lock           |  2 +-
 Ix/Claim.lean        |  2 +-
 Ix/Ixon/Const.lean   | 11 +++---
 Tests/Ix.lean        | 14 ++++----
 Tests/Ix/Common.lean | 35 ++++++++++---------
 Tests/Ix/IR.lean     | 40 ++++++++++-----------
 Tests/Ix/Ixon.lean   | 82 +++++++++++++++++++++++++++++++-------------
 Tests/Main.lean      |  4 +--
 8 files changed, 115 insertions(+), 75 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bcf3b772..0687a936 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3244,7 +3244,7 @@ checksum = "f71ee38b42f8459a88d3362be6f9b841ad2d5421844f61eb1c59c11bff3ac14a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.104",
+ "syn 2.0.106",
 ]
 
 [[package]]
diff --git a/Ix/Claim.lean b/Ix/Claim.lean
index 5b02a610..24f23626 100644
--- a/Ix/Claim.lean
+++ b/Ix/Claim.lean
@@ -14,8 +14,8 @@ structure CheckClaim where
 deriving BEq, Repr, Inhabited
 
 inductive Claim where
-| checks : CheckClaim -> Claim
 | evals : EvalClaim -> Claim
+| checks : CheckClaim -> Claim
 deriving BEq, Repr, Inhabited
 
 instance : ToString CheckClaim where
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index 4f8d536d..a15752da 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -196,7 +196,10 @@ instance : Serialize Comm where
   get := (fun (x,y) => .mk x y) <$> Serialize.get
 
 instance : Serialize CheckClaim where
-  put x := Serialize.put (x.lvls, x.type, x.value)
+  put x := do
+    Serialize.put x.lvls
+    Serialize.put x.type
+    Serialize.put x.value
   get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
 
 instance : Serialize EvalClaim where
@@ -205,10 +208,10 @@ instance : Serialize EvalClaim where
 
 instance : Serialize Claim where
   put
-  | .checks x => putTag4 ⟨0xE, 2⟩ *> Serialize.put x
-  | .evals x => putTag4 ⟨0xE, 3⟩ *> Serialize.put x
+  | .evals x => putTag4 ⟨0xE, 2⟩ *> Serialize.put x
+  | .checks x => putTag4 ⟨0xE, 3⟩ *> Serialize.put x
   get := do match <- getTag4 with
-  | ⟨0xE,2⟩ => .checks <$> Serialize.get
+  | ⟨0xE,2⟩ => .evals <$> Serialize.get
   | ⟨0xE,3⟩ => .checks <$> Serialize.get
   | e => throw s!"expected Claim with tag 0xE2 or 0xE3, got {repr e}"
 
diff --git a/Tests/Ix.lean b/Tests/Ix.lean
index a89d72c9..7ef3605d 100644
--- a/Tests/Ix.lean
+++ b/Tests/Ix.lean
@@ -4,6 +4,7 @@ import Ix.Ixon.Metadata
 import Ix.Address
 import Ix.Ixon.Serialize
 import Ix.Ixon.Univ
+import Ix.Claim
 import Ix.TransportM
 import LSpec.SlimCheck.Gen
 import LSpec
@@ -81,15 +82,16 @@ def dbg : IO UInt32 := do
 def Tests.Ix.suite : List LSpec.TestSeq :=
   [
     check "metadatum serde" (∀ x : Ixon.Metadatum, serde x),
+    check "metadata serde" (∀ x : Ixon.Metadata, serde x),
     check "universe serde" (∀ x : Ixon.Univ, serde x),
     check "universe transport" (∀ x : Ix.Level, transportUniv x),
     check "expr serde" (∀ x : Ixon.IxonExpr, serde x),
     check "expr transport" (∀ x : Ix.Expr, transportExpr x),
-    --check "axiom serde" (∀ x : Ixon.Axiom, serde x),
-    --check "recursor rule serde" (∀ x : Ixon.RecursorRule, serde x),
-    --check "recursor serde" (∀ x : Ixon.Recursor, serde x),
-    --check "constructor serde" (∀ x : Ixon.Constructor, serde x),
-    --check "inductive serde" (∀ x : Ixon.Inductive, serde x),
+    ----check "axiom serde" (∀ x : Ixon.Axiom, serde x),
+    ----check "recursor rule serde" (∀ x : Ixon.RecursorRule, serde x),
+    ----check "recursor serde" (∀ x : Ixon.Recursor, serde x),
+    ----check "constructor serde" (∀ x : Ixon.Constructor, serde x),
+    check "claim serde" (∀ x : Claim, serde x),
     check "const serde" (∀ x : Ixon.IxonConst, serde x),
-    check "const transport" (∀ x : Ix.Const, transportConst x),
+    --check "const transport" (∀ x : Ix.Const, transportConst x),
   ]
diff --git a/Tests/Ix/Common.lean b/Tests/Ix/Common.lean
index ef35f41e..2deeaf0d 100644
--- a/Tests/Ix/Common.lean
+++ b/Tests/Ix/Common.lean
@@ -22,26 +22,27 @@ def genAddress : SlimCheck.Gen Address :=
 def genChar : SlimCheck.Gen Char :=
   Char.ofNat <$> (choose Nat 0 0xd800)
 
-def genString : SlimCheck.Gen String := do
-  let cs ← listOf genChar
-  return String.mk cs
-
 def genBool : Gen Bool := choose Bool .false true
 
+def genListSize (gen: Gen α) (lo hi: Nat): Gen (List α) := do
+  let n ← choose Nat lo hi
+  List.mapM (fun _ => gen) (List.range n)
+
 -- aggressively reduce size parameter to avoid tree blow-up
-def resizeListOf (n: Gen α) : Gen (List α) := resize (· / 2) $ listOf n
+def genList (n: Gen α) : Gen (List α) := do
+  resize (fun s => if s > 8 then 8 else s / 2) $ listOf n
 
-def genNat' : Gen Nat := choose Nat 0 10
+def genString : SlimCheck.Gen String := do
+  let cs ← genList genChar
+  return String.mk cs
 
-def genNatUSize : Gen Nat := USize.toNat <$> genUSize
+--def genNat' : Gen Nat := choose Nat 0 10
 
-def genList' (gen: Gen α) : Gen (List α) := do
-  let n ← genNat'
-  List.mapM (fun _ => gen) (List.range n)
+def genNat : Gen Nat := USize.toNat <$> genUSize
 
-def genListSize (gen: Gen α) (lo hi: Nat): Gen (List α) := do
-  let n ← choose Nat lo hi
-  List.mapM (fun _ => gen) (List.range n)
+--def genList' (gen: Gen α) : Gen (List α) := do
+--  let n ← genNat'
+--  List.mapM (fun _ => gen) (List.range n)
 
 def genOption (gen: Gen α) : Gen (Option α) :=
   oneOf' [ pure .none, .some <$> gen]
@@ -55,11 +56,11 @@ def genAlphaNum : Gen Char := do
   return Char.ofNat n
 
 def genAlphaNumStr : Gen String := do
-  String.mk <$> genList' genAlphaNum
+  String.mk <$> genList genAlphaNum
 
-def genNamePart : Gen Ixon.NamePart := 
-  frequency [ (100, .str <$> genAlphaNumStr)
-    --, (50, .num <$> genNat')
+def genNamePart : Gen Ixon.NamePart :=
+  frequency [ (50, .str <$> genAlphaNumStr)
+  , (50, .num <$> genNat)
   ]
 
 def genName : Gen Lean.Name := Ixon.nameFromParts <$> (fun x => [x]) <$> genNamePart
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index 20fdd96c..03ebabb8 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -20,7 +20,7 @@ def genLevel : Gen Ix.Level := getSize >>= go
     | Nat.succ f =>
       frequency [
         (100, return .zero),
-        (100, .param <$> genName <*> genNatUSize),
+        (100, .param <$> genName <*> genNat),
         (50, .succ <$> go f),
         (25, .max <$> go f <*> go f),
         (25, .imax <$> go f <*> go f)
@@ -37,10 +37,10 @@ def genExpr : Gen Ix.Expr := getSize >>= go
     | 0 => return .lit (.natVal 0)
     | Nat.succ f =>
       frequency [
-        (100, .var <$> genNatUSize),
+        (100, .var <$> genNat),
         (100, .sort <$> genLevel),
-        (50, .const <$> genName <*> genAddress <*> genAddress <*> resizeListOf genLevel),
-        (50, .rec_ <$> genName <*> genNat' <*> resizeListOf genLevel),
+        (50, .const <$> genName <*> genAddress <*> genAddress <*> genList genLevel),
+        (50, .rec_ <$> genName <*> genNat <*> genList genLevel),
         (50, .app <$> go f <*> go f),
         (50, .lam <$> genName <*> genBinderInfo <*> go f <*> go f),
         (50, .pi <$> genName <*> genBinderInfo <*> go f <*> go f),
@@ -48,7 +48,7 @@ def genExpr : Gen Ix.Expr := getSize >>= go
         (25, .letE <$> genName <*> go f <*> go f <*> go f <*> pure .false),
         (100, .lit <$> .strVal <$> genString),
         (100, .lit <$> .natVal <$> chooseAny Nat),
-        (25, .proj <$> genName <*> genAddress <*> genAddress <*> genNat' <*> go f),
+        (25, .proj <$> genName <*> genAddress <*> genAddress <*> genNat <*> go f),
       ]
 
 instance : Shrinkable Ix.Expr where
@@ -58,7 +58,7 @@ instance : SampleableExt Ix.Expr := SampleableExt.mkSelfContained genExpr
 
 def genConst : Gen Ix.Const := getSize >>= go
   where
-    genNames : Gen (List Lean.Name) := resizeListOf genName
+    genNames : Gen (List Lean.Name) := genList genName
     genDef : Gen Ix.Definition := do
       let n <- genName
       let lvls <- genNames
@@ -70,31 +70,31 @@ def genConst : Gen Ix.Const := getSize >>= go
       let all <- genNames
       return ⟨n, lvls, type, mode, value, hints, safety, all⟩
     genCtor : Gen Ix.Constructor := 
-      .mk <$> genName <*> genNames <*> genExpr <*> genNat' <*> genNat' <*> genNat' <*> genBool
+      .mk <$> genName <*> genNames <*> genExpr <*> genNat <*> genNat <*> genNat <*> genBool
     genRecr : Gen Ix.Recursor := 
-      .mk <$> genName <*> genNames <*> genExpr <*> genNat' <*> genNat' <*> genNat' <*> genNat'
-        <*> resizeListOf (.mk <$> genName <*> genNat' <*> genExpr)
+      .mk <$> genName <*> genNames <*> genExpr <*> genNat <*> genNat <*> genNat <*> genNat
+        <*> genList (.mk <$> genName <*> genNat <*> genExpr)
         <*> genBool <*> genBool
     genInd : Gen Ix.Inductive := do
       let n <- genName
       let lvls <- genNames
       let type <- genExpr
-      let params <- genNat'
-      let indices <- genNat'
+      let params <- genNat
+      let indices <- genNat
       let all <- genNames
-      let ctors <- resizeListOf genCtor
-      let recrs <- resizeListOf genRecr
-      let nested <- genNat'
+      let ctors <- genList genCtor
+      let recrs <- genList genRecr
+      let nested <- genNat
       let (isRec, isRefl, isUnsafe) <- (·,·,·) <$> genBool <*> genBool <*> genBool
       return ⟨n, lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl, isUnsafe⟩
     genMutDef : Gen Ix.MutualBlock := do
-      let nns <- resizeListOf (genListSize genName 1 5)
+      let nns <- genList (genListSize genName 1 5)
       let ds <- nns.mapM fun ns => do
         let x <- genDef
         ns.mapM (fun _ => pure x)
       return .mk ds
     genMutInd : Gen Ix.InductiveBlock := do
-      let nns <- resizeListOf (genListSize genName 1 5)
+      let nns <- genList (genListSize genName 1 5)
       let ds <- nns.mapM fun ns => do
         let x <- genInd
         ns.mapM (fun _ => pure x)
@@ -106,10 +106,10 @@ def genConst : Gen Ix.Const := getSize >>= go
         (100, .«axiom» <$> (.mk <$> genName <*> genNames <*> genExpr <*> genBool)),
         (100, .«definition» <$> genDef),
         (100, .quotient <$> (.mk <$> genName <*> genNames <*> genExpr <*> genQuotKind)),
-        (100, .inductiveProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat')),
-        (100, .constructorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat' <*> genName <*> genNat')),
-        (100, .recursorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat' <*> genName <*> genNat')),
-        (100, .definitionProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat')),
+        (100, .inductiveProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat)),
+        (100, .constructorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat <*> genName <*> genNat)),
+        (100, .recursorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat <*> genName <*> genNat)),
+        (100, .definitionProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat)),
         (100, .mutual <$> genMutDef),
         (100, .inductive <$> genMutInd),
       ]
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 40f366cc..6a181528 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -44,11 +44,11 @@ def genExpr : SlimCheck.Gen Ixon := getSize >>= go
       frequency [
         (100, .vari <$> genUInt64),
         (100, .sort <$> genUniv),
-        (100, .refr <$> genAddress <*> resizeListOf genUniv),
-        (100, .recr <$> genUInt64 <*> resizeListOf genUniv),
-        (30, .apps <$> go f <*> go f <*> resizeListOf (go f)),
-        (30, .lams <$> resizeListOf (go f) <*> go f),
-        (30, .alls <$> resizeListOf (go f) <*> go f),
+        (100, .refr <$> genAddress <*> genList genUniv),
+        (100, .recr <$> genUInt64 <*> genList genUniv),
+        (15, .apps <$> go f <*> go f <*> genList (go f)),
+        (15, .lams <$> genList (go f) <*> go f),
+        (15, .alls <$> genList (go f) <*> go f),
         (15, .letE .true <$> go f <*> go f <*> go f),
         (15, .letE .false <$> go f <*> go f <*> go f),
         (50, .proj <$> genAddress <*> genUInt64 <*> go f),
@@ -74,11 +74,11 @@ instance : SampleableExt IxonExpr :=
 -- Metadata
 def genMetadatum : Gen Ixon.Metadatum :=
   frequency [
-    (100, .name <$> genName),
+    (50, .name <$> genName),
     (100, .info <$> genBinderInfo),
     (100, .link <$> genAddress),
     (100, .hints <$> genReducibilityHints),
-    (25, .all <$> genList' genName),
+    (10, .all <$> genList genName),
   ]
 
 instance : Shrinkable Metadatum where
@@ -87,15 +87,20 @@ instance : Shrinkable Metadatum where
 instance : SampleableExt Metadatum :=
   SampleableExt.mkSelfContained genMetadatum
 
-def genMetaNode : Gen (List Metadatum) :=
-  genList' genMetadatum
+def genMetaNode : Gen (List Metadatum) := genList genMetadatum
 
 def genMetadata : Gen Metadata := do
-  let xs ← genList' genMetaNode
+  let xs ← genList genMetaNode
   return .mk (Batteries.RBMap.ofList ((List.range xs.length).zip xs) compare)
 
+instance : Shrinkable Metadata where
+  shrink _ := []
+
+instance : SampleableExt Metadata :=
+  SampleableExt.mkSelfContained genMetadata
+
 -- Const
-def genAxiom : Gen Axiom := .mk <$> genNat' <*> genAddress <*> genBool
+def genAxiom : Gen Axiom := .mk <$> genNat <*> genAddress <*> genBool
 
 -- TODO: useful shrinking
 instance : Shrinkable Axiom where
@@ -105,7 +110,7 @@ instance : SampleableExt Axiom
   := SampleableExt.mkSelfContained genAxiom
 
 def genDefinition : Gen Definition := do
-  let lvls <- genNat'
+  let lvls <- genNat
   let type <- genAddress
   let mode <- genDefKind
   let value <- genAddress
@@ -113,7 +118,7 @@ def genDefinition : Gen Definition := do
   return .mk lvls type mode value safety
 
 def genConstructor : Gen Constructor :=
-  .mk <$> genNat' <*> genAddress <*> genNat' <*> genNat' <*> genNat' <*> genBool
+  .mk <$> genNat <*> genAddress <*> genNat <*> genNat <*> genNat <*> genBool
 
 -- TODO: useful shrinking
 instance : Shrinkable Constructor where
@@ -122,7 +127,7 @@ instance : Shrinkable Constructor where
 instance : SampleableExt Constructor
   := SampleableExt.mkSelfContained genConstructor
 
-def genRecursorRule : Gen RecursorRule := .mk <$> genNat' <*> genAddress
+def genRecursorRule : Gen RecursorRule := .mk <$> genNat <*> genAddress
 
 -- TODO: useful shrinking
 instance : Shrinkable RecursorRule where
@@ -132,8 +137,8 @@ instance : SampleableExt RecursorRule
   := SampleableExt.mkSelfContained genRecursorRule
 
 def genRecursor : Gen Recursor :=
-  .mk <$> genNat' <*> genAddress <*> genNat' <*> genNat' <*> genNat'
-    <*> genNat' <*> genList' genRecursorRule <*> genBool <*> genBool
+  .mk <$> genNat <*> genAddress <*> genNat <*> genNat <*> genNat
+    <*> genNat <*> genList genRecursorRule <*> genBool <*> genBool
 
 -- TODO: useful shrinking
 instance : Shrinkable Recursor where
@@ -143,8 +148,8 @@ instance : SampleableExt Recursor
   := SampleableExt.mkSelfContained genRecursor
 
 def genInductive : Gen Inductive :=
-  .mk <$> genNat' <*> genAddress <*> genNat' <*> genNat'
-    <*> genList' genConstructor <*> genList' genRecursor <*> genNat'
+  .mk <$> genNat <*> genAddress <*> genNat <*> genNat
+    <*> genList genConstructor <*> genList genRecursor <*> genNat
     <*> genBool <*> genBool <*> genBool
 
 -- TODO: useful shrinking
@@ -155,16 +160,32 @@ instance : SampleableExt Inductive
   := SampleableExt.mkSelfContained genInductive
 
 def genConstructorProj : Gen ConstructorProj :=
-  .mk <$> genAddress <*> genNat' <*> genNat'
+  .mk <$> genAddress <*> genNat <*> genNat
 
 def genRecursorProj : Gen RecursorProj :=
-  .mk <$> genAddress <*> genNat' <*> genNat'
+  .mk <$> genAddress <*> genNat <*> genNat
 
 def genDefinitionProj : Gen DefinitionProj :=
-  .mk <$> genAddress <*> genNat'
+  .mk <$> genAddress <*> genNat
 
 def genInductiveProj : Gen InductiveProj :=
-  .mk <$> genAddress <*> genNat'
+  .mk <$> genAddress <*> genNat
+
+def genCheckClaim : Gen CheckClaim :=
+  .mk <$> genAddress <*> genAddress <*> genAddress
+
+def genEvalClaim : Gen EvalClaim :=
+  .mk <$> genAddress <*> genAddress <*> genAddress <*> genAddress
+
+def genClaim: Gen Claim :=
+  oneOf #[.checks <$> genCheckClaim, .evals <$> genEvalClaim]
+
+-- TODO: different dummy ByteArray perhaps
+def genProof: Gen Proof := .mk <$> genClaim <*> (Address.hash <$> genAddress)
+
+def genComm: Gen Comm := .mk <$> genAddress <*> genAddress
+
+def genEnvn: Gen Unit := pure ()
 
 def genConst : Gen Ixon := getSize >>= go
   where
@@ -178,9 +199,14 @@ def genConst : Gen Ixon := getSize >>= go
         (100, .rprj <$> genRecursorProj),
         (100, .iprj <$> genInductiveProj),
         (100, .dprj <$> genDefinitionProj),
-        (100, .defs <$> genList' genDefinition),
-        (100, .inds <$> genList' genInductive),
+        (100, .defs <$> genList genDefinition),
+        (100, .inds <$> genList genInductive),
         (100, .meta <$> genMetadata),
+        (100, .prof <$> genProof),
+        (100, .eval <$> genEvalClaim),
+        (100, .chck <$> genCheckClaim),
+        (100, .comm <$> genComm),
+        (100, .envn <$> genEnvn),
       ]
 
 structure IxonConst where
@@ -198,6 +224,14 @@ instance : Shrinkable IxonConst where
 instance : SampleableExt IxonConst
   := SampleableExt.mkSelfContained (IxonConst.mk <$> genConst)
 
+-- TODO: useful shrinking
+instance : Shrinkable Claim where
+  shrink _ := []
+
+instance : SampleableExt Claim
+  := SampleableExt.mkSelfContained genClaim
+
+
 /--
 Whether the provided IxonFFI term, reconstructed and serialized in Rust, matches
 the provided bytes.
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 4fc48802..8b0c3a82 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -15,7 +15,7 @@ def main (args: List String) : IO UInt32 := do
     LSpec.lspecIO (.ofList [
       ("aiur", Tests.Aiur.suite),
       ("ffi-consistency", Tests.FFIConsistency.suite),
-      ("byte-array", Tests.ByteArray.suite),
+    ("byte-array", Tests.ByteArray.suite),
       ("ix", Tests.Ix.suite),
       ("keccak", Tests.Keccak.suite),
-    ]) args
+  ]) args

From 4129fb800e718adbec797a3db65c242dedb9b682 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 3 Sep 2025 17:25:40 -0400
Subject: [PATCH 41/74] WIP: Lean -> Rust round-trip serialization test

---
 Ix/Ixon.lean         |  13 +-
 Ix/Ixon/Const.lean   |   8 +
 Tests/Ix.lean        |  15 +-
 Tests/Ix/Ixon.lean   |   3 +-
 src/ixon.rs          | 372 ++++++++++++++++++++++---------------------
 src/ixon/claim.rs    | 145 ++++++++++-------
 src/ixon/tag.rs      | 118 ++++++++++++++
 src/lean/ffi/ixon.rs |  92 ++++++-----
 8 files changed, 486 insertions(+), 280 deletions(-)
 create mode 100644 src/ixon/tag.rs

diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index df161b76..dc851996 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -16,10 +16,10 @@ inductive Ixon where
 | apps : Ixon -> Ixon -> List Ixon -> Ixon    -- 0x3X, funciton application
 | lams : List Ixon -> Ixon -> Ixon            -- 0x4X, lambda abstraction
 | alls : List Ixon -> Ixon -> Ixon            -- 0x5X, universal quantification
-| letE : Bool -> Ixon -> Ixon -> Ixon -> Ixon -- 0x91, 0x92 let expression
 | proj : Address -> UInt64 -> Ixon -> Ixon    -- 0x6X, structure projection
 | strl : String -> Ixon                       -- 0x7X, utf8 string
 | natl : Nat -> Ixon                          -- 0x8X, natural number
+| letE : Bool -> Ixon -> Ixon -> Ixon -> Ixon -- 0x91, 0x92 let expression
 | list : List Ixon -> Ixon                    -- 0xAX, list
 | defn : Definition -> Ixon                   -- 0xB0, definition
 | axio : Axiom -> Ixon                        -- 0xB1, axiom
@@ -35,7 +35,7 @@ inductive Ixon where
 | eval : EvalClaim -> Ixon                    -- 0xE2, cryptographic claim
 | chck : CheckClaim -> Ixon                   -- 0xE3, cryptographic claim
 | comm : Comm -> Ixon                         -- 0xE4, cryptographic commitment
-| envn : Unit -> Ixon                         -- 0xE5, Lean4 environment
+| envn : Env -> Ixon                         -- 0xE5, Lean4 environment
 deriving BEq, Repr, Inhabited
 
 open Serialize
@@ -264,6 +264,11 @@ inductive MetadatumFFI where
 | all : Array NameFFI -> MetadatumFFI
 | mutCtx : Array (Array NameFFI) -> MetadatumFFI
 
+structure EnvFFI where
+  env : Array (Address × Address)
+
+def Env.toFFI (x: Env) : EnvFFI := .mk x.env.toArray
+
 def Metadatum.toFFI : Metadatum → MetadatumFFI
   | .name n => .name n.toFFI
   | .info i => .info i
@@ -299,7 +304,7 @@ inductive IxonFFI where
 | eval : EvalClaim -> IxonFFI
 | chck : CheckClaim -> IxonFFI
 | comm : Comm -> IxonFFI
-| envn : Unit -> IxonFFI
+| envn : EnvFFI -> IxonFFI
 
 def Ixon.toFFI : Ixon → IxonFFI
   | .vari i => .vari i
@@ -330,7 +335,7 @@ def Ixon.toFFI : Ixon → IxonFFI
   | .eval x => .eval x
   | .chck x => .chck x
   | .comm x => .comm x
-  | .envn x => .envn x
+  | .envn x => .envn x.toFFI
 
 end FFI
 
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index a15752da..4385742d 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -191,6 +191,14 @@ structure Comm where
   payload : Address
   deriving BEq, Repr
 
+structure Env where
+  env : List (Address × Address)
+  deriving BEq, Repr
+
+instance : Serialize Env where
+  put x := Serialize.put x.env
+  get := .mk <$> Serialize.get
+
 instance : Serialize Comm where
   put := fun x => Serialize.put (x.secret, x.payload)
   get := (fun (x,y) => .mk x y) <$> Serialize.get
diff --git a/Tests/Ix.lean b/Tests/Ix.lean
index 7ef3605d..0e6272a1 100644
--- a/Tests/Ix.lean
+++ b/Tests/Ix.lean
@@ -53,6 +53,7 @@ def transportConst (x: Ix.Const): Bool :=
     | .error _ _ => .false
   | .error _ _ => .false
 
+
 --def transportExpr' (x: Ix.Expr): Except TransportError Bool :=
 --  match EStateM.run (dematExpr x) emptyDematState with
 --  | .ok ixon stt =>
@@ -61,7 +62,16 @@ def transportConst (x: Ix.Const): Bool :=
 --    | .ok ix _ => .ok (x == ix)
 --    | .error e _ => .error e
 --  | .error e _ => .error e
---
+
+def ffiConst (x: Ixon.IxonConst) : Bool := 
+  let bytes := (Ixon.runPut <| Ixon.Serialize.put x)
+  Ixon.eqLeanRustSerialization x.ixon.toFFI bytes
+
+def ffiExpr (x: Ixon.IxonExpr) : Bool := 
+  let bytes := (Ixon.runPut <| Ixon.Serialize.put x)
+  Ixon.eqLeanRustSerialization x.ixon.toFFI bytes
+
+
 def myConfig : SlimCheck.Configuration where
   numInst := 10000
   maxSize := 100
@@ -87,11 +97,12 @@ def Tests.Ix.suite : List LSpec.TestSeq :=
     check "universe transport" (∀ x : Ix.Level, transportUniv x),
     check "expr serde" (∀ x : Ixon.IxonExpr, serde x),
     check "expr transport" (∀ x : Ix.Expr, transportExpr x),
+    check "expr ffi with Rust" (∀ x : Ixon.IxonExpr, ffiExpr x),
     ----check "axiom serde" (∀ x : Ixon.Axiom, serde x),
     ----check "recursor rule serde" (∀ x : Ixon.RecursorRule, serde x),
     ----check "recursor serde" (∀ x : Ixon.Recursor, serde x),
     ----check "constructor serde" (∀ x : Ixon.Constructor, serde x),
     check "claim serde" (∀ x : Claim, serde x),
-    check "const serde" (∀ x : Ixon.IxonConst, serde x),
+    check "const ffi with Rust" (∀ x : Ixon.IxonConst, ffiConst x),
     --check "const transport" (∀ x : Ix.Const, transportConst x),
   ]
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 6a181528..30934f89 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -1,4 +1,5 @@
 import Ix.Ixon
+import Ix.Claim
 import Ix.Ixon.Serialize
 import Ix.Ixon.Univ
 import LSpec.SlimCheck.Gen
@@ -185,7 +186,7 @@ def genProof: Gen Proof := .mk <$> genClaim <*> (Address.hash <$> genAddress)
 
 def genComm: Gen Comm := .mk <$> genAddress <*> genAddress
 
-def genEnvn: Gen Unit := pure ()
+def genEnvn: Gen Env := .mk <$> genList ((·,·) <$> genAddress <*> genAddress)
 
 def genConst : Gen Ixon := getSize >>= go
   where
diff --git a/src/ixon.rs b/src/ixon.rs
index 5baaef0f..4d7150c7 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -21,38 +21,38 @@ use univ::*;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Ixon {
-    Var(u64),                                   // 0x0X, variables
-    Sort(Box<Univ>),                            // 0xB0, universes
-    Ref(Address, Vec<Univ>),                    // 0x1X, global reference
-    Rec(u64, Vec<Univ>),                        // 0x2X, local const recursion
-    App(Box<Ixon>, Box<Ixon>, Vec<Ixon>),       // 0x3X, applications
-    Lam(Vec<Ixon>, Box<Ixon>),                  // 0x4X, lambdas
-    All(Vec<Ixon>, Box<Ixon>),                  // 0x5X, foralls
-    Proj(Address, u64, Box<Ixon>),              // 0x6X, structure projection
-    Strl(String),                               // 0x7X, unicode string
-    Natl(Nat),                                  // 0x8X, natural numbers
-    Let(bool, Box<Ixon>, Box<Ixon>, Box<Ixon>), // 0xB1, 0xB2, local binder
-    Array(Vec<Ixon>),                           // 0xA, array
-    Defn(Definition),                           // 0xC0, definition
-    Axio(Axiom),                                // 0xC1, axiom
-    Quot(Quotient),                             // 0xC2, quotient
-    CtorProj(ConstructorProj),                  // 0xC3, constructor projection
-    RecrProj(RecursorProj),                     // 0xC4, recursor projection
-    IndcProj(InductiveProj),                    // 0xC5, inductive projection
-    DefnProj(DefinitionProj),                   // 0xC6, definition projection
-    Meta(Metadata),                             // 0xC7, metadata
-    Proof(Proof),                               // 0xC8, zero-knowledge proof
-    Claim(Claim),                               // 0xC9, cryptographic claim
-    Comm(Comm),                                 // 0xCA, cryptographic commitment
-    Env(Env),                                   // 0xCB, multi-claim environment
-    MutDef(Vec<Definition>),                    // 0xDX, mutual definition
-    MutInd(Vec<Inductive>),                     // 0xEX, mutual inductive data
-                                                // unused: 0x9, 0xB3..0xBF, 0xFX
+    Vari(u64),                                   // 0x0X, variables
+    Sort(Box<Univ>),                             // 0x90, universes
+    Refr(Address, Vec<Univ>),                    // 0x1X, global reference
+    Recr(u64, Vec<Univ>),                        // 0x2X, local const recursion
+    Apps(Box<Ixon>, Box<Ixon>, Vec<Ixon>),       // 0x3X, applications
+    Lams(Vec<Ixon>, Box<Ixon>),                  // 0x4X, lambdas
+    Alls(Vec<Ixon>, Box<Ixon>),                  // 0x5X, foralls
+    Proj(Address, u64, Box<Ixon>),               // 0x6X, structure projection
+    Strl(String),                                // 0x7X, unicode string
+    Natl(Nat),                                   // 0x8X, natural numbers
+    LetE(bool, Box<Ixon>, Box<Ixon>, Box<Ixon>), // 0x91, 0x92, local binder
+    List(Vec<Ixon>),                             // 0xA, list
+    Defn(Definition),                            // 0xB0, definition
+    Axio(Axiom),                                 // 0xB1, axiom
+    Quot(Quotient),                              // 0xB2, quotient
+    CPrj(ConstructorProj),                       // 0xB3, constructor projection
+    RPrj(RecursorProj),                          // 0xB4, recursor projection
+    IPrj(InductiveProj),                         // 0xB5, inductive projection
+    DPrj(DefinitionProj),                        // 0xB6, definition projection
+    Inds(Vec<Inductive>),                        // 0xCX, mutual inductive data
+    Defs(Vec<Definition>),                       // 0xDX, mutual definition
+    Meta(Metadata),                              // 0xE0, metadata
+    Prof(Proof),                                 // 0xE1, zero-knowledge proof
+    Eval(EvalClaim),                             // 0xE2, evaluation claim
+    Chck(CheckClaim),                            // 0xE3, typechecking claim
+    Comm(Comm),                                  // 0xE4, cryptographic commitment
+    Envn(Env),                                   // 0xE5, multi-claim environment
 }
 
 impl Default for Ixon {
     fn default() -> Self {
-        Self::Var(0)
+        Self::Vari(0)
     }
 }
 
@@ -160,26 +160,26 @@ impl Ixon {
 impl Serialize for Ixon {
     fn put(&self, buf: &mut Vec<u8>) {
         match self {
-            Self::Var(x) => Self::put_tag(0x0, *x, buf),
+            Self::Vari(x) => Self::put_tag(0x0, *x, buf),
             Self::Sort(x) => {
-                u8::put(&0xB0, buf);
+                u8::put(&0x90, buf);
                 x.put(buf);
             }
-            Self::Ref(addr, lvls) => {
+            Self::Refr(addr, lvls) => {
                 Self::put_tag(0x1, lvls.len() as u64, buf);
                 addr.put(buf);
                 for l in lvls {
                     l.put(buf);
                 }
             }
-            Self::Rec(x, lvls) => {
+            Self::Recr(x, lvls) => {
                 Self::put_tag(0x2, lvls.len() as u64, buf);
                 x.put(buf);
                 for l in lvls {
                     l.put(buf);
                 }
             }
-            Self::App(f, a, args) => {
+            Self::Apps(f, a, args) => {
                 Self::put_tag(0x3, args.len() as u64, buf);
                 f.put(buf);
                 a.put(buf);
@@ -187,14 +187,14 @@ impl Serialize for Ixon {
                     x.put(buf);
                 }
             }
-            Self::Lam(ts, b) => {
+            Self::Lams(ts, b) => {
                 Self::put_tag(0x4, ts.len() as u64, buf);
                 for t in ts {
                     t.put(buf);
                 }
                 b.put(buf);
             }
-            Self::All(ts, b) => {
+            Self::Alls(ts, b) => {
                 Self::put_tag(0x5, ts.len() as u64, buf);
                 for t in ts {
                     t.put(buf);
@@ -216,76 +216,80 @@ impl Serialize for Ixon {
                 Self::put_tag(0x8, bytes.len() as u64, buf);
                 buf.extend_from_slice(&bytes);
             }
-            Self::Let(nd, t, d, b) => {
+            Self::LetE(nd, t, d, b) => {
                 if *nd {
-                    u8::put(&0xB2, buf);
+                    u8::put(&0x91, buf);
                 } else {
-                    u8::put(&0xB1, buf);
+                    u8::put(&0x92, buf);
                 }
                 t.put(buf);
                 d.put(buf);
                 b.put(buf);
             }
-            Self::Array(xs) => Ixon::put_array(xs, buf),
+            Self::List(xs) => Ixon::put_array(xs, buf),
             Self::Defn(x) => {
-                u8::put(&0xC0, buf);
+                u8::put(&0xB0, buf);
                 x.put(buf);
             }
             Self::Axio(x) => {
-                u8::put(&0xC1, buf);
+                u8::put(&0xB1, buf);
                 x.put(buf);
             }
             Self::Quot(x) => {
-                u8::put(&0xC2, buf);
+                u8::put(&0xB2, buf);
                 x.put(buf);
             }
-            Self::CtorProj(x) => {
-                u8::put(&0xC3, buf);
+            Self::CPrj(x) => {
+                u8::put(&0xB3, buf);
                 x.put(buf);
             }
-            Self::RecrProj(x) => {
-                u8::put(&0xC4, buf);
+            Self::RPrj(x) => {
+                u8::put(&0xB4, buf);
                 x.put(buf);
             }
-            Self::IndcProj(x) => {
-                u8::put(&0xC5, buf);
+            Self::IPrj(x) => {
+                u8::put(&0xB5, buf);
                 x.put(buf);
             }
-            Self::DefnProj(x) => {
-                u8::put(&0xC6, buf);
+            Self::DPrj(x) => {
+                u8::put(&0xB6, buf);
                 x.put(buf);
             }
+            Self::Inds(xs) => {
+                Self::put_tag(0xC, xs.len() as u64, buf);
+                for x in xs {
+                    x.put(buf);
+                }
+            }
+            Self::Defs(xs) => {
+                Self::put_tag(0xD, xs.len() as u64, buf);
+                for x in xs {
+                    x.put(buf);
+                }
+            }
             Self::Meta(x) => {
-                u8::put(&0xC7, buf);
+                u8::put(&0xE0, buf);
                 x.put(buf);
             }
-            Self::Proof(x) => {
-                u8::put(&0xC8, buf);
+            Self::Prof(x) => {
+                u8::put(&0xE1, buf);
                 x.put(buf);
             }
-            Self::Claim(x) => {
-                u8::put(&0xC9, buf);
+            Self::Eval(x) => {
+                u8::put(&0xE2, buf);
                 x.put(buf);
             }
-            Self::Comm(x) => {
-                u8::put(&0xCA, buf);
+            Self::Chck(x) => {
+                u8::put(&0xE3, buf);
                 x.put(buf);
             }
-            Self::Env(x) => {
-                u8::put(&0xCB, buf);
+            Self::Comm(x) => {
+                u8::put(&0xE4, buf);
                 x.put(buf);
             }
-            Self::MutDef(xs) => {
-                Self::put_tag(0xD, xs.len() as u64, buf);
-                for x in xs {
-                    x.put(buf);
-                }
-            }
-            Self::MutInd(xs) => {
-                Self::put_tag(0xE, xs.len() as u64, buf);
-                for x in xs {
-                    x.put(buf);
-                }
+            Self::Envn(x) => {
+                u8::put(&0xE5, buf);
+                x.put(buf);
             }
         }
     }
@@ -297,9 +301,9 @@ impl Serialize for Ixon {
         match tag_byte {
             0x00..=0x0F => {
                 let x = Ixon::get_size(is_large, small_size, buf)?;
-                Ok(Self::Var(x))
+                Ok(Self::Vari(x))
             }
-            0xB0 => {
+            0x90 => {
                 let u = Univ::get(buf)?;
                 Ok(Self::Sort(Box::new(u)))
             }
@@ -311,7 +315,7 @@ impl Serialize for Ixon {
                     let l = Univ::get(buf)?;
                     lvls.push(l);
                 }
-                Ok(Self::Ref(a, lvls))
+                Ok(Self::Refr(a, lvls))
             }
             0x20..=0x2F => {
                 let n = Ixon::get_size(is_large, small_size, buf)?;
@@ -321,7 +325,7 @@ impl Serialize for Ixon {
                     let l = Univ::get(buf)?;
                     lvls.push(l);
                 }
-                Ok(Self::Rec(x, lvls))
+                Ok(Self::Recr(x, lvls))
             }
             0x30..=0x3F => {
                 let n = Ixon::get_size(is_large, small_size, buf)?;
@@ -332,7 +336,7 @@ impl Serialize for Ixon {
                     let x = Ixon::get(buf)?;
                     args.push(x);
                 }
-                Ok(Self::App(Box::new(f), Box::new(a), args))
+                Ok(Self::Apps(Box::new(f), Box::new(a), args))
             }
             0x40..=0x4F => {
                 let n = Ixon::get_size(is_large, small_size, buf)?;
@@ -342,7 +346,7 @@ impl Serialize for Ixon {
                     ts.push(x);
                 }
                 let b = Ixon::get(buf)?;
-                Ok(Self::Lam(ts, Box::new(b)))
+                Ok(Self::Lams(ts, Box::new(b)))
             }
             0x50..=0x5F => {
                 let n = Ixon::get_size(is_large, small_size, buf)?;
@@ -352,7 +356,7 @@ impl Serialize for Ixon {
                     ts.push(x);
                 }
                 let b = Ixon::get(buf)?;
-                Ok(Self::All(ts, Box::new(b)))
+                Ok(Self::Alls(ts, Box::new(b)))
             }
             0x60..=0x6F => {
                 let n = Ixon::get_size(is_large, small_size, buf)?;
@@ -383,12 +387,12 @@ impl Serialize for Ixon {
                     None => Err("get Expr Natl EOF".to_string()),
                 }
             }
-            0xB1..=0xB2 => {
-                let nd = tag_byte == 0xB2;
+            0x91..=0x92 => {
+                let nd = tag_byte == 0x91;
                 let t = Ixon::get(buf)?;
                 let d = Ixon::get(buf)?;
                 let b = Ixon::get(buf)?;
-                Ok(Self::Let(nd, Box::new(t), Box::new(d), Box::new(b)))
+                Ok(Self::LetE(nd, Box::new(t), Box::new(d), Box::new(b)))
             }
             0xA0..=0xAF => {
                 let len = Self::get_size(is_large, small_size, buf)?;
@@ -397,38 +401,39 @@ impl Serialize for Ixon {
                     let s = Ixon::get(buf)?;
                     vec.push(s);
                 }
-                Ok(Self::Array(vec))
-            }
-            0xC0 => Ok(Self::Defn(Definition::get(buf)?)),
-            0xC1 => Ok(Self::Axio(Axiom::get(buf)?)),
-            0xC2 => Ok(Self::Quot(Quotient::get(buf)?)),
-            0xC3 => Ok(Self::CtorProj(ConstructorProj::get(buf)?)),
-            0xC4 => Ok(Self::RecrProj(RecursorProj::get(buf)?)),
-            0xC5 => Ok(Self::IndcProj(InductiveProj::get(buf)?)),
-            0xC6 => Ok(Self::DefnProj(DefinitionProj::get(buf)?)),
-            0xC7 => Ok(Self::Meta(Metadata::get(buf)?)),
-            0xC8 => Ok(Self::Proof(Proof::get(buf)?)),
-            0xC9 => Ok(Self::Claim(Claim::get(buf)?)),
-            0xCA => Ok(Self::Comm(Comm::get(buf)?)),
-            0xCB => Ok(Self::Env(Env::get(buf)?)),
-            0xD0..=0xDF => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let mut defs = Vec::new();
-                for _ in 0..n {
-                    let x = Definition::get(buf)?;
-                    defs.push(x);
-                }
-                Ok(Self::MutDef(defs))
+                Ok(Self::List(vec))
             }
-            0xE0..=0xEF => {
+            0xB0 => Ok(Self::Defn(Definition::get(buf)?)),
+            0xB1 => Ok(Self::Axio(Axiom::get(buf)?)),
+            0xB2 => Ok(Self::Quot(Quotient::get(buf)?)),
+            0xB3 => Ok(Self::CPrj(ConstructorProj::get(buf)?)),
+            0xB4 => Ok(Self::RPrj(RecursorProj::get(buf)?)),
+            0xB5 => Ok(Self::IPrj(InductiveProj::get(buf)?)),
+            0xB6 => Ok(Self::DPrj(DefinitionProj::get(buf)?)),
+            0xC0..=0xCF => {
                 let n = Ixon::get_size(is_large, small_size, buf)?;
                 let mut inds = Vec::new();
                 for _ in 0..n {
                     let x = Inductive::get(buf)?;
                     inds.push(x);
                 }
-                Ok(Self::MutInd(inds))
+                Ok(Self::Inds(inds))
             }
+            0xD0..=0xDF => {
+                let n = Ixon::get_size(is_large, small_size, buf)?;
+                let mut defs = Vec::new();
+                for _ in 0..n {
+                    let x = Definition::get(buf)?;
+                    defs.push(x);
+                }
+                Ok(Self::Defs(defs))
+            }
+            0xE0 => Ok(Self::Meta(Metadata::get(buf)?)),
+            0xE1 => Ok(Self::Prof(Proof::get(buf)?)),
+            0xE2 => Ok(Self::Eval(EvalClaim::get(buf)?)),
+            0xE3 => Ok(Self::Chck(CheckClaim::get(buf)?)),
+            0xE4 => Ok(Self::Comm(Comm::get(buf)?)),
+            0xE5 => Ok(Self::Envn(Env::get(buf)?)),
             x => Err(format!("get Ixon invalid tag {x}")),
         }
     }
@@ -541,32 +546,33 @@ pub mod tests {
 
     #[derive(Debug, Clone, Copy)]
     pub enum IxonCase {
-        Var,
+        Vari,
         Sort,
-        Ref,
-        Rec,
-        App,
-        Lam,
-        All,
+        Refr,
+        Recr,
+        Apps,
+        Lams,
+        Alls,
         Proj,
         Strl,
         Natl,
-        Let,
-        Array,
+        LetE,
+        List,
         Defn,
         Axio,
         Quot,
-        CtorProj,
-        RecrProj,
-        IndcProj,
-        DefnProj,
+        CPrj,
+        RPrj,
+        IPrj,
+        DPrj,
+        Defs,
+        Inds,
         Meta,
-        Proof,
-        Claim,
+        Prof,
+        Eval,
+        Chck,
         Comm,
-        Env,
-        MutDef,
-        MutInd,
+        Envn,
     }
 
     pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
@@ -579,44 +585,45 @@ pub mod tests {
 
     // incremental tree generation without recursion stack overflows
     pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
-        let mut root = Ixon::Var(0);
+        let mut root = Ixon::Vari(0);
         let mut stack = vec![&mut root as *mut Ixon];
 
         while let Some(ptr) = stack.pop() {
             let gens: Vec<(usize, IxonCase)> = vec![
-                (100, IxonCase::Var),
+                (100, IxonCase::Vari),
                 (100, IxonCase::Sort),
-                (15, IxonCase::Ref),
-                (15, IxonCase::Rec),
-                (15, IxonCase::App),
-                (15, IxonCase::Lam),
-                (15, IxonCase::All),
-                (50, IxonCase::Let),
+                (15, IxonCase::Refr),
+                (15, IxonCase::Recr),
+                (15, IxonCase::Apps),
+                (15, IxonCase::Lams),
+                (15, IxonCase::Alls),
+                (20, IxonCase::LetE),
                 (50, IxonCase::Proj),
                 (100, IxonCase::Strl),
                 (100, IxonCase::Natl),
-                (10, IxonCase::Array),
+                (10, IxonCase::List),
                 (100, IxonCase::Defn),
                 (100, IxonCase::Axio),
                 (100, IxonCase::Quot),
-                (100, IxonCase::CtorProj),
-                (100, IxonCase::RecrProj),
-                (100, IxonCase::IndcProj),
-                (100, IxonCase::DefnProj),
+                (100, IxonCase::CPrj),
+                (100, IxonCase::RPrj),
+                (100, IxonCase::IPrj),
+                (100, IxonCase::DPrj),
+                (15, IxonCase::Inds),
+                (15, IxonCase::Defs),
                 (100, IxonCase::Meta),
-                (100, IxonCase::Proof),
-                (100, IxonCase::Claim),
+                (100, IxonCase::Prof),
+                (100, IxonCase::Eval),
+                (100, IxonCase::Chck),
                 (100, IxonCase::Comm),
-                (100, IxonCase::Env),
-                (15, IxonCase::MutDef),
-                (15, IxonCase::MutInd),
+                (100, IxonCase::Envn),
             ];
 
             match next_case(g, &gens) {
-                IxonCase::Var => {
+                IxonCase::Vari => {
                     let x: u64 = Arbitrary::arbitrary(g);
                     unsafe {
-                        ptr::replace(ptr, Ixon::Var(x));
+                        ptr::replace(ptr, Ixon::Vari(x));
                     }
                 }
                 IxonCase::Sort => {
@@ -625,27 +632,27 @@ pub mod tests {
                         ptr::replace(ptr, Ixon::Sort(Box::new(u)));
                     }
                 }
-                IxonCase::Ref => {
+                IxonCase::Refr => {
                     let addr = Address::arbitrary(g);
                     let mut lvls = vec![];
                     for _ in 0..gen_range(g, 0..9) {
                         lvls.push(arbitrary_univ(g, ctx));
                     }
                     unsafe {
-                        ptr::replace(ptr, Ixon::Ref(addr, lvls));
+                        ptr::replace(ptr, Ixon::Refr(addr, lvls));
                     }
                 }
-                IxonCase::Rec => {
+                IxonCase::Recr => {
                     let n = u64::arbitrary(g);
                     let mut lvls = vec![];
                     for _ in 0..gen_range(g, 0..9) {
                         lvls.push(arbitrary_univ(g, ctx));
                     }
                     unsafe {
-                        ptr::replace(ptr, Ixon::Rec(n, lvls));
+                        ptr::replace(ptr, Ixon::Recr(n, lvls));
                     }
                 }
-                IxonCase::App => {
+                IxonCase::Apps => {
                     let mut f_box = Box::new(Ixon::default());
                     let f_ptr: *mut Ixon = &mut *f_box;
                     stack.push(f_ptr);
@@ -656,19 +663,19 @@ pub mod tests {
 
                     let n = gen_range(g, 0..9);
                     let mut xs: Vec<Ixon> = Vec::with_capacity(n);
-                    xs.resize(n, Ixon::Var(0));
+                    xs.resize(n, Ixon::Vari(0));
                     for i in 0..n {
                         let p = unsafe { xs.as_mut_ptr().add(i) };
                         stack.push(p);
                     }
                     unsafe {
-                        std::ptr::replace(ptr, Ixon::App(f_box, a_box, xs));
+                        std::ptr::replace(ptr, Ixon::Apps(f_box, a_box, xs));
                     }
                 }
-                IxonCase::Lam => {
+                IxonCase::Lams => {
                     let n = gen_range(g, 0..9);
                     let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-                    ts.resize(n, Ixon::Var(0));
+                    ts.resize(n, Ixon::Vari(0));
                     for i in 0..n {
                         let p = unsafe { ts.as_mut_ptr().add(i) };
                         stack.push(p);
@@ -677,13 +684,13 @@ pub mod tests {
                     let b_ptr: *mut Ixon = &mut *b_box;
                     stack.push(b_ptr);
                     unsafe {
-                        std::ptr::replace(ptr, Ixon::Lam(ts, b_box));
+                        std::ptr::replace(ptr, Ixon::Lams(ts, b_box));
                     }
                 }
-                IxonCase::All => {
+                IxonCase::Alls => {
                     let n = gen_range(g, 0..9);
                     let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-                    ts.resize(n, Ixon::Var(0));
+                    ts.resize(n, Ixon::Vari(0));
                     for i in 0..n {
                         let p = unsafe { ts.as_mut_ptr().add(i) };
                         stack.push(p);
@@ -692,10 +699,10 @@ pub mod tests {
                     let b_ptr: *mut Ixon = &mut *b_box;
                     stack.push(b_ptr);
                     unsafe {
-                        std::ptr::replace(ptr, Ixon::All(ts, b_box));
+                        std::ptr::replace(ptr, Ixon::Alls(ts, b_box));
                     }
                 }
-                IxonCase::Let => {
+                IxonCase::LetE => {
                     let nd = bool::arbitrary(g);
                     let mut t_box = Box::new(Ixon::default());
                     let t_ptr: *mut Ixon = &mut *t_box;
@@ -707,7 +714,7 @@ pub mod tests {
                     let b_ptr: *mut Ixon = &mut *b_box;
                     stack.push(b_ptr);
                     unsafe {
-                        ptr::replace(ptr, Ixon::Let(nd, t_box, d_box, b_box));
+                        ptr::replace(ptr, Ixon::LetE(nd, t_box, d_box, b_box));
                     }
                 }
                 IxonCase::Proj => {
@@ -730,16 +737,16 @@ pub mod tests {
                         ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
                     }
                 }
-                IxonCase::Array => {
+                IxonCase::List => {
                     let n = gen_range(g, 0..9);
                     let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-                    ts.resize(n, Ixon::Var(0));
+                    ts.resize(n, Ixon::Vari(0));
                     for i in 0..n {
                         let p = unsafe { ts.as_mut_ptr().add(i) };
                         stack.push(p);
                     }
                     unsafe {
-                        std::ptr::replace(ptr, Ixon::Array(ts));
+                        std::ptr::replace(ptr, Ixon::List(ts));
                     }
                 }
                 IxonCase::Quot => unsafe {
@@ -751,40 +758,43 @@ pub mod tests {
                 IxonCase::Defn => unsafe {
                     std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
                 },
-                IxonCase::CtorProj => unsafe {
-                    std::ptr::replace(ptr, Ixon::CtorProj(ConstructorProj::arbitrary(g)));
+                IxonCase::CPrj => unsafe {
+                    std::ptr::replace(ptr, Ixon::CPrj(ConstructorProj::arbitrary(g)));
+                },
+                IxonCase::RPrj => unsafe {
+                    std::ptr::replace(ptr, Ixon::RPrj(RecursorProj::arbitrary(g)));
                 },
-                IxonCase::RecrProj => unsafe {
-                    std::ptr::replace(ptr, Ixon::RecrProj(RecursorProj::arbitrary(g)));
+                IxonCase::DPrj => unsafe {
+                    std::ptr::replace(ptr, Ixon::DPrj(DefinitionProj::arbitrary(g)));
                 },
-                IxonCase::DefnProj => unsafe {
-                    std::ptr::replace(ptr, Ixon::DefnProj(DefinitionProj::arbitrary(g)));
+                IxonCase::IPrj => unsafe {
+                    std::ptr::replace(ptr, Ixon::IPrj(InductiveProj::arbitrary(g)));
                 },
-                IxonCase::IndcProj => unsafe {
-                    std::ptr::replace(ptr, Ixon::IndcProj(InductiveProj::arbitrary(g)));
+                IxonCase::Inds => unsafe {
+                    let inds = gen_vec(g, 9, Inductive::arbitrary);
+                    std::ptr::replace(ptr, Ixon::Inds(inds));
+                },
+                IxonCase::Defs => unsafe {
+                    let defs = gen_vec(g, 9, Definition::arbitrary);
+                    std::ptr::replace(ptr, Ixon::Defs(defs));
                 },
                 IxonCase::Meta => unsafe {
                     std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
                 },
-                IxonCase::Proof => unsafe {
-                    std::ptr::replace(ptr, Ixon::Proof(Proof::arbitrary(g)));
+                IxonCase::Prof => unsafe {
+                    std::ptr::replace(ptr, Ixon::Prof(Proof::arbitrary(g)));
                 },
-                IxonCase::Claim => unsafe {
-                    std::ptr::replace(ptr, Ixon::Claim(Claim::arbitrary(g)));
+                IxonCase::Eval => unsafe {
+                    std::ptr::replace(ptr, Ixon::Eval(EvalClaim::arbitrary(g)));
+                },
+                IxonCase::Chck => unsafe {
+                    std::ptr::replace(ptr, Ixon::Chck(CheckClaim::arbitrary(g)));
                 },
                 IxonCase::Comm => unsafe {
                     std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
                 },
-                IxonCase::Env => unsafe {
-                    std::ptr::replace(ptr, Ixon::Env(Env::arbitrary(g)));
-                },
-                IxonCase::MutDef => unsafe {
-                    let defs = gen_vec(g, 9, Definition::arbitrary);
-                    std::ptr::replace(ptr, Ixon::MutDef(defs));
-                },
-                IxonCase::MutInd => unsafe {
-                    let inds = gen_vec(g, 9, Inductive::arbitrary);
-                    std::ptr::replace(ptr, Ixon::MutInd(inds));
+                IxonCase::Envn => unsafe {
+                    std::ptr::replace(ptr, Ixon::Envn(Env::arbitrary(g)));
                 },
             }
         }
diff --git a/src/ixon/claim.rs b/src/ixon/claim.rs
index 0e90b1d6..377f3af2 100644
--- a/src/ixon/claim.rs
+++ b/src/ixon/claim.rs
@@ -1,19 +1,25 @@
 use crate::ixon::address::Address;
 use crate::ixon::serialize::Serialize;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EvalClaim {
+    pub lvls: Address,
+    pub typ: Address,
+    pub input: Address,
+    pub output: Address,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CheckClaim {
+    pub lvls: Address,
+    pub typ: Address,
+    pub value: Address,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Claim {
-    Checks {
-        lvls: Address,
-        typ: Address,
-        value: Address,
-    },
-    Evals {
-        lvls: Address,
-        typ: Address,
-        input: Address,
-        output: Address,
-    },
+    Checks(CheckClaim),
+    Evals(EvalClaim),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -24,29 +30,56 @@ pub struct Proof {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Env {
-    env: Vec<(Address, Address)>,
+    pub env: Vec<(Address, Address)>,
+}
+
+impl Serialize for EvalClaim {
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.input.put(buf);
+        self.output.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Address::get(buf)?;
+        let typ = Address::get(buf)?;
+        let input = Address::get(buf)?;
+        let output = Address::get(buf)?;
+        Ok(Self {
+            lvls,
+            typ,
+            input,
+            output,
+        })
+    }
+}
+
+impl Serialize for CheckClaim {
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.value.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Address::get(buf)?;
+        let typ = Address::get(buf)?;
+        let value = Address::get(buf)?;
+        Ok(Self { lvls, typ, value })
+    }
 }
 
 impl Serialize for Claim {
     fn put(&self, buf: &mut Vec<u8>) {
         match self {
-            Self::Checks { lvls, typ, value } => {
-                buf.push(0);
-                lvls.put(buf);
-                typ.put(buf);
-                value.put(buf);
+            Self::Evals(x) => {
+                u8::put(&0xE2, buf);
+                x.put(buf)
             }
-            Self::Evals {
-                lvls,
-                typ,
-                input,
-                output,
-            } => {
-                buf.push(1);
-                lvls.put(buf);
-                typ.put(buf);
-                input.put(buf);
-                output.put(buf);
+            Self::Checks(x) => {
+                u8::put(&0xE3, buf);
+                x.put(buf)
             }
         }
     }
@@ -56,23 +89,13 @@ impl Serialize for Claim {
             Some((head, rest)) => {
                 *buf = rest;
                 match head[0] {
-                    0 => {
-                        let lvls = Address::get(buf)?;
-                        let typ = Address::get(buf)?;
-                        let value = Address::get(buf)?;
-                        Ok(Self::Checks { lvls, typ, value })
+                    0xE2 => {
+                        let x = EvalClaim::get(buf)?;
+                        Ok(Self::Evals(x))
                     }
-                    1 => {
-                        let lvls = Address::get(buf)?;
-                        let typ = Address::get(buf)?;
-                        let input = Address::get(buf)?;
-                        let output = Address::get(buf)?;
-                        Ok(Self::Evals {
-                            lvls,
-                            typ,
-                            input,
-                            output,
-                        })
+                    0xE3 => {
+                        let x = CheckClaim::get(buf)?;
+                        Ok(Self::Checks(x))
                     }
                     x => Err(format!("get Claim invalid {x}")),
                 }
@@ -113,21 +136,33 @@ mod tests {
     use crate::ixon::tests::gen_range;
     use quickcheck::{Arbitrary, Gen};
 
+    impl Arbitrary for EvalClaim {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Address::arbitrary(g),
+                typ: Address::arbitrary(g),
+                input: Address::arbitrary(g),
+                output: Address::arbitrary(g),
+            }
+        }
+    }
+
+    impl Arbitrary for CheckClaim {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Address::arbitrary(g),
+                typ: Address::arbitrary(g),
+                value: Address::arbitrary(g),
+            }
+        }
+    }
+
     impl Arbitrary for Claim {
         fn arbitrary(g: &mut Gen) -> Self {
             let x = gen_range(g, 0..1);
             match x {
-                0 => Self::Checks {
-                    lvls: Address::arbitrary(g),
-                    typ: Address::arbitrary(g),
-                    value: Address::arbitrary(g),
-                },
-                _ => Self::Evals {
-                    lvls: Address::arbitrary(g),
-                    typ: Address::arbitrary(g),
-                    input: Address::arbitrary(g),
-                    output: Address::arbitrary(g),
-                },
+                0 => Self::Evals(EvalClaim::arbitrary(g)),
+                _ => Self::Checks(CheckClaim::arbitrary(g)),
             }
         }
     }
diff --git a/src/ixon/tag.rs b/src/ixon/tag.rs
new file mode 100644
index 00000000..37731901
--- /dev/null
+++ b/src/ixon/tag.rs
@@ -0,0 +1,118 @@
+use crate::ixon::serialize::Serialize;
+
+pub fn u64_byte_count(x: u64) -> u8 {
+  match x {
+    0 => 0,
+    x if x < 0x0000000000000100 => 1,
+    x if x < 0x0000000000010000 => 2,
+    x if x < 0x0000000001000000 => 3,
+    x if x < 0x0000000100000000 => 4,
+    x if x < 0x0000010000000000 => 5,
+    x if x < 0x0001000000000000 => 6,
+    x if x < 0x0100000000000000 => 7,
+    _ => 8,
+  }
+}
+
+pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
+  let n = u64_byte_count(x) as usize;
+  buf.extend_from_slice(&x.to_le_bytes()[..n])
+}
+
+pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
+  let mut res = [0u8; 8];
+  if len > 8 {
+    return Err("get trimmed_le_64 len > 8".to_string());
+  }
+  match buf.split_at_checked(len) {
+    Some((head, rest)) => {
+      *buf = rest;
+      res[..len].copy_from_slice(head);
+      Ok(u64::from_le_bytes(res))
+    },
+    None => Err("get trimmed_le_u64 EOF".to_string()),
+  }
+}
+
+//  F := flag, L := large-bit, X := small-field, A := large_field
+// 0xFFLX_XXXX {AAAA_AAAA, ...}
+#[derive(Clone, Debug)]
+pub struct Tag2 {
+  flag: u8,
+  size: u64,
+}
+
+impl Tag2 {
+  pub fn encode_head(&self) -> u8 {
+    if self.size < 32 {
+      (self.flag << 6) + (self.size as u8)
+    } else {
+      (self.flag << 6) + 0b10_0000 + u64_byte_count(self.size) - 1
+    }
+  }
+  pub fn decode_head(head: u8) -> (u8, bool, u8) {
+    (head >> 6, head & 0b10_0000 == 0, head % 0b10_0000)
+  }
+}
+
+impl Serialize for Tag2 {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.encode_head().put(buf);
+    if self.size >= 32 {
+      u64_put_trimmed_le(self.size, buf)
+    }
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let head = u8::get(buf)?;
+    let (flag, large, small) = Tag2::decode_head(head);
+    let size = if large {
+      u64_get_trimmed_le((small + 1) as usize, buf)?
+    } else {
+      small as u64
+    };
+    Ok(Tag2 { flag, size })
+  }
+}
+
+//  F := flag, L := large-bit, X := small-field, A := large_field
+// 0xFFFF_LXXX {AAAA_AAAA, ...}
+// "Tag" means the whole thing
+// "Head" means the first byte of the tag
+// "Flag" means the first nibble of the head
+#[derive(Clone, Debug)]
+pub struct Tag4 {
+  flag: u8,
+  size: u64,
+}
+
+impl Tag4 {
+  pub fn encode_head(&self) -> u8 {
+    if self.size < 8 {
+      (self.flag << 4) + (self.size as u8)
+    } else {
+      (self.flag << 4) + 0b1000 + u64_byte_count(self.size) - 1
+    }
+  }
+  pub fn decode_head(head: u8) -> (u8, bool, u8) {
+    (head >> 4, head & 0b1000 == 0, head % 0b1000)
+  }
+}
+
+impl Serialize for Tag4 {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.encode_head().put(buf);
+    if self.size >= 8 {
+      u64_put_trimmed_le(self.size, buf)
+    }
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let head = u8::get(buf)?;
+    let (flag, large, small) = Tag4::decode_head(head);
+    let size = if large {
+      u64_get_trimmed_le((small + 1) as usize, buf)?
+    } else {
+      small as u64
+    };
+    Ok(Tag4 { flag, size })
+  }
+}
diff --git a/src/lean/ffi/ixon.rs b/src/lean/ffi/ixon.rs
index 96acde67..71db74d8 100644
--- a/src/lean/ffi/ixon.rs
+++ b/src/lean/ffi/ixon.rs
@@ -6,7 +6,7 @@ use crate::{
     ixon::{
         Ixon,
         address::Address,
-        claim::{Claim, Proof},
+        claim::{CheckClaim, Claim, Env, EvalClaim, Proof},
         constant::{
             Axiom, Comm, Constructor, ConstructorProj, DefKind, DefSafety, Definition,
             DefinitionProj, Inductive, InductiveProj, QuotKind, Quotient, Recursor, RecursorProj,
@@ -57,6 +57,7 @@ fn lean_ctor_to_univ(ctor: &LeanCtorObject) -> Univ {
     }
 }
 
+// FIXME
 fn lean_ptr_to_address(ptr: *const c_void) -> Address {
     let sarray: &LeanSArrayObject = as_ref_unsafe(ptr.cast());
     let hash = Hash::from_slice(sarray.data()).unwrap();
@@ -95,7 +96,7 @@ fn lean_ptr_to_definition(ptr: *const c_void) -> Definition {
     Definition {
         lvls,
         typ,
-        mode: mode,
+        mode,
         value,
         safety,
     }
@@ -230,7 +231,9 @@ fn lean_ptr_to_name_parts(ptr: *const c_void) -> Vec<NamePart> {
 fn lean_ptr_to_name(ptr: *const c_void) -> Name {
     let parts = lean_ptr_to_name_parts(ptr);
     // Is `parts` reversed?
-    Name { parts }
+    Name {
+        parts: parts.into_iter().rev().collect(),
+    }
 }
 
 fn lean_ptr_to_metadatum(ptr: *const c_void) -> Metadatum {
@@ -298,10 +301,17 @@ fn lean_ptr_to_metadata_entry(ptr: *const c_void) -> (Nat, Vec<Metadatum>) {
     (fst, snd)
 }
 
-fn lean_ptr_to_eval_claim(ptr: *const c_void) -> Claim {
+// FIXME
+fn lean_ptr_to_env_entry(ptr: *const c_void) -> (Address, Address) {
+    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+    let [fst, snd] = ctor.objs().map(lean_ptr_to_address);
+    (fst, snd)
+}
+
+fn lean_ptr_to_eval_claim(ptr: *const c_void) -> EvalClaim {
     let evals: &LeanCtorObject = as_ref_unsafe(ptr.cast());
     let [lvls, input, output, typ] = evals.objs().map(lean_ptr_to_address);
-    Claim::Evals {
+    EvalClaim {
         lvls,
         typ,
         input,
@@ -309,10 +319,10 @@ fn lean_ptr_to_eval_claim(ptr: *const c_void) -> Claim {
     }
 }
 
-fn lean_ptr_to_check_claim(ptr: *const c_void) -> Claim {
+fn lean_ptr_to_check_claim(ptr: *const c_void) -> CheckClaim {
     let checks: &LeanCtorObject = as_ref_unsafe(ptr.cast());
     let [lvls, typ, value] = checks.objs().map(lean_ptr_to_address);
-    Claim::Checks { lvls, typ, value }
+    CheckClaim { lvls, typ, value }
 }
 
 fn lean_ptr_to_ixon(ptr: *const c_void) -> Ixon {
@@ -323,7 +333,7 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
     match ctor.tag() {
         0 => {
             let [idx] = ctor.objs();
-            Ixon::Var(idx as u64)
+            Ixon::Vari(idx as u64)
         }
         1 => {
             let [univ_ptr] = ctor.objs();
@@ -333,11 +343,11 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
         2 => {
             let [addr_ptr, univs_ptr] = ctor.objs();
             let addr = lean_ptr_to_address(addr_ptr);
-            Ixon::Ref(addr, lean_ptr_to_univs(univs_ptr))
+            Ixon::Refr(addr, lean_ptr_to_univs(univs_ptr))
         }
         3 => {
             let [univs_ptr, idx] = ctor.objs();
-            Ixon::Rec(idx as u64, lean_ptr_to_univs(univs_ptr))
+            Ixon::Recr(idx as u64, lean_ptr_to_univs(univs_ptr))
         }
         4 => {
             let [f, x, xs] = ctor.objs();
@@ -345,48 +355,48 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let x = lean_ptr_to_ixon(x).into();
             let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
             let xs = xs_array.to_vec(lean_ptr_to_ixon);
-            Ixon::App(f, x, xs)
+            Ixon::Apps(f, x, xs)
         }
         5 => {
             let [xs, x] = ctor.objs();
             let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
             let xs = xs_array.to_vec(lean_ptr_to_ixon);
             let x = lean_ptr_to_ixon(x);
-            Ixon::Lam(xs, x.into())
+            Ixon::Lams(xs, x.into())
         }
         6 => {
             let [xs, x] = ctor.objs();
             let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
             let xs = xs_array.to_vec(lean_ptr_to_ixon);
             let x = lean_ptr_to_ixon(x).into();
-            Ixon::All(xs, x)
+            Ixon::Alls(xs, x)
         }
         7 => {
-            let [v, t, b, x] = ctor.objs();
-            let v = lean_ptr_to_ixon(v).into();
-            let t = lean_ptr_to_ixon(t).into();
-            let b = lean_ptr_to_ixon(b).into();
-            Ixon::Let(x as usize == 1, v, t, b)
-        }
-        8 => {
             let [addr_ptr, ptr, idx] = ctor.objs();
             let addr = lean_ptr_to_address(addr_ptr);
             let term = lean_ptr_to_ixon(ptr).into();
             Ixon::Proj(addr, idx as u64, term)
         }
-        9 => {
+        8 => {
             let [str_ptr] = ctor.objs();
             let str: &LeanStringObject = as_ref_unsafe(str_ptr.cast());
             Ixon::Strl(str.as_string())
         }
-        10 => {
+        9 => {
             let [nat_bytes_ptr] = ctor.objs();
             Ixon::Natl(lean_ptr_to_nat(nat_bytes_ptr))
         }
+        10 => {
+            let [v, t, b, x] = ctor.objs();
+            let v = lean_ptr_to_ixon(v).into();
+            let t = lean_ptr_to_ixon(t).into();
+            let b = lean_ptr_to_ixon(b).into();
+            Ixon::LetE(x as usize == 1, v, t, b)
+        }
         11 => {
             let [xs] = ctor.objs();
             let xs: &LeanArrayObject = as_ref_unsafe(xs.cast());
-            Ixon::Array(xs.to_vec(lean_ptr_to_ixon))
+            Ixon::List(xs.to_vec(lean_ptr_to_ixon))
         }
         12 => {
             let [defn_ptr] = ctor.objs();
@@ -427,7 +437,7 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let block = lean_ptr_to_address(block);
             let idx = lean_ptr_to_nat(idx);
             let cidx = lean_ptr_to_nat(cidx);
-            Ixon::CtorProj(ConstructorProj { block, idx, cidx })
+            Ixon::CPrj(ConstructorProj { block, idx, cidx })
         }
         16 => {
             let [rprj_ptr] = ctor.objs();
@@ -436,7 +446,7 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let block = lean_ptr_to_address(block);
             let idx = lean_ptr_to_nat(idx);
             let ridx = lean_ptr_to_nat(ridx);
-            Ixon::RecrProj(RecursorProj { block, idx, ridx })
+            Ixon::RPrj(RecursorProj { block, idx, ridx })
         }
         17 => {
             let [iprj_ptr] = ctor.objs();
@@ -444,7 +454,7 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let [block, idx] = iprj_ctor.objs();
             let block = lean_ptr_to_address(block);
             let idx = lean_ptr_to_nat(idx);
-            Ixon::IndcProj(InductiveProj { block, idx })
+            Ixon::IPrj(InductiveProj { block, idx })
         }
         18 => {
             let [dprj_ptr] = ctor.objs();
@@ -452,19 +462,19 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let [block, idx] = dprj_ctor.objs();
             let block = lean_ptr_to_address(block);
             let idx = lean_ptr_to_nat(idx);
-            Ixon::DefnProj(DefinitionProj { block, idx })
+            Ixon::DPrj(DefinitionProj { block, idx })
         }
         19 => {
             let [inds_ptr] = ctor.objs();
             let inds: &LeanArrayObject = as_ref_unsafe(inds_ptr.cast());
             let inds = inds.to_vec(lean_ptr_to_inductive);
-            Ixon::MutInd(inds)
+            Ixon::Inds(inds)
         }
         20 => {
             let [defs_ptr] = ctor.objs();
             let defs: &LeanArrayObject = as_ref_unsafe(defs_ptr.cast());
             let defs = defs.to_vec(lean_ptr_to_definition);
-            Ixon::MutDef(defs)
+            Ixon::Defs(defs)
         }
         21 => {
             let [pairs_ptr] = ctor.objs();
@@ -479,28 +489,28 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let claim: &LeanCtorObject = as_ref_unsafe(claim.cast());
             let claim = match claim.tag() {
                 0 => {
-                    let [checks] = claim.objs();
-                    lean_ptr_to_check_claim(checks)
+                    let [evals] = claim.objs();
+                    Claim::Evals(lean_ptr_to_eval_claim(evals))
                 }
                 1 => {
-                    let [evals] = claim.objs();
-                    lean_ptr_to_eval_claim(evals)
+                    let [checks] = claim.objs();
+                    Claim::Checks(lean_ptr_to_check_claim(checks))
                 }
                 _ => unreachable!(),
             };
             let bin: &LeanSArrayObject = as_ref_unsafe(bin.cast());
-            Ixon::Proof(Proof {
+            Ixon::Prof(Proof {
                 claim,
                 proof: bin.data().to_vec(),
             })
         }
         23 => {
             let [evals] = ctor.objs();
-            Ixon::Claim(lean_ptr_to_eval_claim(evals))
+            Ixon::Eval(lean_ptr_to_eval_claim(evals))
         }
         24 => {
             let [checks] = ctor.objs();
-            Ixon::Claim(lean_ptr_to_check_claim(checks))
+            Ixon::Chck(lean_ptr_to_check_claim(checks))
         }
         25 => {
             let [comm] = ctor.objs();
@@ -508,7 +518,15 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let [secret, payload] = comm.objs().map(lean_ptr_to_address);
             Ixon::Comm(Comm { secret, payload })
         }
-        26 => todo!("Env"),
+        // FIXME
+        26 => {
+            let [env_ptr] = ctor.objs();
+            let env: &LeanCtorObject = as_ref_unsafe(env_ptr.cast());
+            let [map_ptr] = env.objs();
+            let map: &LeanArrayObject = as_ref_unsafe(map_ptr.cast());
+            let env = map.to_vec(lean_ptr_to_env_entry);
+            Ixon::Envn(Env { env })
+        }
         _ => unreachable!(),
     }
 }

From 160489ff667e98f201f70b08d0b10160dc86e2e1 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Wed, 3 Sep 2025 22:39:07 -0300
Subject: [PATCH 42/74] fix FFI

---
 Ix/Ixon.lean         | 13 ++++---------
 src/lean/ffi/ixon.rs | 16 ++++------------
 src/lean/string.rs   |  2 +-
 3 files changed, 9 insertions(+), 22 deletions(-)

diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index dc851996..798e7eba 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -264,11 +264,6 @@ inductive MetadatumFFI where
 | all : Array NameFFI -> MetadatumFFI
 | mutCtx : Array (Array NameFFI) -> MetadatumFFI
 
-structure EnvFFI where
-  env : Array (Address × Address)
-
-def Env.toFFI (x: Env) : EnvFFI := .mk x.env.toArray
-
 def Metadatum.toFFI : Metadatum → MetadatumFFI
   | .name n => .name n.toFFI
   | .info i => .info i
@@ -285,10 +280,10 @@ inductive IxonFFI where
 | apps : IxonFFI -> IxonFFI -> Array IxonFFI -> IxonFFI
 | lams : Array IxonFFI -> IxonFFI -> IxonFFI
 | alls : Array IxonFFI -> IxonFFI -> IxonFFI
-| letE : Bool -> IxonFFI -> IxonFFI -> IxonFFI -> IxonFFI
 | proj : Address -> UInt64 -> IxonFFI -> IxonFFI
 | strl : String -> IxonFFI
 | natl : ByteArray -> IxonFFI
+| letE : Bool -> IxonFFI -> IxonFFI -> IxonFFI -> IxonFFI
 | list : Array IxonFFI -> IxonFFI
 | defn : DefinitionFFI -> IxonFFI
 | axio : AxiomFFI -> IxonFFI
@@ -304,7 +299,7 @@ inductive IxonFFI where
 | eval : EvalClaim -> IxonFFI
 | chck : CheckClaim -> IxonFFI
 | comm : Comm -> IxonFFI
-| envn : EnvFFI -> IxonFFI
+| envn : Array (Address × Address) -> IxonFFI
 
 def Ixon.toFFI : Ixon → IxonFFI
   | .vari i => .vari i
@@ -314,10 +309,10 @@ def Ixon.toFFI : Ixon → IxonFFI
   | .apps f a as => .apps f.toFFI a.toFFI (as.map Ixon.toFFI).toArray
   | .lams xs b => .lams (xs.map Ixon.toFFI).toArray b.toFFI
   | .alls xs x => .alls (xs.map Ixon.toFFI).toArray x.toFFI
-  | .letE x v t b => .letE x v.toFFI t.toFFI b.toFFI
   | .proj addr i x => .proj addr i x.toFFI
   | .strl s => .strl s
   | .natl n => .natl (nat2Bytes n)
+  | .letE x v t b => .letE x v.toFFI t.toFFI b.toFFI
   | .list xs => .list (xs.map Ixon.toFFI).toArray
   | .defn d => .defn d.toFFI
   | .axio a => .axio a.toFFI
@@ -335,7 +330,7 @@ def Ixon.toFFI : Ixon → IxonFFI
   | .eval x => .eval x
   | .chck x => .chck x
   | .comm x => .comm x
-  | .envn x => .envn x.toFFI
+  | .envn x => .envn x.env.toArray
 
 end FFI
 
diff --git a/src/lean/ffi/ixon.rs b/src/lean/ffi/ixon.rs
index 71db74d8..130ce040 100644
--- a/src/lean/ffi/ixon.rs
+++ b/src/lean/ffi/ixon.rs
@@ -57,7 +57,6 @@ fn lean_ctor_to_univ(ctor: &LeanCtorObject) -> Univ {
     }
 }
 
-// FIXME
 fn lean_ptr_to_address(ptr: *const c_void) -> Address {
     let sarray: &LeanSArrayObject = as_ref_unsafe(ptr.cast());
     let hash = Hash::from_slice(sarray.data()).unwrap();
@@ -229,11 +228,9 @@ fn lean_ptr_to_name_parts(ptr: *const c_void) -> Vec<NamePart> {
 }
 
 fn lean_ptr_to_name(ptr: *const c_void) -> Name {
-    let parts = lean_ptr_to_name_parts(ptr);
-    // Is `parts` reversed?
-    Name {
-        parts: parts.into_iter().rev().collect(),
-    }
+    let mut parts = lean_ptr_to_name_parts(ptr);
+    parts.reverse();
+    Name { parts }
 }
 
 fn lean_ptr_to_metadatum(ptr: *const c_void) -> Metadatum {
@@ -301,7 +298,6 @@ fn lean_ptr_to_metadata_entry(ptr: *const c_void) -> (Nat, Vec<Metadatum>) {
     (fst, snd)
 }
 
-// FIXME
 fn lean_ptr_to_env_entry(ptr: *const c_void) -> (Address, Address) {
     let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
     let [fst, snd] = ctor.objs().map(lean_ptr_to_address);
@@ -518,11 +514,8 @@ fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
             let [secret, payload] = comm.objs().map(lean_ptr_to_address);
             Ixon::Comm(Comm { secret, payload })
         }
-        // FIXME
         26 => {
-            let [env_ptr] = ctor.objs();
-            let env: &LeanCtorObject = as_ref_unsafe(env_ptr.cast());
-            let [map_ptr] = env.objs();
+            let [map_ptr] = ctor.objs();
             let map: &LeanArrayObject = as_ref_unsafe(map_ptr.cast());
             let env = map.to_vec(lean_ptr_to_env_entry);
             Ixon::Envn(Env { env })
@@ -537,7 +530,6 @@ extern "C" fn rs_eq_lean_rust_serialization(
     bytes: &LeanSArrayObject,
 ) -> bool {
     let mut buf = Vec::new();
-    println!("{:?}", lean_ctor_to_ixon(ixon));
     lean_ctor_to_ixon(ixon).put(&mut buf);
     buf == bytes.data()
 }
diff --git a/src/lean/string.rs b/src/lean/string.rs
index d527caf4..9ca9b953 100644
--- a/src/lean/string.rs
+++ b/src/lean/string.rs
@@ -21,7 +21,7 @@ pub struct LeanStringObject {
 impl LeanStringObject {
     #[inline]
     pub fn as_string(&self) -> String {
-        let bytes = self.m_data.slice(self.m_size);
+        let bytes = self.m_data.slice(self.m_size - 1); // Ignore the last '\0'
         unsafe { String::from_utf8_unchecked(bytes.to_vec()) }
     }
 }

From 6ae63ff4cc065380a07e8e6aeb2ac2518ea86f74 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 11 Sep 2025 14:54:03 -0400
Subject: [PATCH 43/74] WIP: synchronized Lean and Rust implementations,
 failing on metadata FFI?

---
 Ix/Address.lean        |   3 +
 Ix/CompileM.lean       |   6 +-
 Ix/DecompileM.lean     |   2 +-
 Ix/IR.lean             |   4 +-
 Ix/Ixon.lean           |  29 +-
 Ix/Ixon/Const.lean     | 123 ++------
 Ix/Ixon/Metadata.lean  |  16 +-
 Ix/Ixon/Serialize.lean |   2 +-
 Ix/TransportM.lean     |  51 +--
 Tests/Ix.lean          | 222 ++++++++++++-
 Tests/Ix/Ixon.lean     |  31 +-
 Tests/Main.lean        |   1 +
 src/ixon.rs            | 691 ++++++++++++++++++++++++++++++++++++++++-
 src/ixon/address.rs    |   8 +
 src/ixon/constant.rs   | 134 ++++----
 src/ixon/meta.rs       |  14 +-
 src/ixon/nat.rs        |  15 +-
 src/lean/ffi/ixon.rs   |  13 +-
 18 files changed, 1109 insertions(+), 256 deletions(-)

diff --git a/Ix/Address.lean b/Ix/Address.lean
index 85016381..58c90b80 100644
--- a/Ix/Address.lean
+++ b/Ix/Address.lean
@@ -74,6 +74,9 @@ instance : Repr Address where
 instance : Ord Address where
   compare a b := compare a.hash.data.toList b.hash.data.toList
 
+instance : Inhabited Address where
+  default := Address.blake3 ⟨#[]⟩
+
 def byteOfHex : Char -> Char -> Option UInt8
 | hi, lo => do
   let hi <- natOfHex hi
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 352a41c9..67bd53d0 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -327,7 +327,7 @@ partial def preDefinitionToIR (d: PreDefinition)
   : CompileM Ix.Definition := withCurrent d.name $ withLevels d.levelParams do
   let typ <- compileExpr d.type
   let val <- compileExpr d.value
-  return ⟨d.name, d.levelParams, typ, d.mode, val, d.hints, d.safety, d.all⟩
+  return ⟨d.name, d.levelParams, typ, d.kind, val, d.hints, d.safety, d.all⟩
 
 partial def getRecursors (ind : Lean.InductiveVal) 
   : CompileM (List Lean.RecursorVal) := do
@@ -625,11 +625,11 @@ partial def compareDef
   (weakOrd : RBMap Lean.Name Nat compare)
   (x y: PreDefinition)
   : CompileM Ordering := do
-  let mode := compare x.mode y.mode
+  let kind := compare x.kind y.kind
   let ls := compare x.levelParams.length y.levelParams.length
   let ts ← compareExpr weakOrd x.levelParams y.levelParams x.type y.type
   let vs ← compareExpr weakOrd x.levelParams y.levelParams x.value y.value
-  return concatOrds [mode, ls, ts, vs]
+  return concatOrds [kind, ls, ts, vs]
 
 /-- AST equality between two Lean definitions.
   `weakOrd` contains the best known current mutual ordering -/
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index d8be21cd..4da13645 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -331,7 +331,7 @@ partial def decompileDefn (x: Ix.Definition)
   : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
     let type <- decompileExpr x.type
     let val <- decompileExpr x.value
-    match x.mode with
+    match x.kind with
     | .definition => return .defnInfo <|
       Lean.mkDefinitionValEx x.name x.levelParams type val x.hints x.safety x.all
     | .opaque => return .opaqueInfo <|
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 4e85a503..2db59151 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -131,7 +131,7 @@ structure PreDefinition where
   name: Lean.Name
   levelParams : List Lean.Name
   type : Lean.Expr
-  mode : DefKind
+  kind : DefKind
   value : Lean.Expr
   hints : Lean.ReducibilityHints
   safety : Lean.DefinitionSafety
@@ -162,7 +162,7 @@ structure Definition where
   name: Lean.Name
   levelParams : List Lean.Name
   type : Expr
-  mode: DefKind
+  kind: DefKind
   value : Expr
   hints : Lean.ReducibilityHints
   safety: Lean.DefinitionSafety
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 798e7eba..9234b71e 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -136,15 +136,15 @@ This section defines FFI-friendly versions of the original Ixon datatypes by
   ⟨natToBytesLE n⟩
 
 structure DefinitionFFI where
+  kind: Ix.DefKind
+  safety : Lean.DefinitionSafety
   lvls : ByteArray
   type : Address
-  mode : Ix.DefKind
   value : Address
-  safety : Lean.DefinitionSafety
 
 def Definition.toFFI : Definition → DefinitionFFI
-  | ⟨lvls, type, mode, value, safety⟩ =>
-    ⟨nat2Bytes lvls, type, mode, value, safety⟩
+  | ⟨kind, safety, lvls, type, value⟩ =>
+    ⟨kind, safety, nat2Bytes lvls, type, value⟩
 
 structure AxiomFFI where
   lvls : ByteArray
@@ -152,7 +152,7 @@ structure AxiomFFI where
   isUnsafe: Bool
 
 def Axiom.toFFI : Axiom → AxiomFFI
-  | ⟨lvls, type, isUnsafe⟩ => ⟨nat2Bytes lvls, type, isUnsafe⟩
+  | ⟨isUnsafe, lvls, type⟩ => ⟨nat2Bytes lvls, type, isUnsafe⟩
 
 structure QuotientFFI where
   lvls : ByteArray
@@ -160,7 +160,7 @@ structure QuotientFFI where
   kind : Lean.QuotKind
 
 def Quotient.toFFI : Quotient → QuotientFFI
-  | ⟨lvls, type, kind⟩ => ⟨nat2Bytes lvls, type, kind⟩
+  | ⟨kind, lvls, type⟩ => ⟨nat2Bytes lvls, type, kind⟩
 
 structure ConstructorProjFFI where
   block : Address
@@ -168,7 +168,7 @@ structure ConstructorProjFFI where
   cidx : ByteArray
 
 def ConstructorProj.toFFI : ConstructorProj → ConstructorProjFFI
-  | ⟨block, idx, cidx⟩ => ⟨block, nat2Bytes idx, nat2Bytes cidx⟩
+  | ⟨idx, cidx, block⟩ => ⟨block, nat2Bytes idx, nat2Bytes cidx⟩
 
 structure RecursorProjFFI where
   block : Address
@@ -176,21 +176,21 @@ structure RecursorProjFFI where
   ridx : ByteArray
 
 def RecursorProj.toFFI : RecursorProj → RecursorProjFFI
-  | ⟨block, idx, ridx⟩ => ⟨block, nat2Bytes idx, nat2Bytes ridx⟩
+  | ⟨idx, ridx, block⟩ => ⟨block, nat2Bytes idx, nat2Bytes ridx⟩
 
 structure InductiveProjFFI where
   block : Address
   idx : ByteArray
 
 def InductiveProj.toFFI : InductiveProj → InductiveProjFFI
-  | ⟨block, idx⟩ => ⟨block, nat2Bytes idx⟩
+  | ⟨idx, block⟩ => ⟨block, nat2Bytes idx⟩
 
 structure DefinitionProjFFI where
   block : Address
   idx : ByteArray
 
 def DefinitionProj.toFFI : DefinitionProj → DefinitionProjFFI
-  | ⟨block, idx⟩ => ⟨block, nat2Bytes idx⟩
+  | ⟨idx, block⟩ => ⟨block, nat2Bytes idx⟩
 
 structure RecursorRuleFFI where
   fields : ByteArray
@@ -211,7 +211,7 @@ structure RecursorFFI where
   isUnsafe: Bool
 
 def Recursor.toFFI : Recursor → RecursorFFI
-  | ⟨lvls, type, params, indices, motives, minors, rules, k, isUnsafe⟩ =>
+  | ⟨k, isUnsafe, lvls, params, indices, motives, minors, type, rules⟩ =>
     ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
       nat2Bytes motives, nat2Bytes minors, rules.toArray.map RecursorRule.toFFI,
       k, isUnsafe⟩
@@ -225,7 +225,7 @@ structure ConstructorFFI where
   isUnsafe: Bool
 
 def Constructor.toFFI : Constructor → ConstructorFFI
-  | ⟨lvls, type, cidx, params, fields, isUnsafe⟩ =>
+  | ⟨isUnsafe, lvls, cidx, params, fields, type⟩ =>
     ⟨nat2Bytes lvls, type, nat2Bytes cidx, nat2Bytes params, nat2Bytes fields, isUnsafe⟩
 
 structure InductiveFFI where
@@ -241,7 +241,7 @@ structure InductiveFFI where
   isUnsafe: Bool
 
 def Inductive.toFFI : Inductive → InductiveFFI
-  | ⟨lvls, type, params, indices, ctors, recrs, nested, recr, refl, isUnsafe⟩ =>
+  | ⟨recr, refl, isUnsafe, lvls, params, indices, nested, type, ctors, recrs⟩ =>
     ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
       ctors.toArray.map Constructor.toFFI, recrs.toArray.map Recursor.toFFI,
       nat2Bytes nested, recr, refl, isUnsafe⟩
@@ -323,8 +323,7 @@ def Ixon.toFFI : Ixon → IxonFFI
   | .dprj d => .dprj d.toFFI
   | .inds is => .inds (is.map Inductive.toFFI).toArray
   | .defs d => .defs (d.map Definition.toFFI).toArray
-  | .meta ⟨map⟩ =>
-    .meta $ map.toList.toArray.map
+  | .meta ⟨map⟩ => .meta $ map.toArray.map
       fun (x, y) => (nat2Bytes x, y.toArray.map Metadatum.toFFI)
   | .prof p => .prof p
   | .eval x => .eval x
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
index 4385742d..c2269e30 100644
--- a/Ix/Ixon/Const.lean
+++ b/Ix/Ixon/Const.lean
@@ -10,62 +10,49 @@ import Ix.Ixon.Expr
 namespace Ixon
 
 structure Quotient where
+  kind : Lean.QuotKind
   lvls : Nat
   type : Address
-  kind : Lean.QuotKind
   deriving BEq, Repr
 
 instance : Serialize Quotient where
-  put := fun x => Serialize.put (x.lvls, x.type, x.kind)
+  put := fun x => Serialize.put (x.kind, x.lvls, x.type)
   get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
 
 structure Axiom where
+  isUnsafe: Bool
   lvls : Nat
   type : Address
-  isUnsafe: Bool
   deriving BEq, Repr
 
 instance : Serialize Axiom where
-  put := fun x => Serialize.put (x.lvls, x.type, x.isUnsafe)
+  put := fun x => Serialize.put (x.isUnsafe, x.lvls, x.type)
   get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
 
 structure Definition where
+  kind : Ix.DefKind
+  safety : Lean.DefinitionSafety
   lvls : Nat
   type : Address
-  mode : Ix.DefKind
   value : Address
-  safety : Lean.DefinitionSafety
   deriving BEq, Repr
 
 instance : Serialize Definition where
-  put := fun x => Serialize.put (x.lvls, x.type, x.mode, x.value, x.safety)
+  put := fun x => Serialize.put (x.kind, x.safety, x.lvls, x.type, x.value)
   get := (fun (a,b,c,d,e) => .mk a b c d e) <$> Serialize.get
 
 structure Constructor where
+  isUnsafe: Bool
   lvls : Nat
-  type : Address
   cidx : Nat
   params : Nat
   fields : Nat
-  isUnsafe: Bool
+  type : Address
   deriving BEq, Repr
 
 instance : Serialize Constructor where
-  put x := do
-    Serialize.put x.lvls
-    Serialize.put x.type
-    Serialize.put x.cidx
-    Serialize.put x.params
-    Serialize.put x.fields
-    Serialize.put x.isUnsafe
-  get := do
-    let lvls <- Serialize.get
-    let type <- Serialize.get
-    let cidx <- Serialize.get
-    let params <- Serialize.get
-    let fields <- Serialize.get
-    let isUnsafe <- Serialize.get
-    return .mk lvls type cidx params fields isUnsafe
+  put := fun x => Serialize.put (x.isUnsafe, x.lvls, x.cidx, x.params, x.fields, x.type)
+  get := (fun (a,b,c,d,e,f) => .mk a b c d e f) <$> Serialize.get
 
 structure RecursorRule where
   fields : Nat
@@ -73,117 +60,78 @@ structure RecursorRule where
   deriving BEq, Repr
 
 instance : Serialize RecursorRule where
-  put x := do
-    Serialize.put x.fields
-    Serialize.put x.rhs
-  get := do
-    let fields <- Serialize.get
-    let rhs <- Serialize.get
-    return .mk fields rhs
+  put := fun x => Serialize.put (x.fields, x.rhs)
+  get := (fun (a,b) => .mk a b) <$> Serialize.get
 
 structure Recursor where
+  k : Bool
+  isUnsafe: Bool
   lvls : Nat
-  type : Address
   params : Nat
   indices : Nat
   motives : Nat
   minors : Nat
+  type : Address
   rules : List RecursorRule
-  k : Bool
-  isUnsafe: Bool
   deriving BEq, Repr
 
 instance : Serialize Recursor where
-  put x := do
-    Serialize.put x.lvls
-    Serialize.put x.type
-    Serialize.put x.params
-    Serialize.put x.indices
-    Serialize.put x.motives
-    Serialize.put x.minors
-    Serialize.put x.rules
-    Serialize.put (x.k, x.isUnsafe)
-  get := do
-    let lvls <- Serialize.get
-    let type <- Serialize.get
-    let params <- Serialize.get
-    let indices <- Serialize.get
-    let motives <- Serialize.get
-    let minors <- Serialize.get
-    let rules <- Serialize.get
-    let (k, isUnsafe) := <- Serialize.get
-    return .mk lvls type params indices motives minors rules k isUnsafe
+  put := fun x => Serialize.put ((x.k, x.isUnsafe), x.lvls, x.params, x.indices, x.motives, x.minors, x.type, x.rules)
+  get := (fun ((a,b),c,d,e,f,g,h,i) => .mk a b c d e f g h i) <$> Serialize.get
 
 structure Inductive where
+  recr : Bool
+  refl : Bool
+  isUnsafe: Bool
   lvls : Nat
-  type : Address
   params : Nat
   indices : Nat
+  nested : Nat
+  type : Address
   ctors : List Constructor
   recrs : List Recursor
-  nested : Nat
-  recr : Bool
-  refl : Bool
-  isUnsafe: Bool
   deriving BEq, Repr
 
 instance : Serialize Inductive where
-  put x := do
-    Serialize.put x.lvls
-    Serialize.put x.type
-    Serialize.put x.params
-    Serialize.put x.indices
-    Serialize.put x.ctors
-    Serialize.put x.recrs
-    Serialize.put x.nested
-    Serialize.put (x.recr, x.refl, x.isUnsafe)
-  get := do
-    let lvls : Nat <- Serialize.get
-    let type : Address <- Serialize.get
-    let params : Nat <- Serialize.get
-    let indices : Nat <- Serialize.get
-    let ctors : List Constructor <- Serialize.get
-    let recrs : List Recursor <- Serialize.get
-    let nested: Nat <- Serialize.get
-    let (recr, refl, isUnsafe) : (Bool × Bool × Bool) := <- Serialize.get
-    return .mk lvls type params indices ctors recrs nested recr refl isUnsafe
+  put := fun x => Serialize.put ((x.recr,x.refl,x.isUnsafe), x.lvls, x.params, x.indices, x.nested, x.type, x.ctors, x.recrs)
+  get := (fun ((a,b,c),d,e,f,g,h,i,j) => .mk a b c d e f g h i j) <$> Serialize.get
 
 structure InductiveProj where
-  block : Address
   idx : Nat
+  block : Address
   deriving BEq, Repr
 
 instance : Serialize InductiveProj where
-  put := fun x => Serialize.put (x.block, x.idx)
+  put := fun x => Serialize.put (x.idx, x.block)
   get := (fun (x,y) => .mk x y) <$> Serialize.get
 
 structure ConstructorProj where
-  block : Address
   idx : Nat
   cidx : Nat
+  block : Address
   deriving BEq, Repr
 
 instance : Serialize ConstructorProj where
-  put := fun x => Serialize.put (x.block, x.idx, x.cidx)
+  put := fun x => Serialize.put (x.idx, x.cidx, x.block)
   get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
 
 structure RecursorProj where
-  block : Address
   idx : Nat
   ridx : Nat
+  block : Address
   deriving BEq, Repr
 
 instance : Serialize RecursorProj where
-  put := fun x => Serialize.put (x.block, x.idx, x.ridx)
+  put := fun x => Serialize.put (x.idx, x.ridx, x.block)
   get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
 
 structure DefinitionProj where
-  block : Address
   idx : Nat
+  block : Address
   deriving BEq, Repr
 
 instance : Serialize DefinitionProj where
-  put := fun x => Serialize.put (x.block, x.idx)
+  put := fun x => Serialize.put (x.idx, x.block)
   get := (fun (x,y) => .mk x y) <$> Serialize.get
 
 structure Comm where
@@ -204,10 +152,7 @@ instance : Serialize Comm where
   get := (fun (x,y) => .mk x y) <$> Serialize.get
 
 instance : Serialize CheckClaim where
-  put x := do
-    Serialize.put x.lvls
-    Serialize.put x.type
-    Serialize.put x.value
+  put x := Serialize.put (x.lvls, x.type, x.value)
   get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
 
 instance : Serialize EvalClaim where
diff --git a/Ix/Ixon/Metadata.lean b/Ix/Ixon/Metadata.lean
index 36e59fd0..ef0f2c93 100644
--- a/Ix/Ixon/Metadata.lean
+++ b/Ix/Ixon/Metadata.lean
@@ -15,7 +15,7 @@ inductive Metadatum where
 deriving BEq, Repr, Ord, Inhabited
 
 structure Metadata where
-  map: Batteries.RBMap Nat (List Metadatum) compare
+  map: List (Nat × (List Metadatum))
   deriving BEq, Repr
 
 inductive NamePart where
@@ -49,8 +49,8 @@ instance : Serialize NamePart where
   put := putNamePart
   get := getNamePart
 
-def putName (n: Lean.Name): PutM Unit := put (nameToParts n)
-def getName: GetM Lean.Name := nameFromParts <$> get
+def putName (n: Lean.Name): PutM Unit := put (List.reverse $ nameToParts n)
+def getName: GetM Lean.Name := (nameFromParts ∘ List.reverse) <$> get
 
 instance : Serialize Lean.Name where
   put := putName
@@ -78,14 +78,8 @@ instance : Serialize Metadatum where
   put := putMetadatum
   get := getMetadatum
 
-def putMetadata (m: Metadata) : PutM Unit := put m.map.toList
-
-def getMetadata : GetM Metadata := do
-  let xs <- Serialize.get
-  return Metadata.mk (Batteries.RBMap.ofList xs compare)
-
 instance : Serialize Metadata where
-  put := putMetadata
-  get := getMetadata
+  put m := put m.map
+  get := .mk <$> get
 
 end Ixon
diff --git a/Ix/Ixon/Serialize.lean b/Ix/Ixon/Serialize.lean
index 2a4349a3..5598c3c6 100644
--- a/Ix/Ixon/Serialize.lean
+++ b/Ix/Ixon/Serialize.lean
@@ -104,7 +104,7 @@ def getBytes (len: Nat) : GetM ByteArray := do
 
 def putTag2 (tag: Tag2) : PutM Unit := do
   putUInt8 (encodeTag2Head tag)
-  if tag.size < 8
+  if tag.size < 32
   then pure ()
   else putBytes (.mk (trimmedLE tag.size))
 
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index 16453ba4..85846b15 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -12,22 +12,24 @@ namespace Ix.TransportM
 
 open Ixon
 
+abbrev MetadataMap := Batteries.RBMap Nat (List Metadatum) compare
+
 structure DematState where
   idx: Nat
   store: Batteries.RBMap Address Ixon compare
-  meta: Ixon.Metadata
+  meta: MetadataMap
   deriving Repr
 
 def emptyDematState : DematState := 
-  { idx := 0, store := .empty, meta := { map := .empty }}
+  { idx := 0, store := .empty, meta := .empty }
 
 inductive TransportError
 | natTooBig (idx: Nat) (x: Nat)
-| unknownIndex (idx: Nat) (m: Ixon.Metadata)
+| unknownIndex (idx: Nat) (m: MetadataMap)
 | unknownAddress (adr: Address)
-| unexpectedNode (idx: Nat) (m: Ixon.Metadata)
-| nonExprIxon (x: Ixon) (m: Ixon.Metadata)
-| nonConstIxon (x: Ixon) (m: Ixon.Metadata)
+| unexpectedNode (idx: Nat) (m: MetadataMap)
+| nonExprIxon (x: Ixon) (m: MetadataMap)
+| nonConstIxon (x: Ixon) (m: MetadataMap)
 | rawMetadata (m: Ixon.Metadata)
 | expectedMetadata (m: Ixon.Ixon)
 | rawProof (m: Proof)
@@ -60,7 +62,7 @@ def rematStateWithStore (store: Batteries.RBMap Address Ixon compare) : RematSta
   { idx := 0, store }
 
 structure RematCtx where
-  meta: Ixon.Metadata
+  meta: MetadataMap
 
 abbrev RematM := ReaderT RematCtx (EStateM TransportError RematState)
 
@@ -87,8 +89,7 @@ def dematIncr : DematM Nat := dematIncrN 1
 def dematMeta (node: List Ixon.Metadatum): DematM Unit := do
   let n <- (·.idx) <$> get
   modify fun stt =>
-    { stt with meta :=
-      { stt.meta with map := stt.meta.map.insert n node } }
+    { stt with meta := stt.meta.insert n node  }
 
 partial def dematUniv : Ix.Level -> DematM Ixon.Univ
 | .zero => dematIncr *> return .const 0
@@ -122,7 +123,7 @@ def rematIncr : RematM Nat := rematIncrN 1
 def rematMeta : RematM (List Ixon.Metadatum) := do
   let n <- (·.idx) <$> get
   let m <- (·.meta) <$> read
-  match m.map.find? n with
+  match m.find? n with
   | .some n => return n
   | .none => throw (.unknownIndex n m)
 
@@ -269,25 +270,25 @@ partial def dematConst : Ix.Const -> DematM Ixon
   dematMeta [.name x.name]
   let lvls <- dematLevels x.levelParams
   let type <- dematExpr x.type >>= dematStore
-  return .axio (.mk lvls type x.isUnsafe)
+  return .axio (.mk x.isUnsafe lvls type)
 | .«definition» x => .defn <$> dematDefn x
 | .quotient x => do
   dematMeta [.name x.name]
   let lvls <- dematLevels x.levelParams
   let type <- dematExpr x.type >>= dematStore
-  return .quot (.mk lvls type x.kind)
+  return .quot (.mk x.kind lvls type)
 | .inductiveProj x => do
   dematMeta [.name x.name, .link x.blockMeta]
-  return .iprj (.mk x.blockCont x.idx)
+  return .iprj (.mk x.idx x.blockCont)
 | .constructorProj x => do
   dematMeta [.name x.name, .link x.blockMeta, .name x.induct]
-  return .cprj (.mk x.blockCont x.idx x.cidx)
+  return .cprj (.mk x.idx x.cidx x.blockCont)
 | .recursorProj x => do
   dematMeta [.name x.name, .link x.blockMeta, .name x.induct]
-  return .rprj (.mk x.blockCont x.idx x.ridx)
+  return .rprj (.mk x.idx x.ridx x.blockCont)
 | .definitionProj x => do
   dematMeta [.name x.name, .link x.blockMeta]
-  return .dprj (.mk x.blockCont x.idx)
+  return .dprj (.mk x.idx x.blockCont)
 | .mutual x => do
   dematMeta [.mutCtx x.ctx]
   let defs <- x.defs.mapM fun ds => ds.mapM dematDefn
@@ -309,13 +310,13 @@ partial def dematConst : Ix.Const -> DematM Ixon
       let lvls <- dematLevels x.levelParams
       let type <- dematExpr x.type >>= dematStore
       let value <- dematExpr x.value >>= dematStore
-      return .mk lvls type x.mode value x.safety
+      return .mk x.kind x.safety lvls type value
     dematCtor (x: Ix.Constructor): DematM Ixon.Constructor := do
       let _ <- dematIncr
       dematMeta [.name x.name]
       let lvls <- dematLevels x.levelParams
       let t <- dematExpr x.type >>= dematStore
-      return .mk lvls t x.cidx x.numParams x.numFields x.isUnsafe
+      return .mk x.isUnsafe lvls x.cidx x.numParams x.numFields t
     dematRecrRule (x: Ix.RecursorRule): DematM Ixon.RecursorRule := do
       let _ <- dematIncr
       dematMeta [.name x.ctor]
@@ -327,8 +328,8 @@ partial def dematConst : Ix.Const -> DematM Ixon
       let lvls <- dematLevels x.levelParams
       let t <- dematExpr x.type >>= dematStore
       let rrs <- x.rules.mapM dematRecrRule
-      return ⟨lvls, t, x.numParams, x.numIndices, x.numMotives, x.numMinors, 
-        rrs, x.k, x.isUnsafe⟩
+      return ⟨x.k, x.isUnsafe, lvls, x.numParams, x.numIndices, x.numMotives, 
+        x.numMinors, t, rrs⟩
     dematIndc (x: Ix.Inductive): DematM Ixon.Inductive := do
       let _ <- dematIncr
       dematMeta [.name x.name, .all x.all]
@@ -336,12 +337,13 @@ partial def dematConst : Ix.Const -> DematM Ixon
       let type <- dematExpr x.type >>= dematStore
       let ctors <- x.ctors.mapM dematCtor
       let recrs <- x.recrs.mapM dematRecr
-      return ⟨lvls, type, x.numParams, x.numIndices, ctors, recrs, x.numNested,
-        x.isRec, x.isReflexive, x.isUnsafe⟩
+      return ⟨x.isRec, x.isReflexive, x.isUnsafe,
+        lvls, x.numParams, x.numIndices,x.numNested, type, ctors, recrs,
+        ⟩
 
 def constToIxon (x: Ix.Const) : Except TransportError (Ixon × Ixon) := 
   match EStateM.run (dematConst x) emptyDematState with
-  | .ok ix stt => .ok (ix, Ixon.meta stt.meta)
+  | .ok ix stt => .ok (ix, Ixon.meta ⟨stt.meta.toList⟩)
   | .error e _ => .error e
 
 def constToBytes (x: Ix.Const) : Except TransportError ByteArray := do
@@ -436,7 +438,7 @@ partial def rematConst : Ixon -> RematM Ix.Const
       let lvls <- rematLevels x.lvls
       let type <- rematExprAddress x.type
       let value <- rematExprAddress x.value
-      return .mk name lvls type x.mode value hints x.safety all
+      return .mk name lvls type x.kind value hints x.safety all
     rematCtor (x: Ixon.Constructor) : RematM Ix.Constructor := do
       let _ <- rematIncr
       let name <- match (<- rematMeta) with
@@ -477,6 +479,7 @@ def rematerialize (c m: Ixon) : Except TransportError Ix.Const := do
   let m <- match m with
   | .meta m => pure m
   | x => throw <| .expectedMetadata x
+  let m := Batteries.RBMap.ofList m.map compare
   match ((rematConst c).run { meta := m }).run emptyRematState with
     | .ok a _ => return a
     | .error e _ => throw e
diff --git a/Tests/Ix.lean b/Tests/Ix.lean
index 0e6272a1..877c2cb9 100644
--- a/Tests/Ix.lean
+++ b/Tests/Ix.lean
@@ -98,11 +98,223 @@ def Tests.Ix.suite : List LSpec.TestSeq :=
     check "expr serde" (∀ x : Ixon.IxonExpr, serde x),
     check "expr transport" (∀ x : Ix.Expr, transportExpr x),
     check "expr ffi with Rust" (∀ x : Ixon.IxonExpr, ffiExpr x),
-    ----check "axiom serde" (∀ x : Ixon.Axiom, serde x),
-    ----check "recursor rule serde" (∀ x : Ixon.RecursorRule, serde x),
-    ----check "recursor serde" (∀ x : Ixon.Recursor, serde x),
-    ----check "constructor serde" (∀ x : Ixon.Constructor, serde x),
+    --check "axiom serde" (∀ x : Ixon.Axiom, serde x),
+    --check "recursor rule serde" (∀ x : Ixon.RecursorRule, serde x),
+    --check "recursor serde" (∀ x : Ixon.Recursor, serde x),
+    --check "constructor serde" (∀ x : Ixon.Constructor, serde x),
     check "claim serde" (∀ x : Claim, serde x),
     check "const ffi with Rust" (∀ x : Ixon.IxonConst, ffiConst x),
-    --check "const transport" (∀ x : Ix.Const, transportConst x),
+    check "const transport" (∀ x : Ix.Const, transportConst x),
   ]
+
+
+def hexVal? (c : Char) : Option UInt8 :=
+  if '0' ≤ c ∧ c ≤ '9' then
+    some (UInt8.ofNat (c.toNat - '0'.toNat))
+  else if 'a' ≤ c ∧ c ≤ 'f' then
+    some (UInt8.ofNat (10 + (c.toNat - 'a'.toNat)))
+  else if 'A' ≤ c ∧ c ≤ 'F' then
+    some (UInt8.ofNat (10 + (c.toNat - 'A'.toNat)))
+  else
+    none
+
+/-- Parse a hexadecimal string like `0xdead_beef_cafe_0123_4567_89ab_cdef` into a `ByteArray`.
+Underscores are ignored; `0x`/`0X` prefix is optional. Panics on invalid input. -/
+def parseHex (x : String) : ByteArray :=
+  -- drop optional 0x/0X
+  let x :=
+    if x.startsWith "0x" || x.startsWith "0X" then x.drop 2 else x
+  -- remove underscores
+  let x := String.mk (x.toList.filter (· ≠ '_'))
+  -- must have an even number of hex digits
+  if x.length % 2 = 1 then
+    panic! "parseHex: odd number of hex digits"
+  else
+    let n := x.length
+    let rec loop (i : Nat) (acc : ByteArray) : ByteArray :=
+      if i < n then
+        -- safe since ASCII: `String.get!` indexes by chars
+        let c1 := x.get! ⟨i⟩
+        let c2 := x.get! ⟨i+1⟩
+        match hexVal? c1, hexVal? c2 with
+        | some hi, some lo =>
+          let b : UInt8 := (hi <<< 4) ||| lo
+          loop (i + 2) (acc.push b)
+        | _, _ =>
+          panic! s!"parseHex: invalid hex at positions {i}..{i+1}"
+      else
+        acc
+    loop 0 ByteArray.empty
+
+/-- Print a `ByteArray` as a lowercase hex string with a `0x` prefix. -/
+def printHex (ba : ByteArray) : String :=
+  let hexdigits := "0123456789abcdef"
+  let rec go (i : Nat) (acc : String) : String :=
+    if h : i < ba.size then
+      let b := ba.get! i
+      let hi := (b.toNat / 16)
+      let lo := (b.toNat % 16)
+      let acc := acc.push (hexdigits.get! ⟨hi⟩)
+      let acc := acc.push (hexdigits.get! ⟨lo⟩)
+      go (i + 1) acc
+    else acc
+  "0x" ++ go 0 ""
+
+def serde_is [Ixon.Serialize A] [BEq A] (x: A) (expect: String): Bool := Id.run do
+  let expected := parseHex expect
+  let bytes := Ixon.runPut (Ixon.Serialize.put x)
+  if bytes == expected then
+    match Ixon.runGet Ixon.Serialize.get bytes with
+    | .ok (y : A) => x == y
+    | _ => false
+  else false
+
+def test_serde [Ixon.Serialize A] [BEq A] [Repr A] (x: A) (expect: String): LSpec.TestSeq :=
+  let expected := parseHex expect
+  let bytes := Ixon.runPut (Ixon.Serialize.put x)
+  let res := if bytes == expected then
+    match Ixon.runGet Ixon.Serialize.get bytes with
+    | .ok (y : A) => x == y
+    | _ => false
+    else false
+  test s!"serde {repr x} <-> {expect}" res
+
+open Ixon
+
+
+-- TODO
+def bad : Ixon := Ixon.meta <| .mk [
+  (0, [Metadatum.name `d, .link default, .hints (.regular 576554452), .link default]),
+  (1, [.info .instImplicit, .info .instImplicit, .info .strictImplicit]),
+  (2, [.all [.mkNum .anonymous 165851424810452359], .info .default]),
+  (3, []),
+  (4, []),
+  (5, [.hints .opaque]),
+  (6, [.name <| .mkNum .anonymous 871843802607008850]),
+  ]
+
+--#eval printHex <| runPut <| Serialize.put bad
+--"0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
+
+--#eval runGet (@Serialize.get Ixon _) (runPut (Serialize.put bad))
+
+
+def Tests.Ixon.units : List LSpec.TestSeq :=
+  [
+    test_serde (Ixon.vari 0x0) "0x00",
+    test_serde (Ixon.vari 0x7) "0x07",
+    test_serde (Ixon.vari 0x8) "0x0808",
+    test_serde (Ixon.vari 0xFF) "0x08FF",
+    test_serde (Ixon.vari 0x0100) "0x090001",
+    test_serde (Ixon.vari 0x0100) "0x090001",
+    test_serde (Ixon.vari 0xFFFF) "0x09FFFF",
+    test_serde (Ixon.vari 0x010000) "0x0A000001",
+    test_serde (Ixon.vari 0xFFFFFF) "0x0AFFFFFF",
+    test_serde (Ixon.vari 0x01000000) "0x0B00000001",
+    test_serde (Ixon.vari 0xFFFFFFFF) "0x0BFFFFFFFF",
+    test_serde (Ixon.vari 0x0100000000) "0x0C0000000001",
+    test_serde (Ixon.vari 0xFFFFFFFFFF) "0x0CFFFFFFFFFF",
+    test_serde (Ixon.vari 0x010000000000) "0x0D000000000001",
+    test_serde (Ixon.vari 0xFFFFFFFFFFFF) "0x0DFFFFFFFFFFFF",
+    test_serde (Ixon.vari 0x01000000000000) "0x0E00000000000001",
+    test_serde (Ixon.vari 0xFFFFFFFFFFFFFF) "0x0EFFFFFFFFFFFFFF",
+    test_serde (Ixon.vari 0x0100000000000000) "0x0F0000000000000001",
+    test_serde (Ixon.vari 0xFFFFFFFFFFFFFFFF) "0x0FFFFFFFFFFFFFFFFF",
+    test_serde (Ixon.sort <| .const 0x0) "0x9000",
+    test_serde (Ixon.sort <| .const 0x1F) "0x901F",
+    test_serde (Ixon.sort <| .const 0x20) "0x902020",
+    test_serde (Ixon.sort <| .const 0xFF) "0x9020FF",
+    test_serde (Ixon.sort <| .const 0x0100) "0x90210001",
+    test_serde (Ixon.sort <| .const 0xFFFF) "0x9021FFFF",
+    test_serde (Ixon.sort <| .const 0x010000) "0x9022000001",
+    test_serde (Ixon.sort <| .const 0xFFFFFF) "0x9022FFFFFF",
+    test_serde (Ixon.sort <| .const 0x01000000) "0x902300000001",
+    test_serde (Ixon.sort <| .const 0xFFFFFFFF) "0x9023FFFFFFFF",
+    test_serde (Ixon.sort <| .const 0x0100000000) "0x90240000000001",
+    test_serde (Ixon.sort <| .const 0xFFFFFFFFFF) "0x9024FFFFFFFFFF",
+    test_serde (Ixon.sort <| .const 0x010000000000) "0x9025000000000001",
+    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFF) "0x9025FFFFFFFFFFFF",
+    test_serde (Ixon.sort <| .const 0x01000000000000) "0x902600000000000001",
+    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFFFF) "0x9026FFFFFFFFFFFFFF",
+    test_serde (Ixon.sort <| .const 0x0100000000000000) "0x90270000000000000001",
+    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFFFFFF) "0x9027FFFFFFFFFFFFFFFF",
+    test_serde (Ixon.sort <| .var 0x0) "0x9040",
+    test_serde (Ixon.sort <| .var 0x1F) "0x905F",
+    test_serde (Ixon.sort <| .var 0x20) "0x906020",
+    test_serde (Ixon.sort <| .var 0xFF) "0x9060FF",
+    test_serde (Ixon.sort <| .var 0x0100) "0x90610001",
+    test_serde (Ixon.sort <| .var 0xFFFFFFFFFFFFFFFF) "0x9067FFFFFFFFFFFFFFFF",
+    test_serde (Ixon.sort <| .add 0x0 (.const 0x0)) "0x908000",
+    test_serde (Ixon.sort <| .add 0x0 (.var 0x0)) "0x908040",
+    test_serde (Ixon.sort <| .add 0x1F (.var 0x0)) "0x909F40",
+    test_serde (Ixon.sort <| .add 0x20 (.var 0x0)) "0x90A02040",
+    test_serde (Ixon.sort <| .add 0xFF (.var 0x0)) "0x90A0FF40",
+    test_serde (Ixon.sort <| .add 0xFFFF_FFFF_FFFF_FFFF (.var 0x0)) "0x90A7FFFFFFFFFFFFFFFF40",
+    test_serde (Ixon.sort <| .max (.var 0x0) (.var 0x0)) "0x90C04040",
+    test_serde (Ixon.sort <| .max (.var 0x0) (.var 0x1)) "0x90C04041",
+    test_serde (Ixon.sort <| .max (.var 0x1) (.var 0x0)) "0x90C04140",
+    test_serde (Ixon.sort <| .max (.var 0x1) (.var 0x1)) "0x90C04141",
+    test_serde (Ixon.sort <| .imax (.var 0x0) (.var 0x0)) "0x90C14040",
+    test_serde (Ixon.sort <| .imax (.var 0x0) (.var 0x1)) "0x90C14041",
+    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x0)) "0x90C14140",
+    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x1)) "0x90C14141",
+    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x1)) "0x90C14141",
+    test_serde (Ixon.refr (default) []) "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.refr (default) [.var 0x0]) "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240",
+    test_serde (Ixon.recr 0x0 [.var 0x0]) "0x20A140",
+    test_serde (Ixon.recr 0x0 [.var 0x0, .var 0x1]) "0x20A24041",
+    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1) []) "0x300001",
+    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1) [Ixon.vari 0x2]) "0x31000102",
+    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1)
+      [
+        Ixon.vari 0x2, Ixon.vari 0x3, Ixon.vari 0x4, Ixon.vari 0x5,
+        Ixon.vari 0x6, Ixon.vari 0x7, Ixon.vari 0x8, Ixon.vari 0x9,
+      ]) "0x3808000102030405060708080809",
+    test_serde (Ixon.lams [Ixon.vari 0x0] (Ixon.vari 0x1)) "0x410001",
+    test_serde (Ixon.lams
+      [
+        Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2, Ixon.vari 0x3, 
+        Ixon.vari 0x4, Ixon.vari 0x5, Ixon.vari 0x6, Ixon.vari 0x7,
+      ] (Ixon.vari 0x8)) "0x480800010203040506070808",
+    test_serde (Ixon.alls [Ixon.vari 0x0] (Ixon.vari 0x1)) "0x510001",
+    test_serde (Ixon.alls
+      [
+        Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2, Ixon.vari 0x3, 
+        Ixon.vari 0x4, Ixon.vari 0x5, Ixon.vari 0x6, Ixon.vari 0x7,
+      ] (Ixon.vari 0x8)) "0x580800010203040506070808",
+    test_serde (Ixon.proj (default) 0x0 (Ixon.vari 0x0)) "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200",
+    test_serde (Ixon.proj (default) 0x8 (Ixon.vari 0x0)) "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200",
+    test_serde (Ixon.strl "") "0x70",
+    test_serde (Ixon.strl "foobar") "0x76666f6f626172",
+    test_serde (Ixon.natl 0x0) "0x8100",
+    test_serde (Ixon.natl 0xFF) "0x81FF",
+    test_serde (Ixon.natl 0x100) "0x820001",
+    test_serde (Ixon.letE true (Ixon.vari 0x0) (Ixon.vari 0x1) (Ixon.vari 0x2)) "0x91000102",
+    test_serde (Ixon.list []) "0xA0",
+    test_serde (Ixon.list [Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2]) "0xA3000102",
+    test_serde (Ixon.defn (.mk .definition .unsafe 0 (default) (default))) "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.defn (.mk .opaque .safe 1 default default)) "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.axio ⟨true, 0, default⟩) "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.quot ⟨.type, 0, default⟩) "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.cprj ⟨0, 0, default⟩) "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.rprj ⟨0, 0, default⟩) "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.iprj ⟨0, default⟩) "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.dprj ⟨0, default⟩) "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.inds []) "0xC0",
+    test_serde (Ixon.inds [⟨false, false, false, 0, 0, 0, 0, default, [], []⟩]) "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0",
+    test_serde (Ixon.inds [⟨false, false, false, 0, 0, 0, 0, default, [⟨false, 0,0,0,0, default⟩], [⟨false, false, 0,0,0,0,0,default, [⟨0, default⟩]⟩]⟩]) "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.defs []) "0xD0",
+    test_serde (Ixon.defs [⟨.definition, .unsafe, 0, default, default⟩]) "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.meta ⟨[]⟩) "0xE0A0",
+    test_serde (Ixon.meta ⟨[(0, [])]⟩) "0xE0A18100A0",
+    test_serde (Ixon.meta ⟨[(0, [.name .anonymous])]⟩) "0xE0A18100A100A0",
+    test_serde (Ixon.meta ⟨[(0, [.name `a])]⟩) "0xE0A18100A100A17161",
+    test_serde (Ixon.meta ⟨[(0, [.name `a.b])]⟩) "0xE0A18100A100A271617162",
+    test_serde (Ixon.meta ⟨[(0, [.name `a.b.c])]⟩) "0xE0A18100A100A3716171627163",
+    test_serde (Ixon.meta ⟨[(0, [.name (.mkNum .anonymous 165851424810452359)])]⟩) "0xE0A18100A100A1880887C551FDFD384D02",
+    test_serde (Ixon.meta ⟨[(0, [Metadatum.name `d, .link default, .hints (.regular 576554452), .link default])]⟩) "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+    test_serde (Ixon.meta ⟨[(0, [.hints (.regular 42)])]⟩) "0xe0a18100a103022a000000",
+    test_serde bad "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
+  ]
+
+
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 30934f89..0ff27aec 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -14,7 +14,6 @@ open SlimCheck.Gen
 open Ixon
 
 -- Univ
-
 namespace Ixon
 
 def genUniv : Gen Ixon.Univ := getSize >>= go
@@ -92,7 +91,7 @@ def genMetaNode : Gen (List Metadatum) := genList genMetadatum
 
 def genMetadata : Gen Metadata := do
   let xs ← genList genMetaNode
-  return .mk (Batteries.RBMap.ofList ((List.range xs.length).zip xs) compare)
+  return .mk ((List.range xs.length).zip xs)
 
 instance : Shrinkable Metadata where
   shrink _ := []
@@ -101,7 +100,7 @@ instance : SampleableExt Metadata :=
   SampleableExt.mkSelfContained genMetadata
 
 -- Const
-def genAxiom : Gen Axiom := .mk <$> genNat <*> genAddress <*> genBool
+def genAxiom : Gen Axiom := .mk <$> genBool <*> genNat <*> genAddress
 
 -- TODO: useful shrinking
 instance : Shrinkable Axiom where
@@ -113,13 +112,13 @@ instance : SampleableExt Axiom
 def genDefinition : Gen Definition := do
   let lvls <- genNat
   let type <- genAddress
-  let mode <- genDefKind
+  let kind <- genDefKind
   let value <- genAddress
   let safety <- oneOf #[pure .safe, pure .unsafe, pure .partial]
-  return .mk lvls type mode value safety
+  return .mk kind safety lvls type value
 
 def genConstructor : Gen Constructor :=
-  .mk <$> genNat <*> genAddress <*> genNat <*> genNat <*> genNat <*> genBool
+  .mk <$> genBool <*> genNat <*> genNat <*> genNat <*> genNat <*> genAddress
 
 -- TODO: useful shrinking
 instance : Shrinkable Constructor where
@@ -138,8 +137,8 @@ instance : SampleableExt RecursorRule
   := SampleableExt.mkSelfContained genRecursorRule
 
 def genRecursor : Gen Recursor :=
-  .mk <$> genNat <*> genAddress <*> genNat <*> genNat <*> genNat
-    <*> genNat <*> genList genRecursorRule <*> genBool <*> genBool
+  .mk <$> genBool <*> genBool <*> genNat <*> genNat <*> genNat <*> genNat
+    <*> genNat <*> genAddress <*> genList genRecursorRule
 
 -- TODO: useful shrinking
 instance : Shrinkable Recursor where
@@ -149,9 +148,9 @@ instance : SampleableExt Recursor
   := SampleableExt.mkSelfContained genRecursor
 
 def genInductive : Gen Inductive :=
-  .mk <$> genNat <*> genAddress <*> genNat <*> genNat
-    <*> genList genConstructor <*> genList genRecursor <*> genNat
-    <*> genBool <*> genBool <*> genBool
+  .mk <$> genBool <*> genBool <*> genBool
+    <*> genNat <*> genNat <*> genNat <*> genNat
+    <*> genAddress <*> genList genConstructor <*> genList genRecursor
 
 -- TODO: useful shrinking
 instance : Shrinkable Inductive where
@@ -161,16 +160,16 @@ instance : SampleableExt Inductive
   := SampleableExt.mkSelfContained genInductive
 
 def genConstructorProj : Gen ConstructorProj :=
-  .mk <$> genAddress <*> genNat <*> genNat
+  .mk <$> genNat <*> genNat <*> genAddress
 
 def genRecursorProj : Gen RecursorProj :=
-  .mk <$> genAddress <*> genNat <*> genNat
+  .mk <$> genNat <*> genNat <*> genAddress
 
 def genDefinitionProj : Gen DefinitionProj :=
-  .mk <$> genAddress <*> genNat
+  .mk <$> genNat <*> genAddress
 
 def genInductiveProj : Gen InductiveProj :=
-  .mk <$> genAddress <*> genNat
+  .mk <$> genNat <*> genAddress
 
 def genCheckClaim : Gen CheckClaim :=
   .mk <$> genAddress <*> genAddress <*> genAddress
@@ -240,4 +239,6 @@ the provided bytes.
 @[extern "rs_eq_lean_rust_serialization"]
 opaque eqLeanRustSerialization : @& IxonFFI -> @& ByteArray -> Bool
 
+
 end Ixon
+
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 8b0c3a82..24aa1765 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -17,5 +17,6 @@ def main (args: List String) : IO UInt32 := do
       ("ffi-consistency", Tests.FFIConsistency.suite),
     ("byte-array", Tests.ByteArray.suite),
       ("ix", Tests.Ix.suite),
+      ("ixon", Tests.Ixon.units),
       ("keccak", Tests.Keccak.suite),
   ]) args
diff --git a/src/ixon.rs b/src/ixon.rs
index 4d7150c7..15e0d96b 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -1,4 +1,3 @@
-use blake3::Hash;
 use num_bigint::BigUint;
 
 pub mod address;
@@ -173,11 +172,8 @@ impl Serialize for Ixon {
                 }
             }
             Self::Recr(x, lvls) => {
-                Self::put_tag(0x2, lvls.len() as u64, buf);
-                x.put(buf);
-                for l in lvls {
-                    l.put(buf);
-                }
+                Self::put_tag(0x2, *x, buf);
+                Ixon::put_array(lvls, buf);
             }
             Self::Apps(f, a, args) => {
                 Self::put_tag(0x3, args.len() as u64, buf);
@@ -318,13 +314,8 @@ impl Serialize for Ixon {
                 Ok(Self::Refr(a, lvls))
             }
             0x20..=0x2F => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let x = u64::get(buf)?;
-                let mut lvls = Vec::new();
-                for _ in 0..n {
-                    let l = Univ::get(buf)?;
-                    lvls.push(l);
-                }
+                let x = Ixon::get_size(is_large, small_size, buf)?;
+                let lvls = Ixon::get_array(buf)?;
                 Ok(Self::Recr(x, lvls))
             }
             0x30..=0x3F => {
@@ -445,6 +436,7 @@ pub mod tests {
     use crate::ixon::nat::tests::arbitrary_nat;
     use crate::ixon::univ::tests::arbitrary_univ;
     use quickcheck::{Arbitrary, Gen};
+    use std::fmt::Write;
     use std::ops::Range;
     use std::ptr;
 
@@ -820,6 +812,679 @@ pub mod tests {
             }
         }
     }
+
+    /// Parse a hex string (optional `0x`/`0X` prefix, `_` separators OK) into bytes.
+    pub fn parse_hex(s: &str) -> Result<Vec<u8>, String> {
+        // Strip prefix, drop underscores, and require an even count of hex digits.
+        let s = s.trim();
+        let s = s
+            .strip_prefix("0x")
+            .or_else(|| s.strip_prefix("0X"))
+            .unwrap_or(s);
+        let clean: String = s.chars().filter(|&c| c != '_').collect();
+
+        if clean.len() % 2 != 0 {
+            return Err("odd number of hex digits".into());
+        }
+
+        // Parse each 2-char chunk as a byte.
+        (0..clean.len())
+            .step_by(2)
+            .map(|i| {
+                u8::from_str_radix(&clean[i..i + 2], 16)
+                    .map_err(|_| format!("invalid hex at chars {}..{}", i, i + 2))
+            })
+            .collect()
+    }
+
+    /// Format bytes as a lowercase hex string with a `0x` prefix.
+    pub fn to_hex(bytes: &[u8]) -> String {
+        let mut out = String::with_capacity(2 + bytes.len() * 2);
+        out.push_str("0x");
+        for b in bytes {
+            // `{:02x}` = two lowercase hex digits, zero-padded.
+            write!(&mut out, "{b:02x}").unwrap();
+        }
+        out
+    }
+
+    #[test]
+    fn unit_ixon() {
+        fn test(input: Ixon, expected: &str) -> bool {
+            let mut tmp = Vec::new();
+            let expect = parse_hex(expected).unwrap();
+            Serialize::put(&input, &mut tmp);
+            if tmp != expect {
+                println!(
+                    "serialied {input:?} as:\n {}\n test expects:\n {}",
+                    to_hex(&tmp),
+                    to_hex(&expect),
+                );
+                return false;
+            }
+            match Serialize::get(&mut tmp.as_slice()) {
+                Ok(output) => {
+                    if input != output {
+                        println!(
+                            "deserialized {} as {output:?}, expected {input:?}",
+                            to_hex(&tmp)
+                        );
+                        false
+                    } else {
+                        true
+                    }
+                }
+                Err(e) => {
+                    println!("err: {e}");
+                    false
+                }
+            }
+        }
+        assert!(test(Ixon::Vari(0x0), "0x00"));
+        assert!(test(Ixon::Vari(0x7), "0x07"));
+        assert!(test(Ixon::Vari(0x8), "0x0808"));
+        assert!(test(Ixon::Vari(0xff), "0x08FF"));
+        assert!(test(Ixon::Vari(0x0100), "0x090001"));
+        assert!(test(Ixon::Vari(0xFFFF), "0x09FFFF"));
+        assert!(test(Ixon::Vari(0x010000), "0x0A000001"));
+        assert!(test(Ixon::Vari(0xFFFFFF), "0x0AFFFFFF"));
+        assert!(test(Ixon::Vari(0x01000000), "0x0B00000001"));
+        assert!(test(Ixon::Vari(0xFFFFFFFF), "0x0BFFFFFFFF"));
+        assert!(test(Ixon::Vari(0x0100000000), "0x0C0000000001"));
+        assert!(test(Ixon::Vari(0xFFFFFFFFFF), "0x0CFFFFFFFFFF"));
+        assert!(test(Ixon::Vari(0x010000000000), "0x0D000000000001"));
+        assert!(test(Ixon::Vari(0xFFFFFFFFFFFF), "0x0DFFFFFFFFFFFF"));
+        assert!(test(Ixon::Vari(0x01000000000000), "0x0E00000000000001"));
+        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFF), "0x0EFFFFFFFFFFFFFF"));
+        assert!(test(Ixon::Vari(0x0100000000000000), "0x0F0000000000000001"));
+        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFFFF), "0x0FFFFFFFFFFFFFFFFF"));
+        // universes use 2-bit sub-tags
+        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x0))), "0x9000"));
+        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x1F))), "0x901F"));
+        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x20))), "0x902020"));
+        assert!(test(Ixon::Sort(Box::new(Univ::Const(0xFF))), "0x9020FF"));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0x0100))),
+            "0x90210001"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0xFFFF))),
+            "0x9021FFFF"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0x010000))),
+            "0x9022000001"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0xFFFFFF))),
+            "0x9022FFFFFF"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0x01000000))),
+            "0x902300000001"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFF))),
+            "0x9023FFFFFFFF"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0x0100000000))),
+            "0x90240000000001"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFF))),
+            "0x9024FFFFFFFFFF"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0x010000000000))),
+            "0x9025000000000001"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFF))),
+            "0x9025FFFFFFFFFFFF"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0x01000000000000))),
+            "0x902600000000000001"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFF))),
+            "0x9026FFFFFFFFFFFFFF"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0x0100000000000000))),
+            "0x90270000000000000001"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFFFF))),
+            "0x9027FFFFFFFFFFFFFFFF"
+        ));
+        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0))), "0x9040"));
+        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x1F))), "0x905F"));
+        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x20))), "0x906020"));
+        assert!(test(Ixon::Sort(Box::new(Univ::Var(0xFF))), "0x9060FF"));
+        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0100))), "0x90610001"));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Var(0xFFFFFFFFFFFFFFFF))),
+            "0x9067FFFFFFFFFFFFFFFF"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Const(0x0))))),
+            "0x908000"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Var(0x0))))),
+            "0x908040"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Add(0x1F, Box::new(Univ::Var(0x0))))),
+            "0x909F40"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Add(0x20, Box::new(Univ::Var(0x0))))),
+            "0x90A02040"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Add(0xFF, Box::new(Univ::Var(0x0))))),
+            "0x90A0FF40"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Add(
+                0xFFFF_FFFF_FFFF_FFFF,
+                Box::new(Univ::Var(0x0))
+            ))),
+            "0x90A7FFFFFFFFFFFFFFFF40"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Max(
+                Box::new(Univ::Var(0x0)),
+                Box::new(Univ::Var(0x0))
+            ))),
+            "0x90C04040"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Max(
+                Box::new(Univ::Var(0x0)),
+                Box::new(Univ::Var(0x1))
+            ))),
+            "0x90C04041"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Max(
+                Box::new(Univ::Var(0x1)),
+                Box::new(Univ::Var(0x0))
+            ))),
+            "0x90C04140"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::Max(
+                Box::new(Univ::Var(0x1)),
+                Box::new(Univ::Var(0x1))
+            ))),
+            "0x90C04141"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::IMax(
+                Box::new(Univ::Var(0x0)),
+                Box::new(Univ::Var(0x0))
+            ))),
+            "0x90C14040"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::IMax(
+                Box::new(Univ::Var(0x0)),
+                Box::new(Univ::Var(0x1))
+            ))),
+            "0x90C14041"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::IMax(
+                Box::new(Univ::Var(0x1)),
+                Box::new(Univ::Var(0x0))
+            ))),
+            "0x90C14140"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::IMax(
+                Box::new(Univ::Var(0x1)),
+                Box::new(Univ::Var(0x1))
+            ))),
+            "0x90C14141"
+        ));
+        assert!(test(
+            Ixon::Sort(Box::new(Univ::IMax(
+                Box::new(Univ::Var(0x1)),
+                Box::new(Univ::Var(0x1))
+            ))),
+            "0x90C14141"
+        ));
+        assert!(test(
+            Ixon::Refr(Address::hash(&[]), vec![]),
+            "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::Refr(Address::hash(&[]), vec![Univ::Var(0x0)]),
+            "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240"
+        ));
+        assert!(test(Ixon::Recr(0x0, vec![Univ::Var(0x0)]), "0x20A140"));
+        assert!(test(
+            Ixon::Recr(0x0, vec![Univ::Var(0x0), Univ::Var(0x1)]),
+            "0x20A24041"
+        ));
+        assert!(test(
+            Ixon::Recr(0x8, vec![Univ::Var(0x0), Univ::Var(0x1)]),
+            "0x2808A24041"
+        ));
+        assert!(test(
+            Ixon::Apps(Box::new(Ixon::Vari(0x0)), Box::new(Ixon::Vari(0x1)), vec![]),
+            "0x300001"
+        ));
+        assert!(test(
+            Ixon::Apps(
+                Box::new(Ixon::Vari(0x0)),
+                Box::new(Ixon::Vari(0x1)),
+                vec![Ixon::Vari(0x2)]
+            ),
+            "0x31000102"
+        ));
+        assert!(test(
+            Ixon::Apps(
+                Box::new(Ixon::Vari(0x0)),
+                Box::new(Ixon::Vari(0x1)),
+                vec![
+                    Ixon::Vari(0x2),
+                    Ixon::Vari(0x3),
+                    Ixon::Vari(0x4),
+                    Ixon::Vari(0x5),
+                    Ixon::Vari(0x6),
+                    Ixon::Vari(0x7),
+                    Ixon::Vari(0x8),
+                    Ixon::Vari(0x9),
+                ]
+            ),
+            "0x3808000102030405060708080809"
+        ));
+        assert!(test(
+            Ixon::Lams(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
+            "0x410001"
+        ));
+        assert!(test(
+            Ixon::Lams(
+                vec![
+                    Ixon::Vari(0x0),
+                    Ixon::Vari(0x1),
+                    Ixon::Vari(0x2),
+                    Ixon::Vari(0x3),
+                    Ixon::Vari(0x4),
+                    Ixon::Vari(0x5),
+                    Ixon::Vari(0x6),
+                    Ixon::Vari(0x7)
+                ],
+                Box::new(Ixon::Vari(0x8))
+            ),
+            "0x480800010203040506070808"
+        ));
+        assert!(test(
+            Ixon::Alls(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
+            "0x510001"
+        ));
+        assert!(test(
+            Ixon::Alls(
+                vec![
+                    Ixon::Vari(0x0),
+                    Ixon::Vari(0x1),
+                    Ixon::Vari(0x2),
+                    Ixon::Vari(0x3),
+                    Ixon::Vari(0x4),
+                    Ixon::Vari(0x5),
+                    Ixon::Vari(0x6),
+                    Ixon::Vari(0x7)
+                ],
+                Box::new(Ixon::Vari(0x8))
+            ),
+            "0x580800010203040506070808"
+        ));
+        assert!(test(
+            Ixon::Proj(Address::hash(&[]), 0x0, Box::new(Ixon::Vari(0x0))),
+            "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
+        ));
+        assert!(test(
+            Ixon::Proj(Address::hash(&[]), 0x8, Box::new(Ixon::Vari(0x0))),
+            "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
+        ));
+        assert!(test(Ixon::Strl("".to_string()), "0x70"));
+        assert!(test(Ixon::Strl("foobar".to_string()), "0x76666f6f626172"));
+        assert!(test(Ixon::Natl(Nat::new_le(&[])), "0x8100"));
+        assert!(test(Ixon::Natl(Nat::new_le(&[0x0])), "0x8100"));
+        assert!(test(Ixon::Natl(Nat::new_le(&[0xFF])), "0x81FF"));
+        assert!(test(Ixon::Natl(Nat::new_le(&[0x00, 0x01])), "0x820001"));
+        assert!(test(
+            Ixon::LetE(
+                true,
+                Box::new(Ixon::Vari(0x0)),
+                Box::new(Ixon::Vari(0x1)),
+                Box::new(Ixon::Vari(0x2))
+            ),
+            "0x91000102"
+        ));
+        assert!(test(Ixon::List(vec![]), "0xA0"));
+        assert!(test(
+            Ixon::List(vec![Ixon::Vari(0x0), Ixon::Vari(0x1), Ixon::Vari(0x2)]),
+            "0xA3000102"
+        ));
+        assert!(test(
+            Ixon::Defn(Definition {
+                kind: DefKind::Definition,
+                safety: DefSafety::Unsafe,
+                lvls: 0u64.into(),
+                typ: Address::hash(&[]),
+                value: Address::hash(&[]),
+            }),
+            "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::Defn(Definition {
+                kind: DefKind::Opaque,
+                safety: DefSafety::Safe,
+                lvls: 1u64.into(),
+                typ: Address::hash(&[]),
+                value: Address::hash(&[]),
+            }),
+            "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::Axio(Axiom {
+                is_unsafe: true,
+                lvls: 0u64.into(),
+                typ: Address::hash(&[]),
+            }),
+            "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::Quot(Quotient {
+                kind: QuotKind::Type,
+                lvls: 0u64.into(),
+                typ: Address::hash(&[]),
+            }),
+            "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::CPrj(ConstructorProj {
+                idx: 0u64.into(),
+                cidx: 0u64.into(),
+                block: Address::hash(&[]),
+            }),
+            "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::RPrj(RecursorProj {
+                idx: 0u64.into(),
+                ridx: 0u64.into(),
+                block: Address::hash(&[]),
+            }),
+            "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::IPrj(InductiveProj {
+                idx: 0u64.into(),
+                block: Address::hash(&[]),
+            }),
+            "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::DPrj(DefinitionProj {
+                idx: 0u64.into(),
+                block: Address::hash(&[]),
+            }),
+            "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(Ixon::Inds(vec![]), "0xC0"));
+        assert!(test(
+            Ixon::Inds(vec![Inductive {
+                recr: false,
+                refl: false,
+                is_unsafe: false,
+                lvls: 0u64.into(),
+                params: 0u64.into(),
+                indices: 0u64.into(),
+                nested: 0u64.into(),
+                typ: Address::hash(&[]),
+                ctors: vec![],
+                recrs: vec![],
+            }]),
+            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
+        ));
+        assert!(test(
+            Ixon::Inds(vec![Inductive {
+                recr: false,
+                refl: false,
+                is_unsafe: false,
+                lvls: 0u64.into(),
+                params: 0u64.into(),
+                indices: 0u64.into(),
+                nested: 0u64.into(),
+                typ: Address::hash(&[]),
+                ctors: vec![],
+                recrs: vec![],
+            }]),
+            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
+        ));
+        assert!(test(
+            Ixon::Inds(vec![Inductive {
+                recr: false,
+                refl: false,
+                is_unsafe: false,
+                lvls: 0u64.into(),
+                params: 0u64.into(),
+                indices: 0u64.into(),
+                nested: 0u64.into(),
+                typ: Address::hash(&[]),
+                ctors: vec![Constructor {
+                    is_unsafe: false,
+                    lvls: 0u64.into(),
+                    cidx: 0u64.into(),
+                    params: 0u64.into(),
+                    fields: 0u64.into(),
+                    typ: Address::hash(&[])
+                }],
+                recrs: vec![Recursor {
+                    k: false,
+                    is_unsafe: false,
+                    lvls: 0u64.into(),
+                    params: 0u64.into(),
+                    indices: 0u64.into(),
+                    motives: 0u64.into(),
+                    minors: 0u64.into(),
+                    typ: Address::hash(&[]),
+                    rules: vec![RecursorRule {
+                        fields: 0u64.into(),
+                        rhs: Address::hash(&[])
+                    }]
+                }],
+            }]),
+            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(Ixon::Defs(vec![]), "0xD0"));
+        assert!(test(
+            Ixon::Defs(vec![Definition {
+                kind: DefKind::Definition,
+                safety: DefSafety::Unsafe,
+                lvls: 0u64.into(),
+                typ: Address::hash(&[]),
+                value: Address::hash(&[]),
+            }]),
+            "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(Ixon::Meta(Metadata { map: vec![] }), "0xE0A0"));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(0u64.into(), vec![])]
+            }),
+            "0xE0A18100A0"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(0u64.into(), vec![Metadatum::Name(Name { parts: vec![] })])]
+            }),
+            "0xE0A18100A100A0"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(
+                    0u64.into(),
+                    vec![Metadatum::Name(Name {
+                        parts: vec![NamePart::Str("a".to_string())]
+                    })]
+                )]
+            }),
+            "0xE0A18100A100A17161"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(
+                    0u64.into(),
+                    vec![Metadatum::Name(Name {
+                        parts: vec![
+                            NamePart::Str("a".to_string()),
+                            NamePart::Str("b".to_string()),
+                        ]
+                    })]
+                )]
+            }),
+            "0xE0A18100A100A271617162"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(
+                    0u64.into(),
+                    vec![Metadatum::Name(Name {
+                        parts: vec![
+                            NamePart::Str("a".to_string()),
+                            NamePart::Str("b".to_string()),
+                            NamePart::Str("c".to_string()),
+                        ]
+                    })]
+                )]
+            }),
+            "0xE0A18100A100A3716171627163"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(
+                    0u64.into(),
+                    vec![Metadatum::Name(Name {
+                        parts: vec![NamePart::Num(165851424810452359u64.into())]
+                    })]
+                )]
+            }),
+            "0xE0A18100A100A1880887C551FDFD384D02"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(0u64.into(), vec![Metadatum::Info(BinderInfo::Default)])]
+            }),
+            "0xE0A18100A10100"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(0u64.into(), vec![Metadatum::Link(Address::hash(&[]))])]
+            }),
+            "0xE0A18100A102af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(
+                    0u64.into(),
+                    vec![
+                        Metadatum::Name(Name {
+                            parts: vec![NamePart::Str("d".to_string())]
+                        }),
+                        Metadatum::Link(Address::hash(&[])),
+                        Metadatum::Hints(ReducibilityHints::Regular(576554452)),
+                        Metadatum::Link(Address::hash(&[]))
+                    ]
+                )]
+            }),
+            "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(
+                    0u64.into(),
+                    vec![Metadatum::Hints(ReducibilityHints::Opaque)]
+                )]
+            }),
+            "0xE0A18100A10300"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(0u64.into(), vec![Metadatum::All(vec![])])]
+            }),
+            "0xE0A18100A104A0"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(0u64.into(), vec![Metadatum::MutCtx(vec![])])]
+            }),
+            "0xE0A18100A105A0"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![(
+                    0u64.into(),
+                    vec![Metadatum::Hints(ReducibilityHints::Regular(42))]
+                )]
+            }),
+            "0xe0a18100a103022a000000"
+        ));
+        assert!(test(
+            Ixon::Meta(Metadata {
+                map: vec![
+                    (
+                        0u64.into(),
+                        vec![
+                            Metadatum::Name(Name {
+                                parts: vec![NamePart::Str("d".to_string())]
+                            }),
+                            Metadatum::Link(Address::hash(&[])),
+                            Metadatum::Hints(ReducibilityHints::Regular(576554452)),
+                            Metadatum::Link(Address::hash(&[]))
+                        ]
+                    ),
+                    (
+                        1u64.into(),
+                        vec![
+                            Metadatum::Info(BinderInfo::InstImplicit),
+                            Metadatum::Info(BinderInfo::InstImplicit),
+                            Metadatum::Info(BinderInfo::StrictImplicit),
+                        ]
+                    ),
+                    (
+                        2u64.into(),
+                        vec![
+                            Metadatum::All(vec![Name {
+                                parts: vec![NamePart::Num(165851424810452359u64.into())]
+                            }]),
+                            Metadatum::Info(BinderInfo::Default)
+                        ]
+                    ),
+                    (3u64.into(), vec![]),
+                    (4u64.into(), vec![]),
+                    (
+                        5u64.into(),
+                        vec![Metadatum::Hints(ReducibilityHints::Opaque)]
+                    ),
+                    (
+                        6u64.into(),
+                        vec![Metadatum::Name(Name {
+                            parts: vec![NamePart::Num(871843802607008850u64.into())]
+                        })]
+                    )
+                ]
+            }),
+            "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
+        ));
+    }
 }
 
 //}
diff --git a/src/ixon/address.rs b/src/ixon/address.rs
index d2d43049..ca9d50fc 100644
--- a/src/ixon/address.rs
+++ b/src/ixon/address.rs
@@ -7,6 +7,14 @@ pub struct Address {
     pub hash: Hash,
 }
 
+impl Address {
+    pub fn hash(input: &[u8]) -> Self {
+        Address {
+            hash: blake3::hash(input),
+        }
+    }
+}
+
 impl Serialize for Address {
     fn put(&self, buf: &mut Vec<u8>) {
         buf.extend_from_slice(self.hash.as_bytes())
diff --git a/src/ixon/constant.rs b/src/ixon/constant.rs
index 40ad6dd8..178d5435 100644
--- a/src/ixon/constant.rs
+++ b/src/ixon/constant.rs
@@ -13,16 +13,16 @@ pub enum QuotKind {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Quotient {
+    pub kind: QuotKind,
     pub lvls: Nat,
     pub typ: Address,
-    pub kind: QuotKind,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Axiom {
+    pub is_unsafe: bool,
     pub lvls: Nat,
     pub typ: Address,
-    pub is_unsafe: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -41,21 +41,21 @@ pub enum DefSafety {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Definition {
+    pub kind: DefKind,
+    pub safety: DefSafety,
     pub lvls: Nat,
     pub typ: Address,
-    pub mode: DefKind,
     pub value: Address,
-    pub safety: DefSafety,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Constructor {
+    pub is_unsafe: bool,
     pub lvls: Nat,
-    pub typ: Address,
     pub cidx: Nat,
     pub params: Nat,
     pub fields: Nat,
-    pub is_unsafe: bool,
+    pub typ: Address,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -66,55 +66,55 @@ pub struct RecursorRule {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Recursor {
+    pub k: bool,
+    pub is_unsafe: bool,
     pub lvls: Nat,
-    pub typ: Address,
     pub params: Nat,
     pub indices: Nat,
     pub motives: Nat,
     pub minors: Nat,
+    pub typ: Address,
     pub rules: Vec<RecursorRule>,
-    pub k: bool,
-    pub is_unsafe: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Inductive {
+    pub recr: bool,
+    pub refl: bool,
+    pub is_unsafe: bool,
     pub lvls: Nat,
-    pub typ: Address,
     pub params: Nat,
     pub indices: Nat,
+    pub nested: Nat,
+    pub typ: Address,
     pub ctors: Vec<Constructor>,
     pub recrs: Vec<Recursor>,
-    pub nested: Nat,
-    pub recr: bool,
-    pub refl: bool,
-    pub is_unsafe: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct InductiveProj {
-    pub block: Address,
-    pub idx: Nat,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ConstructorProj {
-    pub block: Address,
     pub idx: Nat,
     pub cidx: Nat,
+    pub block: Address,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RecursorProj {
-    pub block: Address,
     pub idx: Nat,
     pub ridx: Nat,
+    pub block: Address,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct DefinitionProj {
+pub struct InductiveProj {
+    pub idx: Nat,
     pub block: Address,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DefinitionProj {
     pub idx: Nat,
+    pub block: Address,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -152,30 +152,30 @@ impl Serialize for QuotKind {
 
 impl Serialize for Quotient {
     fn put(&self, buf: &mut Vec<u8>) {
+        self.kind.put(buf);
         self.lvls.put(buf);
         self.typ.put(buf);
-        self.kind.put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let kind = QuotKind::get(buf)?;
         let lvls = Nat::get(buf)?;
         let typ = Address::get(buf)?;
-        let kind = QuotKind::get(buf)?;
-        Ok(Quotient { lvls, typ, kind })
+        Ok(Quotient { kind, lvls, typ })
     }
 }
 
 impl Serialize for Axiom {
     fn put(&self, buf: &mut Vec<u8>) {
+        self.is_unsafe.put(buf);
         self.lvls.put(buf);
         self.typ.put(buf);
-        self.is_unsafe.put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let is_unsafe = bool::get(buf)?;
         let lvls = Nat::get(buf)?;
         let typ = Address::get(buf)?;
-        let is_unsafe = bool::get(buf)?;
         Ok(Axiom {
             lvls,
             typ,
@@ -236,46 +236,46 @@ impl Serialize for DefSafety {
 
 impl Serialize for Definition {
     fn put(&self, buf: &mut Vec<u8>) {
+        self.kind.put(buf);
+        self.safety.put(buf);
         self.lvls.put(buf);
         self.typ.put(buf);
-        self.mode.put(buf);
         self.value.put(buf);
-        self.safety.put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let kind = DefKind::get(buf)?;
+        let safety = DefSafety::get(buf)?;
         let lvls = Nat::get(buf)?;
         let typ = Address::get(buf)?;
-        let mode = DefKind::get(buf)?;
         let value = Address::get(buf)?;
-        let safety = DefSafety::get(buf)?;
         Ok(Definition {
+            kind,
+            safety,
             lvls,
             typ,
-            mode,
             value,
-            safety,
         })
     }
 }
 
 impl Serialize for Constructor {
     fn put(&self, buf: &mut Vec<u8>) {
+        self.is_unsafe.put(buf);
         self.lvls.put(buf);
-        self.typ.put(buf);
         self.cidx.put(buf);
         self.params.put(buf);
         self.fields.put(buf);
-        self.is_unsafe.put(buf);
+        self.typ.put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let is_unsafe = bool::get(buf)?;
         let lvls = Nat::get(buf)?;
-        let typ = Address::get(buf)?;
         let cidx = Nat::get(buf)?;
         let params = Nat::get(buf)?;
         let fields = Nat::get(buf)?;
-        let is_unsafe = bool::get(buf)?;
+        let typ = Address::get(buf)?;
         Ok(Constructor {
             lvls,
             typ,
@@ -302,25 +302,25 @@ impl Serialize for RecursorRule {
 
 impl Serialize for Recursor {
     fn put(&self, buf: &mut Vec<u8>) {
+        Ixon::pack_bools(vec![self.k, self.is_unsafe]).put(buf);
         self.lvls.put(buf);
-        self.typ.put(buf);
         self.params.put(buf);
         self.indices.put(buf);
         self.motives.put(buf);
         self.minors.put(buf);
+        self.typ.put(buf);
         self.rules.put(buf);
-        Ixon::pack_bools(vec![self.k, self.is_unsafe]).put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let bools = Ixon::unpack_bools(2, u8::get(buf)?);
         let lvls = Nat::get(buf)?;
-        let typ = Serialize::get(buf)?;
         let params = Nat::get(buf)?;
         let indices = Nat::get(buf)?;
         let motives = Nat::get(buf)?;
         let minors = Nat::get(buf)?;
+        let typ = Serialize::get(buf)?;
         let rules = Serialize::get(buf)?;
-        let bools = Ixon::unpack_bools(2, u8::get(buf)?);
         Ok(Recursor {
             lvls,
             typ,
@@ -337,93 +337,93 @@ impl Serialize for Recursor {
 
 impl Serialize for Inductive {
     fn put(&self, buf: &mut Vec<u8>) {
+        Ixon::pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
         self.lvls.put(buf);
-        self.typ.put(buf);
         self.params.put(buf);
         self.indices.put(buf);
+        self.nested.put(buf);
+        self.typ.put(buf);
         Serialize::put(&self.ctors, buf);
         Serialize::put(&self.recrs, buf);
-        self.nested.put(buf);
-        Ixon::pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let bools = Ixon::unpack_bools(3, u8::get(buf)?);
         let lvls = Nat::get(buf)?;
-        let typ = Address::get(buf)?;
         let params = Nat::get(buf)?;
         let indices = Nat::get(buf)?;
+        let nested = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
         let ctors = Serialize::get(buf)?;
         let recrs = Serialize::get(buf)?;
-        let nested = Nat::get(buf)?;
-        let bools = Ixon::unpack_bools(3, u8::get(buf)?);
         Ok(Inductive {
+            recr: bools[0],
+            refl: bools[1],
+            is_unsafe: bools[2],
             lvls,
-            typ,
             params,
             indices,
+            nested,
+            typ,
             ctors,
             recrs,
-            nested,
-            recr: bools[0],
-            refl: bools[1],
-            is_unsafe: bools[2],
         })
     }
 }
 
 impl Serialize for InductiveProj {
     fn put(&self, buf: &mut Vec<u8>) {
-        self.block.put(buf);
         self.idx.put(buf);
+        self.block.put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let block = Address::get(buf)?;
         let idx = Nat::get(buf)?;
-        Ok(InductiveProj { block, idx })
+        let block = Address::get(buf)?;
+        Ok(InductiveProj { idx, block })
     }
 }
 
 impl Serialize for ConstructorProj {
     fn put(&self, buf: &mut Vec<u8>) {
-        self.block.put(buf);
         self.idx.put(buf);
         self.cidx.put(buf);
+        self.block.put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let block = Address::get(buf)?;
         let idx = Nat::get(buf)?;
         let cidx = Nat::get(buf)?;
-        Ok(ConstructorProj { block, idx, cidx })
+        let block = Address::get(buf)?;
+        Ok(ConstructorProj { idx, cidx, block })
     }
 }
 
 impl Serialize for RecursorProj {
     fn put(&self, buf: &mut Vec<u8>) {
-        self.block.put(buf);
         self.idx.put(buf);
         self.ridx.put(buf);
+        self.block.put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let block = Address::get(buf)?;
         let idx = Nat::get(buf)?;
         let ridx = Nat::get(buf)?;
-        Ok(RecursorProj { block, idx, ridx })
+        let block = Address::get(buf)?;
+        Ok(RecursorProj { idx, ridx, block })
     }
 }
 
 impl Serialize for DefinitionProj {
     fn put(&self, buf: &mut Vec<u8>) {
-        self.block.put(buf);
         self.idx.put(buf);
+        self.block.put(buf);
     }
 
     fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let block = Address::get(buf)?;
         let idx = Nat::get(buf)?;
-        Ok(DefinitionProj { block, idx })
+        let block = Address::get(buf)?;
+        Ok(DefinitionProj { idx, block })
     }
 }
 
@@ -505,11 +505,11 @@ mod tests {
     impl Arbitrary for Definition {
         fn arbitrary(g: &mut Gen) -> Self {
             Self {
+                kind: DefKind::arbitrary(g),
+                safety: DefSafety::arbitrary(g),
                 lvls: Nat::arbitrary(g),
                 typ: Address::arbitrary(g),
-                mode: DefKind::arbitrary(g),
                 value: Address::arbitrary(g),
-                safety: DefSafety::arbitrary(g),
             }
         }
     }
diff --git a/src/ixon/meta.rs b/src/ixon/meta.rs
index 3ecbfbfb..0c6b8b26 100644
--- a/src/ixon/meta.rs
+++ b/src/ixon/meta.rs
@@ -16,7 +16,7 @@ pub enum BinderInfo {
 pub enum ReducibilityHints {
     Opaque,
     Abbrev,
-    Regular,
+    Regular(u32),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -68,7 +68,10 @@ impl Serialize for ReducibilityHints {
         match self {
             Self::Opaque => buf.push(0),
             Self::Abbrev => buf.push(1),
-            Self::Regular => buf.push(2),
+            Self::Regular(x) => {
+                buf.push(2);
+                x.put(buf);
+            }
         }
     }
 
@@ -79,7 +82,10 @@ impl Serialize for ReducibilityHints {
                 match head[0] {
                     0 => Ok(Self::Opaque),
                     1 => Ok(Self::Abbrev),
-                    2 => Ok(Self::Regular),
+                    2 => {
+                        let x: u32 = Serialize::get(buf)?;
+                        Ok(Self::Regular(x))
+                    }
                     x => Err(format!("get ReducibilityHints invalid {x}")),
                 }
             }
@@ -192,7 +198,7 @@ mod tests {
             match x {
                 0 => Self::Opaque,
                 1 => Self::Abbrev,
-                _ => Self::Regular,
+                _ => Self::Regular(Arbitrary::arbitrary(g)),
             }
         }
     }
diff --git a/src/ixon/nat.rs b/src/ixon/nat.rs
index 2c413339..f8278709 100644
--- a/src/ixon/nat.rs
+++ b/src/ixon/nat.rs
@@ -5,7 +5,11 @@ use num_bigint::BigUint;
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Nat(pub BigUint);
 
-impl Nat {}
+impl Nat {
+    pub fn new_le(bytes: &[u8]) -> Self {
+        Nat(BigUint::from_bytes_le(bytes))
+    }
+}
 
 impl Serialize for Nat {
     fn put(&self, buf: &mut Vec<u8>) {
@@ -20,6 +24,15 @@ impl Serialize for Nat {
     }
 }
 
+impl<T> From<T> for Nat
+where
+    T: Into<BigUint>,
+{
+    fn from(x: T) -> Self {
+        Nat(x.into())
+    }
+}
+
 #[cfg(test)]
 pub mod tests {
     use super::*;
diff --git a/src/lean/ffi/ixon.rs b/src/lean/ffi/ixon.rs
index 130ce040..b6f714f6 100644
--- a/src/lean/ffi/ixon.rs
+++ b/src/lean/ffi/ixon.rs
@@ -20,7 +20,7 @@ use crate::{
     },
     lean::{
         array::LeanArrayObject, as_ref_unsafe, ctor::LeanCtorObject, lean_is_scalar,
-        sarray::LeanSArrayObject, string::LeanStringObject,
+        lean_unbox_u32, sarray::LeanSArrayObject, string::LeanStringObject,
     },
     lean_unbox,
 };
@@ -79,8 +79,8 @@ fn lean_ptr_to_definition(ptr: *const c_void) -> Definition {
     let lvls = lean_ptr_to_nat(lvls);
     let typ = lean_ptr_to_address(typ);
     let value = lean_ptr_to_address(value);
-    let [mode, safety, ..] = (mode_safety as usize).to_le_bytes();
-    let mode = match mode {
+    let [kind, safety, ..] = (mode_safety as usize).to_le_bytes();
+    let kind = match kind {
         0 => DefKind::Definition,
         1 => DefKind::Opaque,
         2 => DefKind::Theorem,
@@ -95,7 +95,7 @@ fn lean_ptr_to_definition(ptr: *const c_void) -> Definition {
     Definition {
         lvls,
         typ,
-        mode,
+        kind,
         value,
         safety,
     }
@@ -266,7 +266,10 @@ fn lean_ptr_to_metadatum(ptr: *const c_void) -> Metadatum {
                     _ => unreachable!(),
                 }
             } else {
-                ReducibilityHints::Regular
+                let ctor: &LeanCtorObject = as_ref_unsafe(hints.cast());
+                let [x] = ctor.objs();
+                let x = lean_unbox_u32(x);
+                ReducibilityHints::Regular(x)
             };
             Metadatum::Hints(hints)
         }

From 5fa0c6f5654eb14103a01062d26d0b0f77c78a82 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Thu, 11 Sep 2025 16:08:33 -0300
Subject: [PATCH 44/74] fix FFI for ReducibilityHints::Regular

---
 Tests/Ix/Ixon.lean   | 3 ---
 src/lean/ffi/ixon.rs | 7 +++----
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 0ff27aec..06c9a7fe 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -231,7 +231,6 @@ instance : Shrinkable Claim where
 instance : SampleableExt Claim
   := SampleableExt.mkSelfContained genClaim
 
-
 /--
 Whether the provided IxonFFI term, reconstructed and serialized in Rust, matches
 the provided bytes.
@@ -239,6 +238,4 @@ the provided bytes.
 @[extern "rs_eq_lean_rust_serialization"]
 opaque eqLeanRustSerialization : @& IxonFFI -> @& ByteArray -> Bool
 
-
 end Ixon
-
diff --git a/src/lean/ffi/ixon.rs b/src/lean/ffi/ixon.rs
index b6f714f6..9a3908bd 100644
--- a/src/lean/ffi/ixon.rs
+++ b/src/lean/ffi/ixon.rs
@@ -20,7 +20,7 @@ use crate::{
     },
     lean::{
         array::LeanArrayObject, as_ref_unsafe, ctor::LeanCtorObject, lean_is_scalar,
-        lean_unbox_u32, sarray::LeanSArrayObject, string::LeanStringObject,
+        sarray::LeanSArrayObject, string::LeanStringObject,
     },
     lean_unbox,
 };
@@ -267,9 +267,8 @@ fn lean_ptr_to_metadatum(ptr: *const c_void) -> Metadatum {
                 }
             } else {
                 let ctor: &LeanCtorObject = as_ref_unsafe(hints.cast());
-                let [x] = ctor.objs();
-                let x = lean_unbox_u32(x);
-                ReducibilityHints::Regular(x)
+                let [height] = ctor.objs();
+                ReducibilityHints::Regular(height as u32)
             };
             Metadatum::Hints(hints)
         }

From b900a8f30c9d43a128ab269bcb0b526166e19381 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 18 Sep 2025 21:32:31 -0400
Subject: [PATCH 45/74] WIP: improved performance of mutual def sorting, but
 compilation still OOM on large terms

---
 Ix/Common.lean                | 164 ++++++-
 Ix/CompileM.lean              | 794 +++++++++++++++++-----------------
 Ix/Cronos.lean                |  32 +-
 Ix/DecompileM.lean            |  46 +-
 Ix/IR.lean                    |  79 +++-
 Ix/Ixon.lean                  |   5 +-
 Ix/Ixon/Serialize.lean        |   6 +
 Ix/SOrder.lean                |  57 +++
 Ix/Store.lean                 |  14 +-
 Ix/Toy.lean                   | 325 ++++++++++++++
 Ix/TransportM.lean            |  56 +--
 Ix/UnionFind.lean             |  41 ++
 Tests/Ix/Common.lean          |   2 +-
 Tests/Ix/Compile.lean         | 127 ++++--
 Tests/Ix/Fixtures/Mutual.lean | 162 +++++++
 ix_test/IxTest.lean           |   4 +
 16 files changed, 1401 insertions(+), 513 deletions(-)
 create mode 100644 Ix/SOrder.lean
 create mode 100644 Ix/Toy.lean
 create mode 100644 Ix/UnionFind.lean
 create mode 100644 Tests/Ix/Fixtures/Mutual.lean

diff --git a/Ix/Common.lean b/Ix/Common.lean
index 9416ba8b..38b28c89 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -1,7 +1,6 @@
 import Lean
 import Batteries
 
--- TODO: move to a utils namespace
 def compareList [Ord α] : List α -> List α -> Ordering
 | a::as, b::bs => match compare a b with
   | .eq => compareList as bs
@@ -29,7 +28,7 @@ instance [Ord α] [Ord β] : Ord (α × β) where
     | x => x
 
 instance : Ord Lean.Name where
-  compare := Lean.Name.quickCmp
+  compare := Lean.Name.cmp
 
 deriving instance Ord for Lean.Literal
 --deriving instance Ord for Lean.Expr
@@ -108,13 +107,15 @@ def sortByM [Monad μ] (xs: List α) (cmp: α -> α -> μ Ordering) : μ (List 
   sequencesM cmp xs >>= mergeAllM cmp
 
 /--
-Mergesort from least to greatest. To sort from greatest to least set `rev`
+Mergesort from least to greatest.
 -/
 def sortBy (cmp : α -> α -> Ordering) (xs: List α) : List α :=
   Id.run <| xs.sortByM (fun x y => pure <| cmp x y)
 
+
 def sort [Ord α] (xs: List α) : List α := sortBy compare xs
 
+
 def groupByMAux [Monad μ] (eq : α → α → μ Bool) : List α → List (List α) → μ (List (List α))
   | a::as, (ag::g)::gs => do match (← eq a ag) with
     | true  => groupByMAux eq as ((a::ag::g)::gs)
@@ -129,6 +130,88 @@ def joinM [Monad μ] : List (List α) → μ (List α)
   | []      => return []
   | a :: as => do return a ++ (← joinM as)
 
+-- Combined sort and group operations over (List (List α))
+
+-- Merge two sorted lists of groups, combining groups with equal elements
+partial def mergeGroupsM [Monad μ] (cmp : α → α → μ Ordering)
+  : List (List α) → List (List α) → μ (List (List α))
+  | gs@((g@(a::_))::gs'), hs@((h@(b::_))::hs') => do
+    match (← cmp a b) with
+    | Ordering.lt => List.cons g <$> mergeGroupsM cmp gs' hs
+    | Ordering.gt => List.cons h <$> mergeGroupsM cmp gs hs'
+    | Ordering.eq => List.cons (g ++ h) <$> mergeGroupsM cmp gs' hs'  -- Combine equal groups
+  | [], hs => return hs
+  | gs, [] => return gs
+  | _, _ => return []
+
+-- Merge pairs of grouped lists
+def mergePairsGroupsM [Monad μ] (cmp: α → α → μ Ordering) 
+  : List (List (List α)) → μ (List (List (List α)))
+  | a::b::xs => List.cons <$> (mergeGroupsM cmp a b) <*> mergePairsGroupsM cmp xs
+  | xs => return xs
+
+-- Merge all grouped lists
+partial def mergeAllGroupsM [Monad μ] (cmp: α → α → μ Ordering) 
+  : List (List (List α)) → μ (List (List α))
+  | [] => return []
+  | [x] => return x
+  | xs => mergePairsGroupsM cmp xs >>= mergeAllGroupsM cmp
+
+-- Helper to collect equal consecutive elements into a group
+def collectEqualM [Monad μ] (cmp : α → α → μ Ordering) (x : α)
+  : List α → μ (List α × List α)
+  | y::ys => do
+    if (← cmp x y) == Ordering.eq
+    then do
+      let (group, rest) ← collectEqualM cmp x ys
+      return (y::group, rest)
+    else return ([x], y::ys)
+  | [] => return ([x], [])
+
+mutual
+  -- Build sequences of groups (ascending/descending runs with grouping)
+  partial def sequencesGroupedM [Monad μ] (cmp : α → α → μ Ordering)
+    : List α → μ (List (List (List α)))
+    | [] => return []
+    | a::xs => do
+      let (aGroup, rest) ← collectEqualM cmp a xs
+      match rest with
+      | [] => return [[aGroup]]
+      | b::bs => do
+        let (bGroup, rest') ← collectEqualM cmp b bs
+        if (← cmp a b) == .gt
+        then descendingGroupedM cmp b bGroup [aGroup] rest'
+        else ascendingGroupedM cmp b bGroup (fun gs => aGroup :: gs) rest'
+
+  partial def descendingGroupedM [Monad μ]
+    (cmp : α → α → μ Ordering) (rep : α) (curr : List α) (acc : List (List α))
+    : List α → μ (List (List (List α)))
+    | [] => return [curr::acc]
+    | x::xs => do
+      let (xGroup, rest) ← collectEqualM cmp x xs
+      if (← cmp rep x) == .gt
+      then descendingGroupedM cmp x xGroup (curr::acc) rest
+      else List.cons (curr::acc) <$> sequencesGroupedM cmp (x::xs)
+
+  partial def ascendingGroupedM [Monad μ]
+    (cmp : α → α → μ Ordering) (rep : α) (curr : List α)
+    (acc : List (List α) → List (List α))
+    : List α → μ (List (List (List α)))
+    | [] => return [acc [curr]]
+    | x::xs => do
+      let (xGroup, rest) ← collectEqualM cmp x xs
+      if (← cmp rep x) != .gt
+      then ascendingGroupedM cmp x xGroup (fun gs => acc (curr :: gs)) rest
+      else List.cons (acc [curr]) <$> sequencesGroupedM cmp (x::xs)
+end
+
+def sortAndGroupByM [Monad μ] (xs: List α) (cmp: α -> α -> μ Ordering)
+  : μ (List (List α)) :=
+  sequencesGroupedM cmp xs >>= mergeAllGroupsM cmp
+
+def sortGroupsByM [Monad μ] (xs: List (List α)) (cmp: α -> α -> μ Ordering)
+  : μ (List (List α)) := sortAndGroupByM xs.flatten cmp
+
 end List
 
 namespace Lean
@@ -238,6 +321,24 @@ def runFrontend (input : String) (filePath : FilePath) : IO Environment := do
       (← msgs.toList.mapM (·.toString)).map String.trim
   else return s.commandState.env
 
+def Expr.size: Expr -> Nat
+| .mdata _ x => 1 + x.size
+| .app f a => 1 + f.size + a.size
+| .lam bn bt b bi => 1 + bt.size + b.size
+| .forallE bn bt b bi => 1 + bt.size + b.size
+| .letE ln t v b nd =>  1 + t.size + v.size + b.size
+| .proj tn i s => 1 + s.size
+| x => 1
+
+def Expr.msize: Expr -> Nat
+| .mdata _ x => 1 + x.msize
+| .app f a => f.msize + a.msize
+| .lam bn bt b bi => bt.msize + b.msize
+| .forallE bn bt b bi => bt.msize + b.msize
+| .letE ln t v b nd => t.msize + v.msize + b.msize
+| .proj tn i s => s.msize
+| x => 0
+
 def Expr.stripMData : Expr -> Expr
 | .mdata _ x => x.stripMData
 | .app f a => .app f.stripMData a.stripMData
@@ -245,19 +346,56 @@ def Expr.stripMData : Expr -> Expr
 | .forallE bn bt b bi => .forallE bn bt.stripMData b.stripMData bi
 | .letE ln t v b nd => .letE ln t.stripMData v.stripMData b.stripMData nd
 | .proj tn i s => .proj tn i s.stripMData
-| x => x
+| x@(.lit ..) => x
+| x@(.const ..) => x
+| x@(.bvar ..) => x
+| x@(.fvar ..) => x
+| x@(.sort ..) => x
+| x@(.mvar ..) => x
 
 def RecursorRule.stripMData : RecursorRule -> RecursorRule
-| ⟨c, nf, rhs⟩ => ⟨c, nf, rhs.stripMData⟩
+| x =>
+  dbg_trace s!"RecursorRule.stripMData"
+  match x with
+  | ⟨c, nf, rhs⟩ => ⟨c, nf, rhs.stripMData⟩
+
+def RecursorRule.size : RecursorRule -> Nat
+| ⟨c, nf, rhs⟩ => rhs.size
+
+def RecursorRule.msize : RecursorRule -> Nat
+| ⟨c, nf, rhs⟩ => rhs.msize
 
 def ConstantInfo.stripMData : Lean.ConstantInfo -> Lean.ConstantInfo
-| .axiomInfo x => .axiomInfo { x with type := x.type.stripMData }
-| .defnInfo x => .defnInfo { x with type := x.type.stripMData, value := x.value.stripMData }
-| .thmInfo x => .thmInfo { x with type := x.type.stripMData, value := x.value.stripMData }
-| .quotInfo x => .quotInfo { x with type := x.type.stripMData }
-| .opaqueInfo x => .opaqueInfo { x with type := x.type.stripMData, value := x.value.stripMData }
-| .inductInfo x => .inductInfo { x with type := x.type.stripMData }
-| .ctorInfo x => .ctorInfo { x with type := x.type.stripMData }
-| .recInfo x => .recInfo { x with type := x.type.stripMData, rules := x.rules.map (·.stripMData) }
+| x =>
+  dbg_trace s!"ConstantInfo.stripMData"
+  match x with
+  | .axiomInfo x => .axiomInfo { x with type := x.type.stripMData }
+  | .defnInfo x => .defnInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+  | .thmInfo x => .thmInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+  | .quotInfo x => .quotInfo { x with type := x.type.stripMData }
+  | .opaqueInfo x => .opaqueInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+  | .inductInfo x => .inductInfo { x with type := x.type.stripMData }
+  | .ctorInfo x => .ctorInfo { x with type := x.type.stripMData }
+  | .recInfo x => .recInfo { x with type := x.type.stripMData, rules := x.rules.map (·.stripMData) }
+
+def ConstantInfo.size : Lean.ConstantInfo -> Nat
+| .axiomInfo x => x.type.size
+| .defnInfo x => x.type.size + x.value.size
+| .thmInfo x => x.type.size + x.value.size
+| .quotInfo x => x.type.size
+| .opaqueInfo x => x.type.size + x.value.size
+| .inductInfo x => x.type.size
+| .ctorInfo x => x.type.size
+| .recInfo x => x.type.size + x.rules.foldr (fun a acc => a.size + acc) 0
+
+def ConstantInfo.msize : Lean.ConstantInfo -> Nat
+| .axiomInfo x => x.type.msize
+| .defnInfo x => x.type.msize + x.value.msize
+| .thmInfo x => x.type.msize + x.value.msize
+| .quotInfo x => x.type.msize
+| .opaqueInfo x => x.type.msize + x.value.msize
+| .inductInfo x => x.type.msize
+| .ctorInfo x => x.type.msize
+| .recInfo x => x.type.msize + x.rules.foldr (fun a acc => a.msize + acc) 0
 end Lean
 
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 67bd53d0..b28c6c36 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -1,4 +1,4 @@
-import Batteries.Data.RBMap
+import Std.Data.HashMap
 import Ix.TransportM
 import Ix.Ixon.Metadata
 import Ix.Ixon
@@ -6,9 +6,10 @@ import Ix.Ixon.Const
 import Ix.Ixon.Serialize
 import Ix.Common
 import Ix.Store
+import Ix.SOrder
+import Ix.Cronos
+
 
-open Batteries (RBMap)
-open Batteries (RBSet)
 open Ix.TransportM
 
 namespace Ix.Compile
@@ -59,10 +60,11 @@ def CompileError.pretty : CompileError -> IO String
 | .emptyIndsEquivalenceClass dss => 
   pure s!"empty equivalence class while sorting inductives {dss.map fun ds => ds.map (·.name)}"
 
+
 structure CompileEnv where
   univCtx : List Lean.Name
   bindCtx : List Lean.Name
-  mutCtx  : RBMap Lean.Name Nat compare
+  mutCtx: Std.HashMap Lean.Name Nat
   maxHeartBeats: USize
   current : Lean.Name
 
@@ -74,27 +76,26 @@ open Ixon
 structure CompileState where
   env: Lean.Environment
   prng: StdGen
-  names: RBMap Lean.Name (Address × Address) compare
-  store: RBMap Address Ixon compare
-  cache: RBMap Ix.Const (Address × Address) compare
-  comms: RBMap Lean.Name (Address × Address) compare
-  axioms: RBMap Lean.Name (Address × Address) compare
-  blocks: RBSet (Address × Address) compare
+  names: Std.HashMap Lean.Name (Address × Address)
+  cache: Std.HashMap Ix.Const (Address × Address)
+  comms: Std.HashMap Lean.Name (Address × Address)
+  eqConst: Std.HashMap (Lean.Name × Lean.Name) Ordering
+  axioms: Std.HashMap Lean.Name (Address × Address)
+  blocks: Std.HashSet (Address × Address)
+  cronos: Cronos
 
 def CompileState.init (env: Lean.Environment) (seed: Nat): CompileState :=
-  ⟨env, mkStdGen seed, default, default, default, default, default, default⟩
+  ⟨env, mkStdGen seed, default, default, default, default, default, default, default, default⟩
 
-abbrev CompileM := ReaderT CompileEnv <| EStateM CompileError CompileState
+abbrev CompileM :=
+  ReaderT CompileEnv <| ExceptT CompileError <| StateT CompileState IO
 
 def CompileM.run (env: CompileEnv) (stt: CompileState) (c : CompileM α)
-  : EStateM.Result CompileError CompileState α
-  := EStateM.run (ReaderT.run c env) stt
+  : IO (Except CompileError α × CompileState)
+  := StateT.run (ExceptT.run (ReaderT.run c env)) stt
 
 def storeConst (const: Ixon): CompileM Address := do
-  let addr := Address.blake3 (runPut (Serialize.put const))
-  modifyGet fun stt => (addr, { stt with
-    store := stt.store.insert addr const
-  })
+  liftM (Store.writeConst const).toIO
 
 def randByte (lo hi: Nat): CompileM Nat := do
   modifyGet fun s => 
@@ -121,65 +122,77 @@ def withLevels (lvls : List Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with univCtx := lvls }
 
 -- add mutual recursion info to local context
-def withMutCtx (mutCtx : RBMap Lean.Name Nat compare) 
+def withMutCtx (mutCtx : Std.HashMap Lean.Name Nat)
   : CompileM α -> CompileM α :=
   withReader $ fun c => { c with mutCtx := mutCtx }
 
 -- reset local context
 def resetCtx : CompileM α -> CompileM α :=
-  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := .empty }
+  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {} }
 
 def resetCtxWithLevels (lvls: List Lean.Name) : CompileM α -> CompileM α :=
-  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := .empty }
+  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := {} }
+
+def dematerializeConst (x: Ix.Const) : CompileM (Ixon × Ixon) :=
+  match dematerialize x with
+  | .ok (ix, tstt) => do
+    for (addr, ixon) in tstt.store do
+      let _ <- liftM (Store.forceWriteConst addr ixon).toIO
+    return (ix, Ixon.meta ⟨tstt.meta.toList⟩)
+  | .error e => throw (.transportError e)
+
+def cron (tag: String) : CompileM Unit := do
+  let stt <- get
+  let c <- liftM <| Cronos.clock stt.cronos tag
+  modify fun stt => { stt with cronos := c }
+
+def getCron (tag: String) : CompileM String := do
+  return (<- get).cronos.tagSummary tag
 
 -- lookup or compute the addresses of a constant
 def hashConst (const: Ix.Const) : CompileM (Address × Address) := do
-  match (<- get).cache.find? const with
+  match (<- get).cache.get? const with
   | some (anonAddr, metaAddr) => pure (anonAddr, metaAddr)
   | none => do
-    let (anonIxon, metaIxon) <- match constToIxon const with
-      | .ok (a, m) => pure (a, m)
-      | .error e => throw (.transportError e)
+    let cronTag := s!"hashConst {const.name}"
+    dbg_trace "-> hashConst {const.name}";
+    cron cronTag
+    let (anonIxon, metaIxon) <- dematerializeConst const
     let anonAddr <- storeConst anonIxon
     let metaAddr <- storeConst metaIxon
+    cron cronTag
+    let timing <- getCron cronTag
+    dbg_trace "✓ {timing}";
+    dbg_trace "names: {(<- get).names.size}";
+    dbg_trace "cache: {(<- get).cache.size}";
+    dbg_trace "eqConst: {(<- get).eqConst.size}";
+    dbg_trace "blocks: {(<- get).blocks.size}";
     modifyGet fun stt => ((anonAddr, metaAddr), { stt with
       cache := stt.cache.insert const (anonAddr, metaAddr)
     })
 
-scoped instance : HMul Ordering Ordering Ordering where hMul
-  | .gt, _ => .gt
-  | .lt, _ => .lt
-  | .eq, x => x
-
-def concatOrds : List Ordering → Ordering :=
-  List.foldl (· * ·) .eq
-
 /-- Defines an ordering for Lean universes -/
 def compareLevel (xctx yctx: List Lean.Name)
-  : Lean.Level -> Lean.Level -> CompileM Ordering
+  : Lean.Level -> Lean.Level -> CompileM SOrder
   | x@(.mvar ..), _ => throw $ .unfilledLevelMetavariable x
   | _, y@(.mvar ..) => throw $ .unfilledLevelMetavariable y
-  | .zero, .zero => return .eq
-  | .zero, _ => return .lt
-  | _, .zero => return .gt
+  | .zero, .zero => return ⟨true, .eq⟩
+  | .zero, _ => return ⟨true, .lt⟩
+  | _, .zero => return ⟨true, .gt⟩
   | .succ x, .succ y => compareLevel xctx yctx x y
-  | .succ .., _ => return .lt
-  | _, .succ .. => return .gt
-  | .max xl xr, .max yl yr => do
-    let l' <- compareLevel xctx yctx xl yl
-    let r' <- compareLevel xctx yctx xr yr
-    return l' * r'
-  | .max .., _ => return .lt
-  | _, .max .. => return .gt
-  | .imax xl xr, .imax yl yr => do
-    let l' <- compareLevel xctx yctx xl yl
-    let r' <- compareLevel xctx yctx xr yr
-    return l' * r'
-  | .imax .., _ => return .lt
-  | _, .imax .. => return .gt
+  | .succ .., _ => return ⟨true, .lt⟩
+  | _, .succ .. => return ⟨true, .gt⟩
+  | .max xl xr, .max yl yr => SOrder.cmpM
+    (compareLevel xctx yctx xl yl) (compareLevel xctx yctx xr yr)
+  | .max .., _ => return ⟨true, .lt⟩
+  | _, .max .. => return ⟨true, .gt⟩
+  | .imax xl xr, .imax yl yr => SOrder.cmpM
+      (compareLevel xctx yctx xl yl) (compareLevel xctx yctx xr yr)
+  | .imax .., _ => return ⟨true, .lt⟩
+  | _, .imax .. => return ⟨true, .gt⟩
   | .param x, .param y => do
     match (xctx.idxOf? x), (yctx.idxOf? y) with
-    | some xi, some yi => return (compare xi yi)
+    | some xi, some yi => return ⟨true, compare xi yi⟩
     | none,    _       => 
       throw $ .levelNotFound x xctx s!"compareLevel @ {(<- read).current}"
     | _,       none    => 
@@ -220,12 +233,22 @@ mutual
 partial def compileConst (const : Lean.ConstantInfo)
   : CompileM (Address × Address) := do
   -- first check if we've already compiled this const
-  match (← get).names.find? const.name with
+  match (← get).names.get? const.name with
   -- if we have, returned the cached address
   | some (anonAddr, metaAddr) => do
     pure (anonAddr, metaAddr)
   -- if not, pattern match on the const
-  | none => resetCtx $ withCurrent const.name $ match const with
+  | none => do
+    dbg_trace "-> compileConst {const.name}";
+    let cronTag := s!"compileConst {const.name}"
+    cron cronTag
+    let addrs <- compileInner const
+    cron cronTag
+    let timing <- getCron cronTag
+    dbg_trace "✓ {timing}";
+    return addrs
+  where
+    compileInner (const: Lean.ConstantInfo) := resetCtx $ withCurrent const.name $ match const with
     -- convert possible mutual block elements to PreDefinitions
     | .defnInfo val => do
       compileDefinition (mkPreDefinition val)
@@ -274,9 +297,10 @@ partial def compileConst (const : Lean.ConstantInfo)
 /-- compile possibly mutual Lean definition --/
 partial def compileDefinition (struct: PreDefinition)
   : CompileM (Address × Address) := do
+  dbg_trace "compileDefinition {struct.name}"
   -- If the mutual size is one, simply content address the single definition
   if struct.all matches [_] then
-    let defn <- withMutCtx (.single struct.name 0) $ preDefinitionToIR struct
+    let defn <- withMutCtx ({(struct.name,0)}) $ preDefinitionToIR struct
     let (anonAddr, metaAddr) <- hashConst $ .definition defn
     modify fun stt => { stt with
       names := stt.names.insert struct.name (anonAddr, metaAddr)
@@ -291,19 +315,11 @@ partial def compileDefinition (struct: PreDefinition)
       | .thmInfo x => mutDefs := mutDefs.push (mkPreTheorem x)
       | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
   let mutualDefs <- sortDefs mutDefs.toList
-  -- Building the `mutCtx`
-  let mut mutCtx := default
-  let mut i := 0
-  for ds in mutualDefs do
-    let mut x := #[]
-    for d in ds do
-      x := x.push d.name
-      mutCtx := mutCtx.insert d.name i
-    i := i + 1
-  let definitions ← withMutCtx mutCtx $ mutualDefs.mapM (·.mapM preDefinitionToIR)
+  let mutCtx := defMutCtx mutualDefs
+  let definitions ← withMutCtx mutCtx <|
+    mutualDefs.mapM (·.mapM preDefinitionToIR)
   -- Building and storing the block
-  let (blockAnonAddr, blockMetaAddr) ←
-    hashConst $ .mutual ⟨definitions⟩
+  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .mutual ⟨definitions⟩
   modify fun stt =>
     { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
   -- While iterating on the definitions from the mutual block, we need to track
@@ -312,7 +328,7 @@ partial def compileDefinition (struct: PreDefinition)
   for name in struct.all do
     -- Storing and caching the definition projection
     -- Also adds the constant to the array of constants
-    let some idx := mutCtx.find? name | throw $ .cantFindMutDefIndex name
+    let some idx := mutCtx.get? name | throw $ .cantFindMutDefIndex name
     let (anonAddr, metaAddr) ←
       hashConst $ .definitionProj ⟨name, blockAnonAddr, blockMetaAddr, idx⟩
     modify fun stt => { stt with
@@ -325,6 +341,7 @@ partial def compileDefinition (struct: PreDefinition)
 
 partial def preDefinitionToIR (d: PreDefinition)
   : CompileM Ix.Definition := withCurrent d.name $ withLevels d.levelParams do
+  dbg_trace "preDefinitionToIR {d.name}"
   let typ <- compileExpr d.type
   let val <- compileExpr d.value
   return ⟨d.name, d.levelParams, typ, d.kind, val, d.hints, d.safety, d.all⟩
@@ -346,6 +363,7 @@ partial def getRecursors (ind : Lean.InductiveVal)
 
 partial def makePreInductive (ind: Lean.InductiveVal) 
   : CompileM Ix.PreInductive := do
+    dbg_trace "-> makePreInductive {ind.name}";
     let ctors <- ind.ctors.mapM getCtor
     let recrs <- getRecursors ind
     return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices,
@@ -356,16 +374,6 @@ partial def makePreInductive (ind: Lean.InductiveVal)
         | .ctorInfo c => pure c
         | _ => throw <| .invalidConstantKind name "constructor" ""
 
-partial def checkCtorRecrLengths : List PreInductive -> CompileM (Nat × Nat)
-| [] => return (0, 0)
-| x::xs => go x xs
-  where
-    go : PreInductive -> List PreInductive -> CompileM (Nat × Nat)
-    | x, [] => return (x.ctors.length, x.recrs.length)
-    | x, a::as =>
-      if x.ctors.length == a.ctors.length && x.recrs.length == a.recrs.length
-      then go x as else throw <| .nonCongruentInductives x a
-
 /--
 Content-addresses an inductive and all inductives in the mutual block as a
 mutual block, even if the inductive itself is not in a mutual block.
@@ -375,9 +383,9 @@ constructors and recursors, hence the complexity of this function.
 -/
 partial def compileInductive (initInd: Lean.InductiveVal) 
   : CompileM (Address × Address) := do
+  dbg_trace "-> compileInductive {initInd.name}";
   let mut preInds := #[]
-  let mut nameData : RBMap Lean.Name (List Lean.Name × List Lean.Name) compare
-    := .empty
+  let mut nameData : Std.HashMap Lean.Name (List Lean.Name × List Lean.Name) := {}
   -- collect all mutual inductives as Ix.PreInductives
   for indName in initInd.all do
     match ← findLeanConst indName with
@@ -388,22 +396,7 @@ partial def compileInductive (initInd: Lean.InductiveVal)
     | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
   -- sort PreInductives into equivalence classes
   let mutualInds <- sortInds preInds.toList
-  let mut mutCtx : RBMap Lean.Name Nat compare := default
-  let mut i := 0
-  -- build the mutual context
-  for inds in mutualInds do
-    let mut x := #[]
-    -- double-check that all inductives in the class have the same number
-    -- of constructors and recursors
-    let (numCtors, numRecrs) <- checkCtorRecrLengths inds
-    for ind in inds do
-      x := x.push ind.name
-      mutCtx := mutCtx.insert ind.name i
-      for (c, cidx) in List.zipIdx ind.ctors do
-        mutCtx := mutCtx.insert c.name (i + cidx)
-      for (r, ridx) in List.zipIdx ind.recrs do
-        mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
-    i := i + 1 + numCtors + numRecrs
+  let mutCtx := indMutCtx mutualInds
   -- compile each preinductive with the mutCtx
   let irInds ← withMutCtx mutCtx $ mutualInds.mapM (·.mapM preInductiveToIR)
   let (blockAnonAddr, blockMetaAddr) ← hashConst $ .inductive ⟨irInds⟩
@@ -421,7 +414,7 @@ partial def compileInductive (initInd: Lean.InductiveVal)
       names := stt.names.insert name (anonAddr, metaAddr)
     }
     if name == initInd.name then ret? := some (anonAddr, metaAddr)
-    let some (ctors, recrs) := nameData.find? indName
+    let some (ctors, recrs) := nameData.get? indName
       | throw $ .cantFindMutDefIndex indName
     for (ctorName, ctorIdx) in ctors.zipIdx do
       -- Store and cache constructor projections
@@ -445,6 +438,7 @@ partial def compileInductive (initInd: Lean.InductiveVal)
 
 partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive 
   := withCurrent ind.name $ withLevels ind.levelParams $ do
+  dbg_trace "-> preInductiveToIR {ind.name}";
   let (recs, ctors) := <- ind.recrs.foldrM (init := ([], [])) collectRecsCtors
   let type <- compileExpr ind.type
     -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
@@ -467,6 +461,7 @@ partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive
 partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
   : CompileM (Ix.Recursor × List Ix.Constructor) :=
   withCurrent recr.name $ withLevels recr.levelParams do
+    dbg_trace s!"internalRecToIR"
     let typ ← compileExpr recr.type
     let (retCtors, retRules) ← recr.rules.foldrM (init := ([], []))
       fun r (retCtors, retRules) => do
@@ -480,6 +475,7 @@ partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
 
 partial def externalRecToIR (recr: Lean.RecursorVal): CompileM Recursor :=
   withCurrent recr.name $ withLevels recr.levelParams do
+    dbg_trace s!"externalRecToIR"
     let typ ← compileExpr recr.type
     let rules ← recr.rules.mapM externalRecRuleToIR
     return ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
@@ -487,6 +483,7 @@ partial def externalRecToIR (recr: Lean.RecursorVal): CompileM Recursor :=
 
 partial def recRuleToIR (rule : Lean.RecursorRule)
   : CompileM (Ix.Constructor × Ix.RecursorRule) := do
+  dbg_trace s!"recRuleToIR"
   let rhs ← compileExpr rule.rhs
   match ← findLeanConst rule.ctor with
   | .ctorInfo ctor => withCurrent ctor.name $ withLevels ctor.levelParams do
@@ -511,314 +508,333 @@ encoded as `.rec_` with indexes based on order in the mutual definition
 and thus we can canon the actual constant right away
 -/
 partial def compileExpr : Lean.Expr → CompileM Expr
-| .mdata _ e => compileExpr e
-| expr => match expr with
-  | .bvar idx => do match (← read).bindCtx[idx]? with
-    -- Bound variables must be in the bind context
-    | some _ => return .var idx
-    | none => throw $ .invalidBVarIndex idx
-  | .sort lvl => return .sort $ ← compileLevel lvl
-  | .const name lvls => do
-    let univs ← lvls.mapM compileLevel
-    match (← read).mutCtx.find? name with
-    -- recursing!
-    | some i => return .rec_ name i univs
-    | none => match (<- get).comms.find? name with
-      | some (commAddr, metaAddr) => do
-        return .const name commAddr metaAddr univs
-      | none => do
-        let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
-        return .const name contAddr metaAddr univs
-  | .app fnc arg => return .app (← compileExpr fnc) (← compileExpr arg)
-  | .lam name typ bod info =>
-    return .lam name info (← compileExpr typ) (← withBinder name $ compileExpr bod)
-  | .forallE name dom img info =>
-    return .pi name info (← compileExpr dom) (← withBinder name $ compileExpr img)
-  | .letE name typ exp bod nD =>
-    return .letE name (← compileExpr typ) (← compileExpr exp)
-      (← withBinder name $ compileExpr bod) nD
-  | .lit lit => return .lit lit
-  | .proj name idx exp => do
-    let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
-    return .proj name contAddr metaAddr idx (← compileExpr exp)
-  | .fvar ..  => throw $ .freeVariableExpr expr
-  | .mvar ..  => throw $ .metaVariableExpr expr
-  | .mdata .. => throw $ .metaDataExpr expr
+| .bvar idx => do match (← read).bindCtx[idx]? with
+  -- Bound variables must be in the bind context
+  | some _ => return .var idx
+  | none => throw $ .invalidBVarIndex idx
+| .sort lvl => return .sort $ ← compileLevel lvl
+| .const name lvls => do
+  let univs ← lvls.mapM compileLevel
+  match (← read).mutCtx.get? name with
+  -- recursing!
+  | some i => return .rec_ name i univs
+  | none => match (<- get).comms.get? name with
+    | some (commAddr, metaAddr) => do
+      return .const name commAddr metaAddr univs
+    | none => do
+      let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
+      return .const name contAddr metaAddr univs
+| .app fnc arg => return .app (← compileExpr fnc) (← compileExpr arg)
+| .lam name typ bod info =>
+  return .lam name info (← compileExpr typ) (← withBinder name $ compileExpr bod)
+| .forallE name dom img info =>
+  return .pi name info (← compileExpr dom) (← withBinder name $ compileExpr img)
+| .letE name typ exp bod nD =>
+  return .letE name (← compileExpr typ) (← compileExpr exp)
+    (← withBinder name $ compileExpr bod) nD
+| .lit lit => return .lit lit
+| .proj name idx exp => do
+  let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
+  return .proj name contAddr metaAddr idx (← compileExpr exp)
+| expr@(.fvar ..)  => throw $ .freeVariableExpr expr
+| expr@(.mvar ..)  => throw $ .metaVariableExpr expr
+-- TODO: cursed
+| (.mdata _ x) => compileExpr x
 
 /--
 A name-irrelevant ordering of Lean expressions.
-`weakOrd` contains the best known current mutual ordering
 -/
-partial def compareExpr
-  (weakOrd : RBMap Lean.Name Nat compare)
+partial def compareExpr (ctx: Std.HashMap Lean.Name Nat)
   (xlvls ylvls: List Lean.Name)
-  : Lean.Expr → Lean.Expr → CompileM Ordering
+  --: Lean.Expr → Lean.Expr → CompileM SOrder
+  (x y: Lean.Expr) : CompileM SOrder := do
+  --dbg_trace "compareExpr {repr xlvls} {repr ylvls} {repr x} {repr y}"
+  --let mutCtx := (<- read).mutCtx
+  --dbg_trace "mutCtx {repr mutCtx}";
+  match x, y with
   | e@(.mvar ..), _ => throw $ .unfilledExprMetavariable e
   | _, e@(.mvar ..) => throw $ .unfilledExprMetavariable e
   | e@(.fvar ..), _ => throw $ .freeVariableExpr e
   | _, e@(.fvar ..) => throw $ .freeVariableExpr e
-  | .mdata _ x, .mdata _ y  => compareExpr weakOrd xlvls ylvls x y
-  | .mdata _ x, y  => compareExpr weakOrd xlvls ylvls x y
-  | x, .mdata _ y  => compareExpr weakOrd xlvls ylvls x y
-  | .bvar x, .bvar y => return (compare x y)
-  | .bvar .., _ => return .lt
-  | _, .bvar .. => return .gt
+  | .mdata _ x, .mdata _ y  => compareExpr ctx xlvls ylvls x y
+  | .mdata _ x, y  => compareExpr ctx xlvls ylvls x y
+  | x, .mdata _ y  => compareExpr ctx xlvls ylvls x y
+  | .bvar x, .bvar y => return ⟨true, compare x y⟩
+  | .bvar .., _ => return ⟨true, .lt⟩
+  | _, .bvar .. => return ⟨true, .gt⟩
   | .sort x, .sort y => compareLevel xlvls ylvls x y
-  | .sort .., _ => return .lt
-  | _, .sort .. => return .gt
+  | .sort .., _ => return ⟨true, .lt⟩
+  | _, .sort .. => return ⟨true, .gt⟩
   | .const x xls, .const y yls => do
-    let univs ← concatOrds <$> (xls.zip yls).mapM
-      fun (x,y) => compareLevel xlvls ylvls x y
-    if univs != .eq then
-      return univs
-    match weakOrd.find? x, weakOrd.find? y with
-    | some nx, some ny => return compare nx ny
+    --dbg_trace "compare const {x} {y}";
+    let univs ← SOrder.zipM (compareLevel xlvls ylvls) xls yls
+    if univs.ord != .eq then return univs
+    --dbg_trace "compare const {x} {y} {repr ctx}";
+    match ctx.get? x, ctx.get? y with
+    | some nx, some ny => return ⟨false, compare nx ny⟩
     | none, some _ => do
-      return .gt
+      return ⟨true, .gt⟩
     | some _, none =>
-      return .lt
+      return ⟨true, .lt⟩
     | none, none =>
       if x == y then 
-        return .eq
+        return ⟨true, .eq⟩
       else do
         let x' <- compileConst $ ← findLeanConst x
         let y' <- compileConst $ ← findLeanConst y
-        return compare x' y'
-  | .const .., _ => return .lt
-  | _, .const .. => return .gt
-  | .app xf xa, .app yf ya => do
-    let f' <- compareExpr weakOrd xlvls ylvls xf yf
-    let a' <- compareExpr weakOrd xlvls ylvls xa ya
-    return f' * a'
-  | .app .., _ => return .lt
-  | _, .app .. => return .gt
-  | .lam _ xt xb _, .lam _ yt yb _ => do
-    let t' <- compareExpr weakOrd xlvls ylvls xt yt
-    let b' <- compareExpr weakOrd xlvls ylvls xb yb
-    return t' * b'
-  | .lam .., _ => return .lt
-  | _, .lam .. => return .gt
-  | .forallE _ xt xb _, .forallE _ yt yb _ => do
-    let t' <- compareExpr weakOrd xlvls ylvls xt yt
-    let b' <- compareExpr weakOrd xlvls ylvls xb yb
-    return t' * b'
-  | .forallE .., _ => return .lt
-  | _, .forallE .. => return .gt
-  | .letE _ xt xv xb _, .letE _ yt yv yb _ => do
-    let t' <- compareExpr weakOrd xlvls ylvls xt yt
-    let v' <- compareExpr weakOrd xlvls ylvls xv yv
-    let b' <- compareExpr weakOrd xlvls ylvls xb yb
-    return t' * v' * b'
-  | .letE .., _ => return .lt
-  | _, .letE .. => return .gt
-  | .lit x, .lit y =>
-    return if x < y then .lt else if x == y then .eq else .gt
-  | .lit .., _ => return .lt
-  | _, .lit .. => return .gt
-  | .proj _ nx tx, .proj _ ny ty => do
-    let ts ← compareExpr weakOrd xlvls ylvls tx ty
-    return concatOrds [compare nx ny, ts]
-
-/-- AST comparison of two Lean definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-partial def compareDef
-  (weakOrd : RBMap Lean.Name Nat compare)
-  (x y: PreDefinition)
-  : CompileM Ordering := do
-  let kind := compare x.kind y.kind
-  let ls := compare x.levelParams.length y.levelParams.length
-  let ts ← compareExpr weakOrd x.levelParams y.levelParams x.type y.type
-  let vs ← compareExpr weakOrd x.levelParams y.levelParams x.value y.value
-  return concatOrds [kind, ls, ts, vs]
-
-/-- AST equality between two Lean definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-@[inline] partial def eqDef
-  (weakOrd : RBMap Lean.Name Nat compare)
-  (x y : PreDefinition) 
-  : CompileM Bool :=
-  return (← compareDef weakOrd x y) == .eq
+        return ⟨true, compare x' y'⟩
+  | .const .., _ => return ⟨true, .lt⟩
+  | _, .const .. => return ⟨true, .gt⟩
+  | .app xf xa, .app yf ya =>
+    SOrder.cmpM 
+      (compareExpr ctx xlvls ylvls xf yf) 
+      (compareExpr ctx xlvls ylvls xa ya)
+  | .app .., _ => return ⟨true, .lt⟩
+  | _, .app .. => return ⟨true, .gt⟩
+  | .lam _ xt xb _, .lam _ yt yb _ => 
+    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
+  | .lam .., _ => return ⟨true, .lt⟩
+  | _, .lam .. => return ⟨true, .gt⟩
+  | .forallE _ xt xb _, .forallE _ yt yb _ => 
+    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
+  | .forallE .., _ => return ⟨true, .lt⟩
+  | _, .forallE .. => return ⟨true, .gt⟩
+  | .letE _ xt xv xb _, .letE _ yt yv yb _ =>
+    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) <|
+    SOrder.cmpM (compareExpr ctx xlvls ylvls xv yv)
+      (compareExpr ctx xlvls ylvls xb yb)
+  | .letE .., _ => return ⟨true, .lt⟩
+  | _, .letE .. => return ⟨true, .gt⟩
+  | .lit x, .lit y => return ⟨true, compare x y⟩
+  | .lit .., _ => return ⟨true, .lt⟩
+  | _, .lit .. => return ⟨true, .gt⟩
+  | .proj _ nx tx, .proj _ ny ty => 
+    SOrder.cmpM (pure ⟨true, compare nx ny⟩) 
+      (compareExpr ctx xlvls ylvls tx ty)
+
+/-- AST comparison of two Lean definitions. --/
+partial def compareDef (ctx: Std.HashMap Lean.Name Nat) (x y: PreDefinition) : CompileM Ordering := do
+  let key := match compare x.name y.name with
+    | .lt => (x.name, y.name)
+    | _ => (y.name, x.name)
+  match (<- get).eqConst.get? key with
+  | some o => return o
+  | none => do
+    let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
+    if sorder.strong then modify fun stt => { stt with
+        eqConst := stt.eqConst.insert key sorder.ord
+      }
+    return sorder.ord
 
 /--
-`sortDefs` recursively sorts a list of mutual definitions into weakly equal blocks.
-At each stage, we take as input the current best approximation of known weakly equal
-blocks as a List of blocks, hence the `List (List DefinitionVal)` as the argument type.
-We recursively take the input blocks and resort to improve the approximate known
-weakly equal blocks, obtaining a sequence of list of blocks:
+`sortDefs` recursively sorts a list of mutual definitions into equivalence classes.
+At each stage, we take as input the current best known equivalence
+classes (held in the `mutCtx` of the CompileEnv). For most cases, equivalence
+can be determined by syntactic differences which are invariant to the current
+best known classification. For example:
+
 ```
-dss₀ := [startDefs]
-dss₁ := sortDefs dss₀
-dss₂ := sortDefs dss₁
-dss₍ᵢ₊₁₎ := sortDefs dssᵢ ...
+mutual
+  def : Nat := 1
+  def bar : Nat := 2
+end
+```
+
+are both different due to the different values in the definition. We call this a
+"strong" ordering, and comparisons between defintions that produce strong
+orderings are cached across compilation.
+
+However, there are also weak orderings, where the order of definitions in a
+mutual block depends on itself.
+
+```
+mutual
+  def A : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + C n + 1
+
+  def B : Nat → Nat
+  | 0 => 0
+  | n + 1 => C n + 1
+
+  def C : Nat → Nat
+  | 0 => 0
+  | n + 1 => A n + 1
+end
 ```
-Initially, `startDefs` is simply the list of definitions we receive from `DefinitionVal.all`;
-since there is no order yet, we treat it as one block all weakly equal. On the other hand,
-at the end, there is some point where `dss₍ᵢ₊₁₎ := dssᵢ`, then we have hit a fixed point
-and we may end the sorting process. (We claim that such a fixed point exists, although
-technically we don't really have a proof.)
-
-On each iteration, we hope to improve our knowledge of weakly equal blocks and use that
-knowledge in the next iteration. e.g. We start with just one block with everything in it,
-but the first sort may differentiate the one block into 3 blocks. Then in the second
-iteration, we have more information than than first, since the relationship of the 3 blocks
-gives us more information; this information may then be used to sort again, turning 3 blocks
-into 4 blocks, and again 4 blocks into 6 blocks, etc, until we have hit a fixed point.
-This step is done in the computation of `newDss` and then comparing it to the original `dss`.
-
-Two optimizations:
-
-1. `names := enum dss` records the ordering information in a map for faster access.
-    Directly using `List.findIdx?` on dss is slow and introduces `Option` everywhere.
-    `names` is used as a custom comparison in `ds.sortByM (cmpDef names)`.
-2. `normDss/normNewDss`. We want to compare if two lists of blocks are equal.
-    Technically blocks are sets and their order doesn't matter, but we have encoded
-    them as lists. To fix this, we sort the list by name before comparing. Note we
-    could maybe also use `List (RBTree ..)` everywhere, but it seemed like a hassle.
+
+Here since any reference to A, B, C has to be compiled into an index, the
+ordering chosen for A, B, C will effect itself, since we compile into
+something that looks, with order [A, B, C] like:
+
+```
+mutual
+  def #1 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #2 n + #3 n + 1
+
+  def #2 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #3 n + 1
+
+  def #3 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #1 n + 1
+end
+```
+
+This is all well and good, but if we chose order `[C, B, A]` then the block
+would compile as
+
+```
+mutual
+  def #1 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #3 n + 1
+
+  def #2 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #1 n + 1
+
+  def #3 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #2 n + #1 n + 1
+end
+```
+
+with completely different hashes. So we need to figure out a canonical order for
+such mutual blocks.
+
+We start by assuming that all definitions in a mutual block are equal and then 
+recursively refining this assumption through successive sorting passes. This
+algorithm bears some similarity to partition refinement:
+```
+classes₀ := [startDefs]
+classes₁ := sortDefs classes₀
+classes₂ := sortDefs classes₁
+classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
+```
+Initially, `startDefs` is simply the list of definitions we receive from
+`DefinitionVal.all`, sorted by name. We assume that at we will reach some
+fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no further refinement is
+possible (we have not rigourously proven such a fixed point exists, but
+it seams reasonable given that after the first pass to find the strongly ordered
+definitions, the algorithm should only separate partitions into smaller ones)
 -/
-partial def sortPreDefs (dss : List (List PreDefinition)) :
-    CompileM (List (List PreDefinition)) := do
-  let enum (ll : List (List PreDefinition)) :=
-    RBMap.ofList (ll.zipIdx.map fun (xs, n) => xs.map (·.name, n)).flatten
-  let weakOrd := enum dss _
-  let newDss ← (← dss.mapM fun ds =>
-    match ds with
-    | []  => unreachable!
-    | [d] => pure [[d]]
-    | ds  => do pure $ (← List.groupByM (eqDef weakOrd) $
-      ← ds.sortByM (compareDef weakOrd))).joinM
-  -- must normalize, see comments
-  let normDss    := dss.map    fun ds => ds.map (·.name) |>.sort
-  let normNewDss := newDss.map fun ds => ds.map (·.name) |>.sort
-  if normDss == normNewDss then return newDss
-  else sortPreDefs newDss
-
-partial def sortDefs: List PreDefinition -> CompileM (List (List PreDefinition))
-| [] => return []
-| xs => sortDefs' [xs.sortBy (fun x y => compare x.name y.name)]
-
-partial def weakOrdDefs (dss: List (List PreDefinition)) 
-  : CompileM (RBMap Lean.Name Nat compare) := do
-  let mut weakOrd := default
-  for (ds, n) in dss.zipIdx do
-    for d in ds do
-      weakOrd := weakOrd.insert d.name n
-  return weakOrd
-
-partial def sortDefs' (dss: List (List PreDefinition))
+partial def sortDefs (classes : List PreDefinition)
   : CompileM (List (List PreDefinition)) := do
-  let weakOrd <- weakOrdDefs dss
-  let mut dss' : Array (List PreDefinition) := default
-  for ds in dss do
-    match ds with
-    | [] => throw <| .emptyDefsEquivalenceClass dss
-    | [d] => dss' := dss'.push [d]
-    | ds => do
-      let ds' <- ds.sortByM (compareDef weakOrd)
-      let ds' <- List.groupByM (eqDef weakOrd) ds'
-      for d in ds' do
-        let d' <- d.sortByM (fun x y => pure $ compare x.name y.name)
-        dss' := dss'.push d'
-  if dss == dss'.toList
-  then return dss
-  else sortDefs' dss'.toList
-
-
-/-- AST comparison of two Lean opaque definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-partial def compareInd
-  (weakOrd : RBMap Lean.Name Nat compare)
-  (x y: PreInductive)
+    sortDefsInner [List.sortBy (compare ·.name ·.name) classes] 0
+  where
+    eqDef (ctx: Std.HashMap Lean.Name Nat) (x y: PreDefinition) 
+      : CompileM Bool := (· == .eq) <$> compareDef ctx x y
+    sortDefsInner (classes: List (List PreDefinition)) (iter: Nat)
+      : CompileM (List (List PreDefinition)) := do
+      let ctx := defMutCtx classes
+      dbg_trace "sortdefs {iter} classes {repr (classes.map (·.map (·.name)))}";
+      let newClasses ← classes.mapM fun ds =>
+        match ds with
+        | []  => unreachable!
+        | [d] => pure [[d]]
+        | ds  => do pure $ (← List.groupByM (eqDef ctx) $ ← ds.sortByM (compareDef ctx))
+      let newClasses := newClasses.flatten.map (List.sortBy (compare ·.name ·.name))
+      if classes == newClasses then return newClasses
+      else sortDefsInner newClasses (iter + 1)
+
+/-- AST comparison of two Lean inductives. --/
+partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInductive) 
   : CompileM Ordering := do
-  let ls := compare x.levelParams.length y.levelParams.length
-  let ts ← compareExpr weakOrd x.levelParams y.levelParams x.type y.type
-  let nps := compare x.numParams y.numParams
-  let nis := compare x.numIndices y.numIndices
-  let ctors <- compareListM compareCtors x.ctors y.ctors
-  let recrs <- compareListM compareRecrs x.recrs y.recrs
-  return concatOrds [ls, ts,nps, nis, ctors, recrs]
+  --dbg_trace "compareInd {x.name} {y.name}";
+  let key := match compare x.name y.name with
+    | .lt => (x.name, y.name)
+    | _ => (y.name, x.name)
+  match (<- get).eqConst.get? key with
+  | some o => return o
+  | none => do
+    let sorder <- do
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.numIndices y.numIndices⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.ctors.length y.ctors.length⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.recrs.length y.recrs.length⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+      SOrder.cmpM (SOrder.zipM compareCtor x.ctors y.ctors)
+        (SOrder.zipM compareRecr x.recrs y.recrs)
+    if sorder.strong then modify fun stt => { stt with
+        eqConst := stt.eqConst.insert key sorder.ord
+      }
+    --dbg_trace "compareInd {x.name} {y.name} -> {repr sorder.ord}";
+    return sorder.ord
   where
-    compareCtors (x y: Lean.ConstructorVal) : CompileM Ordering := do
-      let ls := compare x.levelParams.length y.levelParams.length
-      let ts <- compareExpr weakOrd x.levelParams y.levelParams x.type y.type
-      let cis := compare x.cidx y.cidx
-      let nps := compare x.numParams y.numParams
-      let nfs := compare x.numFields y.numFields
-      return concatOrds [ls, ts, cis, nps, nfs]
-    compareRecrs (x y: Lean.RecursorVal) : CompileM Ordering := do
-      let ls := compare x.levelParams.length y.levelParams.length
-      let ts <- compareExpr weakOrd x.levelParams y.levelParams x.type y.type
-      let nps := compare x.numParams y.numParams
-      let nis := compare x.numIndices y.numIndices
-      let nmos := compare x.numMotives y.numMotives
-      let nmis := compare x.numMinors y.numMinors
-      let rrs <- compareListM (compareRules x.levelParams y.levelParams) x.rules y.rules
-      let ks := compare x.k y.k
-      return concatOrds [ls, ts, nps, nis, nmos, nmis, rrs, ks]
-    compareRules (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule) 
-      : CompileM Ordering := do
-      let nfs := compare x.nfields y.nfields
-      let rs <- compareExpr weakOrd xlvls ylvls x.rhs y.rhs
-      return concatOrds [nfs, rs]
-
-/-- AST equality between two Lean opaque definitions.
-  `weakOrd` contains the best known current mutual ordering -/
-@[inline] partial def eqInd
-  (weakOrd : RBMap Lean.Name Nat compare)
-  (x y : PreInductive)
-  : CompileM Bool :=
-  return (← compareInd weakOrd x y) == .eq
-
-partial def sortInds: List PreInductive -> CompileM (List (List PreInductive))
-| [] => return []
-| xs => sortInds' [xs.sortBy (fun x y => compare x.name y.name)]
-
---          e_1                    e_2                         e_k
--- [ [i_1_1, i_1_2, ..., i_1_E1], [i_2_1, i_2_2, ..., i_1_E2], ... [i_k_1, i_k_2, ..., i_k_EK]]
--- let x be the class index, and y be the inductive index within the class
---  i_x_y contains c constructors and r recursors, each with a `cidx`
---  constructor index and a `ridx` recursor index
--- to construct a weak ordering, we need to create a natural number index `n` for each
--- inductive, constructor and recursors in the list of equivalence classes, such
--- that inductives in the same class, constructors with the same cidx, and
--- recursors with the same ridx all have the same weak index
-
-partial def weakOrdInds (iss: List (List PreInductive))
-  : CompileM (RBMap Lean.Name Nat compare) := do
-  let mut weakOrd := default
-  let mut idx := 0
-  for is in iss do
-    let mut maxCtors := 0
-    let mut maxRecrs := 0
-    for i in is do
-      weakOrd := weakOrd.insert i.name idx
-      let numCtors := i.ctors.length
-      let numRecrs := i.recrs.length
-      if numCtors > maxCtors then maxCtors := numCtors
-      if numRecrs > maxRecrs then maxRecrs := numRecrs
-      for (ctor, cidx) in i.ctors.zipIdx do
-        weakOrd := weakOrd.insert ctor.name (idx + 1 + cidx )
-      for (recr, ridx) in i.recrs.zipIdx do
-        weakOrd := weakOrd.insert recr.name (idx + 1 + numCtors + ridx)
-    idx := idx + 1 + maxCtors + maxRecrs
-  return weakOrd
-
-partial def sortInds' (iss: List (List PreInductive))
+    compareCtor (x y: Lean.ConstructorVal) : CompileM SOrder := do
+     --dbg_trace "compareCtor {x.name} {y.name}";
+      let key := match compare x.name y.name with
+        | .lt => (x.name, y.name)
+        | _ => (y.name, x.name)
+      match (<- get).eqConst.get? key with
+      | some o => return ⟨true, o⟩
+      | none => do
+      let sorder <- do
+        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.cidx y.cidx⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.numFields y.numFields⟩) <|
+          (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+      if sorder.strong then modify fun stt => { stt with
+          eqConst := stt.eqConst.insert key sorder.ord
+        }
+      return sorder
+    compareRecr (x y: Lean.RecursorVal) : CompileM SOrder := do
+      --dbg_trace "compareRecr {x.name} {y.name}";
+      let key := match compare x.name y.name with
+        | .lt => (x.name, y.name)
+        | _ => (y.name, x.name)
+      match (<- get).eqConst.get? key with
+      | some o => return ⟨true, o⟩
+      | none => do
+      let sorder <- do
+        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+        SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
+        SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
+        SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
+        SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+          (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
+      if sorder.strong then modify fun stt => { stt with
+          eqConst := stt.eqConst.insert key sorder.ord
+        }
+      return sorder
+    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
+      : CompileM SOrder := do
+        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
+          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
+
+--#check List.sortBy (compare ·.name ·.name) [`Test.Ix.Inductives.C, `Test.Ix.Inductives.A, `Test.Ix.Inductives.B]
+
+/-- `sortInds` recursively sorts a list of inductive datatypes into equivalence
+classes, analogous to `sortDefs`
+--/
+partial def sortInds (classes : (List PreInductive)) 
   : CompileM (List (List PreInductive)) := do
-  let weakOrd <- weakOrdInds iss
-  let mut iss' : Array (List PreInductive) := default
-  for is in iss do
-    match is with
-    | [] => throw <| .emptyIndsEquivalenceClass iss
-    | [i] => iss' := iss'.push [i]
-    | is => do
-      let is' <- is.sortByM (compareInd weakOrd)
-      let is' <- List.groupByM (eqInd weakOrd) is'
-      for i in is' do
-        let i' <- i.sortByM (fun x y => pure $ compare x.name y.name)
-        iss' := iss'.push i'
-  if iss == iss'.toList
-  then return iss
-  else sortInds' iss'.toList
+    sortIndsInner [List.sortBy (compare ·.name ·.name) classes] 0
+  where
+    eqInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInductive) : CompileM Bool
+      := (· == .eq) <$> compareInd ctx x y
+    sortIndsInner (classes: List (List PreInductive)) (iter: Nat)
+      : CompileM (List (List PreInductive)) := do
+      dbg_trace "sortInds {iter} classes {repr (classes.map (·.map (·.name)))}";
+      let ctx := indMutCtx classes
+      let newClasses ← classes.mapM fun ds =>
+        match ds with
+        | []  => unreachable!
+        | [d] => pure [[d]]
+        | ds  => do pure $ (← List.groupByM (eqInd ctx) $ ← ds.sortByM (compareInd ctx))
+      let newClasses := newClasses.flatten.map (List.sortBy (compare ·.name ·.name))
+      if classes == newClasses then return newClasses
+      else sortIndsInner newClasses (iter + 1)
 
 end
 
@@ -848,9 +864,7 @@ partial def addDef
   let val' <- compileExpr val
   let anonConst := Ix.Const.definition 
     ⟨.anonymous, lvls, typ', .definition, val', .opaque, .safe, []⟩
-  let anonIxon <- match constToIxon anonConst with
-    | .ok (a, _) => pure a
-    | .error e => throw (.transportError e)
+  let (anonIxon,_) <- dematerializeConst anonConst
   let anonAddr <- storeConst anonIxon
   let name := anonAddr.toUniqueName
   let const := 
@@ -954,21 +968,17 @@ def CompileM.runIO (c : CompileM α)
   let seed <- match seed with
     | .none => IO.monoNanosNow
     | .some s => pure s
-  match c.run (.init maxHeartBeats) (.init env seed) with
-  | .ok a stt => do
-    stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
-    return (a, stt)
-  | .error e _ => throw (IO.userError (<- e.pretty))
+  match <- c.run (.init maxHeartBeats) (.init env seed) with
+  | (.ok a, stt) => return (a, stt)
+  | (.error e, _) => throw (IO.userError (<- e.pretty))
 
 def CompileM.runIO' (c : CompileM α) 
   (stt: CompileState)
   (maxHeartBeats: USize := 200000)
   : IO (α × CompileState) := do
-  match c.run (.init maxHeartBeats) stt with
-  | .ok a stt => do
-    stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
-    return (a, stt)
-  | .error e _ => throw (IO.userError (<- e.pretty))
+  match <- c.run (.init maxHeartBeats) stt with
+  | (.ok a, stt) => return (a, stt)
+  | (.error e, _) => throw (IO.userError (<- e.pretty))
 
-def compileEnvIO (env: Lean.Environment) : IO CompileState := do
+def compileEnvIO (env: Lean.Environment) : IO (CompileState):= do
   Prod.snd <$> (compileDelta env.getDelta).runIO env
diff --git a/Ix/Cronos.lean b/Ix/Cronos.lean
index 92f1992e..4b09d3b8 100644
--- a/Ix/Cronos.lean
+++ b/Ix/Cronos.lean
@@ -1,10 +1,8 @@
-import Batteries
-
-open Batteries (RBMap)
+import Std.Data.HashMap
 
 structure Cronos where
-  refs : RBMap String Nat compare
-  data : RBMap String Nat compare
+  refs : Std.HashMap String Nat
+  data : Std.HashMap String Nat
   deriving Inhabited
 
 namespace Cronos
@@ -14,7 +12,7 @@ def new : Cronos :=
 
 def clock (c : Cronos) (tag : String) : IO Cronos := do
   let now ← IO.monoNanosNow
-  match c.refs.find? tag with
+  match c.refs.get? tag with
   | none => return { c with refs := c.refs.insert tag now }
   | some ref => return {
     refs := c.refs.insert tag now,
@@ -26,14 +24,22 @@ def nanoToSec (nanos : Nat) : Float :=
 def secToNano (s : Float) : Nat :=
   s.toUInt64.toNat * 1000000000
 
-def summary (c : Cronos) : String :=
-  let timings := c.data.foldl (init := "")
-    fun acc tag time => s!"{acc}\n  {tag} | {nanoToSec time}s"
-  s!"Timings:{timings}"
+def tagSummary (c : Cronos) (tag: String): String := Id.run do
+  match c.data.get? tag with
+  | some time => s!"{tag} | {nanoToSec time}s"
+  | none => s!"{tag} not logged"
+
+def summary (c : Cronos) : String := Id.run do
+  let mut str := ""
+  for (tag, time) in c.data do
+    str := str.append s!"\n  {tag} | {nanoToSec time}s"
+  s!"Timings:{str}"
 
 -- Get the average time in nanoseconds, returns NaN if no `data` entries
-def mean (c : Cronos) : Float :=
-  let timings := c.data.valuesList
-  Float.ofNat timings.sum / Float.ofNat timings.length
+def mean (c : Cronos) : Float := Id.run do
+  let mut sum : Nat := 0
+  for (_, time) in c.data do
+    sum := sum + time
+  Float.ofNat sum / Float.ofNat c.data.size
 
 end Cronos
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index 4da13645..0c3755de 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -1,4 +1,4 @@
-import Batteries.Data.RBMap
+import Std.Data.HashMap
 import Ix.TransportM
 import Ix.Ixon.Metadata
 import Ix.Ixon.Const
@@ -7,8 +7,6 @@ import Ix.Common
 import Ix.Store
 import Ix.CompileM
 
-open Batteries (RBMap)
-open Batteries (RBSet)
 open Ix.TransportM
 open Ix.Compile
 open Ixon
@@ -27,18 +25,18 @@ instance : ToString Named where
 
 /- The local environment for the Ix -> Lean4 decompiler -/
 structure DecompileEnv where
-  names : RBMap Lean.Name (Address × Address) compare
-  store : RBMap Address Ixon compare
+  names : Std.HashMap Lean.Name (Address × Address) 
+  store : Std.HashMap Address Ixon
   univCtx : List Lean.Name
   bindCtx : List Lean.Name
-  mutCtx  : RBMap Lean.Name Nat compare
+  mutCtx  : Std.HashMap Lean.Name Nat
   current: Named
   deriving Repr, Inhabited
 
 /- initialize from an Ixon store and a name-index to the store -/
 def DecompileEnv.init
-  (names : RBMap Lean.Name (Address × Address) compare)
-  (store : RBMap Address Ixon compare)
+  (names : Std.HashMap Lean.Name (Address × Address))
+  (store : Std.HashMap Address Ixon)
   : DecompileEnv
   := ⟨names, store, default, default, default, default⟩
 
@@ -99,8 +97,8 @@ def BlockNames.contains (name: Lean.Name) : BlockNames -> Bool
 | .inductive is => is.any (fun i => i.contains name)
 
 structure DecompileState where
-  constants: RBMap Lean.Name Lean.ConstantInfo compare
-  blocks : RBMap (Address × Address) BlockNames compare
+  constants: Std.HashMap Lean.Name Lean.ConstantInfo
+  blocks : Std.HashMap (Address × Address) BlockNames
   deriving Inhabited
 
 inductive DecompileError
@@ -110,10 +108,10 @@ inductive DecompileError
   (exp: Lean.Name) (idx: Nat)
 | invalidBVarIndex (curr: Named) (ctx: List Lean.Name) (idx: Nat)
 | mismatchedMutIdx
-  (curr: Named) (ctx: RBMap Lean.Name Nat compare) (exp: Lean.Name) 
+  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) 
   (idx: Nat) (got: Nat)
 | unknownMutual 
-  (curr: Named) (ctx: RBMap Lean.Name Nat compare) (exp: Lean.Name) (idx: Nat)
+  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) (idx: Nat)
 | transport (curr: Named) (err: TransportError) (cont meta: Address)
 | unknownName (curr: Named) (name: Lean.Name)
 | unknownStoreAddress (curr: Named) (exp: Address)
@@ -190,7 +188,7 @@ def withLevels (lvls : List Lean.Name) : DecompileM α -> DecompileM α :=
   withReader $ fun c => { c with univCtx := lvls }
 
 -- add mutual recursion info to local context
-def withMutCtx (mutCtx : RBMap Lean.Name Nat compare) 
+def withMutCtx (mutCtx : Std.HashMap Lean.Name Nat)
   : DecompileM α -> DecompileM α :=
   withReader $ fun c => { c with mutCtx := mutCtx }
 
@@ -200,10 +198,10 @@ def withNamed (name: Lean.Name) (cont meta: Address)
 
 -- reset local context
 def resetCtx : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := .empty }
+  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {} }
 
 def resetCtxWithLevels (lvls: List Lean.Name) : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := .empty }
+  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := {} }
 
 def decompileLevel: Ix.Level → DecompileM Lean.Level
 | .zero => pure .zero
@@ -221,7 +219,7 @@ def decompileLevel: Ix.Level → DecompileM Lean.Level
 partial def insertConst
   (const: Lean.ConstantInfo)
   : DecompileM Lean.Name := do
-  match (<- get).constants.find? const.name with
+  match (<- get).constants.get? const.name with
   | .some const' =>
       if const == const' then return const.name
       else throw <| .overloadedConstants (<- read).current const const'
@@ -244,8 +242,8 @@ partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
       return ⟨val, ctors, recrs⟩
 
 partial def decompileMutualCtx (ctx: List (List Lean.Name))
-  : DecompileM (RBMap Lean.Name Nat compare) := do
-  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
+  : DecompileM (Std.HashMap Lean.Name Nat) := do
+  let mut mutCtx : Std.HashMap Lean.Name Nat := {}
   for (ns, i) in List.zipIdx ctx do
     for n in ns do
       mutCtx := mutCtx.insert n i
@@ -262,8 +260,8 @@ partial def checkCtorRecrLengths : List Ix.Inductive -> DecompileM (Nat × Nat)
       then go x as else throw <| .nonCongruentInductives (<- read).current x a
 
 partial def decompileMutIndCtx (block: Ix.InductiveBlock)
-  : DecompileM (RBMap Lean.Name Nat compare) := do
-  let mut mutCtx : RBMap Lean.Name Nat compare := RBMap.empty
+  : DecompileM (Std.HashMap Lean.Name Nat) := do
+  let mut mutCtx : Std.HashMap Lean.Name Nat := {}
   let mut i := 0
   for inds in block.inds do
     let (numCtors, numRecrs) <- checkCtorRecrLengths inds
@@ -301,22 +299,22 @@ partial def decompileExpr: Ix.Expr → DecompileM Lean.Expr
 | .const n cont meta us => do
     let _ <- ensureBlock n cont meta
     return Lean.mkConst n (<- us.mapM decompileLevel)
-| .rec_ n i us => do match (<- read).mutCtx.find? n with
+| .rec_ n i us => do match (<- read).mutCtx.get? n with
   | some i' =>
     if i == i' then return Lean.mkConst n (<- us.mapM decompileLevel)
     else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx n i i'
   | none => throw <| .unknownMutual (<- read).current (<- read).mutCtx n i
 
 partial def ensureBlock (name: Lean.Name) (c m: Address) : DecompileM BlockNames := do
-  match (<- get).blocks.find? (c, m) with
+  match (<- get).blocks.get? (c, m) with
   | .some b =>
     if b.contains name then pure b
     else throw <| .nameNotInBlockNames (<- read).current b name c m
   | .none =>
-    let cont : Ixon.Const <- match (<- read).store.find? c with
+    let cont : Ixon.Const <- match (<- read).store.get? c with
       | .some ixon => pure ixon
       | .none => throw <| .unknownStoreAddress (<- read).current c
-    let meta : Ixon.Const <- match (<- read).store.find? m with
+    let meta : Ixon.Const <- match (<- read).store.get? m with
       | .some ixon => pure ixon
       | .none => throw <| .unknownStoreAddress (<- read).current m
     match rematerialize cont meta with
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 2db59151..ec745652 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -77,7 +77,7 @@ are closed.
 
 /--
 Ix.Level universe levels are almost identical to Lean.Level, except that they
-exclude metavariables and de-bruijn index variable parameters.
+add de-bruijn indices for variable parameters and exclude metavariables.
 --/
 inductive Level
   | zero
@@ -136,7 +136,7 @@ structure PreDefinition where
   hints : Lean.ReducibilityHints
   safety : Lean.DefinitionSafety
   all : List Lean.Name
-  deriving BEq, Repr, Nonempty
+  deriving BEq, Repr, Nonempty, Hashable, Inhabited
 
 def mkPreDefinition (x: Lean.DefinitionVal) : PreDefinition := 
   ⟨x.name, x.levelParams, x.type, .definition, x.value, x.hints, x.safety, x.all⟩
@@ -148,6 +148,18 @@ def mkPreOpaque (x: Lean.OpaqueVal) : PreDefinition :=
   ⟨x.name, x.levelParams, x.type, .opaque, x.value, .opaque,
     if x.isUnsafe then .unsafe else .safe, x.all⟩
 
+def defMutCtx (defss: List (List PreDefinition)) : Std.HashMap Lean.Name Nat 
+  := Id.run do
+  let mut mutCtx := default
+  let mut i := 0
+  for defs in defss do
+    let mut x := #[]
+    for d in defs do
+      x := x.push d.name
+      mutCtx := mutCtx.insert d.name i
+    i := i + 1
+  return mutCtx
+
 /--
 Ix.Definition definitions combine Lean.DefinitionVal, Lean.OpaqueVal and
 Lean.TheoremVal into a single structure in order to enable content-addressing of
@@ -208,7 +220,7 @@ structure Constructor where
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 /--
-Ix.RecursorRule is analogous to Lean.RecursorRule 
+Ix.RecursorRule is analogous to Lean.RecursorRule
 --/
 structure RecursorRule where
   ctor : Lean.Name
@@ -253,7 +265,53 @@ structure PreInductive where
   isRec : Bool
   isReflexive : Bool
   isUnsafe: Bool
-  deriving BEq, Repr, Nonempty
+  deriving BEq, Repr, Nonempty, Inhabited
+
+
+-- We have a list of classes of inductive datatypes, each class representing a
+-- possible equivalence class. We would like to construct a unique numerical
+-- index for each inductive, constructor and recursor within this list of
+-- classes.
+
+-- Consider the classes: `[e_0, e_1, ..., e_a]`, where `a` is the maximum index
+-- of our input. Each class `e_x` contains inductives `[i_x_0, i_j_1, ...,
+-- i_j_b]`, where `b` is the maximum index of `e_x`. Each `i_x_y` contains
+-- `i_x_y_c` constructors and `i_x_y_r` recursors. If the classes are true
+-- equivalence classes then the all inductives in `e_x` will have the same
+-- number of constructors and recursors and 
+-- `∀ y1 y2: i_x_y1_c == i_x_y2_c && i_x_y1_r == i_x_y2_r` 
+--
+-- Unfortunately, since we use this function within the sorting function that
+-- produces the equivalence classes, our indexing has to be robust to the
+-- possiblity that inductives in a class do *not* have the same number of
+-- constructors and recursors.
+--
+-- We do this by first finding the inductives in the class with the maximum
+-- number of constructors and the maximum number of recursors. Then we
+-- "reserves" index space for the entire class based on those two maxima.
+-- Inductives with smaller numbers of constructors or recursors will not create
+-- conflicts. For example, if a class has an inductive with 2 ctors and 4 recrs
+-- and an inductive with 3 ctors and 2 recrs, then the whole class will reserve
+-- 8 indices (one for the inductive type itself plus 3 ctors and 4 recrs).
+
+def indMutCtx (indss: List (List PreInductive))
+  : Std.HashMap Lean.Name Nat := Id.run do
+  let mut mutCtx := default
+  let mut idx := 0
+  for inds in indss do
+    let mut maxCtors := 0
+    let mut maxRecrs := 0
+    for ind in inds do
+      maxCtors := max maxCtors ind.ctors.length
+      maxRecrs := max maxRecrs ind.recrs.length
+    for ind in inds do
+      mutCtx := mutCtx.insert ind.name idx
+      for (c, cidx) in List.zipIdx ind.ctors do
+        mutCtx := mutCtx.insert c.name (idx + 1 + cidx)
+      for (r, ridx) in List.zipIdx ind.recrs do
+        mutCtx := mutCtx.insert r.name (idx + 1 + maxCtors + ridx)
+    idx := idx + 1 + maxCtors + maxRecrs
+  return mutCtx
 
 /--
 Ix.Inductive represents inductive datatypes and is analogous to
@@ -355,12 +413,23 @@ inductive Const where
   -- constants to represent mutual blocks
   | «mutual» : MutualBlock → Const
   | «inductive» : InductiveBlock → Const
-  deriving Ord, BEq, Inhabited, Repr, Nonempty
+  deriving Ord, BEq, Inhabited, Repr, Nonempty, Hashable
 
 def Const.isMutBlock : Const → Bool
   | .mutual _ | .inductive _ => true
   | _ => false
 
+def Const.name : Const → List (Lean.Name)
+  | .axiom x => [x.name]
+  | .quotient x => [x.name]
+  | .definition x => [x.name]
+  | .inductiveProj x => [x.name]
+  | .constructorProj x => [x.name]
+  | .recursorProj x => [x.name]
+  | .definitionProj x => [x.name]
+  | .mutual x => x.ctx.flatten
+  | .inductive x => x.ctx.flatten
+
 namespace Level
 
 /--
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 9234b71e..f4cbfbcd 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -1,3 +1,4 @@
+import Std.Data.HashMap
 import Ix.Address
 import Ix.Ixon.Serialize
 import Ix.Ixon.Univ
@@ -13,7 +14,7 @@ inductive Ixon where
 | sort : Univ -> Ixon                         -- 0x90, universes
 | refr : Address -> List Univ -> Ixon         -- 0x1X, global reference
 | recr : UInt64 -> List Univ -> Ixon          -- 0x2X, local recursion
-| apps : Ixon -> Ixon -> List Ixon -> Ixon    -- 0x3X, funciton application
+| apps : Ixon -> Ixon -> List Ixon -> Ixon    -- 0x3X, function application
 | lams : List Ixon -> Ixon -> Ixon            -- 0x4X, lambda abstraction
 | alls : List Ixon -> Ixon -> Ixon            -- 0x5X, universal quantification
 | proj : Address -> UInt64 -> Ixon -> Ixon    -- 0x6X, structure projection
@@ -38,6 +39,8 @@ inductive Ixon where
 | envn : Env -> Ixon                         -- 0xE5, Lean4 environment
 deriving BEq, Repr, Inhabited
 
+abbrev Store := Std.HashMap Address Ixon
+
 open Serialize
 
 partial def putIxon : Ixon -> PutM Unit
diff --git a/Ix/Ixon/Serialize.lean b/Ix/Ixon/Serialize.lean
index 5598c3c6..d8be32b3 100644
--- a/Ix/Ixon/Serialize.lean
+++ b/Ix/Ixon/Serialize.lean
@@ -399,4 +399,10 @@ instance : Serialize Address where
   put x := putBytes x.hash
   get := Address.mk <$> getBytes 32
 
+def serialize {A: Type} [Serialize A] (x: A) : ByteArray :=
+  runPut <| Serialize.put x
+
+def deserialize {A: Type} [Serialize A] (bs: ByteArray) : Except String A :=
+  runGet Serialize.get bs
+
 end Ixon
diff --git a/Ix/SOrder.lean b/Ix/SOrder.lean
new file mode 100644
index 00000000..661fbdf2
--- /dev/null
+++ b/Ix/SOrder.lean
@@ -0,0 +1,57 @@
+/-- an Ordering with a boolean strength --/
+structure SOrder where
+  strong: Bool
+  ord: Ordering
+
+namespace SOrder
+
+@[inline]
+def cmp : SOrder -> SOrder -> SOrder
+| ⟨true, .eq⟩, y => y
+| ⟨false, .eq⟩, y => ⟨false, y.ord⟩
+| x, _ => x
+
+@[inline]
+def cmpM [Monad μ] (x y: μ SOrder) : μ SOrder := do
+  match <- x with
+  | ⟨true, .eq⟩ => y
+  | ⟨false, .eq⟩ => y >>= fun ⟨_, b⟩ => pure ⟨false, b⟩
+  | x => pure x
+
+@[inline]
+def cmpMany : SOrder -> List SOrder -> SOrder
+| a, [] => a
+| a, b::[] => cmp a b
+| a, b::bs => match cmp a b with
+  | x@⟨_, .eq⟩ => cmpMany x bs
+  | x => x
+
+@[specialize]
+def cmpManyM [Monad μ] : μ SOrder -> List (μ SOrder) -> μ SOrder
+| ma, [] => ma
+| ma, mb::[] => cmpM ma mb
+| ma, mb::mbs => do match (<- cmpM ma mb) with
+  | x@⟨_, .eq⟩ => cmpManyM (pure x) mbs
+  | x => pure x
+
+@[specialize, inline]
+def zip (f: α -> α -> SOrder) : List α -> List α -> SOrder
+| [] , [] => ⟨true, .eq⟩
+| [], _ => ⟨true, .lt⟩
+| _, [] => ⟨true, .gt⟩
+| x::xs, y::ys => 
+  match f x y with
+  | a@⟨_, .eq⟩ => cmp a (zip f xs ys)
+  | a => a
+
+@[specialize, inline]
+def zipM [Monad μ] (f: α -> α -> μ SOrder)
+  : List α -> List α -> μ SOrder
+  | [] , [] => pure ⟨true, .eq⟩
+  | [], _ => pure ⟨true, .lt⟩
+  | _, [] => pure ⟨true, .gt⟩
+  | x::xs, y::ys => do match <- (f x y) with
+    | a@⟨_, .eq⟩ => cmpM (pure a) (zipM f xs ys)
+    | a => pure a
+
+end SOrder
diff --git a/Ix/Store.lean b/Ix/Store.lean
index cb11c5fd..6ec0b5e8 100644
--- a/Ix/Store.lean
+++ b/Ix/Store.lean
@@ -33,20 +33,22 @@ def getHomeDir : StoreIO FilePath := do
   | .some path => return ⟨path⟩
   | .none => throw .noHome
 
+-- TODO: make this the default dir for the store, but customizable
 def storeDir : StoreIO FilePath := do
   let home ← getHomeDir
-  return home / ".ix" / "store"
-
-def ensureStoreDir : StoreIO Unit := do
-  let store ← storeDir
-  IO.toEIO .ioError (IO.FS.createDirAll store)
+  let path := home / ".ix" / "store"
+  if !(<- path.pathExists) then
+    IO.toEIO .ioError (IO.FS.createDirAll path)
+  return path
 
 def writeConst (x: Ixon) : StoreIO Address := do
   let bytes := runPut (Serialize.put x)
   let addr  := Address.blake3 bytes
   let store ← storeDir
   let path := store / hexOfBytes addr.hash
-  let _ <- IO.toEIO .ioError (IO.FS.writeBinFile path bytes)
+  -- trust that the store is correct
+  if !(<- path.pathExists) then
+    let _ <- IO.toEIO .ioError (IO.FS.writeBinFile path bytes)
   return addr
 
 -- unsafe, can corrupt store if called with bad address
diff --git a/Ix/Toy.lean b/Ix/Toy.lean
new file mode 100644
index 00000000..5a343438
--- /dev/null
+++ b/Ix/Toy.lean
@@ -0,0 +1,325 @@
+--import Lean
+--import Std.Data.HashMap
+--import Blake3
+--
+--namespace List
+--
+--partial def mergeM [Monad μ] (cmp : α → α → μ Ordering) : List α → List α → μ (List α)
+--  | as@(a::as'), bs@(b::bs') => do
+--    if (← cmp a b) == Ordering.gt
+--    then List.cons b <$> mergeM cmp as bs'
+--    else List.cons a <$> mergeM cmp as' bs
+--  | [], bs => return bs
+--  | as, [] => return as
+--
+--def mergePairsM [Monad μ] (cmp: α → α → μ Ordering) : List (List α) → μ (List (List α))
+--  | a::b::xs => List.cons <$> (mergeM cmp a b) <*> mergePairsM cmp xs
+--  | xs => return xs
+--
+--partial def mergeAllM [Monad μ] (cmp: α → α → μ Ordering) : List (List α) → μ (List α)
+--  | [x] => return x
+--  | xs => mergePairsM cmp xs >>= mergeAllM cmp
+--
+--mutual
+--  partial def sequencesM [Monad μ] (cmp : α → α → μ Ordering) : List α → μ (List (List α))
+--    | a::b::xs => do
+--      if (← cmp a b) == .gt
+--      then descendingM cmp b [a] xs
+--      else ascendingM cmp b (fun ys => a :: ys) xs
+--    | xs => return [xs]
+--
+--  partial def descendingM [Monad μ] (cmp : α → α → μ Ordering) (a : α) (as : List α) : List α → μ (List (List α))
+--    | b::bs => do
+--      if (← cmp a b) == .gt
+--      then descendingM cmp b (a::as) bs
+--      else List.cons (a::as) <$> sequencesM cmp (b::bs)
+--    | [] => List.cons (a::as) <$> sequencesM cmp []
+--
+--  partial def ascendingM [Monad μ] (cmp : α → α → μ Ordering) (a : α) (as : List α → List α) : List α → μ (List (List α))
+--    | b::bs => do
+--      if (← cmp a b) != .gt
+--      then ascendingM cmp b (fun ys => as (a :: ys)) bs
+--      else List.cons (as [a]) <$> sequencesM cmp (b::bs)
+--    | [] => List.cons (as [a]) <$> sequencesM cmp []
+--end
+--
+--def sortByM [Monad μ] (xs: List α) (cmp: α -> α -> μ Ordering) : μ (List α) :=
+--  sequencesM cmp xs >>= mergeAllM cmp
+--
+--end List
+--
+--
+--namespace Ix.Toy
+--
+--deriving instance BEq for ByteArray
+--
+--structure Address where
+--  hash : ByteArray
+--  deriving Inhabited, BEq, Hashable
+--
+--instance : Ord Address where
+--  compare a b := compare a.hash.data.toList b.hash.data.toList
+--
+--def Address.blake3 (x: ByteArray) : Address := ⟨(Blake3.hash x).val⟩
+--
+--inductive AST where
+--| var : Nat -> AST
+--| lam : AST -> AST
+--| app : AST -> AST -> AST
+--| ref : String -> AST
+--deriving Inhabited, BEq, Hashable
+--
+--structure Def where
+--  name: String
+--  val: AST
+--  all: List String
+--deriving BEq, Inhabited
+--
+--structure Env where
+--  decls: Std.HashMap String Def
+--
+--inductive HAST where
+--| var : Nat -> HAST
+--| ref : Address -> HAST
+--| rcr : Nat -> HAST
+--| lam : HAST -> HAST
+--| app : HAST -> HAST -> HAST
+--deriving BEq, Hashable
+--
+--def natToBytesLE (x: Nat) : Array UInt8 :=
+--  if x == 0 then Array.mkArray1 0 else List.toArray (go x x)
+--  where
+--    go : Nat -> Nat -> List UInt8
+--    | _, 0 => []
+--    | 0, _ => []
+--    | Nat.succ f, x => Nat.toUInt8 x:: go f (x / 256)
+--
+--def HAST.serialize : HAST -> ByteArray
+--| .var x => ⟨#[0x0]⟩ ++ ⟨natToBytesLE x⟩
+--| .ref x => ⟨#[0x1]⟩ ++ x.hash
+--| .rcr x => ⟨#[0x2]⟩ ++ ⟨natToBytesLE x⟩
+--| .lam x => ⟨#[0x3]⟩ ++ x.serialize
+--| .app x y => ⟨#[0x4]⟩ ++ x.serialize ++ y.serialize
+--
+----def HAST.hash (x: HAST) : Address := Address.blake3 x.serialize
+--
+--inductive HConst where
+--| defn : HAST -> HConst
+--| defs : List HAST -> HConst
+--| dprj : Address -> Nat -> HConst
+--deriving BEq, Hashable
+--
+--def HConst.serialize : HConst -> ByteArray
+--| .defn x => ⟨#[0x5]⟩ ++ x.serialize
+--| .defs xs => ⟨#[0x6]⟩ ++ (xs.foldr (fun a acc => a.serialize ++ acc) ⟨#[]⟩)
+--| .dprj a n => ⟨#[0x7]⟩ ++ a.hash ++ ⟨natToBytesLE n⟩
+--
+--structure HEnv where
+--  names: Std.HashMap String (Address × Nat)
+--  consts: Std.HashMap Address HConst
+--
+--structure CompileState where
+--  env: Std.HashMap String Def
+--  names: Std.HashMap String Address
+--  cache: Std.HashMap HConst Address
+--  consts: Std.HashMap Address HConst
+--
+--def CompileState.init (x: Env) : CompileState := 
+--  ⟨x.decls, default, default, default⟩
+--
+--abbrev CompileM := ExceptT String <| StateT CompileState Id
+--
+--def CompileM.run (stt: CompileState) (c : CompileM α)
+--  : Except String α × CompileState
+--  := StateT.run (ExceptT.run c) stt
+--
+--def hashHConst (const: HConst) : CompileM Address := do
+--  match (<- get).cache.get? const with
+--  | some a => pure a
+--  | none => do
+--    let addr := Address.blake3 const.serialize
+--    modifyGet fun stt => (addr, { stt with
+--      cache := stt.cache.insert const addr
+--      consts := stt.consts.insert addr const
+--    })
+--
+--abbrev MutCtx := Std.HashMap String Nat
+--
+--structure SOrder where
+--  strong: Bool
+--  ord: Ordering
+--deriving Inhabited
+--
+--def SOrder.cmp : SOrder -> SOrder -> SOrder
+--| ⟨true, .eq⟩, y => y
+--| ⟨false, .eq⟩, y => ⟨false, y.ord⟩
+--| x, _ => x
+--
+--def SOrder.cmpM [Monad μ] (x y: μ SOrder) : μ SOrder := do
+--  match <- x with
+--  | ⟨true, .eq⟩ => y
+--  | ⟨false, .eq⟩ => y >>= fun ⟨_, b⟩ => pure ⟨false, b⟩
+--  | x => pure x
+--
+--def lookupDef (s: String) : CompileM Def := do match (<- get).env.get? s with
+--| some d => pure d
+--| none => throw "unknown def"
+--
+--mutual
+--
+--partial def compileDef (defn: Def): CompileM Address := do
+--  match (<- get).names.get? defn.name with
+--  | some a => pure a
+--  | none => match defn.all with
+--  | [] => do
+--    let addr <- (.defn <$> compileAST {} defn.val) >>= hashHConst
+--    modifyGet fun stt => (addr, { stt with
+--      names := stt.names.insert defn.name addr
+--    })
+--  | ds => do
+--    let defs <- ds.mapM lookupDef
+--    let (mutDefs, mutCtx) <- partitionDefs defs.toArray
+--    let hasts <- mutDefs.mapM (fun ds => compileAST mutCtx ds[0]!)
+--    let block <- hashHConst (.defs hasts)
+--    for d in ds do
+--      let idx := mutCtx.get! d
+--      let addr <- hashHConst (.dprj block idx)
+--      modify fun stt => { stt with names := stt.names.insert d addr }
+--    hashHConst (.dprj block (mutCtx.get! defn.name))
+--
+--partial def compileAST (mutCtx: MutCtx) : AST -> CompileM HAST
+--| .var x => pure <| .var x
+--| .lam x => .lam <$> compileAST mutCtx x
+--| .app x y => .app <$> compileAST mutCtx x <*> compileAST mutCtx y
+--| .ref s => match mutCtx.get? s with
+--  | .some n => pure <| .rcr n
+--  | .none => do match (<- get).env.get? s with
+--    | some x => do
+--      let addr <- compileDef x
+--      pure $ .ref addr
+--    | .none => throw "unknown reference"
+--
+--partial def compareAST (mutCtx: MutCtx) : AST -> AST -> CompileM SOrder
+--| .var x, .var y => pure ⟨true, compare x y⟩
+--| .var _, _ => pure ⟨true, .lt⟩
+--| _, .var _=> pure ⟨true, .gt⟩
+--| .lam x, .lam y => compareAST mutCtx x y
+--| .lam _, _ => pure ⟨true, .lt⟩
+--| _, .lam _=> pure ⟨true, .gt⟩
+--| .app xf xa, .app yf ya =>
+--  SOrder.cmpM (compareAST mutCtx xf yf) (compareAST mutCtx xa ya)
+--| .app _ _, _ => pure ⟨true, .lt⟩
+--| _ , .app _ _ => pure ⟨true, .gt⟩
+--| .ref x, .ref y => match mutCtx.get? x, mutCtx.get? y with
+--  | some nx, some ny => pure ⟨false, compare nx ny⟩
+--  | none, some _ => pure ⟨true, .gt⟩
+--  | some _, none => pure ⟨true, .lt⟩
+--  | none, none => do 
+--    let x' <- lookupDef x >>= compileDef
+--    let y' <- lookupDef y >>= compileDef
+--    pure ⟨true, compare x' y'⟩
+--
+--
+--partial def partitionDefs (defs: Array Def) : CompileM ((List (List Def)) × MutCtx) := do
+--  -- initial state
+--  let mut partOf: Array Nat := Array.replicate defs.size 0
+--  let mut parts : Array (Array Nat) := #[Array.range defs.size]
+--  let mut cache : Std.HashMap (Nat × Nat) SOrder := {}
+--
+--  -- partiton refinement loop
+--  while true do
+--    let mutCtx := buildMutCtx partOf
+--    let mut newParts : Array (Array Nat) := #[]
+--    let mut nextPartId := 0
+--    let mut changed := false
+--    let mut newPartOf := partOf
+--
+--    for part in parts do
+--      -- singleton partition
+--      if part.size <= 1 then
+--        newParts := newParts.push part
+--        for i in part do
+--          newPartOf := newPartOf.set! i nextPartId
+--        nextPartId := nextPartId + 1
+--      else
+--        -- build comparison signatures
+--        let mut sigs : Array (Array SOrder) := Array.replicate part.size #[]
+--
+--        for idx in [0:part.size] do
+--          let i := part[idx]!
+--          let mut sig : Array SOrder := #[]
+--
+--          for jdx in part[0:part.size] do
+--            let j := part[jdx]!
+--            if i != j then
+--              let key := (min i j, max i j)
+--              let cmp <- match cache.get? key with
+--              | some cmp => pure cmp
+--              | none => do
+--                let cmp <- compareAST mutCtx defs[i]!.val defs[j]!.val
+--                if cmp.strong then cache := cache.insert key cmp
+--                pure cmp
+--              sig := sig.push cmp
+--
+--          sigs := sigs.set! idx sig
+--
+--        let mut splits : Array (Array Nat) := #[]
+--        let mut splitSigs: Array (Array SOrder) := #[]
+--
+--        for idx in [0:part.size] do
+--          let idx := part[idx]!
+--          let sig := sigs[idx]!
+--          let mut found := false
+--
+--          for g in [0:splits.size] do
+--            if sigsEqual sig splitSigs[g]! then
+--              splits := splits.set! g (splits[g]!.push idx)
+--              found := true
+--              break
+--          if !found then
+--            splits := splits.push #[idx]
+--            splitSigs := splitSigs.push sig
+--
+--        if splits.size > 1 then
+--          changed := true
+--        for split in splits do
+--          for idx in split do
+--            newPartOf := newPartOf.set! idx nextPartId
+--          newParts := newParts.push split
+--          nextPartId := nextPartId + 1
+--
+--    parts := newParts
+--    partOf := newPartOf
+--    if !changed then break
+--
+--  let ctx := buildMutCtx partOf
+--  let sortedParts <- sortParts parts ctx
+--
+--  sorry
+--  where
+--    sigsEqual (x y: Array SOrder) : Bool :=
+--      x.size == y.size && ((List.range x.size).all fun i => 
+--        x[i]!.ord == y[i]!.ord)
+--
+--    buildMutCtx (partOf: Array Nat) : MutCtx := Id.run do
+--      let mut ctx : MutCtx := {}
+--      for i in [0:defs.size] do
+--        ctx := ctx.insert defs[i]!.name partOf[i]!
+--      ctx
+--    sortParts (parts: Array (Array Nat)) (ctx: MutCtx) : CompileM (List (List Def)) := do
+--      let mut reps : Array (Nat × Nat) := #[]
+--      for i in [0:parts.size] do
+--        reps := reps.push (i, parts[i]![0]!)
+--
+--      let sortedParts : List (Nat × Nat) <- do
+--        reps.toList.sortByM <| fun (_, i) (_, j) => (·.ord) <$>
+--          compareAST ctx defs[i]!.val defs[j]!.val
+--      let sorted := sortedParts.map <| fun (i, _) => 
+--        parts[pidx]!.qsort (fun i j => defs[i]!.name < defs[j]!.name)
+--      pure sorted
+--
+--end
+--
+--end Ix.Toy
+--
+--
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
index 85846b15..f97095e4 100644
--- a/Ix/TransportM.lean
+++ b/Ix/TransportM.lean
@@ -1,3 +1,4 @@
+import Std.Data.HashMap
 import Ix.IR
 import Ix.Ixon.Univ
 import Ix.Ixon
@@ -12,24 +13,21 @@ namespace Ix.TransportM
 
 open Ixon
 
-abbrev MetadataMap := Batteries.RBMap Nat (List Metadatum) compare
-
 structure DematState where
   idx: Nat
-  store: Batteries.RBMap Address Ixon compare
-  meta: MetadataMap
+  store: Store
+  meta: Std.HashMap Nat (List Metadatum)
   deriving Repr
 
-def emptyDematState : DematState := 
-  { idx := 0, store := .empty, meta := .empty }
+def emptyDematState : DematState := { idx := 0, store := {}, meta := {} }
 
 inductive TransportError
 | natTooBig (idx: Nat) (x: Nat)
-| unknownIndex (idx: Nat) (m: MetadataMap)
+| unknownIndex (idx: Nat) (m: List (Nat × List Metadatum))
 | unknownAddress (adr: Address)
-| unexpectedNode (idx: Nat) (m: MetadataMap)
-| nonExprIxon (x: Ixon) (m: MetadataMap)
-| nonConstIxon (x: Ixon) (m: MetadataMap)
+| unexpectedNode (idx: Nat) (m: List (Nat × List Metadatum))
+| nonExprIxon (x: Ixon) (m: List (Nat × List Metadatum))
+| nonConstIxon (x: Ixon) (m: List (Nat × List Metadatum))
 | rawMetadata (m: Ixon.Metadata)
 | expectedMetadata (m: Ixon.Ixon)
 | rawProof (m: Proof)
@@ -54,15 +52,15 @@ abbrev DematM := EStateM TransportError DematState
 
 structure RematState where
   idx: Nat
-  store: Batteries.RBMap Address Ixon compare
+  store: Store
 
-def emptyRematState : RematState := { idx := 0, store := .empty }
+def emptyRematState : RematState := { idx := 0, store := {} }
 
-def rematStateWithStore (store: Batteries.RBMap Address Ixon compare) : RematState := 
+def rematStateWithStore (store: Std.HashMap Address Ixon) : RematState := 
   { idx := 0, store }
 
 structure RematCtx where
-  meta: MetadataMap
+  meta: Std.HashMap Nat (List Metadatum)
 
 abbrev RematM := ReaderT RematCtx (EStateM TransportError RematState)
 
@@ -123,14 +121,14 @@ def rematIncr : RematM Nat := rematIncrN 1
 def rematMeta : RematM (List Ixon.Metadatum) := do
   let n <- (·.idx) <$> get
   let m <- (·.meta) <$> read
-  match m.find? n with
+  match m.get? n with
   | .some n => return n
-  | .none => throw (.unknownIndex n m)
+  | .none => throw (.unknownIndex n m.toList)
 
 def rematThrowUnexpected : RematM α := do
   let n <- (·.idx) <$> get
   let m <- (·.meta) <$> read
-  throw (.unexpectedNode n m)
+  throw (.unexpectedNode n m.toList)
 
 partial def rematLevels (lvls: Nat): RematM (List Lean.Name) := do
   go [] lvls
@@ -257,7 +255,7 @@ partial def rematExpr : Ixon -> RematM Ix.Expr
   .proj name t link i.toNat <$> rematExpr s
 | .strl s => rematIncr *> return .lit (.strVal s)
 | .natl n => rematIncr *> return .lit (.natVal n)
-| e => do throw (.nonExprIxon e (<- read).meta)
+| e => do throw (.nonExprIxon e (<- read).meta.toList)
 
 def dematStore (ixon: Ixon): DematM Address :=
   let addr := Address.blake3 (Ixon.runPut (Ixon.Serialize.put ixon))
@@ -341,26 +339,19 @@ partial def dematConst : Ix.Const -> DematM Ixon
         lvls, x.numParams, x.numIndices,x.numNested, type, ctors, recrs,
         ⟩
 
-def constToIxon (x: Ix.Const) : Except TransportError (Ixon × Ixon) := 
+def dematerialize (x: Ix.Const) : Except TransportError (Ixon × DematState) :=
+  dbg_trace "dematerialize"
   match EStateM.run (dematConst x) emptyDematState with
-  | .ok ix stt => .ok (ix, Ixon.meta ⟨stt.meta.toList⟩)
+  | .ok ix stt => .ok (ix, stt)
   | .error e _ => .error e
 
-def constToBytes (x: Ix.Const) : Except TransportError ByteArray := do
-  let (ix, _) <- constToIxon x
-  return runPut (Serialize.put ix)
-
-def constAddress (x: Ix.Const) : Except TransportError Address := do
-  let bs <- constToBytes x
-  return Address.blake3 bs
-
 def rematAddress (adr: Address): RematM Ixon := do
-  match (<- get).store.find? adr with
+  match (<- get).store.get? adr with
   | .some x => return x
   | .none => throw (.unknownAddress adr)
 
 def rematExprAddress (adr: Address): RematM Ix.Expr := do
-  match (<- get).store.find? adr with
+  match (<- get).store.get? adr with
   | .some x => rematExpr x
   | .none => throw (.unknownAddress adr)
 
@@ -428,7 +419,7 @@ partial def rematConst : Ixon -> RematM Ix.Const
 -- TODO: This could return a Proof inductive, since proofs have no metadata
 | .prof p => throw (.rawProof p)
 | .comm p => throw (.rawComm p)
-| e => do throw (.nonConstIxon e (<- read).meta)
+| e => do throw (.nonConstIxon e (<- read).meta.toList)
   where
     rematDefn (x: Ixon.Definition) : RematM Ix.Definition := do
       let _ <- rematIncr
@@ -476,10 +467,11 @@ partial def rematConst : Ixon -> RematM Ix.Const
         x.refl, x.isUnsafe⟩
 
 def rematerialize (c m: Ixon) : Except TransportError Ix.Const := do
+  dbg_trace "rematerialize"
   let m <- match m with
   | .meta m => pure m
   | x => throw <| .expectedMetadata x
-  let m := Batteries.RBMap.ofList m.map compare
+  let m := Std.HashMap.ofList m.map
   match ((rematConst c).run { meta := m }).run emptyRematState with
     | .ok a _ => return a
     | .error e _ => throw e
diff --git a/Ix/UnionFind.lean b/Ix/UnionFind.lean
new file mode 100644
index 00000000..4c2c087a
--- /dev/null
+++ b/Ix/UnionFind.lean
@@ -0,0 +1,41 @@
+structure UnionFind where
+  parent : IO.Ref (Array Nat)
+  rank : IO.Ref (Array Nat)
+
+namespace UnionFind
+
+def init (n: Nat) : IO UnionFind := do
+  let parent <- IO.mkRef (Array.range n)
+  let rank <- IO.mkRef (Array.replicate n 0)
+  return ⟨parent, rank⟩
+
+partial def find (uf: UnionFind) (x: Nat) : IO Nat := do
+  let parent <- uf.parent.get
+  let p := parent[x]!
+  if p == x then return x
+  else do
+    let root <- find uf p
+    uf.parent.modify fun arr => arr.set! x root
+    return root
+
+def union (uf : UnionFind) (x y: Nat) : IO Unit := do
+  let rx <- find uf x
+  let ry <- find uf y
+  if rx == ry then return ()
+  let rank <- uf.rank.get
+  let rankX := rank[rx]!
+  let rankY := rank[ry]!
+  if rankX < rankY then
+    uf.parent.modify fun arr => arr.set! rx ry
+  else if rankX > rankY then
+    uf.parent.modify fun arr => arr.set! ry rx
+  else
+    uf.parent.modify fun arr => arr.set! ry rx
+    uf.rank.modify fun arr => arr.set! rx (rankX + 1)
+
+def unionMany (uf: UnionFind) (pairs: Array (Nat × Nat)) : IO Unit := do
+  for (x, y) in pairs do
+    union uf x y
+
+end UnionFind
+
diff --git a/Tests/Ix/Common.lean b/Tests/Ix/Common.lean
index 2deeaf0d..6f9339b9 100644
--- a/Tests/Ix/Common.lean
+++ b/Tests/Ix/Common.lean
@@ -81,7 +81,7 @@ def genDefKind : Gen Ix.DefKind := oneOf'
 def genReducibilityHints : Gen Lean.ReducibilityHints := oneOf'
    [ pure .opaque
    , pure .abbrev
-   , (.regular ·.toUInt32) <$> genUSize
+   --, (.regular ·.toUInt32) <$> genUSize
    ]
 
 def genQuotKind : Gen Lean.QuotKind := oneOf'
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 9ab23afb..d422129f 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -7,8 +7,10 @@ import Ix.CompileM
 import Ix.DecompileM
 import Ix.Meta
 import Ix.IR
+import Ix.Store
 import Lean
 import Tests.Ix.Fixtures
+import Tests.Ix.Fixtures.Mutual
 import Lean
 
 open LSpec
@@ -26,10 +28,8 @@ end
 
 end Test.Ix.Inductives
 
-
 namespace Test.Ix.Mutual
 
-
 mutual
   unsafe def A : Nat → Nat
   | 0 => 0
@@ -47,6 +47,25 @@ end
 end Test.Ix.Mutual
 
 
+--def addrOfName (name: Lean.Name) : IO Address := do
+--  let env <- get_env!
+--  let const := match (env.find? name) with
+--    | .some c => c
+--    | .none => env.getDelta.find! name
+--  let ((a, _), _) <- (Ix.Compile.compileConst const).runIO env
+--  return a
+
+--def testUnits : IO TestSeq := do
+--  let x <- addrOfName `Nat
+--  IO.println s!"Nat is {x}"
+--  let x <- addrOfName `Nat.add
+--  IO.println s!"Nat.add is {x}"
+--  let x <- addrOfName `Peano
+--  IO.println s!"Peano is {x}"
+--  let x <- addrOfName `Peano.add
+--  IO.println s!"Peano.add is {x}"
+--  return test "false" (true == false)
+
 def testMutual : IO TestSeq := do
   let env <- get_env!
   let mut cstt : CompileState := .init env 0
@@ -56,12 +75,12 @@ def testMutual : IO TestSeq := do
     | .opaqueInfo d => pure <| Ix.mkPreOpaque d
     | .thmInfo d => pure <| Ix.mkPreTheorem d
     | _ => throw (IO.userError "not a def")
-  let (dss, _) <- match (sortDefs predefs).run (.init 200000) cstt with
-    | .ok a stt => do
+  let (dss, _) <- match (<- (sortDefs predefs).run (.init 200000) cstt) with
+    | (.ok a, stt) => do
       pure (a, stt)
-    | .error e _ => do
+    | (.error e, _) => do
       throw (IO.userError (<- e.pretty))
-  let res := [[`Test.Ix.Mutual.C, `Test.Ix.Mutual.B],[`Test.Ix.Mutual.A]]
+  let res := [[`Test.Ix.Mutual.B, `Test.Ix.Mutual.C],[`Test.Ix.Mutual.A]]
   let nss := dss.map fun ds => ds.map (·.name)
   return test "test mutual" (res == nss)
 
@@ -72,52 +91,106 @@ def testInductives : IO TestSeq := do
   --let consts := env.getConstMap.filter fun n _ => namesp.isPrefixOf n
   let all := (env.getDelta.find! `Test.Ix.Inductives.A).all
   let preinds <- all.mapM fun n => match env.getDelta.find! n with
-    | .inductInfo v => match (makePreInductive v).run (.init 200000) cstt with
-      | .ok a _ => pure a
-      | .error e _ => do throw (IO.userError (<- e.pretty))
+    | .inductInfo v => do match (<- (makePreInductive v).run (.init 200000) cstt) with
+      | (.ok a, _) => pure a
+      | (.error e, _) => do throw (IO.userError (<- e.pretty))
     | _ => throw (IO.userError "not an inductive")
-  let (dss, _) <- match (sortInds preinds).run (.init 200000) cstt with
-    | .ok a stt => do
+  let (dss, _) <- do match (<- (sortInds preinds).run (.init 200000) cstt) with
+    | (.ok a, stt) => do
       pure (a, stt)
-    | .error e _ => do
+    | (.error e, _) => do
       throw (IO.userError (<- e.pretty))
-  let res := [[`Test.Ix.Inductives.C], [`Test.Ix.Inductives.B],[`Test.Ix.Inductives.A]]
+  let res := [[`Test.Ix.Inductives.C],[`Test.Ix.Inductives.B], [`Test.Ix.Inductives.A]]
   let nss := dss.map fun ds => ds.map (·.name)
   return test "test inductives" (res == nss)
 
+def testDifficult : IO TestSeq := do
+  let env <- get_env!
+  let difficult := [
+    `Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_blastDivSubtractShift_q
+  ]
+  let mut res := true
+  for name in difficult do
+    let mut cstt : CompileState := .init env 0
+    let const <- do match env.getDelta.find? name with
+      | some c => pure c
+      | none => match env.getConstMap.get? name with
+        | some c => pure c
+        | none => throw (IO.userError s!"{name} not in env")
+    let (_, stt) <- do match (<- (compileConst const).run (.init 200000) cstt) with
+    | (.ok a, stt) => pure (a, stt)
+    | (.error e, _) => IO.println s!"failed {const.name}" *> throw (IO.userError (<- e.pretty))
+    --cstt := stt
+    --let mut store : Ixon.Store := {}
+    --for (_,(a, b)) in cstt.names do
+    --  let a_ixon <- (Store.readConst a).toIO
+    --  let b_ixon <- (Store.readConst b).toIO
+    --  store := store.insert a a_ixon
+    --  store := store.insert b b_ixon
+    --let denv := DecompileEnv.init cstt.names store
+    --let dstt <- match decompileEnv.run denv default with
+    --  | .ok _ s => pure s
+    --    --IO.println s!"✓ {n} @ {anon}:{meta}"
+    --  | .error e _ => do
+    --    throw (IO.userError e.pretty)
+    --IO.println s!"decompiled env"
+    --for (n, (anon, meta)) in denv.names do
+    --  let c <- match env.constants.find? n with
+    --  | .some c => pure c
+    --  | .none => throw (IO.userError "name {n} not in env")
+    --  match dstt.constants.get? n with
+    --  | .some c2 =>
+    --    if c.stripMData == c2.stripMData
+    --    then
+    --      IO.println s!"✓ {n} @ {anon}:{meta}"
+    --    else
+    --      IO.println s!"× {n} @ {anon}:{meta}"
+    --      IO.FS.writeFile "c.out" s!"{repr c.stripMData}"
+    --      IO.FS.writeFile "c2.out" s!"{repr c2.stripMData}"
+    --      res := false
+    --      break
+    --  | .none => do
+    --    let e' := (DecompileError.unknownName default n).pretty
+    --    throw (IO.userError e')
+  return test "difficult compile roundtrip" (res == true)
+
 def testRoundtripGetEnv : IO TestSeq := do
   let env <- get_env!
   let mut cstt : CompileState := .init env 0
   --IO.println s!"compiling env"
   for (_, c) in env.getDelta do
-    let (_, stt) <- match (compileConst c).run (.init 200000) cstt with
-    | .ok a stt => do
-      --stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
+    let (_, stt) <- do match (<- (compileConst c).run (.init 200000) cstt) with
+    | (.ok a, stt) => do
       pure (a, stt)
-    | .error e _ => do
+    | (.error e, _) => do
       IO.println s!"failed {c.name}"
       throw (IO.userError (<- e.pretty))
-    let (anon, meta) <- match stt.names.find? c.name with
+    let (anon, meta) <- match stt.names.get? c.name with
     | .some (a, m) => pure (a, m)
     | .none => throw (IO.userError "name {n} not in env")
     IO.println s!"✓ {c.name} -> {anon}:{meta}"
     cstt := stt
   for (_, c) in env.getConstMap do
-    let (_, stt) <- match (compileConst c).run (.init 200000) cstt with
-    | .ok a stt => do
-      --stt.store.forM fun a c => discard $ (Store.forceWriteConst a c).toIO
+    let (_, stt) <- do match (<- (compileConst c).run (.init 200000) cstt) with
+    | (.ok a, stt) => do
       pure (a, stt)
-    | .error e _ => do
+    | (.error e, _) => do
       IO.println s!"failed {c.name}"
       throw (IO.userError (<- e.pretty))
-    let (anon, meta) <- match stt.names.find? c.name with
+    let (anon, meta) <- match stt.names.get? c.name with
     | .some (a, m) => pure (a, m)
     | .none => throw (IO.userError "name {n} not in env")
     IO.println s!"✓ {c.name} -> {anon}:{meta}"
     cstt := stt
   IO.println s!"compiled env"
   IO.println s!"decompiling env"
-  let denv := DecompileEnv.init cstt.names cstt.store
+  let mut store : Ixon.Store := {}
+  for (_,(a, b)) in cstt.names do
+    let a_ixon <- (Store.readConst a).toIO
+    let b_ixon <- (Store.readConst b).toIO
+    store := store.insert a a_ixon
+    store := store.insert b b_ixon
+  let denv := DecompileEnv.init cstt.names store
   let dstt <- match decompileEnv.run denv default with
     | .ok _ s => pure s
       --IO.println s!"✓ {n} @ {anon}:{meta}"
@@ -129,7 +202,7 @@ def testRoundtripGetEnv : IO TestSeq := do
     let c <- match env.constants.find? n with
     | .some c => pure c
     | .none => throw (IO.userError "name {n} not in env")
-    match dstt.constants.find? n with
+    match dstt.constants.get? n with
     | .some c2 =>
       if c.stripMData == c2.stripMData
       then
@@ -151,5 +224,7 @@ def testRoundtripGetEnv : IO TestSeq := do
 def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
    testMutual,
    testInductives,
-   testRoundtripGetEnv
+   testDifficult,
+--   testUnits,
+   --testRoundtripGetEnv
 ]
diff --git a/Tests/Ix/Fixtures/Mutual.lean b/Tests/Ix/Fixtures/Mutual.lean
new file mode 100644
index 00000000..a8978d0c
--- /dev/null
+++ b/Tests/Ix/Fixtures/Mutual.lean
@@ -0,0 +1,162 @@
+namespace Test.Ix.Mutual
+
+namespace WellFounded
+mutual
+
+  def A : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + C n + 1
+
+  def C : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + F n + A n + 1
+
+  def E : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + A n + F n + 1
+
+  def F : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + C n + E n + 1
+
+  def B : Nat → Nat
+  | 0 => 0
+  | n + 1 => C n + 2
+
+  def G : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + F n + H n + 2
+
+  def H : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+
+end
+
+mutual
+
+  def A' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + E' n + C' n + 1
+
+  def C' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + F' n + A' n + 1
+
+  def E' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + A' n + F' n + 1
+
+  def F' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + C' n + E' n + 1
+
+  def B' : Nat → Nat
+  | 0 => 0
+  | n + 1 => C' n + 2
+
+  def G' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + F' n + H' n + 2
+
+  def H' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B' n + E' n + G' n + 2
+
+end
+
+mutual
+  def I : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+end
+
+def I' : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+
+end WellFounded
+
+namespace Partial
+
+mutual
+
+  partial def A : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + C n + 1
+
+  partial def C : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + F n + A n + 1
+
+  partial def E : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + A n + F n + 1
+
+  partial def F : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + C n + E n + 1
+
+  partial def B : Nat → Nat
+  | 0 => 0
+  | n + 1 => C n + 2
+
+  partial def G : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + F n + H n + 2
+
+  partial def H : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+
+end
+
+partial def I : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + E n + G n + 2
+
+end Partial
+
+namespace Inductive
+
+inductive BLA
+  | nil
+  | bla : BLA → BLA → BLA
+
+-- an inductive with a differently named constructor but all else equal should be the smae
+inductive BLU
+  | nil
+  | blu : BLU → BLU → BLU
+
+-- an inductive with a different constructor order should be distinct
+inductive BLA'
+  | bla : BLA' → BLA' → BLA'
+  | nil
+
+mutual
+  -- BLE and BLI should be distinct because we don't group by weak equality
+  inductive BLE | bli : BLI → BLE
+  inductive BLI | ble : BLE → BLI
+  inductive BLO | blea : BLE → BLI → BLO
+end
+
+mutual
+  inductive BLE' | bli : BLI' → BLE'
+  inductive BLI' | ble : BLE' → BLI'
+  inductive BLO' | blea : BLE' → BLI' → BLO'
+end
+
+mutual
+  -- BLE and BLI should be distinct because we don't group by weak equality
+  inductive BLE'' | bli : BLI'' → BLE''
+  inductive BLO'' | blea : BLE'' → BLA' → BLO''
+  inductive BLI'' | ble : BLE'' → BLI''
+end
+
+-- testing external reference into mutual
+inductive BLEH
+  | bleh : BLE → BLEH
+  | bloh : BLO → BLEH
+end Inductive
+
+end Test.Ix.Mutual
diff --git a/ix_test/IxTest.lean b/ix_test/IxTest.lean
index ab035316..f64d0469 100644
--- a/ix_test/IxTest.lean
+++ b/ix_test/IxTest.lean
@@ -7,4 +7,8 @@ import Std
 def id' (A: Type) (x: A) := x
 def ref (A: Type) (_x : A) := hello
 
+def idX {A: Type} : A -> A := fun x => x
+def idY {A: Type} : A -> A := fun y => y
+def idSquared {A: Type} : A -> A := idX idY
+
 def one : Nat := 1

From ee44897d150d67d8cb80a4c44b0e17ac833ced2f Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 3 Oct 2025 14:16:14 -0400
Subject: [PATCH 46/74] very WIP compiler rewrite

---
 Ix.lean                 |    9 +-
 Ix/Address.lean         |    7 +
 Ix/Benchmark/Bench.lean |    2 +-
 Ix/Claim.lean           |   33 -
 Ix/Common.lean          |  232 +++--
 Ix/CompileM.lean        | 2148 +++++++++++++++++++++++----------------
 Ix/DecompileM.lean      |  812 ++++++++-------
 Ix/IR.lean              |   25 +-
 Ix/Ixon.lean            | 1278 +++++++++++++++++------
 Ix/Ixon/Const.lean      |  175 ----
 Ix/Ixon/Expr.lean       |  174 ----
 Ix/Ixon/Metadata.lean   |   85 --
 Ix/Ixon/Serialize.lean  |  408 --------
 Ix/Ixon/Tag.lean        |   83 --
 Ix/Ixon/Univ.lean       |   48 -
 Ix/Prove.lean           |   26 -
 Ix/Store.lean           |    1 -
 Ix/TransportM.lean      |  479 ---------
 18 files changed, 2819 insertions(+), 3206 deletions(-)
 delete mode 100644 Ix/Claim.lean
 delete mode 100644 Ix/Ixon/Const.lean
 delete mode 100644 Ix/Ixon/Expr.lean
 delete mode 100644 Ix/Ixon/Metadata.lean
 delete mode 100644 Ix/Ixon/Serialize.lean
 delete mode 100644 Ix/Ixon/Tag.lean
 delete mode 100644 Ix/Ixon/Univ.lean
 delete mode 100644 Ix/Prove.lean
 delete mode 100644 Ix/TransportM.lean

diff --git a/Ix.lean b/Ix.lean
index e2d4bc7e..0d370956 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -1,10 +1,9 @@
 -- This module serves as the root of the `Ix` library.
 -- Import modules here that should be built as part of the library.
 import Ix.Ixon
-import Ix.TransportM
 import Ix.IR
-import Ix.Meta
+--import Ix.Meta
 import Ix.CompileM
-import Ix.DecompileM
-import Ix.Claim
-import Ix.Prove
+--import Ix.DecompileM
+--import Ix.Claim
+--import Ix.Prove
diff --git a/Ix/Address.lean b/Ix/Address.lean
index 58c90b80..20d19d1a 100644
--- a/Ix/Address.lean
+++ b/Ix/Address.lean
@@ -4,6 +4,7 @@ import Ix.Common
 import Blake3
 
 deriving instance Lean.ToExpr for ByteArray
+deriving instance Repr for ByteArray
 
 structure Address where
   hash : ByteArray
@@ -11,6 +12,7 @@ structure Address where
 
 def Address.blake3 (x: ByteArray) : Address := ⟨(Blake3.hash x).val⟩
 
+
 def hexOfNat : Nat -> Option Char
 | 0 => .some '0'
 | 1 => .some '1'
@@ -107,3 +109,8 @@ def Address.fromUniqueName (name: Lean.Name) : Option Address :=
   | .str (.str (.str .anonymous "Ix") "_#") s => Address.fromString s
   | _ => .none
 
+structure MetaAddress where
+  data : Address
+  meta : Address
+  deriving Inhabited, Lean.ToExpr, BEq, Hashable, Repr, Ord
+
diff --git a/Ix/Benchmark/Bench.lean b/Ix/Benchmark/Bench.lean
index 59ba6d9a..66145ec3 100644
--- a/Ix/Benchmark/Bench.lean
+++ b/Ix/Benchmark/Bench.lean
@@ -1,4 +1,4 @@
-import Ix.Claim
+import Ix.Ixon
 import Ix.Address
 import Ix.Meta
 import Ix.CompileM
diff --git a/Ix/Claim.lean b/Ix/Claim.lean
deleted file mode 100644
index 24f23626..00000000
--- a/Ix/Claim.lean
+++ /dev/null
@@ -1,33 +0,0 @@
-import Ix.Address
-
-structure EvalClaim where
-  lvls : Address
-  input: Address
-  output: Address
-  type : Address
-deriving BEq, Repr, Inhabited
-
-structure CheckClaim where
-  lvls : Address
-  type : Address
-  value : Address
-deriving BEq, Repr, Inhabited
-
-inductive Claim where
-| evals : EvalClaim -> Claim
-| checks : CheckClaim -> Claim
-deriving BEq, Repr, Inhabited
-
-instance : ToString CheckClaim where
-  toString x := s!"#{x.value} : #{x.type} @ #{x.lvls}"
-
-instance : ToString EvalClaim where
-  toString x := s!"#{x.input} ~> #{x.output} : #{x.type} @ #{x.lvls}"
-
-instance : ToString Claim where
-  toString
-  | .checks x => toString x
-  | .evals x => toString x
-
-
-
diff --git a/Ix/Common.lean b/Ix/Common.lean
index 38b28c89..d3336ac8 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -36,17 +36,17 @@ deriving instance Ord for Lean.BinderInfo
 deriving instance BEq, Repr, Hashable, Ord for Lean.QuotKind
 deriving instance Hashable, Repr for Lean.ReducibilityHints
 deriving instance BEq, Ord, Hashable, Repr for Lean.DefinitionSafety
-deriving instance BEq, Repr for Lean.ConstantVal
-deriving instance BEq, Repr for Lean.QuotVal
-deriving instance BEq, Repr for Lean.AxiomVal
-deriving instance BEq, Repr for Lean.TheoremVal
-deriving instance BEq, Repr for Lean.DefinitionVal
-deriving instance BEq, Repr for Lean.OpaqueVal
-deriving instance BEq, Repr for Lean.RecursorRule
-deriving instance BEq, Repr for Lean.RecursorVal
-deriving instance BEq, Repr for Lean.ConstructorVal
-deriving instance BEq, Repr for Lean.InductiveVal
-deriving instance BEq, Repr for Lean.ConstantInfo
+deriving instance BEq, Repr, Hashable for Lean.ConstantVal
+deriving instance BEq, Repr, Hashable for Lean.QuotVal
+deriving instance BEq, Repr, Hashable for Lean.AxiomVal
+deriving instance BEq, Repr, Hashable for Lean.TheoremVal
+deriving instance BEq, Repr, Hashable for Lean.DefinitionVal
+deriving instance BEq, Repr, Hashable for Lean.OpaqueVal
+deriving instance BEq, Repr, Hashable for Lean.RecursorRule
+deriving instance BEq, Repr, Hashable for Lean.RecursorVal
+deriving instance BEq, Repr, Hashable for Lean.ConstructorVal
+deriving instance BEq, Repr, Hashable for Lean.InductiveVal
+deriving instance BEq, Repr, Hashable for Lean.ConstantInfo
 deriving instance BEq, Repr for Ordering
 
 def UInt8.MAX : UInt64 := 0xFF
@@ -54,6 +54,40 @@ def UInt16.MAX : UInt64 := 0xFFFF
 def UInt32.MAX : UInt64 := 0xFFFFFFFF
 def UInt64.MAX : UInt64 := 0xFFFFFFFFFFFFFFFF
 
+def UInt64.byteCount (x: UInt64) : UInt8 :=
+  if      x < 0x0000000000000100 then 1
+  else if x < 0x0000000000010000 then 2
+  else if x < 0x0000000001000000 then 3
+  else if x < 0x0000000100000000 then 4
+  else if x < 0x0000010000000000 then 5
+  else if x < 0x0001000000000000 then 6
+  else if x < 0x0100000000000000 then 7
+  else 8
+
+def UInt64.trimmedLE (x: UInt64) : Array UInt8 :=
+  if x == 0 then Array.mkArray1 0 else List.toArray (go 8 x)
+  where
+    go : Nat → UInt64 → List UInt8
+    | _, 0 => []
+    | 0, _ => []
+    | Nat.succ f, x =>
+      Nat.toUInt8 (UInt64.toNat x) :: go f (UInt64.shiftRight x 8)
+
+def UInt64.fromTrimmedLE (xs: Array UInt8) : UInt64 := List.foldr step 0 xs.toList
+  where
+    step byte acc := UInt64.shiftLeft acc 8 + (UInt8.toUInt64 byte)
+
+def Nat.toBytesLE (x: Nat) : Array UInt8 :=
+  if x == 0 then Array.mkArray1 0 else List.toArray (go x x)
+  where
+    go : Nat -> Nat -> List UInt8
+    | _, 0 => []
+    | 0, _ => []
+    | Nat.succ f, x => Nat.toUInt8 x:: go f (x / 256)
+
+def Nat.fromBytesLE (xs: Array UInt8) : Nat :=
+  (xs.toList.zipIdx 0).foldl (fun acc (b, i) => acc + (UInt8.toNat b) * 256 ^ i) 0
+
 /-- Distinguish different kinds of Ix definitions --/
 inductive Ix.DefKind where
 | «definition»
@@ -115,7 +149,6 @@ def sortBy (cmp : α -> α -> Ordering) (xs: List α) : List α :=
 
 def sort [Ord α] (xs: List α) : List α := sortBy compare xs
 
-
 def groupByMAux [Monad μ] (eq : α → α → μ Bool) : List α → List (List α) → μ (List (List α))
   | a::as, (ag::g)::gs => do match (← eq a ag) with
     | true  => groupByMAux eq as ((a::ag::g)::gs)
@@ -214,6 +247,17 @@ def sortGroupsByM [Monad μ] (xs: List (List α)) (cmp: α -> α -> μ Ordering)
 
 end List
 
+abbrev MutCtx := Std.HashMap Lean.Name Nat
+
+instance : BEq MutCtx where
+  beq a b := a.size == b.size && a.fold
+    (fun acc k v => acc && match b.get? k with
+      | some v' => v == v'
+      | none => false) true
+
+instance : Hashable MutCtx where
+  hash a := hash a.toList.sort
+
 namespace Lean
 
 def ConstantInfo.formatAll (c : ConstantInfo) : String :=
@@ -321,81 +365,93 @@ def runFrontend (input : String) (filePath : FilePath) : IO Environment := do
       (← msgs.toList.mapM (·.toString)).map String.trim
   else return s.commandState.env
 
-def Expr.size: Expr -> Nat
-| .mdata _ x => 1 + x.size
-| .app f a => 1 + f.size + a.size
-| .lam bn bt b bi => 1 + bt.size + b.size
-| .forallE bn bt b bi => 1 + bt.size + b.size
-| .letE ln t v b nd =>  1 + t.size + v.size + b.size
-| .proj tn i s => 1 + s.size
-| x => 1
-
-def Expr.msize: Expr -> Nat
-| .mdata _ x => 1 + x.msize
-| .app f a => f.msize + a.msize
-| .lam bn bt b bi => bt.msize + b.msize
-| .forallE bn bt b bi => bt.msize + b.msize
-| .letE ln t v b nd => t.msize + v.msize + b.msize
-| .proj tn i s => s.msize
-| x => 0
-
-def Expr.stripMData : Expr -> Expr
-| .mdata _ x => x.stripMData
-| .app f a => .app f.stripMData a.stripMData
-| .lam bn bt b bi => .lam bn bt.stripMData b.stripMData bi
-| .forallE bn bt b bi => .forallE bn bt.stripMData b.stripMData bi
-| .letE ln t v b nd => .letE ln t.stripMData v.stripMData b.stripMData nd
-| .proj tn i s => .proj tn i s.stripMData
-| x@(.lit ..) => x
-| x@(.const ..) => x
-| x@(.bvar ..) => x
-| x@(.fvar ..) => x
-| x@(.sort ..) => x
-| x@(.mvar ..) => x
-
-def RecursorRule.stripMData : RecursorRule -> RecursorRule
-| x =>
-  dbg_trace s!"RecursorRule.stripMData"
-  match x with
-  | ⟨c, nf, rhs⟩ => ⟨c, nf, rhs.stripMData⟩
-
-def RecursorRule.size : RecursorRule -> Nat
-| ⟨c, nf, rhs⟩ => rhs.size
-
-def RecursorRule.msize : RecursorRule -> Nat
-| ⟨c, nf, rhs⟩ => rhs.msize
-
-def ConstantInfo.stripMData : Lean.ConstantInfo -> Lean.ConstantInfo
-| x =>
-  dbg_trace s!"ConstantInfo.stripMData"
-  match x with
-  | .axiomInfo x => .axiomInfo { x with type := x.type.stripMData }
-  | .defnInfo x => .defnInfo { x with type := x.type.stripMData, value := x.value.stripMData }
-  | .thmInfo x => .thmInfo { x with type := x.type.stripMData, value := x.value.stripMData }
-  | .quotInfo x => .quotInfo { x with type := x.type.stripMData }
-  | .opaqueInfo x => .opaqueInfo { x with type := x.type.stripMData, value := x.value.stripMData }
-  | .inductInfo x => .inductInfo { x with type := x.type.stripMData }
-  | .ctorInfo x => .ctorInfo { x with type := x.type.stripMData }
-  | .recInfo x => .recInfo { x with type := x.type.stripMData, rules := x.rules.map (·.stripMData) }
-
-def ConstantInfo.size : Lean.ConstantInfo -> Nat
-| .axiomInfo x => x.type.size
-| .defnInfo x => x.type.size + x.value.size
-| .thmInfo x => x.type.size + x.value.size
-| .quotInfo x => x.type.size
-| .opaqueInfo x => x.type.size + x.value.size
-| .inductInfo x => x.type.size
-| .ctorInfo x => x.type.size
-| .recInfo x => x.type.size + x.rules.foldr (fun a acc => a.size + acc) 0
-
-def ConstantInfo.msize : Lean.ConstantInfo -> Nat
-| .axiomInfo x => x.type.msize
-| .defnInfo x => x.type.msize + x.value.msize
-| .thmInfo x => x.type.msize + x.value.msize
-| .quotInfo x => x.type.msize
-| .opaqueInfo x => x.type.msize + x.value.msize
-| .inductInfo x => x.type.msize
-| .ctorInfo x => x.type.msize
-| .recInfo x => x.type.msize + x.rules.foldr (fun a acc => a.msize + acc) 0
+--def Expr.size: Expr -> Nat
+--| .mdata _ x => 1 + x.size
+--| .app f a => 1 + f.size + a.size
+--| .lam bn bt b bi => 1 + bt.size + b.size
+--| .forallE bn bt b bi => 1 + bt.size + b.size
+--| .letE ln t v b nd =>  1 + t.size + v.size + b.size
+--| .proj tn i s => 1 + s.size
+--| x => 1
+
+--def Expr.size (e : Expr) : Nat :=
+--  go e 0
+--where
+--  go e n := match e with
+--    | .mdata _ x => go x n + 1
+--    | .app f a => go a (go f n + 1)
+--    | .lam bn bt b bi => go bt (go b n + 1)
+--    | .forallE bn bt b bi => go bt (go b n + 1)
+--    | .letE ln t v b nd => go b (go v (go t n + 1))
+--    | .proj tn i s => go s n + 1
+--    | x => n
+
+--def Expr.msize: Expr -> Nat
+--| .mdata _ x => 1 + x.msize
+--| .app f a => f.msize + a.msize
+--| .lam bn bt b bi => bt.msize + b.msize
+--| .forallE bn bt b bi => bt.msize + b.msize
+--| .letE ln t v b nd => t.msize + v.msize + b.msize
+--| .proj tn i s => s.msize
+--| x => 0
+--
+--def Expr.stripMData : Expr -> Expr
+--| .mdata _ x => x.stripMData
+--| .app f a => .app f.stripMData a.stripMData
+--| .lam bn bt b bi => .lam bn bt.stripMData b.stripMData bi
+--| .forallE bn bt b bi => .forallE bn bt.stripMData b.stripMData bi
+--| .letE ln t v b nd => .letE ln t.stripMData v.stripMData b.stripMData nd
+--| .proj tn i s => .proj tn i s.stripMData
+--| x@(.lit ..) => x
+--| x@(.const ..) => x
+--| x@(.bvar ..) => x
+--| x@(.fvar ..) => x
+--| x@(.sort ..) => x
+--| x@(.mvar ..) => x
+
+--def RecursorRule.stripMData : RecursorRule -> RecursorRule
+--| x =>
+--  dbg_trace s!"RecursorRule.stripMData"
+--  match x with
+--  | ⟨c, nf, rhs⟩ => ⟨c, nf, rhs.stripMData⟩
+--
+--def RecursorRule.size : RecursorRule -> Nat
+--| ⟨c, nf, rhs⟩ => rhs.size
+--
+--def RecursorRule.msize : RecursorRule -> Nat
+--| ⟨c, nf, rhs⟩ => rhs.msize
+--
+--def ConstantInfo.stripMData : Lean.ConstantInfo -> Lean.ConstantInfo
+--| x =>
+--  dbg_trace s!"ConstantInfo.stripMData"
+--  match x with
+--  | .axiomInfo x => .axiomInfo { x with type := x.type.stripMData }
+--  | .defnInfo x => .defnInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+--  | .thmInfo x => .thmInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+--  | .quotInfo x => .quotInfo { x with type := x.type.stripMData }
+--  | .opaqueInfo x => .opaqueInfo { x with type := x.type.stripMData, value := x.value.stripMData }
+--  | .inductInfo x => .inductInfo { x with type := x.type.stripMData }
+--  | .ctorInfo x => .ctorInfo { x with type := x.type.stripMData }
+--  | .recInfo x => .recInfo { x with type := x.type.stripMData, rules := x.rules.map (·.stripMData) }
+--
+--def ConstantInfo.size : Lean.ConstantInfo -> Nat
+--| .axiomInfo x => x.type.size
+--| .defnInfo x => x.type.size + x.value.size
+--| .thmInfo x => x.type.size + x.value.size
+--| .quotInfo x => x.type.size
+--| .opaqueInfo x => x.type.size + x.value.size
+--| .inductInfo x => x.type.size
+--| .ctorInfo x => x.type.size
+--| .recInfo x => x.type.size + x.rules.foldr (fun a acc => a.size + acc) 0
+--
+--def ConstantInfo.msize : Lean.ConstantInfo -> Nat
+--| .axiomInfo x => x.type.msize
+--| .defnInfo x => x.type.msize + x.value.msize
+--| .thmInfo x => x.type.msize + x.value.msize
+--| .quotInfo x => x.type.msize
+--| .opaqueInfo x => x.type.msize + x.value.msize
+--| .inductInfo x => x.type.msize
+--| .ctorInfo x => x.type.msize
+--| .recInfo x => x.type.msize + x.rules.foldr (fun a acc => a.msize + acc) 0
 end Lean
 
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index b28c6c36..ec6a55f1 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -1,91 +1,95 @@
 import Std.Data.HashMap
-import Ix.TransportM
-import Ix.Ixon.Metadata
 import Ix.Ixon
-import Ix.Ixon.Const
-import Ix.Ixon.Serialize
+import Ix.Address
+import Ix.IR
 import Ix.Common
-import Ix.Store
+--import Ix.Store
 import Ix.SOrder
 import Ix.Cronos
 
+open Std (HashMap)
+--open Ix.TransportM
 
-open Ix.TransportM
-
-namespace Ix.Compile
-
-inductive CompileError
-| unknownConstant : Lean.Name → CompileError
-| unfilledLevelMetavariable : Lean.Level → CompileError
-| unfilledExprMetavariable : Lean.Expr → CompileError
-| invalidBVarIndex : Nat → CompileError
-| freeVariableExpr : Lean.Expr → CompileError
-| metaVariableExpr : Lean.Expr → CompileError
-| metaDataExpr : Lean.Expr → CompileError
-| levelNotFound : Lean.Name → List Lean.Name -> String → CompileError
-| invalidConstantKind : Lean.Name → String → String → CompileError
-| constantNotContentAddressed : Lean.Name → CompileError
-| nonRecursorExtractedFromChildren : Lean.Name → CompileError
-| cantFindMutDefIndex : Lean.Name → CompileError
-| transportError : TransportError → CompileError
-| kernelException : Lean.Kernel.Exception → CompileError
-| cantPackLevel : Nat → CompileError
-| nonCongruentInductives : PreInductive -> PreInductive -> CompileError
-| alphaInvarianceFailure : Ix.Const -> Address -> Ix.Const -> Address -> CompileError
-| emptyDefsEquivalenceClass: List (List PreDefinition) -> CompileError
-| emptyIndsEquivalenceClass: List (List PreInductive) -> CompileError
-
-def CompileError.pretty : CompileError -> IO String
-| .unknownConstant n => pure s!"Unknown constant '{n}'"
-| .unfilledLevelMetavariable l => pure s!"Unfilled level metavariable on universe '{l}'"
-| .unfilledExprMetavariable e => pure s!"Unfilled level metavariable on expression '{e}'"
-| .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
-| .freeVariableExpr e => pure s!"Free variable in expression '{e}'"
-| .metaVariableExpr e => pure s!"Metavariable in expression '{e}'"
-| .metaDataExpr e => pure s!"Meta data in expression '{e}'"
-| .levelNotFound n ns msg => pure s!"'Level {n}' not found in '{ns}', {msg}"
-| .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
-| .constantNotContentAddressed n => pure s!"Constant '{n}' wasn't content-addressed"
-| .nonRecursorExtractedFromChildren n => pure
-  s!"Non-recursor '{n}' extracted from children"
-| .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
-| .transportError n => pure s!"compiler transport error '{repr n}'"
-| .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
-| .cantPackLevel n => pure s!"Can't pack level {n} greater than 2^256'"
-| .nonCongruentInductives a b => pure s!"noncongruent inductives {a.name} {b.name}'"
-| .alphaInvarianceFailure x xa y ya => 
-  pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
-| .emptyDefsEquivalenceClass dss => 
-  pure s!"empty equivalence class while sorting definitions {dss.map fun ds => ds.map (·.name)}"
-| .emptyIndsEquivalenceClass dss => 
-  pure s!"empty equivalence class while sorting inductives {dss.map fun ds => ds.map (·.name)}"
-
+namespace Ix
+open Ixon
 
 structure CompileEnv where
   univCtx : List Lean.Name
   bindCtx : List Lean.Name
-  mutCtx: Std.HashMap Lean.Name Nat
-  maxHeartBeats: USize
-  current : Lean.Name
+  mutCtx  : MutCtx
+deriving BEq, Hashable
 
-def CompileEnv.init (maxHeartBeats: USize): CompileEnv :=
-  ⟨default, default, default, maxHeartBeats, default⟩
-
-open Ixon
+def CompileEnv.init: CompileEnv := ⟨default, default, default⟩
 
 structure CompileState where
+  maxHeartBeats: USize
   env: Lean.Environment
   prng: StdGen
-  names: Std.HashMap Lean.Name (Address × Address)
-  cache: Std.HashMap Ix.Const (Address × Address)
-  comms: Std.HashMap Lean.Name (Address × Address)
-  eqConst: Std.HashMap (Lean.Name × Lean.Name) Ordering
-  axioms: Std.HashMap Lean.Name (Address × Address)
-  blocks: Std.HashSet (Address × Address)
+  store: HashMap Address ByteArray
+  names: HashMap Lean.Name Address
+  univCache: HashMap Lean.Level Ix.Level
+  univAddrs: HashMap Ix.Level MetaAddress
+  constCache: HashMap Lean.ConstantInfo Ix.Const
+  constAddrs : HashMap Ix.Const MetaAddress
+  exprCache: HashMap Lean.Expr Ix.Expr
+  exprAddrs: HashMap Ix.Expr MetaAddress
+  comms: HashMap Lean.Name MetaAddress
+  constCmp: HashMap (Lean.Name × Lean.Name) Ordering
+  exprCmp: HashMap (CompileEnv × Lean.Expr × Lean.Expr) Ordering
+  axioms: Std.HashMap Lean.Name MetaAddress
+  blocks: Std.HashSet MetaAddress
   cronos: Cronos
 
-def CompileState.init (env: Lean.Environment) (seed: Nat): CompileState :=
-  ⟨env, mkStdGen seed, default, default, default, default, default, default, default, default⟩
+def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize) : CompileState :=
+  ⟨maxHeartBeats, env, mkStdGen seed, default, default, default, default,
+  default, default, default, default, default, default, default, default,
+  default, default⟩
+
+inductive CompileError where
+| unknownConstant : Lean.Name → CompileError
+| unfilledLevelMetavariable : Lean.Level → CompileError
+--| unfilledExprMetavariable : Lean.Expr → CompileError
+--| invalidBVarIndex : Nat → CompileError
+--| freeVariableExpr : Lean.Expr → CompileError
+--| metaVariableExpr : Lean.Expr → CompileError
+--| metaDataExpr : Lean.Expr → CompileError
+| levelNotFound : Lean.Name → List Lean.Name -> String → CompileError
+--| invalidConstantKind : Lean.Name → String → String → CompileError
+--| constantNotContentAddressed : Lean.Name → CompileError
+--| nonRecursorExtractedFromChildren : Lean.Name → CompileError
+--| cantFindMutDefIndex : Lean.Name → CompileError
+----| transportError : TransportError → CompileError
+--| kernelException : Lean.Kernel.Exception → CompileError
+--| cantPackLevel : Nat → CompileError
+--| nonCongruentInductives : PreInductive -> PreInductive -> CompileError
+--| alphaInvarianceFailure : Ix.Const -> Address -> Ix.Const -> Address -> CompileError
+--| emptyDefsEquivalenceClass: List (List PreDefinition) -> CompileError
+--| emptyIndsEquivalenceClass: List (List PreInductive) -> CompileError
+--
+--def CompileError.pretty : CompileError -> IO String
+--| .unknownConstant n => pure s!"Unknown constant '{n}'"
+--| .unfilledLevelMetavariable l => pure s!"Unfilled level metavariable on universe '{l}'"
+--| .unfilledExprMetavariable e => pure s!"Unfilled level metavariable on expression '{e}'"
+--| .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
+--| .freeVariableExpr e => pure s!"Free variable in expression '{e}'"
+--| .metaVariableExpr e => pure s!"Metavariable in expression '{e}'"
+--| .metaDataExpr e => pure s!"Meta data in expression '{e}'"
+--| .levelNotFound n ns msg => pure s!"'Level {n}' not found in '{ns}', {msg}"
+--| .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
+--| .constantNotContentAddressed n => pure s!"Constant '{n}' wasn't content-addressed"
+--| .nonRecursorExtractedFromChildren n => pure
+--  s!"Non-recursor '{n}' extracted from children"
+--| .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
+----| .transportError n => pure s!"compiler transport error '{repr n}'"
+--| .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
+--| .cantPackLevel n => pure s!"Can't pack level {n} greater than 2^256'"
+--| .nonCongruentInductives a b => pure s!"noncongruent inductives {a.name} {b.name}'"
+--| .alphaInvarianceFailure x xa y ya => 
+--  pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
+--| .emptyDefsEquivalenceClass dss => 
+--  pure s!"empty equivalence class while sorting definitions {dss.map fun ds => ds.map (·.name)}"
+--| .emptyIndsEquivalenceClass dss => 
+--  pure s!"empty equivalence class while sorting inductives {dss.map fun ds => ds.map (·.name)}"
 
 abbrev CompileM :=
   ReaderT CompileEnv <| ExceptT CompileError <| StateT CompileState IO
@@ -94,9 +98,6 @@ def CompileM.run (env: CompileEnv) (stt: CompileState) (c : CompileM α)
   : IO (Except CompileError α × CompileState)
   := StateT.run (ExceptT.run (ReaderT.run c env)) stt
 
-def storeConst (const: Ixon): CompileM Address := do
-  liftM (Store.writeConst const).toIO
-
 def randByte (lo hi: Nat): CompileM Nat := do
   modifyGet fun s => 
   let (res, g') := randNat s.prng lo hi
@@ -109,9 +110,12 @@ def freshSecret : CompileM Address := do
     secret := secret.push rand.toUInt8
   return ⟨secret⟩
 
+--def storeConst (const: Ixon): CompileM Address := do
+--  liftM (Store.writeConst const).toIO
+
 -- add binding name to local context
-def withCurrent (name: Lean.Name) : CompileM α -> CompileM α :=
-  withReader $ fun c => { c with current := name }
+--def withCurrent (name: Lean.Name) : CompileM α -> CompileM α :=
+--  withReader $ fun c => { c with current := name }
 
 -- add binding name to local context
 def withBinder (name: Lean.Name) : CompileM α -> CompileM α :=
@@ -133,43 +137,53 @@ def resetCtx : CompileM α -> CompileM α :=
 def resetCtxWithLevels (lvls: List Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := {} }
 
-def dematerializeConst (x: Ix.Const) : CompileM (Ixon × Ixon) :=
-  match dematerialize x with
-  | .ok (ix, tstt) => do
-    for (addr, ixon) in tstt.store do
-      let _ <- liftM (Store.forceWriteConst addr ixon).toIO
-    return (ix, Ixon.meta ⟨tstt.meta.toList⟩)
-  | .error e => throw (.transportError e)
-
-def cron (tag: String) : CompileM Unit := do
-  let stt <- get
-  let c <- liftM <| Cronos.clock stt.cronos tag
-  modify fun stt => { stt with cronos := c }
-
-def getCron (tag: String) : CompileM String := do
-  return (<- get).cronos.tagSummary tag
-
--- lookup or compute the addresses of a constant
-def hashConst (const: Ix.Const) : CompileM (Address × Address) := do
-  match (<- get).cache.get? const with
-  | some (anonAddr, metaAddr) => pure (anonAddr, metaAddr)
+def storeIxon (ixon: Ixon): CompileM Address := do
+  let bytes := Ixon.ser ixon
+  let addr := Address.blake3 bytes
+  modifyGet fun stt => (addr, { stt with
+    store := stt.store.insert addr bytes
+  })
+
+def storeString (str: String): CompileM Address := do
+  let bytes := str.toUTF8
+  let addr := Address.blake3 bytes
+  modifyGet fun stt => (addr, { stt with
+    store := stt.store.insert addr bytes
+  })
+
+def storeNat (nat: Nat): CompileM Address := do
+  let bytes := nat.toBytesLE
+  let addr := Address.blake3 ⟨bytes⟩
+  modifyGet fun stt => (addr, { stt with
+    store := stt.store.insert addr ⟨bytes⟩
+  })
+
+def storeMetadata (meta: Metadata): CompileM Address := do
+  let bytes := Ixon.ser meta
+  let addr := Address.blake3 bytes
+  modifyGet fun stt => (addr, { stt with
+    store := stt.store.insert addr bytes
+  })
+
+def dematerializeName (name: Lean.Name): CompileM Address := do
+  match (<- get).names.get? name with
+  | some addr => pure addr
   | none => do
-    let cronTag := s!"hashConst {const.name}"
-    dbg_trace "-> hashConst {const.name}";
-    cron cronTag
-    let (anonIxon, metaIxon) <- dematerializeConst const
-    let anonAddr <- storeConst anonIxon
-    let metaAddr <- storeConst metaIxon
-    cron cronTag
-    let timing <- getCron cronTag
-    dbg_trace "✓ {timing}";
-    dbg_trace "names: {(<- get).names.size}";
-    dbg_trace "cache: {(<- get).cache.size}";
-    dbg_trace "eqConst: {(<- get).eqConst.size}";
-    dbg_trace "blocks: {(<- get).blocks.size}";
-    modifyGet fun stt => ((anonAddr, metaAddr), { stt with
-      cache := stt.cache.insert const (anonAddr, metaAddr)
+    let addr <- go name
+    modifyGet fun stt => (addr, { stt with
+      names := stt.names.insert name addr
     })
+  where
+    go : Lean.Name -> CompileM Address
+    | .anonymous => pure <| Address.blake3 ⟨#[]⟩
+    | .str n s => do
+      let n' <- dematerializeName n
+      let s' <- storeString s
+      storeIxon (.nstr n' s')
+    | .num n i => do
+      let n' <- dematerializeName n
+      let i' <- storeNat i
+      storeIxon (.nnum n' i')
 
 /-- Defines an ordering for Lean universes -/
 def compareLevel (xctx yctx: List Lean.Name)
@@ -194,791 +208,1147 @@ def compareLevel (xctx yctx: List Lean.Name)
     match (xctx.idxOf? x), (yctx.idxOf? y) with
     | some xi, some yi => return ⟨true, compare xi yi⟩
     | none,    _       => 
-      throw $ .levelNotFound x xctx s!"compareLevel @ {(<- read).current}"
+      throw $ .levelNotFound x xctx s!"compareLevel"
     | _,       none    => 
-      throw $ .levelNotFound y yctx s!"compareLevel @ {(<- read).current}"
-
-/-- Canonicalizes a Lean universe level and adds it to the store -/
-def compileLevel : Lean.Level → CompileM Ix.Level
-| .zero => pure .zero
-| .succ u => return .succ (← compileLevel u)
-| .max a b  => return .max (← compileLevel a) (← compileLevel b)
-| .imax a b => return .imax (← compileLevel a) (← compileLevel b)
-| .param name => do
-  let lvls := (← read).univCtx
-  match lvls.idxOf? name with
-  | some n => pure $ .param name n
-  | none   => throw $ .levelNotFound name lvls s!"compileLevel @ {(<- read).current}"
-| l@(.mvar ..) => throw $ .unfilledLevelMetavariable l
-
-/-- Retrieves a Lean constant from the environment by its name -/
-def findLeanConst (name : Lean.Name) : CompileM Lean.ConstantInfo := do
-  match (← get).env.constants.find? name with
-  | some const => pure const
-  | none => throw $ .unknownConstant name
-
-/-- Check if expression is an internal recursor --/
-def isInternalRec (expr : Lean.Expr) (name : Lean.Name) : Bool :=
-  match expr with
-  | .forallE _ t e _  => match e with
-    | .forallE ..  => isInternalRec e name
-    | _ => isInternalRec t name -- t is the major premise
-  | .app e .. => isInternalRec e name
-  | .const n .. => n == name
-  | _ => false
-
-mutual
-
-/-- compile Lean Constant --/
-partial def compileConst (const : Lean.ConstantInfo)
-  : CompileM (Address × Address) := do
-  -- first check if we've already compiled this const
-  match (← get).names.get? const.name with
-  -- if we have, returned the cached address
-  | some (anonAddr, metaAddr) => do
-    pure (anonAddr, metaAddr)
-  -- if not, pattern match on the const
+      throw $ .levelNotFound y yctx s!"compareLevel"
+
+def dematerializeLevel (lvl: Ix.Level): CompileM MetaAddress := do
+  match (<- get).univAddrs.get? lvl with
+  | some l => pure l
   | none => do
-    dbg_trace "-> compileConst {const.name}";
-    let cronTag := s!"compileConst {const.name}"
-    cron cronTag
-    let addrs <- compileInner const
-    cron cronTag
-    let timing <- getCron cronTag
-    dbg_trace "✓ {timing}";
-    return addrs
-  where
-    compileInner (const: Lean.ConstantInfo) := resetCtx $ withCurrent const.name $ match const with
-    -- convert possible mutual block elements to PreDefinitions
-    | .defnInfo val => do
-      compileDefinition (mkPreDefinition val)
-    | .thmInfo val => do
-      compileDefinition (mkPreTheorem val)
-    | .opaqueInfo val => do
-      compileDefinition (mkPreOpaque val)
-    -- compile possible mutual inductive block elements
-    | .inductInfo val => do
-      compileInductive val
-    -- compile constructors through their parent inductive
-    | .ctorInfo val => do
-      match ← findLeanConst val.induct with
-      | .inductInfo ind => do
-        let _ <- compileInductive ind
-        compileConst (.ctorInfo val)
-      | const =>
-        throw $ .invalidConstantKind const.name "inductive" const.ctorName
-    -- compile recursors through their parent inductive
-    | .recInfo val => do
-      match ← findLeanConst val.getMajorInduct with
-      | .inductInfo ind => do
-        let _ <- compileInductive ind
-        compileConst (.recInfo val)
-      | const =>
-        throw $ .invalidConstantKind const.name "inductive" const.ctorName
-    -- The rest adds the constants to the cache one by one
-    | .axiomInfo val => resetCtxWithLevels const.levelParams do
-      let c := .axiom ⟨val.name, val.levelParams, ← compileExpr val.type, val.isUnsafe⟩
-      let (anonAddr, metaAddr) ← hashConst c
-      modify fun stt => { stt with
-        axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
-        names := stt.names.insert const.name (anonAddr, metaAddr)
-      }
-      return (anonAddr, metaAddr)
-    | .quotInfo val => resetCtxWithLevels const.levelParams do
-      let type <- compileExpr val.type
-      let c := .quotient ⟨val.name, val.levelParams, type, val.kind⟩
-      let (anonAddr, metaAddr) ← hashConst c
-      modify fun stt => { stt with
-        axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
-        names := stt.names.insert const.name (anonAddr, metaAddr)
-      }
-      return (anonAddr, metaAddr)
-
-/-- compile possibly mutual Lean definition --/
-partial def compileDefinition (struct: PreDefinition)
-  : CompileM (Address × Address) := do
-  dbg_trace "compileDefinition {struct.name}"
-  -- If the mutual size is one, simply content address the single definition
-  if struct.all matches [_] then
-    let defn <- withMutCtx ({(struct.name,0)}) $ preDefinitionToIR struct
-    let (anonAddr, metaAddr) <- hashConst $ .definition defn
-    modify fun stt => { stt with
-      names := stt.names.insert struct.name (anonAddr, metaAddr)
-    }
-    return (anonAddr, metaAddr)
-  -- Collecting and sorting all definitions in the mutual block
-  let mut mutDefs : Array PreDefinition := #[]
-  for n in struct.all do
-    match <- findLeanConst n with
-      | .defnInfo x => mutDefs := mutDefs.push (mkPreDefinition x)
-      | .opaqueInfo x => mutDefs := mutDefs.push (mkPreOpaque x)
-      | .thmInfo x => mutDefs := mutDefs.push (mkPreTheorem x)
-      | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
-  let mutualDefs <- sortDefs mutDefs.toList
-  let mutCtx := defMutCtx mutualDefs
-  let definitions ← withMutCtx mutCtx <|
-    mutualDefs.mapM (·.mapM preDefinitionToIR)
-  -- Building and storing the block
-  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .mutual ⟨definitions⟩
-  modify fun stt =>
-    { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
-  -- While iterating on the definitions from the mutual block, we need to track
-  -- the correct objects to return
-  let mut ret? : Option (Address × Address) := none
-  for name in struct.all do
-    -- Storing and caching the definition projection
-    -- Also adds the constant to the array of constants
-    let some idx := mutCtx.get? name | throw $ .cantFindMutDefIndex name
-    let (anonAddr, metaAddr) ←
-      hashConst $ .definitionProj ⟨name, blockAnonAddr, blockMetaAddr, idx⟩
-    modify fun stt => { stt with
-      names := stt.names.insert name (anonAddr, metaAddr)
-    }
-    if struct.name == name then ret? := some (anonAddr, metaAddr)
-  match ret? with
-  | some ret => return ret
-  | none => throw $ .constantNotContentAddressed struct.name
-
-partial def preDefinitionToIR (d: PreDefinition)
-  : CompileM Ix.Definition := withCurrent d.name $ withLevels d.levelParams do
-  dbg_trace "preDefinitionToIR {d.name}"
-  let typ <- compileExpr d.type
-  let val <- compileExpr d.value
-  return ⟨d.name, d.levelParams, typ, d.kind, val, d.hints, d.safety, d.all⟩
-
-partial def getRecursors (ind : Lean.InductiveVal) 
-  : CompileM (List Lean.RecursorVal) := do
-    return (<- get).env.constants.fold accRecr []
-    where
-      accRecr (acc: List Lean.RecursorVal) (n: Lean.Name) (c: Lean.ConstantInfo)
-        : List Lean.RecursorVal :=
-        match n with
-        | .str n ..
-        | .num n .. =>
-          if n == ind.name then match c with
-            | .recInfo r => r :: acc
-            | _ => acc
-          else acc
-        | _ => acc
-
-partial def makePreInductive (ind: Lean.InductiveVal) 
-  : CompileM Ix.PreInductive := do
-    dbg_trace "-> makePreInductive {ind.name}";
-    let ctors <- ind.ctors.mapM getCtor
-    let recrs <- getRecursors ind
-    return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices,
-      ind.all, ctors, recrs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
-    where
-      getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
-        match (<- findLeanConst name) with
-        | .ctorInfo c => pure c
-        | _ => throw <| .invalidConstantKind name "constructor" ""
-
-/--
-Content-addresses an inductive and all inductives in the mutual block as a
-mutual block, even if the inductive itself is not in a mutual block.
-
-Content-addressing an inductive involves content-addressing its associated
-constructors and recursors, hence the complexity of this function.
--/
-partial def compileInductive (initInd: Lean.InductiveVal) 
-  : CompileM (Address × Address) := do
-  dbg_trace "-> compileInductive {initInd.name}";
-  let mut preInds := #[]
-  let mut nameData : Std.HashMap Lean.Name (List Lean.Name × List Lean.Name) := {}
-  -- collect all mutual inductives as Ix.PreInductives
-  for indName in initInd.all do
-    match ← findLeanConst indName with
-    | .inductInfo ind =>
-      let preInd <- makePreInductive ind
-      preInds := preInds.push preInd
-      nameData := nameData.insert indName (ind.ctors, preInd.recrs.map (·.name))
-    | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
-  -- sort PreInductives into equivalence classes
-  let mutualInds <- sortInds preInds.toList
-  let mutCtx := indMutCtx mutualInds
-  -- compile each preinductive with the mutCtx
-  let irInds ← withMutCtx mutCtx $ mutualInds.mapM (·.mapM preInductiveToIR)
-  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .inductive ⟨irInds⟩
-  modify fun stt =>
-    { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
-  -- While iterating on the inductives from the mutual block, we need to track
-  -- the correct objects to return
-  let mut ret? : Option (Address × Address) := none
-  for (indName, indIdx) in initInd.all.zipIdx do
-    -- Store and cache inductive projections
-    let name := indName
-    let (anonAddr, metaAddr) ←
-      hashConst $ .inductiveProj ⟨name, blockAnonAddr, blockMetaAddr, indIdx⟩
-    modify fun stt => { stt with
-      names := stt.names.insert name (anonAddr, metaAddr)
-    }
-    if name == initInd.name then ret? := some (anonAddr, metaAddr)
-    let some (ctors, recrs) := nameData.get? indName
-      | throw $ .cantFindMutDefIndex indName
-    for (ctorName, ctorIdx) in ctors.zipIdx do
-      -- Store and cache constructor projections
-      let (anonAddr, metaAddr) ←
-        hashConst $ .constructorProj
-          ⟨ctorName, blockAnonAddr, blockMetaAddr, indIdx, indName, ctorIdx⟩
-      modify fun stt => { stt with
-        names := stt.names.insert ctorName (anonAddr, metaAddr)
-      }
-    for (recrName, recrIdx) in recrs.zipIdx do
-      -- Store and cache recursor projections
-      let (anonAddr, metaAddr) ←
-        hashConst $ .recursorProj
-          ⟨recrName, blockAnonAddr, blockMetaAddr, indIdx, indName, recrIdx⟩
-      modify fun stt => { stt with
-        names := stt.names.insert recrName (anonAddr, metaAddr)
-      }
-  match ret? with
-  | some ret => return ret
-  | none => throw $ .constantNotContentAddressed initInd.name
-
-partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive 
-  := withCurrent ind.name $ withLevels ind.levelParams $ do
-  dbg_trace "-> preInductiveToIR {ind.name}";
-  let (recs, ctors) := <- ind.recrs.foldrM (init := ([], [])) collectRecsCtors
-  let type <- compileExpr ind.type
-    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
-    -- match the order used in `mutCtx`
-  return ⟨ind.name, ind.levelParams, type, ind.numParams, ind.numIndices,
-    ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
+    let (anon, meta) <- go lvl
+    let anonAddr <- storeIxon anon
+    let metaAddr <- storeIxon meta
+    let maddr := ⟨anonAddr, metaAddr⟩
+    modifyGet fun stt => (maddr, { stt with
+      univAddrs := stt.univAddrs.insert lvl maddr
+    })
   where
-    collectRecsCtors
-      : Lean.RecursorVal
-      -> List Recursor × List Constructor 
-      -> CompileM (List Recursor × List Constructor)
-      | r, (recs, ctors) =>
-        if isInternalRec r.type ind.name then do
-          let (thisRec, thisCtors) <- internalRecToIR (ind.ctors.map (·.name)) r
-          pure (thisRec :: recs, thisCtors)
-        else do
-          let thisRec ← externalRecToIR r
-          pure (thisRec :: recs, ctors)
-
-partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
-  : CompileM (Ix.Recursor × List Ix.Constructor) :=
-  withCurrent recr.name $ withLevels recr.levelParams do
-    dbg_trace s!"internalRecToIR"
-    let typ ← compileExpr recr.type
-    let (retCtors, retRules) ← recr.rules.foldrM (init := ([], []))
-      fun r (retCtors, retRules) => do
-        if ctors.contains r.ctor then
-          let (ctor, rule) ← recRuleToIR r
-          pure $ (ctor :: retCtors, rule :: retRules)
-        else pure (retCtors, retRules) -- this is an external recursor rule
-    let recr := ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
-      recr.numMotives, recr.numMinors, retRules, recr.k, recr.isUnsafe⟩
-    return (recr, retCtors)
-
-partial def externalRecToIR (recr: Lean.RecursorVal): CompileM Recursor :=
-  withCurrent recr.name $ withLevels recr.levelParams do
-    dbg_trace s!"externalRecToIR"
-    let typ ← compileExpr recr.type
-    let rules ← recr.rules.mapM externalRecRuleToIR
-    return ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
-      recr.numMotives, recr.numMinors, rules, recr.k, recr.isUnsafe⟩
-
-partial def recRuleToIR (rule : Lean.RecursorRule)
-  : CompileM (Ix.Constructor × Ix.RecursorRule) := do
-  dbg_trace s!"recRuleToIR"
-  let rhs ← compileExpr rule.rhs
-  match ← findLeanConst rule.ctor with
-  | .ctorInfo ctor => withCurrent ctor.name $ withLevels ctor.levelParams do
-    let typ ← compileExpr ctor.type
-    let ctor :=
-      ⟨ctor.name, ctor.levelParams, typ, ctor.cidx, ctor.numParams, ctor.numFields, ctor.isUnsafe⟩
-    pure (ctor, ⟨rule.ctor, rule.nfields, rhs⟩)
-  | const =>
-    throw $ .invalidConstantKind const.name "constructor" const.ctorName
-
-partial def externalRecRuleToIR (rule : Lean.RecursorRule) 
-  : CompileM RecursorRule :=
-  return ⟨rule.ctor, rule.nfields, ← compileExpr rule.rhs⟩
-
-/--
-Content-addresses a Lean expression and adds it to the store.
-
-Constants are the tricky case, for which there are two possibilities:
-* The constant belongs to `mutCtx`, representing a recursive call. Those are
-encoded as `.rec_` with indexes based on order in the mutual definition
-* The constant doesn't belong to `mutCtx`, meaning that it's not a recursion
-and thus we can canon the actual constant right away
--/
-partial def compileExpr : Lean.Expr → CompileM Expr
-| .bvar idx => do match (← read).bindCtx[idx]? with
-  -- Bound variables must be in the bind context
-  | some _ => return .var idx
-  | none => throw $ .invalidBVarIndex idx
-| .sort lvl => return .sort $ ← compileLevel lvl
-| .const name lvls => do
-  let univs ← lvls.mapM compileLevel
-  match (← read).mutCtx.get? name with
-  -- recursing!
-  | some i => return .rec_ name i univs
-  | none => match (<- get).comms.get? name with
-    | some (commAddr, metaAddr) => do
-      return .const name commAddr metaAddr univs
-    | none => do
-      let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
-      return .const name contAddr metaAddr univs
-| .app fnc arg => return .app (← compileExpr fnc) (← compileExpr arg)
-| .lam name typ bod info =>
-  return .lam name info (← compileExpr typ) (← withBinder name $ compileExpr bod)
-| .forallE name dom img info =>
-  return .pi name info (← compileExpr dom) (← withBinder name $ compileExpr img)
-| .letE name typ exp bod nD =>
-  return .letE name (← compileExpr typ) (← compileExpr exp)
-    (← withBinder name $ compileExpr bod) nD
-| .lit lit => return .lit lit
-| .proj name idx exp => do
-  let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
-  return .proj name contAddr metaAddr idx (← compileExpr exp)
-| expr@(.fvar ..)  => throw $ .freeVariableExpr expr
-| expr@(.mvar ..)  => throw $ .metaVariableExpr expr
--- TODO: cursed
-| (.mdata _ x) => compileExpr x
-
-/--
-A name-irrelevant ordering of Lean expressions.
--/
-partial def compareExpr (ctx: Std.HashMap Lean.Name Nat)
-  (xlvls ylvls: List Lean.Name)
-  --: Lean.Expr → Lean.Expr → CompileM SOrder
-  (x y: Lean.Expr) : CompileM SOrder := do
-  --dbg_trace "compareExpr {repr xlvls} {repr ylvls} {repr x} {repr y}"
-  --let mutCtx := (<- read).mutCtx
-  --dbg_trace "mutCtx {repr mutCtx}";
-  match x, y with
-  | e@(.mvar ..), _ => throw $ .unfilledExprMetavariable e
-  | _, e@(.mvar ..) => throw $ .unfilledExprMetavariable e
-  | e@(.fvar ..), _ => throw $ .freeVariableExpr e
-  | _, e@(.fvar ..) => throw $ .freeVariableExpr e
-  | .mdata _ x, .mdata _ y  => compareExpr ctx xlvls ylvls x y
-  | .mdata _ x, y  => compareExpr ctx xlvls ylvls x y
-  | x, .mdata _ y  => compareExpr ctx xlvls ylvls x y
-  | .bvar x, .bvar y => return ⟨true, compare x y⟩
-  | .bvar .., _ => return ⟨true, .lt⟩
-  | _, .bvar .. => return ⟨true, .gt⟩
-  | .sort x, .sort y => compareLevel xlvls ylvls x y
-  | .sort .., _ => return ⟨true, .lt⟩
-  | _, .sort .. => return ⟨true, .gt⟩
-  | .const x xls, .const y yls => do
-    --dbg_trace "compare const {x} {y}";
-    let univs ← SOrder.zipM (compareLevel xlvls ylvls) xls yls
-    if univs.ord != .eq then return univs
-    --dbg_trace "compare const {x} {y} {repr ctx}";
-    match ctx.get? x, ctx.get? y with
-    | some nx, some ny => return ⟨false, compare nx ny⟩
-    | none, some _ => do
-      return ⟨true, .gt⟩
-    | some _, none =>
-      return ⟨true, .lt⟩
-    | none, none =>
-      if x == y then 
-        return ⟨true, .eq⟩
-      else do
-        let x' <- compileConst $ ← findLeanConst x
-        let y' <- compileConst $ ← findLeanConst y
-        return ⟨true, compare x' y'⟩
-  | .const .., _ => return ⟨true, .lt⟩
-  | _, .const .. => return ⟨true, .gt⟩
-  | .app xf xa, .app yf ya =>
-    SOrder.cmpM 
-      (compareExpr ctx xlvls ylvls xf yf) 
-      (compareExpr ctx xlvls ylvls xa ya)
-  | .app .., _ => return ⟨true, .lt⟩
-  | _, .app .. => return ⟨true, .gt⟩
-  | .lam _ xt xb _, .lam _ yt yb _ => 
-    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
-  | .lam .., _ => return ⟨true, .lt⟩
-  | _, .lam .. => return ⟨true, .gt⟩
-  | .forallE _ xt xb _, .forallE _ yt yb _ => 
-    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
-  | .forallE .., _ => return ⟨true, .lt⟩
-  | _, .forallE .. => return ⟨true, .gt⟩
-  | .letE _ xt xv xb _, .letE _ yt yv yb _ =>
-    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) <|
-    SOrder.cmpM (compareExpr ctx xlvls ylvls xv yv)
-      (compareExpr ctx xlvls ylvls xb yb)
-  | .letE .., _ => return ⟨true, .lt⟩
-  | _, .letE .. => return ⟨true, .gt⟩
-  | .lit x, .lit y => return ⟨true, compare x y⟩
-  | .lit .., _ => return ⟨true, .lt⟩
-  | _, .lit .. => return ⟨true, .gt⟩
-  | .proj _ nx tx, .proj _ ny ty => 
-    SOrder.cmpM (pure ⟨true, compare nx ny⟩) 
-      (compareExpr ctx xlvls ylvls tx ty)
-
-/-- AST comparison of two Lean definitions. --/
-partial def compareDef (ctx: Std.HashMap Lean.Name Nat) (x y: PreDefinition) : CompileM Ordering := do
-  let key := match compare x.name y.name with
-    | .lt => (x.name, y.name)
-    | _ => (y.name, x.name)
-  match (<- get).eqConst.get? key with
-  | some o => return o
+    go : Ix.Level -> CompileM (Ixon × Ixon)
+    | .zero => pure (.uzero, .meta default)
+    | .succ x => do
+      let ⟨a, m⟩ <- dematerializeLevel x
+      pure (.usucc a, .meta ⟨[.link m]⟩)
+    | .max x y => do
+      let ⟨xa, xm⟩ <- dematerializeLevel x
+      let ⟨ya, ym⟩ <- dematerializeLevel y
+      pure (.umax xa ya, .meta ⟨[.link xm, .link ym]⟩)
+    | .imax x y => do
+      let ⟨xa, xm⟩ <- dematerializeLevel x
+      let ⟨ya, ym⟩ <- dematerializeLevel y
+      pure (.uimax xa ya, .meta ⟨[.link xm, .link ym]⟩)
+    | .param n i => do
+      let n' <- dematerializeName n
+      pure (.uvar i, .meta ⟨[.name n']⟩)
+
+/-- Canonicalizes a Lean universe level --/
+def compileLevel (lvl: Lean.Level): CompileM Ix.Level := do
+  match (<- get).univCache.get? lvl with
+  | some l => pure l
   | none => do
-    let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
-        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
-    if sorder.strong then modify fun stt => { stt with
-        eqConst := stt.eqConst.insert key sorder.ord
-      }
-    return sorder.ord
-
-/--
-`sortDefs` recursively sorts a list of mutual definitions into equivalence classes.
-At each stage, we take as input the current best known equivalence
-classes (held in the `mutCtx` of the CompileEnv). For most cases, equivalence
-can be determined by syntactic differences which are invariant to the current
-best known classification. For example:
-
-```
-mutual
-  def : Nat := 1
-  def bar : Nat := 2
-end
-```
-
-are both different due to the different values in the definition. We call this a
-"strong" ordering, and comparisons between defintions that produce strong
-orderings are cached across compilation.
-
-However, there are also weak orderings, where the order of definitions in a
-mutual block depends on itself.
-
-```
-mutual
-  def A : Nat → Nat
-  | 0 => 0
-  | n + 1 => B n + C n + 1
-
-  def B : Nat → Nat
-  | 0 => 0
-  | n + 1 => C n + 1
-
-  def C : Nat → Nat
-  | 0 => 0
-  | n + 1 => A n + 1
-end
-```
-
-Here since any reference to A, B, C has to be compiled into an index, the
-ordering chosen for A, B, C will effect itself, since we compile into
-something that looks, with order [A, B, C] like:
-
-```
-mutual
-  def #1 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #2 n + #3 n + 1
-
-  def #2 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #3 n + 1
-
-  def #3 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #1 n + 1
-end
-```
-
-This is all well and good, but if we chose order `[C, B, A]` then the block
-would compile as
-
-```
-mutual
-  def #1 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #3 n + 1
-
-  def #2 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #1 n + 1
-
-  def #3 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #2 n + #1 n + 1
-end
-```
-
-with completely different hashes. So we need to figure out a canonical order for
-such mutual blocks.
-
-We start by assuming that all definitions in a mutual block are equal and then 
-recursively refining this assumption through successive sorting passes. This
-algorithm bears some similarity to partition refinement:
-```
-classes₀ := [startDefs]
-classes₁ := sortDefs classes₀
-classes₂ := sortDefs classes₁
-classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
-```
-Initially, `startDefs` is simply the list of definitions we receive from
-`DefinitionVal.all`, sorted by name. We assume that at we will reach some
-fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no further refinement is
-possible (we have not rigourously proven such a fixed point exists, but
-it seams reasonable given that after the first pass to find the strongly ordered
-definitions, the algorithm should only separate partitions into smaller ones)
--/
-partial def sortDefs (classes : List PreDefinition)
-  : CompileM (List (List PreDefinition)) := do
-    sortDefsInner [List.sortBy (compare ·.name ·.name) classes] 0
+    let lvl' <- go lvl
+    let _ <- dematerializeLevel lvl'
+    modifyGet fun stt => (lvl', { stt with
+      univCache := stt.univCache.insert lvl lvl'
+    })
   where
-    eqDef (ctx: Std.HashMap Lean.Name Nat) (x y: PreDefinition) 
-      : CompileM Bool := (· == .eq) <$> compareDef ctx x y
-    sortDefsInner (classes: List (List PreDefinition)) (iter: Nat)
-      : CompileM (List (List PreDefinition)) := do
-      let ctx := defMutCtx classes
-      dbg_trace "sortdefs {iter} classes {repr (classes.map (·.map (·.name)))}";
-      let newClasses ← classes.mapM fun ds =>
-        match ds with
-        | []  => unreachable!
-        | [d] => pure [[d]]
-        | ds  => do pure $ (← List.groupByM (eqDef ctx) $ ← ds.sortByM (compareDef ctx))
-      let newClasses := newClasses.flatten.map (List.sortBy (compare ·.name ·.name))
-      if classes == newClasses then return newClasses
-      else sortDefsInner newClasses (iter + 1)
-
-/-- AST comparison of two Lean inductives. --/
-partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInductive) 
-  : CompileM Ordering := do
-  --dbg_trace "compareInd {x.name} {y.name}";
-  let key := match compare x.name y.name with
-    | .lt => (x.name, y.name)
-    | _ => (y.name, x.name)
-  match (<- get).eqConst.get? key with
-  | some o => return o
+    go : Lean.Level -> CompileM Ix.Level
+    | .zero => pure .zero
+    | .succ u => return .succ (← compileLevel u)
+    | .max a b  => return .max (← compileLevel a) (← compileLevel b)
+    | .imax a b => return .imax (← compileLevel a) (← compileLevel b)
+    | .param name => do
+      let lvls := (← read).univCtx
+      match lvls.idxOf? name with
+      | some n => pure $ .param name n
+      | none   => throw $ .levelNotFound name lvls s!"compileLevel"
+    | l@(.mvar ..) => throw $ .unfilledLevelMetavariable l
+
+def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
+  match (<- get).exprAddrs.get? expr with
+  | some x => pure x
   | none => do
-    let sorder <- do
-      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.numIndices y.numIndices⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.ctors.length y.ctors.length⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.recrs.length y.recrs.length⟩) <|
-      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
-      SOrder.cmpM (SOrder.zipM compareCtor x.ctors y.ctors)
-        (SOrder.zipM compareRecr x.recrs y.recrs)
-    if sorder.strong then modify fun stt => { stt with
-        eqConst := stt.eqConst.insert key sorder.ord
-      }
-    --dbg_trace "compareInd {x.name} {y.name} -> {repr sorder.ord}";
-    return sorder.ord
-  where
-    compareCtor (x y: Lean.ConstructorVal) : CompileM SOrder := do
-     --dbg_trace "compareCtor {x.name} {y.name}";
-      let key := match compare x.name y.name with
-        | .lt => (x.name, y.name)
-        | _ => (y.name, x.name)
-      match (<- get).eqConst.get? key with
-      | some o => return ⟨true, o⟩
-      | none => do
-      let sorder <- do
-        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.cidx y.cidx⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.numFields y.numFields⟩) <|
-          (compareExpr ctx x.levelParams y.levelParams x.type y.type)
-      if sorder.strong then modify fun stt => { stt with
-          eqConst := stt.eqConst.insert key sorder.ord
-        }
-      return sorder
-    compareRecr (x y: Lean.RecursorVal) : CompileM SOrder := do
-      --dbg_trace "compareRecr {x.name} {y.name}";
-      let key := match compare x.name y.name with
-        | .lt => (x.name, y.name)
-        | _ => (y.name, x.name)
-      match (<- get).eqConst.get? key with
-      | some o => return ⟨true, o⟩
-      | none => do
-      let sorder <- do
-        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-        SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
-        SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
-        SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
-        SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
-          (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
-      if sorder.strong then modify fun stt => { stt with
-          eqConst := stt.eqConst.insert key sorder.ord
-        }
-      return sorder
-    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
-      : CompileM SOrder := do
-        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
-          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
-
---#check List.sortBy (compare ·.name ·.name) [`Test.Ix.Inductives.C, `Test.Ix.Inductives.A, `Test.Ix.Inductives.B]
-
-/-- `sortInds` recursively sorts a list of inductive datatypes into equivalence
-classes, analogous to `sortDefs`
---/
-partial def sortInds (classes : (List PreInductive)) 
-  : CompileM (List (List PreInductive)) := do
-    sortIndsInner [List.sortBy (compare ·.name ·.name) classes] 0
+    let (anon, meta) <- go expr
+    let anonAddr <- storeIxon anon
+    let metaAddr <- storeIxon meta
+    let maddr := ⟨anonAddr, metaAddr⟩
+    modifyGet fun stt => (maddr, { stt with
+      exprAddrs := stt.exprAddrs.insert expr maddr
+    })
   where
-    eqInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInductive) : CompileM Bool
-      := (· == .eq) <$> compareInd ctx x y
-    sortIndsInner (classes: List (List PreInductive)) (iter: Nat)
-      : CompileM (List (List PreInductive)) := do
-      dbg_trace "sortInds {iter} classes {repr (classes.map (·.map (·.name)))}";
-      let ctx := indMutCtx classes
-      let newClasses ← classes.mapM fun ds =>
-        match ds with
-        | []  => unreachable!
-        | [d] => pure [[d]]
-        | ds  => do pure $ (← List.groupByM (eqInd ctx) $ ← ds.sortByM (compareInd ctx))
-      let newClasses := newClasses.flatten.map (List.sortBy (compare ·.name ·.name))
-      if classes == newClasses then return newClasses
-      else sortIndsInner newClasses (iter + 1)
-
-end
-
-partial def makeLeanDef
-  (name: Lean.Name) (levelParams: List Lean.Name) (type value: Lean.Expr) 
-  : Lean.DefinitionVal :=
-  { name, levelParams, type, value, hints := .opaque, safety := .safe }
-
-partial def tryAddLeanDef (defn: Lean.DefinitionVal) : CompileM Unit := do
-  match (<- get).env.constants.find? defn.name with
-  | some _ => pure ()
+    go : Ix.Expr -> CompileM (Ixon × Ixon)
+    | .var kvs idx => pure (.evar idx, .meta ⟨kvs.map .kvmap⟩)
+    | .sort kvs univ => do
+      let ⟨udata, umeta⟩ <- dematerializeLevel univ
+      let data := .esort udata
+      let meta := .meta { nodes := [.link umeta] ++ kvs.map .kvmap}
+      pure (data, meta)
+    | .const kvs name ref univs => do
+      let n <- dematerializeName name
+      let us <- univs.mapM dematerializeLevel
+      let data := .eref ref.data (us.map (·.data))
+      let meta := .meta ⟨[.name n, .link ref.meta] ++ us.map (.name ·.meta) ++ kvs.map .kvmap⟩
+      pure (data, meta)
+    | .rec_ kvs name idx univs => do
+      let n <- dematerializeName name
+      let us <- univs.mapM dematerializeLevel
+      let data := .erec idx (us.map (·.data))
+      let meta := .meta ⟨[.name n] ++ us.map (.name ·.meta) ++ kvs.map .kvmap⟩
+      pure (data, meta)
+    | .app kvs func argm => do
+      let f' <- dematerializeExpr func
+      let a' <- dematerializeExpr argm
+      let data := .eapp f'.data a'.data
+      let meta := .meta ⟨[.link f'.meta, .link a'.meta] ++ kvs.map .kvmap⟩
+      pure (data, meta)
+    | .lam kvs name info type body => do
+      let n <- dematerializeName name
+      let t' <- dematerializeExpr type
+      let b' <- dematerializeExpr body
+      let data := .elam t'.data b'.data
+      let meta := .meta ⟨[.name n, .info info, .link t'.meta, .link b'.meta] ++ kvs.map .kvmap⟩
+      pure (data, meta)
+    | .pi kvs name info type body => do
+      let n <- dematerializeName name
+      let t' <- dematerializeExpr type
+      let b' <- dematerializeExpr body
+      let data := .eall t'.data b'.data
+      let meta := .meta ⟨[.name n, .info info, .link t'.meta, .link b'.meta] ++ kvs.map .kvmap⟩
+      pure (data, meta)
+    | .letE kvs name type value body nD => do
+      let n <- dematerializeName name
+      let t' <- dematerializeExpr type
+      let v' <- dematerializeExpr value
+      let b' <- dematerializeExpr body
+      let data := .elet nD t'.data v'.data b'.data
+      let meta := .meta ⟨[.name n, .link t'.meta, .link v'.meta, .link b'.meta] ++ kvs.map .kvmap⟩
+      pure (data, meta)
+    | .lit kvs (.natVal n) => do pure (.enat (<- storeNat n), .meta ⟨kvs.map .kvmap⟩)
+    | .lit kvs (.strVal s) => do pure (.enat (<- storeString s), .meta ⟨kvs.map .kvmap⟩)
+    | .proj kvs typeName type idx struct => do
+      let n <- dematerializeName typeName
+      let s' <- dematerializeExpr struct
+      let data := .eprj type.data idx s'.data
+      let meta := .meta ⟨[.name n, .link type.meta, .link s'.meta] ++ kvs.map .kvmap⟩
+      pure (data, meta)
+
+def dematerializeConst (const: Ix.Const): CompileM MetaAddress := do
+  match (<- get).constAddrs.get? const with
+  | some x => pure x
   | none => do
-    let env <- (·.env) <$> get
-    let maxHeartBeats <- (·.maxHeartBeats) <$> read
-    let decl := Lean.Declaration.defnDecl defn
-    match Lean.Environment.addDeclCore env maxHeartBeats decl .none with
-    | .ok e => do
-      modify fun stt => { stt with env := e }
-      return ()
-    | .error e => throw $ .kernelException e
-
-partial def addDef
-  (lvls: List Lean.Name)
-  (typ val: Lean.Expr)
-  : CompileM (Address × Address) := do
-  let typ' <- compileExpr typ
-  let val' <- compileExpr val
-  let anonConst := Ix.Const.definition 
-    ⟨.anonymous, lvls, typ', .definition, val', .opaque, .safe, []⟩
-  let (anonIxon,_) <- dematerializeConst anonConst
-  let anonAddr <- storeConst anonIxon
-  let name := anonAddr.toUniqueName
-  let const := 
-    Ix.Const.definition ⟨name, lvls, typ', .definition, val', .opaque, .safe, []⟩
-  let (a, m) <- hashConst const
-  if a != anonAddr then
-    throw <| .alphaInvarianceFailure anonConst anonAddr const a
-  else
-    tryAddLeanDef (makeLeanDef a.toUniqueName lvls typ val)
-    return (a, m)
-
-partial def commitConst (anon meta: Address)
-  : CompileM (Address × Address) := do
-  let secret <- freshSecret
-  let comm := .comm ⟨secret, anon⟩
-  let commAddr <- storeConst comm
-  let commMeta := .comm ⟨secret, meta⟩
-  let commMetaAddr <- storeConst commMeta
-  modify fun stt => { stt with
-    comms := stt.comms.insert commAddr.toUniqueName (commAddr, commMetaAddr)
-  }
-  return (commAddr, commMetaAddr)
-
-partial def commitDef 
-  (lvls: List Lean.Name) 
-  (typ val: Lean.Expr)
-  : CompileM (Address × Address) := do
-  let (a, m) <- addDef lvls typ val
-  let (ca, cm) <- commitConst a m
-  tryAddLeanDef (makeLeanDef ca.toUniqueName lvls typ val)
-  --tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ (mkConst a.toUniqueName []))
-  return (ca, cm)
-
-
-partial def packLevel (lvls: Nat) (commit: Bool): CompileM Address :=
-  match Ixon.natPackAsAddress lvls with
-  | some lvlsAddr => do
-    if commit then
-      let secret <- freshSecret
-      let comm := .comm (Ixon.Comm.mk secret lvlsAddr)
-      let commAddr <- storeConst comm
-      modify fun stt => { stt with
-        comms := stt.comms.insert commAddr.toUniqueName (commAddr, commAddr)
-      }
-      return commAddr
-    else return lvlsAddr
-  | .none => throw $ .cantPackLevel lvls
-
-partial def checkClaim
-  (const: Lean.Name)
-  (type: Lean.Expr)
-  (sort: Lean.Expr)
-  (lvls: List Lean.Name)
-  (commit: Bool)
-  : CompileM (Claim × Address × Address) := do
-  let leanConst <- findLeanConst const
-  let (value, valMeta) <- compileConst leanConst >>= comm
-  let (type, typeMeta) <- addDef lvls sort type >>= comm
-  let lvls <- packLevel lvls.length commit
-  return (Claim.checks (CheckClaim.mk lvls type value), typeMeta, valMeta)
-  where
-    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
-
-partial def evalClaim
-  (lvls: List Lean.Name)
-  (input: Lean.Expr)
-  (output: Lean.Expr)
-  (type: Lean.Expr)
-  (sort: Lean.Expr)
-  (commit: Bool)
-  : CompileM (Claim × Address × Address × Address) := do
-  let (input, inputMeta) <- addDef lvls type input >>= comm
-  let (output, outputMeta) <- addDef lvls type output >>= comm
-  let (type, typeMeta) <- addDef lvls sort type >>= comm
-  let lvlsAddr <- packLevel lvls.length commit
-  return (Claim.evals (EvalClaim.mk lvlsAddr input output type), inputMeta, outputMeta, typeMeta)
+    let (anon, meta) <- go const
+    let anonAddr <- storeIxon anon
+    let metaAddr <- storeIxon meta
+    let maddr := ⟨anonAddr, metaAddr⟩
+    modifyGet fun stt => (maddr, { stt with
+      constAddrs := stt.constAddrs.insert const maddr
+    })
   where
-    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
-
-/--
-Content-addresses the "delta" of an environment, that is, the content that is
-added on top of the imports.
-
-Important: constants with open references in their expressions are filtered out.
-Open references are variables that point to names which aren't present in the
-`Lean.ConstMap`.
--/
-def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
-  : CompileM Unit := delta.forM fun _ c => discard $ compileConst c
-
-def compileEnv (env: Lean.Environment)
-  : CompileM Unit := do
-  compileDelta env.getDelta
-  env.getConstMap.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
-
-def CompileM.runIO (c : CompileM α) 
-  (env: Lean.Environment)
-  (maxHeartBeats: USize := 200000)
-  (seed : Option Nat := .none)
-  : IO (α × CompileState) := do
-  let seed <- match seed with
-    | .none => IO.monoNanosNow
-    | .some s => pure s
-  match <- c.run (.init maxHeartBeats) (.init env seed) with
-  | (.ok a, stt) => return (a, stt)
-  | (.error e, _) => throw (IO.userError (<- e.pretty))
-
-def CompileM.runIO' (c : CompileM α) 
-  (stt: CompileState)
-  (maxHeartBeats: USize := 200000)
-  : IO (α × CompileState) := do
-  match <- c.run (.init maxHeartBeats) stt with
-  | (.ok a, stt) => return (a, stt)
-  | (.error e, _) => throw (IO.userError (<- e.pretty))
-
-def compileEnvIO (env: Lean.Environment) : IO (CompileState):= do
-  Prod.snd <$> (compileDelta env.getDelta).runIO env
+    goDef : Ix.Definition -> CompileM (Ixon.Definition × Ixon.Metadata)
+    | ⟨name, lvls, type, kind, value, hints, safety, all⟩ => do
+      let n <- dematerializeName name
+      let ls <- lvls.mapM (fun n => .name <$> dematerializeName n)
+      let t <- dematerializeExpr type
+      let v <- dematerializeExpr value
+      let as <- all.mapM (fun n => .name <$> dematerializeName n)
+      let data := ⟨kind, safety, lvls.length, t.data, v.data⟩
+      let meta := ⟨[.name n] ++ ls ++ [.link t.meta, .link v.meta] ++ as⟩
+      pure (data, meta)
+    goCtor : Ix.Constructor -> CompileM (Ixon.Constructor × Ixon.Metadata)
+    | ⟨name, lvls, type, cidx, params, fields, usafe⟩ => do
+      let n <- dematerializeName name
+      let ls <- lvls.mapM (fun n => .name <$> dematerializeName n)
+      let t <- dematerializeExpr type
+      let ctor := ⟨usafe, lvls.length, cidx, params, fields, t.data⟩
+      let meta := ⟨[.name n] ++ ls ++ [.link t.meta]⟩
+      pure (ctor, meta)
+    goRecrRule : Ix.RecursorRule -> CompileM (Ixon.RecursorRule × Ixon.Metadata)
+    | ⟨ctor, fields, rhs⟩ => do
+      let c <- dematerializeName ctor
+      let x <- dematerializeExpr rhs
+      let rule := ⟨fields, x.data⟩
+      let meta := ⟨[.name c, .link x.meta]⟩
+      pure (rule, meta)
+    goRecr : Ix.Recursor -> CompileM (Ixon.Recursor × Ixon.Metadata)
+    | ⟨name, lvls, type, params, indices, motives, minors, rules, k, usafe⟩ => do
+      let n <- dematerializeName name
+      let ls <- lvls.mapM (fun n => .name <$> dematerializeName n)
+      let t <- dematerializeExpr type
+      let rules <- rules.mapM goRecrRule
+      let rulesData := rules.map (·.1)
+      let rulesMeta <- rules.mapM (fun x => .link <$> storeMetadata x.2)
+      let recr := ⟨k, usafe, lvls.length, params, indices, motives, minors, t.data, rulesData⟩
+      let meta := ⟨[.name n] ++ ls ++ [.link t.meta] ++ rulesMeta⟩
+      pure (recr, meta)
+    goInd : Ix.Inductive -> CompileM (Ixon.Inductive × Ixon.Metadata)
+    | ⟨name, lvls, type, params, indices, all, ctors, recrs, nested, recr, refl, usafe⟩ => do
+      let n <- dematerializeName name
+      let ls <- lvls.mapM (fun n => Metadatum.name <$> dematerializeName n)
+      let t <- dematerializeExpr type
+      let cs <- ctors.mapM goCtor
+      let ctorsData := cs.map (·.1)
+      let ctorsMeta <- cs.mapM (fun x=> Metadatum.link <$> storeMetadata x.2)
+      let rs <- recrs.mapM goRecr
+      let recrsData := rs.map (·.1)
+      let recrsMeta <- rs.mapM (fun x=> Metadatum.link <$> storeMetadata x.2)
+      let as <- all.mapM (fun n => Metadatum.name <$> dematerializeName n)
+      let data := ⟨recr, refl, usafe, lvls.length, params, indices, nested, t.data, ctorsData, recrsData⟩
+      let meta := ⟨[.name n] ++ ls ++ [.link t.meta] ++ ctorsMeta ++ recrsMeta⟩
+      pure (data, meta)
+    go : Ix.Const -> CompileM (Ixon × Ixon)
+    | .axiom ⟨name, lvls, type, isUnsafe⟩ => do
+      let n <- dematerializeName name
+      let ls <- lvls.mapM (fun n => Metadatum.name <$> dematerializeName n)
+      let t <- dematerializeExpr type
+      let data := .axio ⟨isUnsafe, lvls.length, t.data⟩
+      let meta := .meta ⟨[.name n] ++ ls⟩
+      pure (data, meta)
+    | .quotient ⟨name, lvls, type, kind⟩ => do
+      let n <- dematerializeName name
+      let ls <- lvls.mapM (fun n => Metadatum.name <$> dematerializeName n)
+      let t <- dematerializeExpr type
+      let data := .quot ⟨kind, lvls.length, t.data⟩
+      let meta := .meta ⟨[.name n] ++ ls ++ [.link t.meta]⟩
+      pure (data, meta)
+    | .definition d => (fun (d, m) => (.defn d, .meta m)) <$> goDef d
+    | .inductiveProj _ => sorry
+    | .constructorProj _ => sorry
+    | .recursorProj _ => sorry
+    | .definitionProj _ => sorry
+    | .mutual ds => sorry
+    | .inductive _ => sorry
+
+
+--mutual
+--/--
+--Content-addresses a Lean expressio
+---/
+--partial def compileExpr (expr: Lean.Expr): CompileM Ix.Expr := do
+--  match (<- get).exprCache.get? expr with
+--  | some x => pure x
+--  | none => do
+--    let expr' <- go expr
+--    let _ <- dematerializeExpr expr'
+--    modifyGet fun stt => (lvl', { stt with
+--      exprCache := stt.exprCache.insert expr expr'
+--    })
+--  where
+--    go : Lean.Expr -> CompileM Ix.Expr
+--    | .bvar idx => do match (← read).bindCtx[idx]? with
+--      -- Bound variables must be in the bind context
+--      | some _ => return .var idx
+--      | none => throw $ .invalidBVarIndex idx
+--    | .sort lvl => return .sort $ ← compileLevel lvl
+--    | .const name lvls => do
+--      let univs ← lvls.mapM compileLevel
+--      match (← read).mutCtx.get? name with
+--      -- recursing!
+--      | some i => return .rec_ name i univs
+--      | none => match (<- get).comms.get? name with
+--        | some (commAddr, metaAddr) => do
+--          return .const name commAddr metaAddr univs
+--        | none => do
+--          let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
+--          return .const name contAddr metaAddr univs
+--    | .app fnc arg => return .app (← compileExpr fnc) (← compileExpr arg)
+--    | .lam name typ bod info =>
+--      return .lam name info (← compileExpr typ) (← withBinder name $ compileExpr bod)
+--    | .forallE name dom img info =>
+--      return .pi name info (← compileExpr dom) (← withBinder name $ compileExpr img)
+--    | .letE name typ exp bod nD =>
+--      return .letE name (← compileExpr typ) (← compileExpr exp)
+--        (← withBinder name $ compileExpr bod) nD
+--    | .lit lit => return .lit lit
+--    | .proj name idx exp => do
+--      let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
+--      return .proj name contAddr metaAddr idx (← compileExpr exp)
+--    | expr@(.fvar ..)  => throw $ .freeVariableExpr expr
+--    | expr@(.mvar ..)  => throw $ .metaVariableExpr expr
+--    -- TODO: cursed
+--    | (.mdata _ x) => compileExpr x
+--
+--/-- compile Lean Constant --/
+--partial def compileConst (const : Lean.ConstantInfo) : CompileM Ix.Const := do
+--  -- first check if we've already compiled this const
+--  match (← get).names.get? const.name with
+--  -- if we have, returned the cached address
+--  | some (anonAddr, metaAddr) => do
+--    pure (anonAddr, metaAddr)
+--  -- if not, pattern match on the const
+--  | none => do
+--    dbg_trace "-> compileConst {const.name}";
+--    let cronTag := s!"compileConst {const.name}"
+--    cron cronTag
+--    let cronTag2 := s!"constSize {const.name}"
+--    dbg_trace "-> constSize {const.name}";
+--    cron cronTag2
+--    let size := const.size
+--    cron cronTag2
+--    dbg_trace "✓ {(<- getCron cronTag2)} {size}";
+--    let addrs <- compileInner const
+--    cron cronTag
+--    let timing <- getCron cronTag
+--    dbg_trace "✓ {timing}";
+--    return addrs
+--  where
+--    compileInner (const: Lean.ConstantInfo) := resetCtx $ withCurrent const.name $ match const with
+--    -- convert possible mutual block elements to PreDefinitions
+--    | .defnInfo val => do
+--      compileDefinition (mkPreDefinition val)
+--    | .thmInfo val => do
+--      compileDefinition (mkPreTheorem val)
+--    | .opaqueInfo val => do
+--      compileDefinition (mkPreOpaque val)
+--    -- compile possible mutual inductive block elements
+--    | .inductInfo val => do
+--      compileInductive val
+--    -- compile constructors through their parent inductive
+--    | .ctorInfo val => do
+--      match ← findLeanConst val.induct with
+--      | .inductInfo ind => do
+--        let _ <- compileInductive ind
+--        compileConst (.ctorInfo val)
+--      | const =>
+--        throw $ .invalidConstantKind const.name "inductive" const.ctorName
+--    -- compile recursors through their parent inductive
+--    | .recInfo val => do
+--      match ← findLeanConst val.getMajorInduct with
+--      | .inductInfo ind => do
+--        let _ <- compileInductive ind
+--        compileConst (.recInfo val)
+--      | const =>
+--        throw $ .invalidConstantKind const.name "inductive" const.ctorName
+--    -- The rest adds the constants to the cache one by one
+--    | .axiomInfo val => resetCtxWithLevels const.levelParams do
+--      let c := .axiom ⟨val.name, val.levelParams, ← compileExpr val.type, val.isUnsafe⟩
+--      let (anonAddr, metaAddr) ← hashConst c
+--      modify fun stt => { stt with
+--        axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
+--        names := stt.names.insert const.name (anonAddr, metaAddr)
+--      }
+--      return (anonAddr, metaAddr)
+--    | .quotInfo val => resetCtxWithLevels const.levelParams do
+--      let type <- compileExpr val.type
+--      let c := .quotient ⟨val.name, val.levelParams, type, val.kind⟩
+--      let (anonAddr, metaAddr) ← hashConst c
+--      modify fun stt => { stt with
+--        axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
+--        names := stt.names.insert const.name (anonAddr, metaAddr)
+--      }
+--      return (anonAddr, metaAddr)
+--
+--end
+--def dematerializeConst (x: Ix.Const) : CompileM (Ixon × Ixon) :=
+--  match dematerialize x with
+--  | .ok (ix, tstt) => do
+--    for (addr, ixon) in tstt.store do
+--      let _ <- liftM (Store.forceWriteConst addr ixon).toIO
+--    return (ix, Ixon.meta ⟨tstt.meta.toList⟩)
+--  | .error e => throw (.transportError e)
+--
+--def cron (tag: String) : CompileM Unit := do
+--  let stt <- get
+--  let c <- liftM <| Cronos.clock stt.cronos tag
+--  modify fun stt => { stt with cronos := c }
+--
+--def getCron (tag: String) : CompileM String := do
+--  return (<- get).cronos.tagSummary tag
+
+--def hashConst (const: Ix.Const) : CompileM MetaAddress := do
+--  match (<- get).constAddrs.get? const with
+--  | some m => pure m
+--  | none => do
+--    let (anonIxon, metaIxon) <- dematerializeConst const
+--    let anonAddr <- storeConst anonIxon
+--    let metaAddr <- storeConst metaIxon
+--    let timing <- getCron cronTag
+--    modifyGet fun stt => (⟨anonAddr, metaAddr⟩, { stt with
+--      cache := stt.cache.insert const (anonAddr, metaAddr)
+--    })
+
+
+-- lookup or compute the addresses of a constant
+--def hashConst (const: Ix.Const) : CompileM MetaAddress := do
+--  match (<- get).constAddrs.get? const with
+--  | some (anonAddr, metaAddr) => pure (anonAddr, metaAddr)
+--  | none => do
+--    let cronTag := s!"hashConst {const.name}"
+--    dbg_trace "-> hashConst {const.name}";
+--    cron cronTag
+--    let (anonIxon, metaIxon) <- dematerializeConst const
+--    let anonAddr <- storeConst anonIxon
+--    let metaAddr <- storeConst metaIxon
+--    cron cronTag
+--    let timing <- getCron cronTag
+--    dbg_trace "✓ {timing}";
+--    dbg_trace "names: {(<- get).names.size}";
+--    dbg_trace "cache: {(<- get).cache.size}";
+--    dbg_trace "eqConst: {(<- get).eqConst.size}";
+--    dbg_trace "blocks: {(<- get).blocks.size}";
+--    modifyGet fun stt => ((anonAddr, metaAddr), { stt with
+--      cache := stt.cache.insert const (anonAddr, metaAddr)
+--    })
+
+end Ix
+
+--mutual
+--
+--/-- compile Lean Constant --/
+--partial def compileConst (const : Lean.ConstantInfo)
+--  : CompileM (Address × Address) := do
+--  -- first check if we've already compiled this const
+--  match (← get).names.get? const.name with
+--  -- if we have, returned the cached address
+--  | some (anonAddr, metaAddr) => do
+--    pure (anonAddr, metaAddr)
+--  -- if not, pattern match on the const
+--  | none => do
+--    dbg_trace "-> compileConst {const.name}";
+--    let cronTag := s!"compileConst {const.name}"
+--    cron cronTag
+--    let cronTag2 := s!"constSize {const.name}"
+--    dbg_trace "-> constSize {const.name}";
+--    cron cronTag2
+--    let size := const.size
+--    cron cronTag2
+--    dbg_trace "✓ {(<- getCron cronTag2)} {size}";
+--    let addrs <- compileInner const
+--    cron cronTag
+--    let timing <- getCron cronTag
+--    dbg_trace "✓ {timing}";
+--    return addrs
+--  where
+--    compileInner (const: Lean.ConstantInfo) := resetCtx $ withCurrent const.name $ match const with
+--    -- convert possible mutual block elements to PreDefinitions
+--    | .defnInfo val => do
+--      compileDefinition (mkPreDefinition val)
+--    | .thmInfo val => do
+--      compileDefinition (mkPreTheorem val)
+--    | .opaqueInfo val => do
+--      compileDefinition (mkPreOpaque val)
+--    -- compile possible mutual inductive block elements
+--    | .inductInfo val => do
+--      compileInductive val
+--    -- compile constructors through their parent inductive
+--    | .ctorInfo val => do
+--      match ← findLeanConst val.induct with
+--      | .inductInfo ind => do
+--        let _ <- compileInductive ind
+--        compileConst (.ctorInfo val)
+--      | const =>
+--        throw $ .invalidConstantKind const.name "inductive" const.ctorName
+--    -- compile recursors through their parent inductive
+--    | .recInfo val => do
+--      match ← findLeanConst val.getMajorInduct with
+--      | .inductInfo ind => do
+--        let _ <- compileInductive ind
+--        compileConst (.recInfo val)
+--      | const =>
+--        throw $ .invalidConstantKind const.name "inductive" const.ctorName
+--    -- The rest adds the constants to the cache one by one
+--    | .axiomInfo val => resetCtxWithLevels const.levelParams do
+--      let c := .axiom ⟨val.name, val.levelParams, ← compileExpr val.type, val.isUnsafe⟩
+--      let (anonAddr, metaAddr) ← hashConst c
+--      modify fun stt => { stt with
+--        axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
+--        names := stt.names.insert const.name (anonAddr, metaAddr)
+--      }
+--      return (anonAddr, metaAddr)
+--    | .quotInfo val => resetCtxWithLevels const.levelParams do
+--      let type <- compileExpr val.type
+--      let c := .quotient ⟨val.name, val.levelParams, type, val.kind⟩
+--      let (anonAddr, metaAddr) ← hashConst c
+--      modify fun stt => { stt with
+--        axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
+--        names := stt.names.insert const.name (anonAddr, metaAddr)
+--      }
+--      return (anonAddr, metaAddr)
+--
+--/-- compile possibly mutual Lean definition --/
+--partial def compileDefinition (struct: PreDefinition)
+--  : CompileM (Address × Address) := do
+--  dbg_trace "compileDefinition {struct.name}"
+--  -- If the mutual size is one, simply content address the single definition
+--  if struct.all matches [_] then
+--    let defn <- withMutCtx ({(struct.name,0)}) $ preDefinitionToIR struct
+--    let (anonAddr, metaAddr) <- hashConst $ .definition defn
+--    modify fun stt => { stt with
+--      names := stt.names.insert struct.name (anonAddr, metaAddr)
+--    }
+--    return (anonAddr, metaAddr)
+--  -- Collecting and sorting all definitions in the mutual block
+--  let mut mutDefs : Array PreDefinition := #[]
+--  for n in struct.all do
+--    match <- findLeanConst n with
+--      | .defnInfo x => mutDefs := mutDefs.push (mkPreDefinition x)
+--      | .opaqueInfo x => mutDefs := mutDefs.push (mkPreOpaque x)
+--      | .thmInfo x => mutDefs := mutDefs.push (mkPreTheorem x)
+--      | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
+--  let mutualDefs <- sortDefs mutDefs.toList
+--  let mutCtx := defMutCtx mutualDefs
+--  let definitions ← withMutCtx mutCtx <|
+--    mutualDefs.mapM (·.mapM preDefinitionToIR)
+--  -- Building and storing the block
+--  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .mutual ⟨definitions⟩
+--  modify fun stt =>
+--    { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
+--  -- While iterating on the definitions from the mutual block, we need to track
+--  -- the correct objects to return
+--  let mut ret? : Option (Address × Address) := none
+--  for name in struct.all do
+--    -- Storing and caching the definition projection
+--    -- Also adds the constant to the array of constants
+--    let some idx := mutCtx.get? name | throw $ .cantFindMutDefIndex name
+--    let (anonAddr, metaAddr) ←
+--      hashConst $ .definitionProj ⟨name, blockAnonAddr, blockMetaAddr, idx⟩
+--    modify fun stt => { stt with
+--      names := stt.names.insert name (anonAddr, metaAddr)
+--    }
+--    if struct.name == name then ret? := some (anonAddr, metaAddr)
+--  match ret? with
+--  | some ret => return ret
+--  | none => throw $ .constantNotContentAddressed struct.name
+--
+--partial def preDefinitionToIR (d: PreDefinition)
+--  : CompileM Ix.Definition := withCurrent d.name $ withLevels d.levelParams do
+--  dbg_trace "preDefinitionToIR {d.name}"
+--  let typ <- compileExpr d.type
+--  let val <- compileExpr d.value
+--  return ⟨d.name, d.levelParams, typ, d.kind, val, d.hints, d.safety, d.all⟩
+--
+--partial def getRecursors (ind : Lean.InductiveVal) 
+--  : CompileM (List Lean.RecursorVal) := do
+--    return (<- get).env.constants.fold accRecr []
+--    where
+--      accRecr (acc: List Lean.RecursorVal) (n: Lean.Name) (c: Lean.ConstantInfo)
+--        : List Lean.RecursorVal :=
+--        match n with
+--        | .str n ..
+--        | .num n .. =>
+--          if n == ind.name then match c with
+--            | .recInfo r => r :: acc
+--            | _ => acc
+--          else acc
+--        | _ => acc
+--
+--partial def makePreInductive (ind: Lean.InductiveVal) 
+--  : CompileM Ix.PreInductive := do
+--    dbg_trace "-> makePreInductive {ind.name}";
+--    let ctors <- ind.ctors.mapM getCtor
+--    let recrs <- getRecursors ind
+--    return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices,
+--      ind.all, ctors, recrs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
+--    where
+--      getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
+--        match (<- findLeanConst name) with
+--        | .ctorInfo c => pure c
+--        | _ => throw <| .invalidConstantKind name "constructor" ""
+--
+--/--
+--Content-addresses an inductive and all inductives in the mutual block as a
+--mutual block, even if the inductive itself is not in a mutual block.
+--
+--Content-addressing an inductive involves content-addressing its associated
+--constructors and recursors, hence the complexity of this function.
+---/
+--partial def compileInductive (initInd: Lean.InductiveVal) 
+--  : CompileM (Address × Address) := do
+--  dbg_trace "-> compileInductive {initInd.name}";
+--  let mut preInds := #[]
+--  let mut nameData : Std.HashMap Lean.Name (List Lean.Name × List Lean.Name) := {}
+--  -- collect all mutual inductives as Ix.PreInductives
+--  for indName in initInd.all do
+--    match ← findLeanConst indName with
+--    | .inductInfo ind =>
+--      let preInd <- makePreInductive ind
+--      preInds := preInds.push preInd
+--      nameData := nameData.insert indName (ind.ctors, preInd.recrs.map (·.name))
+--    | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
+--  -- sort PreInductives into equivalence classes
+--  let mutualInds <- sortInds preInds.toList
+--  let mutCtx := indMutCtx mutualInds
+--  -- compile each preinductive with the mutCtx
+--  let irInds ← withMutCtx mutCtx $ mutualInds.mapM (·.mapM preInductiveToIR)
+--  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .inductive ⟨irInds⟩
+--  modify fun stt =>
+--    { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
+--  -- While iterating on the inductives from the mutual block, we need to track
+--  -- the correct objects to return
+--  let mut ret? : Option (Address × Address) := none
+--  for (indName, indIdx) in initInd.all.zipIdx do
+--    -- Store and cache inductive projections
+--    let name := indName
+--    let (anonAddr, metaAddr) ←
+--      hashConst $ .inductiveProj ⟨name, blockAnonAddr, blockMetaAddr, indIdx⟩
+--    modify fun stt => { stt with
+--      names := stt.names.insert name (anonAddr, metaAddr)
+--    }
+--    if name == initInd.name then ret? := some (anonAddr, metaAddr)
+--    let some (ctors, recrs) := nameData.get? indName
+--      | throw $ .cantFindMutDefIndex indName
+--    for (ctorName, ctorIdx) in ctors.zipIdx do
+--      -- Store and cache constructor projections
+--      let (anonAddr, metaAddr) ←
+--        hashConst $ .constructorProj
+--          ⟨ctorName, blockAnonAddr, blockMetaAddr, indIdx, indName, ctorIdx⟩
+--      modify fun stt => { stt with
+--        names := stt.names.insert ctorName (anonAddr, metaAddr)
+--      }
+--    for (recrName, recrIdx) in recrs.zipIdx do
+--      -- Store and cache recursor projections
+--      let (anonAddr, metaAddr) ←
+--        hashConst $ .recursorProj
+--          ⟨recrName, blockAnonAddr, blockMetaAddr, indIdx, indName, recrIdx⟩
+--      modify fun stt => { stt with
+--        names := stt.names.insert recrName (anonAddr, metaAddr)
+--      }
+--  match ret? with
+--  | some ret => return ret
+--  | none => throw $ .constantNotContentAddressed initInd.name
+--
+--partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive 
+--  := withCurrent ind.name $ withLevels ind.levelParams $ do
+--  dbg_trace "-> preInductiveToIR {ind.name}";
+--  let (recs, ctors) := <- ind.recrs.foldrM (init := ([], [])) collectRecsCtors
+--  let type <- compileExpr ind.type
+--    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
+--    -- match the order used in `mutCtx`
+--  return ⟨ind.name, ind.levelParams, type, ind.numParams, ind.numIndices,
+--    ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
+--  where
+--    collectRecsCtors
+--      : Lean.RecursorVal
+--      -> List Recursor × List Constructor 
+--      -> CompileM (List Recursor × List Constructor)
+--      | r, (recs, ctors) =>
+--        if isInternalRec r.type ind.name then do
+--          let (thisRec, thisCtors) <- internalRecToIR (ind.ctors.map (·.name)) r
+--          pure (thisRec :: recs, thisCtors)
+--        else do
+--          let thisRec ← externalRecToIR r
+--          pure (thisRec :: recs, ctors)
+--
+--partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
+--  : CompileM (Ix.Recursor × List Ix.Constructor) :=
+--  withCurrent recr.name $ withLevels recr.levelParams do
+--    dbg_trace s!"internalRecToIR"
+--    let typ ← compileExpr recr.type
+--    let (retCtors, retRules) ← recr.rules.foldrM (init := ([], []))
+--      fun r (retCtors, retRules) => do
+--        if ctors.contains r.ctor then
+--          let (ctor, rule) ← recRuleToIR r
+--          pure $ (ctor :: retCtors, rule :: retRules)
+--        else pure (retCtors, retRules) -- this is an external recursor rule
+--    let recr := ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
+--      recr.numMotives, recr.numMinors, retRules, recr.k, recr.isUnsafe⟩
+--    return (recr, retCtors)
+--
+--partial def externalRecToIR (recr: Lean.RecursorVal): CompileM Recursor :=
+--  withCurrent recr.name $ withLevels recr.levelParams do
+--    dbg_trace s!"externalRecToIR"
+--    let typ ← compileExpr recr.type
+--    let rules ← recr.rules.mapM externalRecRuleToIR
+--    return ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
+--      recr.numMotives, recr.numMinors, rules, recr.k, recr.isUnsafe⟩
+--
+--partial def recRuleToIR (rule : Lean.RecursorRule)
+--  : CompileM (Ix.Constructor × Ix.RecursorRule) := do
+--  dbg_trace s!"recRuleToIR"
+--  let rhs ← compileExpr rule.rhs
+--  match ← findLeanConst rule.ctor with
+--  | .ctorInfo ctor => withCurrent ctor.name $ withLevels ctor.levelParams do
+--    let typ ← compileExpr ctor.type
+--    let ctor :=
+--      ⟨ctor.name, ctor.levelParams, typ, ctor.cidx, ctor.numParams, ctor.numFields, ctor.isUnsafe⟩
+--    pure (ctor, ⟨rule.ctor, rule.nfields, rhs⟩)
+--  | const =>
+--    throw $ .invalidConstantKind const.name "constructor" const.ctorName
+--
+--partial def externalRecRuleToIR (rule : Lean.RecursorRule) 
+--  : CompileM RecursorRule :=
+--  return ⟨rule.ctor, rule.nfields, ← compileExpr rule.rhs⟩
+--
+--/--
+--Content-addresses a Lean expression and adds it to the store.
+--
+--Constants are the tricky case, for which there are two possibilities:
+--* The constant belongs to `mutCtx`, representing a recursive call. Those are
+--encoded as `.rec_` with indexes based on order in the mutual definition
+--* The constant doesn't belong to `mutCtx`, meaning that it's not a recursion
+--and thus we can canon the actual constant right away
+---/
+--partial def compileExpr : Lean.Expr → CompileM Expr
+--| .bvar idx => do match (← read).bindCtx[idx]? with
+--  -- Bound variables must be in the bind context
+--  | some _ => return .var idx
+--  | none => throw $ .invalidBVarIndex idx
+--| .sort lvl => return .sort $ ← compileLevel lvl
+--| .const name lvls => do
+--  let univs ← lvls.mapM compileLevel
+--  match (← read).mutCtx.get? name with
+--  -- recursing!
+--  | some i => return .rec_ name i univs
+--  | none => match (<- get).comms.get? name with
+--    | some (commAddr, metaAddr) => do
+--      return .const name commAddr metaAddr univs
+--    | none => do
+--      let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
+--      return .const name contAddr metaAddr univs
+--| .app fnc arg => return .app (← compileExpr fnc) (← compileExpr arg)
+--| .lam name typ bod info =>
+--  return .lam name info (← compileExpr typ) (← withBinder name $ compileExpr bod)
+--| .forallE name dom img info =>
+--  return .pi name info (← compileExpr dom) (← withBinder name $ compileExpr img)
+--| .letE name typ exp bod nD =>
+--  return .letE name (← compileExpr typ) (← compileExpr exp)
+--    (← withBinder name $ compileExpr bod) nD
+--| .lit lit => return .lit lit
+--| .proj name idx exp => do
+--  let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
+--  return .proj name contAddr metaAddr idx (← compileExpr exp)
+--| expr@(.fvar ..)  => throw $ .freeVariableExpr expr
+--| expr@(.mvar ..)  => throw $ .metaVariableExpr expr
+---- TODO: cursed
+--| (.mdata _ x) => compileExpr x
+--
+--/--
+--A name-irrelevant ordering of Lean expressions.
+---/
+--partial def compareExpr (ctx: Std.HashMap Lean.Name Nat)
+--  (xlvls ylvls: List Lean.Name)
+--  --: Lean.Expr → Lean.Expr → CompileM SOrder
+--  (x y: Lean.Expr) : CompileM SOrder := do
+--  --dbg_trace "compareExpr {repr xlvls} {repr ylvls} {repr x} {repr y}"
+--  --let mutCtx := (<- read).mutCtx
+--  --dbg_trace "mutCtx {repr mutCtx}";
+--  match x, y with
+--  | e@(.mvar ..), _ => throw $ .unfilledExprMetavariable e
+--  | _, e@(.mvar ..) => throw $ .unfilledExprMetavariable e
+--  | e@(.fvar ..), _ => throw $ .freeVariableExpr e
+--  | _, e@(.fvar ..) => throw $ .freeVariableExpr e
+--  | .mdata _ anonmdata _ y  => compareExpr ctx xlvls ylvls x y
+--  | .mdata _ x, y  => compareExpr ctx xlvls ylvls x y
+--  | x, .mdata _ y  => compareExpr ctx xlvls ylvls x y
+--  | .bvar x, .bvar y => return ⟨true, compare x y⟩
+--  | .bvar .., _ => return ⟨true, .lt⟩
+--  | _, .bvar .. => return ⟨true, .gt⟩
+--  | .sort x, .sort y => compareLevel xlvls ylvls x y
+--  | .sort .., _ => return ⟨true, .lt⟩
+--  | _, .sort .. => return ⟨true, .gt⟩
+--  | .const x xls, .const y yls => do
+--    --dbg_trace "compare const {x} {y}";
+--    let univs ← SOrder.zipM (compareLevel xlvls ylvls) xls yls
+--    if univs.ord != .eq then return univs
+--    --dbg_trace "compare const {x} {y} {repr ctx}";
+--    match ctx.get? x, ctx.get? y with
+--    | some nx, some ny => return ⟨false, compare nx ny⟩
+--    | none, some _ => do
+--      return ⟨true, .gt⟩
+--    | some _, none =>
+--      return ⟨true, .lt⟩
+--    | none, none =>
+--      if x == y then 
+--        return ⟨true, .eq⟩
+--      else do
+--        let x' <- compileConst $ ← findLeanConst x
+--        let y' <- compileConst $ ← findLeanConst y
+--        return ⟨true, compare x' y'⟩
+--  | .const .., _ => return ⟨true, .lt⟩
+--  | _, .const .. => return ⟨true, .gt⟩
+--  | .app xf xa, .app yf ya =>
+--    SOrder.cmpM 
+--      (compareExpr ctx xlvls ylvls xf yf) 
+--      (compareExpr ctx xlvls ylvls xa ya)
+--  | .app .., _ => return ⟨true, .lt⟩
+--  | _, .app .. => return ⟨true, .gt⟩
+--  | .lam _ xt xb _, .lam _ yt yb _ => 
+--    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
+--  | .lam .., _ => return ⟨true, .lt⟩
+--  | _, .lam .. => return ⟨true, .gt⟩
+--  | .forallE _ xt xb _, .forallE _ yt yb _ => 
+--    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
+--  | .forallE .., _ => return ⟨true, .lt⟩
+--  | _, .forallE .. => return ⟨true, .gt⟩
+--  | .letE _ xt xv xb _, .letE _ yt yv yb _ =>
+--    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) <|
+--    SOrder.cmpM (compareExpr ctx xlvls ylvls xv yv)
+--      (compareExpr ctx xlvls ylvls xb yb)
+--  | .letE .., _ => return ⟨true, .lt⟩
+--  | _, .letE .. => return ⟨true, .gt⟩
+--  | .lit x, .lit y => return ⟨true, compare x y⟩
+--  | .lit .., _ => return ⟨true, .lt⟩
+--  | _, .lit .. => return ⟨true, .gt⟩
+--  | .proj _ nx tx, .proj _ ny ty => 
+--    SOrder.cmpM (pure ⟨true, compare nx ny⟩) 
+--      (compareExpr ctx xlvls ylvls tx ty)
+--
+--/-- AST comparison of two Lean definitions. --/
+--partial def compareDef (ctx: Std.HashMap Lean.Name Nat) (x y: PreDefinition) : CompileM Ordering := do
+--  let key := match compare x.name y.name with
+--    | .lt => (x.name, y.name)
+--    | _ => (y.name, x.name)
+--  match (<- get).eqConst.get? key with
+--  | some o => return o
+--  | none => do
+--    let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
+--      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+--      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+--        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
+--    if sorder.strong then modify fun stt => { stt with
+--        eqConst := stt.eqConst.insert key sorder.ord
+--      }
+--    return sorder.ord
+--
+--/--
+--`sortDefs` recursively sorts a list of mutual definitions into equivalence classes.
+--At each stage, we take as input the current best known equivalence
+--classes (held in the `mutCtx` of the CompileEnv). For most cases, equivalence
+--can be determined by syntactic differences which are invariant to the current
+--best known classification. For example:
+--
+--```
+--mutual
+--  def : Nat := 1
+--  def bar : Nat := 2
+--end
+--```
+--
+--are both different due to the different values in the definition. We call this a
+--"strong" ordering, and comparisons between defintions that produce strong
+--orderings are cached across compilation.
+--
+--However, there are also weak orderings, where the order of definitions in a
+--mutual block depends on itself.
+--
+--```
+--mutual
+--  def A : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => B n + C n + 1
+--
+--  def B : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => C n + 1
+--
+--  def C : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => A n + 1
+--end
+--```
+--
+--Here since any reference to A, B, C has to be compiled into an index, the
+--ordering chosen for A, B, C will effect itself, since we compile into
+--something that looks, with order [A, B, C] like:
+--
+--```
+--mutual
+--  def #1 : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => #2 n + #3 n + 1
+--
+--  def #2 : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => #3 n + 1
+--
+--  def #3 : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => #1 n + 1
+--end
+--```
+--
+--This is all well and good, but if we chose order `[C, B, A]` then the block
+--would compile as
+--
+--```
+--mutual
+--  def #1 : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => #3 n + 1
+--
+--  def #2 : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => #1 n + 1
+--
+--  def #3 : Nat → Nat
+--  | 0 => 0
+--  | n + 1 => #2 n + #1 n + 1
+--end
+--```
+--
+--with completely different hashes. So we need to figure out a canonical order for
+--such mutual blocks.
+--
+--We start by assuming that all definitions in a mutual block are equal and then 
+--recursively refining this assumption through successive sorting passes. This
+--algorithm bears some similarity to partition refinement:
+--```
+--classes₀ := [startDefs]
+--classes₁ := sortDefs classes₀
+--classes₂ := sortDefs classes₁
+--classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
+--```
+--Initially, `startDefs` is simply the list of definitions we receive from
+--`DefinitionVal.all`, sorted by name. We assume that at we will reach some
+--fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no further refinement is
+--possible (we have not rigourously proven such a fixed point exists, but
+--it seams reasonable given that after the first pass to find the strongly ordered
+--definitions, the algorithm should only separate partitions into smaller ones)
+---/
+--partial def sortDefs (classes : List PreDefinition)
+--  : CompileM (List (List PreDefinition)) := do
+--    sortDefsInner [List.sortBy (compare ·.name ·.name) classes] 0
+--  where
+--    eqDef (ctx: Std.HashMap Lean.Name Nat) (x y: PreDefinition) 
+--      : CompileM Bool := (· == .eq) <$> compareDef ctx x y
+--    sortDefsInner (classes: List (List PreDefinition)) (iter: Nat)
+--      : CompileM (List (List PreDefinition)) := do
+--      let ctx := defMutCtx classes
+--      dbg_trace "sortdefs {iter} classes {repr (classes.map (·.map (·.name)))}";
+--      let newClasses ← classes.mapM fun ds =>
+--        match ds with
+--        | []  => unreachable!
+--        | [d] => pure [[d]]
+--        | ds  => do pure $ (← List.groupByM (eqDef ctx) $ ← ds.sortByM (compareDef ctx))
+--      let newClasses := newClasses.flatten.map (List.sortBy (compare ·.name ·.name))
+--      if classes == newClasses then return newClasses
+--      else sortDefsInner newClasses (iter + 1)
+--
+--/-- AST comparison of two Lean inductives. --/
+--partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInductive) 
+--  : CompileM Ordering := do
+--  --dbg_trace "compareInd {x.name} {y.name}";
+--  let key := match compare x.name y.name with
+--    | .lt => (x.name, y.name)
+--    | _ => (y.name, x.name)
+--  match (<- get).eqConst.get? key with
+--  | some o => return o
+--  | none => do
+--    let sorder <- do
+--      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+--      SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
+--      SOrder.cmpM (pure ⟨true, compare x.numIndices y.numIndices⟩) <|
+--      SOrder.cmpM (pure ⟨true, compare x.ctors.length y.ctors.length⟩) <|
+--      SOrder.cmpM (pure ⟨true, compare x.recrs.length y.recrs.length⟩) <|
+--      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+--      SOrder.cmpM (SOrder.zipM compareCtor x.ctors y.ctors)
+--        (SOrder.zipM compareRecr x.recrs y.recrs)
+--    if sorder.strong then modify fun stt => { stt with
+--        eqConst := stt.eqConst.insert key sorder.ord
+--      }
+--    --dbg_trace "compareInd {x.name} {y.name} -> {repr sorder.ord}";
+--    return sorder.ord
+--  where
+--    compareCtor (x y: Lean.ConstructorVal) : CompileM SOrder := do
+--     --dbg_trace "compareCtor {x.name} {y.name}";
+--      let key := match compare x.name y.name with
+--        | .lt => (x.name, y.name)
+--        | _ => (y.name, x.name)
+--      match (<- get).eqConst.get? key with
+--      | some o => return ⟨true, o⟩
+--      | none => do
+--      let sorder <- do
+--        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+--        SOrder.cmpM (pure ⟨true, compare x.cidx y.cidx⟩) <|
+--        SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
+--        SOrder.cmpM (pure ⟨true, compare x.numFields y.numFields⟩) <|
+--          (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+--      if sorder.strong then modify fun stt => { stt with
+--          eqConst := stt.eqConst.insert key sorder.ord
+--        }
+--      return sorder
+--    compareRecr (x y: Lean.RecursorVal) : CompileM SOrder := do
+--      --dbg_trace "compareRecr {x.name} {y.name}";
+--      let key := match compare x.name y.name with
+--        | .lt => (x.name, y.name)
+--        | _ => (y.name, x.name)
+--      match (<- get).eqConst.get? key with
+--      | some o => return ⟨true, o⟩
+--      | none => do
+--      let sorder <- do
+--        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+--        SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
+--        SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
+--        SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
+--        SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
+--        SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
+--        SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+--          (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
+--      if sorder.strong then modify fun stt => { stt with
+--          eqConst := stt.eqConst.insert key sorder.ord
+--        }
+--      return sorder
+--    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
+--      : CompileM SOrder := do
+--        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
+--          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
+--
+----#check List.sortBy (compare ·.name ·.name) [`Test.Ix.Inductives.C, `Test.Ix.Inductives.A, `Test.Ix.Inductives.B]
+--
+--/-- `sortInds` recursively sorts a list of inductive datatypes into equivalence
+--classes, analogous to `sortDefs`
+----/
+--partial def sortInds (classes : (List PreInductive)) 
+--  : CompileM (List (List PreInductive)) := do
+--    sortIndsInner [List.sortBy (compare ·.name ·.name) classes] 0
+--  where
+--    eqInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInductive) : CompileM Bool
+--      := (· == .eq) <$> compareInd ctx x y
+--    sortIndsInner (classes: List (List PreInductive)) (iter: Nat)
+--      : CompileM (List (List PreInductive)) := do
+--      dbg_trace "sortInds {iter} classes {repr (classes.map (·.map (·.name)))}";
+--      let ctx := indMutCtx classes
+--      let newClasses ← classes.mapM fun ds =>
+--        match ds with
+--        | []  => unreachable!
+--        | [d] => pure [[d]]
+--        | ds  => do pure $ (← List.groupByM (eqInd ctx) $ ← ds.sortByM (compareInd ctx))
+--      let newClasses := newClasses.flatten.map (List.sortBy (compare ·.name ·.name))
+--      if classes == newClasses then return newClasses
+--      else sortIndsInner newClasses (iter + 1)
+--
+--end
+--
+--partial def makeLeanDef
+--  (name: Lean.Name) (levelParams: List Lean.Name) (type value: Lean.Expr) 
+--  : Lean.DefinitionVal :=
+--  { name, levelParams, type, value, hints := .opaque, safety := .safe }
+--
+--partial def tryAddLeanDef (defn: Lean.DefinitionVal) : CompileM Unit := do
+--  match (<- get).env.constants.find? defn.name with
+--  | some _ => pure ()
+--  | none => do
+--    let env <- (·.env) <$> get
+--    let maxHeartBeats <- (·.maxHeartBeats) <$> read
+--    let decl := Lean.Declaration.defnDecl defn
+--    match Lean.Environment.addDeclCore env maxHeartBeats decl .none with
+--    | .ok e => do
+--      modify fun stt => { stt with env := e }
+--      return ()
+--    | .error e => throw $ .kernelException e
+--
+--partial def addDef
+--  (lvls: List Lean.Name)
+--  (typ val: Lean.Expr)
+--  : CompileM (Address × Address) := do
+--  let typ' <- compileExpr typ
+--  let val' <- compileExpr val
+--  let anonConst := Ix.Const.definition 
+--    ⟨.anonymous, lvls, typ', .definition, val', .opaque, .safe, []⟩
+--  let (anonIxon,_) <- dematerializeConst anonConst
+--  let anonAddr <- storeConst anonIxon
+--  let name := anonAddr.toUniqueName
+--  let const := 
+--    Ix.Const.definition ⟨name, lvls, typ', .definition, val', .opaque, .safe, []⟩
+--  let (a, m) <- hashConst const
+--  if a != anonAddr then
+--    throw <| .alphaInvarianceFailure anonConst anonAddr const a
+--  else
+--    tryAddLeanDef (makeLeanDef a.toUniqueName lvls typ val)
+--    return (a, m)
+--
+--partial def commitConst (anon meta: Address)
+--  : CompileM (Address × Address) := do
+--  let secret <- freshSecret
+--  let comm := .comm ⟨secret, anon⟩
+--  let commAddr <- storeConst comm
+--  let commMeta := .comm ⟨secret, meta⟩
+--  let commMetaAddr <- storeConst commMeta
+--  modify fun stt => { stt with
+--    comms := stt.comms.insert commAddr.toUniqueName (commAddr, commMetaAddr)
+--  }
+--  return (commAddr, commMetaAddr)
+--
+--partial def commitDef 
+--  (lvls: List Lean.Name) 
+--  (typ val: Lean.Expr)
+--  : CompileM (Address × Address) := do
+--  let (a, m) <- addDef lvls typ val
+--  let (ca, cm) <- commitConst a m
+--  tryAddLeanDef (makeLeanDef ca.toUniqueName lvls typ val)
+--  --tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ (mkConst a.toUniqueName []))
+--  return (ca, cm)
+--
+--
+--partial def packLevel (lvls: Nat) (commit: Bool): CompileM Address :=
+--  match Ixon.natPackAsAddress lvls with
+--  | some lvlsAddr => do
+--    if commit then
+--      let secret <- freshSecret
+--      let comm := .comm (Ixon.Comm.mk secret lvlsAddr)
+--      let commAddr <- storeConst comm
+--      modify fun stt => { stt with
+--        comms := stt.comms.insert commAddr.toUniqueName (commAddr, commAddr)
+--      }
+--      return commAddr
+--    else return lvlsAddr
+--  | .none => throw $ .cantPackLevel lvls
+--
+--partial def checkClaim
+--  (const: Lean.Name)
+--  (type: Lean.Expr)
+--  (sort: Lean.Expr)
+--  (lvls: List Lean.Name)
+--  (commit: Bool)
+--  : CompileM (Claim × Address × Address) := do
+--  let leanConst <- findLeanConst const
+--  let (value, valMeta) <- compileConst leanConst >>= comm
+--  let (type, typeMeta) <- addDef lvls sort type >>= comm
+--  let lvls <- packLevel lvls.length commit
+--  return (Claim.checks (CheckClaim.mk lvls type value), typeMeta, valMeta)
+--  where
+--    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
+--
+--partial def evalClaim
+--  (lvls: List Lean.Name)
+--  (input: Lean.Expr)
+--  (output: Lean.Expr)
+--  (type: Lean.Expr)
+--  (sort: Lean.Expr)
+--  (commit: Bool)
+--  : CompileM (Claim × Address × Address × Address) := do
+--  let (input, inputMeta) <- addDef lvls type input >>= comm
+--  let (output, outputMeta) <- addDef lvls type output >>= comm
+--  let (type, typeMeta) <- addDef lvls sort type >>= comm
+--  let lvlsAddr <- packLevel lvls.length commit
+--  return (Claim.evals (EvalClaim.mk lvlsAddr input output type), inputMeta, outputMeta, typeMeta)
+--  where
+--    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
+--
+--/--
+--Content-addresses the "delta" of an environment, that is, the content that is
+--added on top of the imports.
+--
+--Important: constants with open references in their expressions are filtered out.
+--Open references are variables that point to names which aren't present in the
+--`Lean.ConstMap`.
+---/
+--def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
+--  : CompileM Unit := delta.forM fun _ c => discard $ compileConst c
+--
+--def compileEnv (env: Lean.Environment)
+--  : CompileM Unit := do
+--  compileDelta env.getDelta
+--  env.getConstMap.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
+--
+--def CompileM.runIO (c : CompileM α) 
+--  (env: Lean.Environment)
+--  (maxHeartBeats: USize := 200000)
+--  (seed : Option Nat := .none)
+--  : IO (α × CompileState) := do
+--  let seed <- match seed with
+--    | .none => IO.monoNanosNow
+--    | .some s => pure s
+--  match <- c.run (.init maxHeartBeats) (.init env seed) with
+--  | (.ok a, stt) => return (a, stt)
+--  | (.error e, _) => throw (IO.userError (<- e.pretty))
+--
+--def CompileM.runIO' (c : CompileM α) 
+--  (stt: CompileState)
+--  (maxHeartBeats: USize := 200000)
+--  : IO (α × CompileState) := do
+--  match <- c.run (.init maxHeartBeats) stt with
+--  | (.ok a, stt) => return (a, stt)
+--  | (.error e, _) => throw (IO.userError (<- e.pretty))
+--
+--def compileEnvIO (env: Lean.Environment) : IO (CompileState):= do
+--  Prod.snd <$> (compileDelta env.getDelta).runIO env
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index 0c3755de..a55de637 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -1,416 +1,412 @@
 import Std.Data.HashMap
-import Ix.TransportM
-import Ix.Ixon.Metadata
-import Ix.Ixon.Const
-import Ix.Ixon.Serialize
+import Ix.Ixon
 import Ix.Common
 import Ix.Store
 import Ix.CompileM
 
-open Ix.TransportM
 open Ix.Compile
 open Ixon
 
-namespace Ix.Decompile
-
-/- the current Ix constant being decompiled -/
-structure Named where
-  name: Lean.Name
-  cont: Address
-  meta: Address
-deriving Inhabited, Repr
-
-instance : ToString Named where
-  toString n := s!"{n.cont}:{n.meta}-{n.name}"
-
-/- The local environment for the Ix -> Lean4 decompiler -/
-structure DecompileEnv where
-  names : Std.HashMap Lean.Name (Address × Address) 
-  store : Std.HashMap Address Ixon
-  univCtx : List Lean.Name
-  bindCtx : List Lean.Name
-  mutCtx  : Std.HashMap Lean.Name Nat
-  current: Named
-  deriving Repr, Inhabited
-
-/- initialize from an Ixon store and a name-index to the store -/
-def DecompileEnv.init
-  (names : Std.HashMap Lean.Name (Address × Address))
-  (store : Std.HashMap Address Ixon)
-  : DecompileEnv
-  := ⟨names, store, default, default, default, default⟩
-
-/- a collection of an inductive datatype with its constructors and recursors -/
-structure InductiveBlock where
-  val: Lean.ConstantInfo
-  ctors: List Lean.ConstantInfo
-  recrs: List Lean.ConstantInfo
-deriving Repr
-
-def InductiveBlock.contains (i: InductiveBlock) (name: Lean.Name) : Bool := 
-  i.val.name == name ||
-  i.ctors.any (fun c => c.name == name) ||
-  i.recrs.any (fun r => r.name == name)
-
-/- A Block is one of the possible sets of Lean constants we could generate
- from a pair of content and metadata Ix addresses -/
-inductive Block where
-| single : Lean.ConstantInfo -> Block
-| mutual : List Lean.ConstantInfo -> Block
-| inductive: List InductiveBlock -> Block
-deriving Repr
-
-def Block.contains (name: Lean.Name) : Block -> Bool
-| .single const => const.name == name
-| .mutual consts => consts.any (fun c => c.name == name)
-| .inductive is => is.any (fun i => i.contains name)
-
-/- The name of an inductive datatype with the names of its constructors and
-recursors. Used to create a BlockNames struct.
--/
-structure InductiveBlockNames where
-  val: Lean.Name
-  ctors: List Lean.Name
-  recrs: List Lean.Name
-deriving Repr
-
-def InductiveBlockNames.contains (i: InductiveBlockNames) (name: Lean.Name) : Bool := 
-  i.val == name ||
-  i.ctors.any (fun c => c == name) ||
-  i.recrs.any (fun r => r == name)
-
-/- A BlockNames struct is the names of a Block. Naively, the decompiler
-operates by mapping content-address pairs to blocks, but since each block might
-be mapped onto by many address pairs, we only record address pair to BlockNames
-mapping, and separately keep a single level map of Lean.Name to
-Lean.ConstantInfo
--/
-inductive BlockNames where
-| single : Lean.Name -> BlockNames
-| mutual : List Lean.Name -> BlockNames
-| inductive : List InductiveBlockNames -> BlockNames
-deriving Repr, Inhabited, Nonempty
-
-def BlockNames.contains (name: Lean.Name) : BlockNames -> Bool
-| .single const => const == name
-| .mutual consts => consts.any (fun c => c == name)
-| .inductive is => is.any (fun i => i.contains name)
-
-structure DecompileState where
-  constants: Std.HashMap Lean.Name Lean.ConstantInfo
-  blocks : Std.HashMap (Address × Address) BlockNames
-  deriving Inhabited
-
-inductive DecompileError
-| freeLevel (curr: Named) (ctx: List Lean.Name) (lvl: Lean.Name) (idx: Nat)
-| mismatchedLevelName
-  (curr: Named) (ctx: List Lean.Name) (got: Lean.Name)
-  (exp: Lean.Name) (idx: Nat)
-| invalidBVarIndex (curr: Named) (ctx: List Lean.Name) (idx: Nat)
-| mismatchedMutIdx
-  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) 
-  (idx: Nat) (got: Nat)
-| unknownMutual 
-  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) (idx: Nat)
-| transport (curr: Named) (err: TransportError) (cont meta: Address)
-| unknownName (curr: Named) (name: Lean.Name)
-| unknownStoreAddress (curr: Named) (exp: Address)
-| expectedIxonMetadata (curr: Named) (exp: Address) (got: Ixon)
-| badProjection
-  (curr: Named) (name: Lean.Name) (cont meta: Address) (msg: String)
-| nonCongruentInductives (curr: Named) (x y: Ix.Inductive)
-| nameNotInBlockNames
-  (curr: Named) (block: BlockNames) (name: Lean.Name) (cont meta: Address)
-| nameNotInBlock
-  (curr: Named) (block: Block) (name: Lean.Name) (cont meta: Address)
-| mismatchedName
-  (curr: Named) (exp: Lean.Name) (got: Lean.Name) (cont meta: Address)
-| expectedNameInBlock
-  (curr: Named) (exp: Lean.Name) (got: BlockNames) (cont meta: Address)
-| expectedDefnBlock (curr: Named) (exp: Lean.Name) (got: Block) (cont meta: Address)
-| expectedMutDefBlock (curr: Named) (got: BlockNames) (cont meta: Address)
-| expectedMutIndBlock (curr: Named) (got: BlockNames) (cont meta: Address)
-| expectedMutIndConst (curr: Named) (got: Ix.Const) (cont meta: Address)
-| expectedMutDefConst (curr: Named) (got: Ix.Const) (cont meta: Address)
-| overloadedConstants (curr: Named) (x y: Lean.ConstantInfo)
-| todo
-deriving Repr
-
-
-def DecompileError.pretty : DecompileError -> String
-| .freeLevel c lvls n i => s!"Free level {n} at {i} with ctx {repr lvls} @ {c}"
-| .mismatchedLevelName c ctx n' n i => 
-  s!"Expected level name {n} at index {i} but got {n'} with context {repr ctx} @ {c}"
-| .invalidBVarIndex c ctx i => 
-  s!"Bound variable {i} escapes context {ctx} @ {c}"
-| .mismatchedMutIdx c ctx n i i' => 
-  s!"expected mutual recusion index {i} at name {n} but got {i'} with context {repr ctx} @ {c}"
-| .unknownMutual c ctx n i => 
-  s!"unknown mutual name {n} with expected index {i} with context {repr ctx} @ {c}"
-| .transport curr e c m => s!"decompiler transport error {e} at {c} {m} @ {curr}"
-| .unknownName c n => s!"unknown name {n} @ {c}"
-| .unknownStoreAddress c x => s!"unknown store address {x} @ {c}"
-| .expectedIxonMetadata c x ixon => s!"expected metadata at address {x}, got {repr ixon} @ {c}"
-| .badProjection curr n c m s => s!"bad projection {n} at address {c}:{m}, {s} @ {curr}"
-| .nonCongruentInductives c x y  => s!"noncongruent inductives {repr x} {repr y} @ {c}"
-| .nameNotInBlockNames curr b n c m  => s!"expected block names {repr b} at {c}:{m} to contain {n} @ {curr}"
-| .nameNotInBlock curr b n c m  => s!"expected block {repr b} at {c}:{m} to contain {n} @ {curr}"
-| .mismatchedName curr e g c m => 
-  s!"expected name {e}, got {g} at address {c} {m} @ {curr}"
-| .expectedNameInBlock curr e b c m => 
-  s!"expected name {e} in block {repr b} at address {c} {m} @ {curr}"
-| .expectedDefnBlock curr e g c m =>
-  s!"expected definition named {e}, got {repr g} at address {c} {m} @ {curr}"
-| .expectedMutDefBlock curr g c m =>
-  s!"expected mutual definition block, got {repr g} at address {c} {m} @ {curr}"
-| .expectedMutIndBlock curr g c m =>
-  s!"expected mutual inductive block, got {repr g} at address {c} {m} @ {curr}"
-| .expectedMutIndConst curr g c m =>
-  s!"expected mutual inductive constant, got {repr g} at address {c} {m} @ {curr}"
-| .expectedMutDefConst curr g c m =>
-  s!"expected mutual definition constant, got {repr g} at address {c} {m} @ {curr}"
-| .overloadedConstants curr x y => 
-  s!"overloaded constants, tried to overwrite {repr y} with {repr x} @ {curr}"
-| .todo => s!"todo"
-
-abbrev DecompileM := ReaderT DecompileEnv <| EStateM DecompileError DecompileState
-
-def DecompileM.run (env: DecompileEnv) (stt: DecompileState) (c : DecompileM α)
-  : EStateM.Result DecompileError DecompileState α
-  := EStateM.run (ReaderT.run c env) stt
-
--- add binding name to local context
-def withBinder (name: Lean.Name) : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
-
--- add levels to local context
-def withLevels (lvls : List Lean.Name) : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with univCtx := lvls }
-
--- add mutual recursion info to local context
-def withMutCtx (mutCtx : Std.HashMap Lean.Name Nat)
-  : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with mutCtx := mutCtx }
-
-def withNamed (name: Lean.Name) (cont meta: Address)
-  : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with current := ⟨name, cont, meta⟩ }
-
--- reset local context
-def resetCtx : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {} }
-
-def resetCtxWithLevels (lvls: List Lean.Name) : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := {} }
-
-def decompileLevel: Ix.Level → DecompileM Lean.Level
-| .zero => pure .zero
-| .succ u => .succ <$> decompileLevel u
-| .max a b => Lean.Level.max  <$> decompileLevel a <*> decompileLevel b
-| .imax a b => Lean.Level.imax <$> decompileLevel a <*> decompileLevel b
-| .param n i => do
-  let env <- read
-  match env.univCtx[i]? with
-  | some n' =>
-    if n == n' then pure (Lean.Level.param n)
-    else throw (.mismatchedLevelName env.current env.univCtx n' n i)
-  | none => throw <| .freeLevel env.current env.univCtx n i
-
-partial def insertConst
-  (const: Lean.ConstantInfo)
-  : DecompileM Lean.Name := do
-  match (<- get).constants.get? const.name with
-  | .some const' =>
-      if const == const' then return const.name
-      else throw <| .overloadedConstants (<- read).current const const'
-  | .none => modify fun stt => 
-    { stt with constants := stt.constants.insert const.name const }
-    return const.name
-
-partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
-  let bn <- match b with
-    | .single const => .single <$> insertConst const
-    | .mutual cs => .mutual <$> cs.mapM insertConst
-    | .inductive is => .inductive <$> is.mapM insertInductive
-  modifyGet fun stt =>
-    (bn, { stt with blocks := stt.blocks.insert (c, m) bn })
-  where
-    insertInductive (i: InductiveBlock) : DecompileM InductiveBlockNames := do
-      let val <- insertConst i.val
-      let ctors <- i.ctors.mapM insertConst
-      let recrs <- i.recrs.mapM insertConst
-      return ⟨val, ctors, recrs⟩
-
-partial def decompileMutualCtx (ctx: List (List Lean.Name))
-  : DecompileM (Std.HashMap Lean.Name Nat) := do
-  let mut mutCtx : Std.HashMap Lean.Name Nat := {}
-  for (ns, i) in List.zipIdx ctx do
-    for n in ns do
-      mutCtx := mutCtx.insert n i
-  return mutCtx
-
-partial def checkCtorRecrLengths : List Ix.Inductive -> DecompileM (Nat × Nat)
-| [] => return (0, 0)
-| x::xs => go x xs
-  where
-    go : Ix.Inductive -> List Ix.Inductive -> DecompileM (Nat × Nat)
-    | x, [] => return (x.ctors.length, x.recrs.length)
-    | x, a::as => do
-      if x.ctors.length == a.ctors.length && x.recrs.length == a.recrs.length
-      then go x as else throw <| .nonCongruentInductives (<- read).current x a
-
-partial def decompileMutIndCtx (block: Ix.InductiveBlock)
-  : DecompileM (Std.HashMap Lean.Name Nat) := do
-  let mut mutCtx : Std.HashMap Lean.Name Nat := {}
-  let mut i := 0
-  for inds in block.inds do
-    let (numCtors, numRecrs) <- checkCtorRecrLengths inds
-    for ind in inds do
-      mutCtx := mutCtx.insert ind.name i
-      for (c, cidx) in List.zipIdx ind.ctors do
-        mutCtx := mutCtx.insert c.name (i + cidx)
-      for (r, ridx) in List.zipIdx ind.recrs do
-        mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
-    i := i + 1 + numCtors + numRecrs
-  return mutCtx
-
-mutual
-
-partial def decompileExpr: Ix.Expr → DecompileM Lean.Expr
-| .var i      => do match (← read).bindCtx[i]? with
-  | some _ => return .bvar i
-  | none => throw <| .invalidBVarIndex (<-read).current (<-read).bindCtx i
-| .sort u     => Lean.Expr.sort <$> decompileLevel u
-| .lit l      => pure (.lit l)
-| .app f a    => Lean.mkApp <$> decompileExpr f <*> decompileExpr a
-| .lam n bi t b =>
-    Lean.mkLambda n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
-| .pi n bi t b =>
-    Lean.mkForall n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
-| .letE n t v b nd =>
-    (@Lean.mkLet n)
-      <$> decompileExpr t
-      <*> decompileExpr v
-      <*> withBinder n (decompileExpr b)
-      <*> pure nd
-| .proj n cont meta i e => do
-    let _ <- ensureBlock n cont meta
-    Lean.mkProj n i <$> decompileExpr e
-| .const n cont meta us => do
-    let _ <- ensureBlock n cont meta
-    return Lean.mkConst n (<- us.mapM decompileLevel)
-| .rec_ n i us => do match (<- read).mutCtx.get? n with
-  | some i' =>
-    if i == i' then return Lean.mkConst n (<- us.mapM decompileLevel)
-    else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx n i i'
-  | none => throw <| .unknownMutual (<- read).current (<- read).mutCtx n i
-
-partial def ensureBlock (name: Lean.Name) (c m: Address) : DecompileM BlockNames := do
-  match (<- get).blocks.get? (c, m) with
-  | .some b =>
-    if b.contains name then pure b
-    else throw <| .nameNotInBlockNames (<- read).current b name c m
-  | .none =>
-    let cont : Ixon.Const <- match (<- read).store.get? c with
-      | .some ixon => pure ixon
-      | .none => throw <| .unknownStoreAddress (<- read).current c
-    let meta : Ixon.Const <- match (<- read).store.get? m with
-      | .some ixon => pure ixon
-      | .none => throw <| .unknownStoreAddress (<- read).current m
-    match rematerialize cont meta with
-    | .ok const  => do
-      let blockNames <- withNamed name c m <| decompileConst const
-      if !blockNames.contains name then
-         throw <| .nameNotInBlockNames (<- read).current blockNames name c m
-      return blockNames
-    | .error e => throw (.transport (<- read).current e c m)
-
-partial def decompileDefn (x: Ix.Definition)
-  : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
-    let type <- decompileExpr x.type
-    let val <- decompileExpr x.value
-    match x.kind with
-    | .definition => return .defnInfo <|
-      Lean.mkDefinitionValEx x.name x.levelParams type val x.hints x.safety x.all
-    | .opaque => return .opaqueInfo <|
-      Lean.mkOpaqueValEx x.name x.levelParams type val (x.safety == .unsafe) x.all
-    | .theorem => return .thmInfo <|
-      Lean.mkTheoremValEx x.name x.levelParams type val x.all
-
-partial def decompileIndc (x: Ix.Inductive)
-  : DecompileM
-    (Lean.ConstantInfo × List Lean.ConstantInfo × List Lean.ConstantInfo)
-    := withLevels x.levelParams do
-      let type <- decompileExpr x.type
-      let indc :=
-        Lean.mkInductiveValEx x.name x.levelParams type x.numParams x.numIndices
-          x.all (x.ctors.map (·.name)) x.numNested x.isRec x.isUnsafe x.isReflexive
-      let ctors <- x.ctors.mapM (decompileCtor x.name)
-      let recrs <- x.recrs.mapM (decompileRecr x.all)
-      return (.inductInfo indc, ctors, recrs)
-  where
-    decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
-      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
-      let type <- decompileExpr x.type
-      return .ctorInfo <|
-        Lean.mkConstructorValEx x.name x.levelParams type indcName
-          x.cidx x.numParams x.numFields x.isUnsafe
-    decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
-      let rhs <- decompileExpr x.rhs
-      return ⟨x.ctor, x.nfields, rhs⟩
-    decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
-      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
-      let type <- decompileExpr x.type
-      let rules <- x.rules.mapM decompileRecrRule
-      return .recInfo <|
-        Lean.mkRecursorValEx x.name x.levelParams type indcAll
-          x.numParams x.numIndices x.numMotives x.numMinors rules x.k x.isUnsafe
-
--- TODO: name integrity
-partial def decompileConst : Ix.Const -> DecompileM BlockNames
-| .axiom x => withLevels x.levelParams do
-  let ⟨_, c, m⟩ := (<- read).current
-  let type <- decompileExpr x.type
-  let const := (.axiomInfo <| Lean.mkAxiomValEx x.name x.levelParams type x.isUnsafe)
-  insertBlock c m (.single const)
-| .definition x => do
-  let ⟨_, c, m⟩ := (<- read).current
-  let const <- decompileDefn x
-  insertBlock c m (.single const)
-| .quotient x => withLevels x.levelParams do
-  let ⟨_, c, m⟩ := (<- read).current
-  let type <- decompileExpr x.type
-  let const := (.quotInfo <| Lean.mkQuotValEx x.name x.levelParams type x.kind)
-  insertBlock c m (.single const)
-| .inductiveProj x => ensureBlock x.name x.blockCont x.blockMeta
-| .constructorProj x => ensureBlock x.induct x.blockCont x.blockMeta
-| .recursorProj x => ensureBlock x.induct x.blockCont x.blockMeta
-| .definitionProj x => ensureBlock x.name x.blockCont x.blockMeta
-| .mutual x => do
-  let ⟨_, c, m⟩ := (<- read).current
-  let mutCtx <- decompileMutualCtx x.ctx
-  withMutCtx mutCtx do
-    let mut block := #[]
-    for defns in x.defs do
-      for defn in defns do
-        let const <- decompileDefn defn
-        block := block.push const
-    insertBlock c m (.mutual block.toList)
-| .inductive x => do
-  let ⟨_, c, m⟩ := (<- read).current
-  let mutCtx <- decompileMutIndCtx x
-  withMutCtx mutCtx do
-    let mut block := #[]
-    for inds in x.inds do
-      for ind in inds do
-        let (i, cs, rs) <- decompileIndc ind
-        block := block.push ⟨i, cs, rs⟩
-    insertBlock c m (Block.inductive block.toList)
-
-end
-
-def decompileEnv : DecompileM Unit := do
-  for (n, (anon, meta)) in (<- read).names do
-    let _ <- ensureBlock n anon meta
-
-end Decompile
+--namespace Ix.Decompile
+--
+--/- the current Ix constant being decompiled -/
+--structure Named where
+--  name: Lean.Name
+--  cont: Address
+--  meta: Address
+--deriving Inhabited, Repr
+--
+--instance : ToString Named where
+--  toString n := s!"{n.cont}:{n.meta}-{n.name}"
+--
+--/- The local environment for the Ix -> Lean4 decompiler -/
+--structure DecompileEnv where
+--  names : Std.HashMap Lean.Name (Address × Address) 
+--  store : Std.HashMap Address Ixon
+--  univCtx : List Lean.Name
+--  bindCtx : List Lean.Name
+--  mutCtx  : Std.HashMap Lean.Name Nat
+--  current: Named
+--  deriving Repr, Inhabited
+--
+--/- initialize from an Ixon store and a name-index to the store -/
+--def DecompileEnv.init
+--  (names : Std.HashMap Lean.Name (Address × Address))
+--  (store : Std.HashMap Address Ixon)
+--  : DecompileEnv
+--  := ⟨names, store, default, default, default, default⟩
+--
+--/- a collection of an inductive datatype with its constructors and recursors -/
+--structure InductiveBlock where
+--  val: Lean.ConstantInfo
+--  ctors: List Lean.ConstantInfo
+--  recrs: List Lean.ConstantInfo
+--deriving Repr
+--
+--def InductiveBlock.contains (i: InductiveBlock) (name: Lean.Name) : Bool := 
+--  i.val.name == name ||
+--  i.ctors.any (fun c => c.name == name) ||
+--  i.recrs.any (fun r => r.name == name)
+--
+--/- A Block is one of the possible sets of Lean constants we could generate
+-- from a pair of content and metadata Ix addresses -/
+--inductive Block where
+--| single : Lean.ConstantInfo -> Block
+--| mutual : List Lean.ConstantInfo -> Block
+--| inductive: List InductiveBlock -> Block
+--deriving Repr
+--
+--def Block.contains (name: Lean.Name) : Block -> Bool
+--| .single const => const.name == name
+--| .mutual consts => consts.any (fun c => c.name == name)
+--| .inductive is => is.any (fun i => i.contains name)
+--
+--/- The name of an inductive datatype with the names of its constructors and
+--recursors. Used to create a BlockNames struct.
+---/
+--structure InductiveBlockNames where
+--  val: Lean.Name
+--  ctors: List Lean.Name
+--  recrs: List Lean.Name
+--deriving Repr
+--
+--def InductiveBlockNames.contains (i: InductiveBlockNames) (name: Lean.Name) : Bool := 
+--  i.val == name ||
+--  i.ctors.any (fun c => c == name) ||
+--  i.recrs.any (fun r => r == name)
+--
+--/- A BlockNames struct is the names of a Block. Naively, the decompiler
+--operates by mapping content-address pairs to blocks, but since each block might
+--be mapped onto by many address pairs, we only record address pair to BlockNames
+--mapping, and separately keep a single level map of Lean.Name to
+--Lean.ConstantInfo
+---/
+--inductive BlockNames where
+--| single : Lean.Name -> BlockNames
+--| mutual : List Lean.Name -> BlockNames
+--| inductive : List InductiveBlockNames -> BlockNames
+--deriving Repr, Inhabited, Nonempty
+--
+--def BlockNames.contains (name: Lean.Name) : BlockNames -> Bool
+--| .single const => const == name
+--| .mutual consts => consts.any (fun c => c == name)
+--| .inductive is => is.any (fun i => i.contains name)
+--
+--structure DecompileState where
+--  constants: Std.HashMap Lean.Name Lean.ConstantInfo
+--  blocks : Std.HashMap (Address × Address) BlockNames
+--  deriving Inhabited
+--
+--inductive DecompileError
+--| freeLevel (curr: Named) (ctx: List Lean.Name) (lvl: Lean.Name) (idx: Nat)
+--| mismatchedLevelName
+--  (curr: Named) (ctx: List Lean.Name) (got: Lean.Name)
+--  (exp: Lean.Name) (idx: Nat)
+--| invalidBVarIndex (curr: Named) (ctx: List Lean.Name) (idx: Nat)
+--| mismatchedMutIdx
+--  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) 
+--  (idx: Nat) (got: Nat)
+--| unknownMutual 
+--  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) (idx: Nat)
+--| transport (curr: Named) (err: TransportError) (cont meta: Address)
+--| unknownName (curr: Named) (name: Lean.Name)
+--| unknownStoreAddress (curr: Named) (exp: Address)
+--| expectedIxonMetadata (curr: Named) (exp: Address) (got: Ixon)
+--| badProjection
+--  (curr: Named) (name: Lean.Name) (cont meta: Address) (msg: String)
+--| nonCongruentInductives (curr: Named) (x y: Ix.Inductive)
+--| nameNotInBlockNames
+--  (curr: Named) (block: BlockNames) (name: Lean.Name) (cont meta: Address)
+--| nameNotInBlock
+--  (curr: Named) (block: Block) (name: Lean.Name) (cont meta: Address)
+--| mismatchedName
+--  (curr: Named) (exp: Lean.Name) (got: Lean.Name) (cont meta: Address)
+--| expectedNameInBlock
+--  (curr: Named) (exp: Lean.Name) (got: BlockNames) (cont meta: Address)
+--| expectedDefnBlock (curr: Named) (exp: Lean.Name) (got: Block) (cont meta: Address)
+--| expectedMutDefBlock (curr: Named) (got: BlockNames) (cont meta: Address)
+--| expectedMutIndBlock (curr: Named) (got: BlockNames) (cont meta: Address)
+--| expectedMutIndConst (curr: Named) (got: Ix.Const) (cont meta: Address)
+--| expectedMutDefConst (curr: Named) (got: Ix.Const) (cont meta: Address)
+--| overloadedConstants (curr: Named) (x y: Lean.ConstantInfo)
+--| todo
+--deriving Repr
+--
+--
+--def DecompileError.pretty : DecompileError -> String
+--| .freeLevel c lvls n i => s!"Free level {n} at {i} with ctx {repr lvls} @ {c}"
+--| .mismatchedLevelName c ctx n' n i => 
+--  s!"Expected level name {n} at index {i} but got {n'} with context {repr ctx} @ {c}"
+--| .invalidBVarIndex c ctx i => 
+--  s!"Bound variable {i} escapes context {ctx} @ {c}"
+--| .mismatchedMutIdx c ctx n i i' => 
+--  s!"expected mutual recusion index {i} at name {n} but got {i'} with context {repr ctx} @ {c}"
+--| .unknownMutual c ctx n i => 
+--  s!"unknown mutual name {n} with expected index {i} with context {repr ctx} @ {c}"
+--| .transport curr e c m => s!"decompiler transport error {e} at {c} {m} @ {curr}"
+--| .unknownName c n => s!"unknown name {n} @ {c}"
+--| .unknownStoreAddress c x => s!"unknown store address {x} @ {c}"
+--| .expectedIxonMetadata c x ixon => s!"expected metadata at address {x}, got {repr ixon} @ {c}"
+--| .badProjection curr n c m s => s!"bad projection {n} at address {c}:{m}, {s} @ {curr}"
+--| .nonCongruentInductives c x y  => s!"noncongruent inductives {repr x} {repr y} @ {c}"
+--| .nameNotInBlockNames curr b n c m  => s!"expected block names {repr b} at {c}:{m} to contain {n} @ {curr}"
+--| .nameNotInBlock curr b n c m  => s!"expected block {repr b} at {c}:{m} to contain {n} @ {curr}"
+--| .mismatchedName curr e g c m => 
+--  s!"expected name {e}, got {g} at address {c} {m} @ {curr}"
+--| .expectedNameInBlock curr e b c m => 
+--  s!"expected name {e} in block {repr b} at address {c} {m} @ {curr}"
+--| .expectedDefnBlock curr e g c m =>
+--  s!"expected definition named {e}, got {repr g} at address {c} {m} @ {curr}"
+--| .expectedMutDefBlock curr g c m =>
+--  s!"expected mutual definition block, got {repr g} at address {c} {m} @ {curr}"
+--| .expectedMutIndBlock curr g c m =>
+--  s!"expected mutual inductive block, got {repr g} at address {c} {m} @ {curr}"
+--| .expectedMutIndConst curr g c m =>
+--  s!"expected mutual inductive constant, got {repr g} at address {c} {m} @ {curr}"
+--| .expectedMutDefConst curr g c m =>
+--  s!"expected mutual definition constant, got {repr g} at address {c} {m} @ {curr}"
+--| .overloadedConstants curr x y => 
+--  s!"overloaded constants, tried to overwrite {repr y} with {repr x} @ {curr}"
+--| .todo => s!"todo"
+--
+--abbrev DecompileM := ReaderT DecompileEnv <| EStateM DecompileError DecompileState
+--
+--def DecompileM.run (env: DecompileEnv) (stt: DecompileState) (c : DecompileM α)
+--  : EStateM.Result DecompileError DecompileState α
+--  := EStateM.run (ReaderT.run c env) stt
+--
+---- add binding name to local context
+--def withBinder (name: Lean.Name) : DecompileM α -> DecompileM α :=
+--  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
+--
+---- add levels to local context
+--def withLevels (lvls : List Lean.Name) : DecompileM α -> DecompileM α :=
+--  withReader $ fun c => { c with univCtx := lvls }
+--
+---- add mutual recursion info to local context
+--def withMutCtx (mutCtx : Std.HashMap Lean.Name Nat)
+--  : DecompileM α -> DecompileM α :=
+--  withReader $ fun c => { c with mutCtx := mutCtx }
+--
+--def withNamed (name: Lean.Name) (cont meta: Address)
+--  : DecompileM α -> DecompileM α :=
+--  withReader $ fun c => { c with current := ⟨name, cont, meta⟩ }
+--
+---- reset local context
+--def resetCtx : DecompileM α -> DecompileM α :=
+--  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {} }
+--
+--def resetCtxWithLevels (lvls: List Lean.Name) : DecompileM α -> DecompileM α :=
+--  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := {} }
+--
+--def decompileLevel: Ix.Level → DecompileM Lean.Level
+--| .zero => pure .zero
+--| .succ u => .succ <$> decompileLevel u
+--| .max a b => Lean.Level.max  <$> decompileLevel a <*> decompileLevel b
+--| .imax a b => Lean.Level.imax <$> decompileLevel a <*> decompileLevel b
+--| .param n i => do
+--  let env <- read
+--  match env.univCtx[i]? with
+--  | some n' =>
+--    if n == n' then pure (Lean.Level.param n)
+--    else throw (.mismatchedLevelName env.current env.univCtx n' n i)
+--  | none => throw <| .freeLevel env.current env.univCtx n i
+--
+--partial def insertConst
+--  (const: Lean.ConstantInfo)
+--  : DecompileM Lean.Name := do
+--  match (<- get).constants.get? const.name with
+--  | .some const' =>
+--      if const == const' then return const.name
+--      else throw <| .overloadedConstants (<- read).current const const'
+--  | .none => modify fun stt => 
+--    { stt with constants := stt.constants.insert const.name const }
+--    return const.name
+--
+--partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
+--  let bn <- match b with
+--    | .single const => .single <$> insertConst const
+--    | .mutual cs => .mutual <$> cs.mapM insertConst
+--    | .inductive is => .inductive <$> is.mapM insertInductive
+--  modifyGet fun stt =>
+--    (bn, { stt with blocks := stt.blocks.insert (c, m) bn })
+--  where
+--    insertInductive (i: InductiveBlock) : DecompileM InductiveBlockNames := do
+--      let val <- insertConst i.val
+--      let ctors <- i.ctors.mapM insertConst
+--      let recrs <- i.recrs.mapM insertConst
+--      return ⟨val, ctors, recrs⟩
+--
+--partial def decompileMutualCtx (ctx: List (List Lean.Name))
+--  : DecompileM (Std.HashMap Lean.Name Nat) := do
+--  let mut mutCtx : Std.HashMap Lean.Name Nat := {}
+--  for (ns, i) in List.zipIdx ctx do
+--    for n in ns do
+--      mutCtx := mutCtx.insert n i
+--  return mutCtx
+--
+--partial def checkCtorRecrLengths : List Ix.Inductive -> DecompileM (Nat × Nat)
+--| [] => return (0, 0)
+--| x::xs => go x xs
+--  where
+--    go : Ix.Inductive -> List Ix.Inductive -> DecompileM (Nat × Nat)
+--    | x, [] => return (x.ctors.length, x.recrs.length)
+--    | x, a::as => do
+--      if x.ctors.length == a.ctors.length && x.recrs.length == a.recrs.length
+--      then go x as else throw <| .nonCongruentInductives (<- read).current x a
+--
+--partial def decompileMutIndCtx (block: Ix.InductiveBlock)
+--  : DecompileM (Std.HashMap Lean.Name Nat) := do
+--  let mut mutCtx : Std.HashMap Lean.Name Nat := {}
+--  let mut i := 0
+--  for inds in block.inds do
+--    let (numCtors, numRecrs) <- checkCtorRecrLengths inds
+--    for ind in inds do
+--      mutCtx := mutCtx.insert ind.name i
+--      for (c, cidx) in List.zipIdx ind.ctors do
+--        mutCtx := mutCtx.insert c.name (i + cidx)
+--      for (r, ridx) in List.zipIdx ind.recrs do
+--        mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
+--    i := i + 1 + numCtors + numRecrs
+--  return mutCtx
+--
+--mutual
+--
+--partial def decompileExpr: Ix.Expr → DecompileM Lean.Expr
+--| .var i      => do match (← read).bindCtx[i]? with
+--  | some _ => return .bvar i
+--  | none => throw <| .invalidBVarIndex (<-read).current (<-read).bindCtx i
+--| .sort u     => Lean.Expr.sort <$> decompileLevel u
+--| .lit l      => pure (.lit l)
+--| .app f a    => Lean.mkApp <$> decompileExpr f <*> decompileExpr a
+--| .lam n bi t b =>
+--    Lean.mkLambda n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
+--| .pi n bi t b =>
+--    Lean.mkForall n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
+--| .letE n t v b nd =>
+--    (@Lean.mkLet n)
+--      <$> decompileExpr t
+--      <*> decompileExpr v
+--      <*> withBinder n (decompileExpr b)
+--      <*> pure nd
+--| .proj n cont meta i e => do
+--    let _ <- ensureBlock n cont meta
+--    Lean.mkProj n i <$> decompileExpr e
+--| .const n cont meta us => do
+--    let _ <- ensureBlock n cont meta
+--    return Lean.mkConst n (<- us.mapM decompileLevel)
+--| .rec_ n i us => do match (<- read).mutCtx.get? n with
+--  | some i' =>
+--    if i == i' then return Lean.mkConst n (<- us.mapM decompileLevel)
+--    else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx n i i'
+--  | none => throw <| .unknownMutual (<- read).current (<- read).mutCtx n i
+--
+--partial def ensureBlock (name: Lean.Name) (c m: Address) : DecompileM BlockNames := do
+--  match (<- get).blocks.get? (c, m) with
+--  | .some b =>
+--    if b.contains name then pure b
+--    else throw <| .nameNotInBlockNames (<- read).current b name c m
+--  | .none =>
+--    let cont : Ixon.Const <- match (<- read).store.get? c with
+--      | .some ixon => pure ixon
+--      | .none => throw <| .unknownStoreAddress (<- read).current c
+--    let meta : Ixon.Const <- match (<- read).store.get? m with
+--      | .some ixon => pure ixon
+--      | .none => throw <| .unknownStoreAddress (<- read).current m
+--    match rematerialize cont meta with
+--    | .ok const  => do
+--      let blockNames <- withNamed name c m <| decompileConst const
+--      if !blockNames.contains name then
+--         throw <| .nameNotInBlockNames (<- read).current blockNames name c m
+--      return blockNames
+--    | .error e => throw (.transport (<- read).current e c m)
+--
+--partial def decompileDefn (x: Ix.Definition)
+--  : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+--    let type <- decompileExpr x.type
+--    let val <- decompileExpr x.value
+--    match x.kind with
+--    | .definition => return .defnInfo <|
+--      Lean.mkDefinitionValEx x.name x.levelParams type val x.hints x.safety x.all
+--    | .opaque => return .opaqueInfo <|
+--      Lean.mkOpaqueValEx x.name x.levelParams type val (x.safety == .unsafe) x.all
+--    | .theorem => return .thmInfo <|
+--      Lean.mkTheoremValEx x.name x.levelParams type val x.all
+--
+--partial def decompileIndc (x: Ix.Inductive)
+--  : DecompileM
+--    (Lean.ConstantInfo × List Lean.ConstantInfo × List Lean.ConstantInfo)
+--    := withLevels x.levelParams do
+--      let type <- decompileExpr x.type
+--      let indc :=
+--        Lean.mkInductiveValEx x.name x.levelParams type x.numParams x.numIndices
+--          x.all (x.ctors.map (·.name)) x.numNested x.isRec x.isUnsafe x.isReflexive
+--      let ctors <- x.ctors.mapM (decompileCtor x.name)
+--      let recrs <- x.recrs.mapM (decompileRecr x.all)
+--      return (.inductInfo indc, ctors, recrs)
+--  where
+--    decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
+--      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+--      let type <- decompileExpr x.type
+--      return .ctorInfo <|
+--        Lean.mkConstructorValEx x.name x.levelParams type indcName
+--          x.cidx x.numParams x.numFields x.isUnsafe
+--    decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
+--      let rhs <- decompileExpr x.rhs
+--      return ⟨x.ctor, x.nfields, rhs⟩
+--    decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
+--      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
+--      let type <- decompileExpr x.type
+--      let rules <- x.rules.mapM decompileRecrRule
+--      return .recInfo <|
+--        Lean.mkRecursorValEx x.name x.levelParams type indcAll
+--          x.numParams x.numIndices x.numMotives x.numMinors rules x.k x.isUnsafe
+--
+---- TODO: name integrity
+--partial def decompileConst : Ix.Const -> DecompileM BlockNames
+--| .axiom x => withLevels x.levelParams do
+--  let ⟨_, c, m⟩ := (<- read).current
+--  let type <- decompileExpr x.type
+--  let const := (.axiomInfo <| Lean.mkAxiomValEx x.name x.levelParams type x.isUnsafe)
+--  insertBlock c m (.single const)
+--| .definition x => do
+--  let ⟨_, c, m⟩ := (<- read).current
+--  let const <- decompileDefn x
+--  insertBlock c m (.single const)
+--| .quotient x => withLevels x.levelParams do
+--  let ⟨_, c, m⟩ := (<- read).current
+--  let type <- decompileExpr x.type
+--  let const := (.quotInfo <| Lean.mkQuotValEx x.name x.levelParams type x.kind)
+--  insertBlock c m (.single const)
+--| .inductiveProj x => ensureBlock x.name x.blockCont x.blockMeta
+--| .constructorProj x => ensureBlock x.induct x.blockCont x.blockMeta
+--| .recursorProj x => ensureBlock x.induct x.blockCont x.blockMeta
+--| .definitionProj x => ensureBlock x.name x.blockCont x.blockMeta
+--| .mutual x => do
+--  let ⟨_, c, m⟩ := (<- read).current
+--  let mutCtx <- decompileMutualCtx x.ctx
+--  withMutCtx mutCtx do
+--    let mut block := #[]
+--    for defns in x.defs do
+--      for defn in defns do
+--        let const <- decompileDefn defn
+--        block := block.push const
+--    insertBlock c m (.mutual block.toList)
+--| .inductive x => do
+--  let ⟨_, c, m⟩ := (<- read).current
+--  let mutCtx <- decompileMutIndCtx x
+--  withMutCtx mutCtx do
+--    let mut block := #[]
+--    for inds in x.inds do
+--      for ind in inds do
+--        let (i, cs, rs) <- decompileIndc ind
+--        block := block.push ⟨i, cs, rs⟩
+--    insertBlock c m (Block.inductive block.toList)
+--
+--end
+--
+--def decompileEnv : DecompileM Unit := do
+--  for (n, (anon, meta)) in (<- read).names do
+--    let _ <- ensureBlock n anon meta
+--
+--end Decompile
diff --git a/Ix/IR.lean b/Ix/IR.lean
index ec745652..54c6de80 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -1,5 +1,6 @@
 import Ix.Common
 import Ix.Address
+import Lean
 
 namespace Ix
 
@@ -93,19 +94,18 @@ and metavariables, and annotate global constant references with Ix.Address
 content-addresses
 --/
 inductive Expr
-  | var   (idx: Nat)
-  | sort  (univ: Level)
-  | const (name: Lean.Name) (ref: Address) (meta: Address) (univs: List Level)
-  | rec_  (name: Lean.Name) (idx: Nat) (univs: List Level)
-  | app   (func: Expr) (argm: Expr)
-  | lam   (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
-  | pi    (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
-  | letE  (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
-  | lit   (lit: Lean.Literal)
-  | proj  (typeName: Lean.Name) (typeCont: Address) (typeMeta: Address) (idx: Nat) (struct: Expr)
+  | var   (mdata: List Address) (idx: Nat)
+  | sort  (mdata: List Address) (univ: Level)
+  | const (mdata: List Address) (name: Lean.Name) (ref: MetaAddress) (univs: List Level)
+  | rec_  (mdata: List Address) (name: Lean.Name) (idx: Nat) (univs: List Level)
+  | app   (mdata: List Address) (func: Expr) (argm: Expr)
+  | lam   (mdata: List Address) (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
+  | pi    (mdata: List Address) (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
+  | letE  (mdata: List Address) (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
+  | lit   (mdata: List Address) (lit: Lean.Literal)
+  | proj  (mdata: List Address) (typeName: Lean.Name) (type: MetaAddress) (idx: Nat) (struct: Expr)
   deriving Inhabited, Ord, BEq, Repr, Hashable
 
-
 /--
 Ix.Quotient quotients are analogous to Lean.QuotVal
 --/
@@ -117,8 +117,7 @@ structure Quotient where
   deriving Ord, BEq, Hashable, Repr, Nonempty
 
 /--
-Ix.Axiom axioms are analogous to Lean.AxiomVal, differing only in not including
-the `isUnsafe` parameter, as Ix constants are never unsafe
+Ix.Axiom axioms are analogous to Lean.AxiomVal
 --/
 structure Axiom where
   name: Lean.Name
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index f4cbfbcd..e8056ee8 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -1,339 +1,1037 @@
 import Std.Data.HashMap
 import Ix.Address
-import Ix.Ixon.Serialize
-import Ix.Ixon.Univ
-import Ix.Claim
-import Ix.Ixon.Tag
-import Ix.Ixon.Const
-import Ix.Ixon.Metadata
+import Lean.Declaration
+import Lean.Data.KVMap
 
 namespace Ixon
 
-inductive Ixon where
-| vari : UInt64 -> Ixon                       -- 0x0X, variables
-| sort : Univ -> Ixon                         -- 0x90, universes
-| refr : Address -> List Univ -> Ixon         -- 0x1X, global reference
-| recr : UInt64 -> List Univ -> Ixon          -- 0x2X, local recursion
-| apps : Ixon -> Ixon -> List Ixon -> Ixon    -- 0x3X, function application
-| lams : List Ixon -> Ixon -> Ixon            -- 0x4X, lambda abstraction
-| alls : List Ixon -> Ixon -> Ixon            -- 0x5X, universal quantification
-| proj : Address -> UInt64 -> Ixon -> Ixon    -- 0x6X, structure projection
-| strl : String -> Ixon                       -- 0x7X, utf8 string
-| natl : Nat -> Ixon                          -- 0x8X, natural number
-| letE : Bool -> Ixon -> Ixon -> Ixon -> Ixon -- 0x91, 0x92 let expression
-| list : List Ixon -> Ixon                    -- 0xAX, list
-| defn : Definition -> Ixon                   -- 0xB0, definition
-| axio : Axiom -> Ixon                        -- 0xB1, axiom
-| quot : Quotient -> Ixon                     -- 0xB2, quotient
-| cprj : ConstructorProj -> Ixon              -- 0xB3, ctor projection
-| rprj : RecursorProj -> Ixon                 -- 0xB4, recr projection
-| iprj : InductiveProj -> Ixon                -- 0xB5, indc projection
-| dprj : DefinitionProj -> Ixon               -- 0xB6, defn projection
-| inds : List Inductive -> Ixon               -- 0xCX, mutual inductive types
-| defs : List Definition -> Ixon              -- 0xDX, mutual definitions
-| meta : Metadata -> Ixon                     -- 0xE0, Lean4 metadata
-| prof : Proof -> Ixon                        -- 0xE1, zero-knowledge proof
-| eval : EvalClaim -> Ixon                    -- 0xE2, cryptographic claim
-| chck : CheckClaim -> Ixon                   -- 0xE3, cryptographic claim
-| comm : Comm -> Ixon                         -- 0xE4, cryptographic commitment
-| envn : Env -> Ixon                         -- 0xE5, Lean4 environment
-deriving BEq, Repr, Inhabited
+-- putter monad
+abbrev PutM := StateM ByteArray
 
-abbrev Store := Std.HashMap Address Ixon
+structure GetState where
+  idx : Nat := 0
+  bytes : ByteArray := .empty
 
-open Serialize
+-- getter monad
+abbrev GetM := EStateM String GetState
 
-partial def putIxon : Ixon -> PutM Unit
-| .vari i => put (Tag4.mk 0x0 i)
-| .sort u => put (Tag4.mk 0x9 0x0) *> put u
-| .refr a lvls => do
-  put (Tag4.mk 0x1 lvls.length.toUInt64) *> put a *> putMany putUniv lvls
-| .recr i lvls => put (Tag4.mk 0x2 i) *> putList lvls
-| .apps f a as => do
-  put (Tag4.mk 0x3 as.length.toUInt64)
-  putIxon f *> putIxon a *> putMany putIxon as
-| .lams ts b => do
-  put (Tag4.mk 0x4 ts.length.toUInt64) *> putMany putIxon ts *> putIxon b
-| .alls ts b => do
-  put (Tag4.mk 0x5 ts.length.toUInt64) *> putMany putIxon ts *> putIxon b
-| .letE nD t d b => do
-  if nD then put (Tag4.mk 0x9 0x1) else put (Tag4.mk 0x9 0x2)
-  putIxon t *> putIxon d *> putIxon b
-| .proj t n x => put (Tag4.mk 0x6 n) *> putBytes t.hash *> putIxon x
-| .strl s => putString s -- 0x7
-| .natl n => putNat n -- 0x8
-| .list xs => do
-  put (Tag4.mk 0xA xs.length.toUInt64)
-  List.forM xs putIxon
-| .defn x => put (Tag4.mk 0xB 0x0) *> put x
-| .axio x => put (Tag4.mk 0xB 0x1) *> put x
-| .quot x => put (Tag4.mk 0xB 0x2) *> put x
-| .cprj x => put (Tag4.mk 0xB 0x3) *> put x
-| .rprj x => put (Tag4.mk 0xB 0x4) *> put x
-| .iprj x => put (Tag4.mk 0xB 0x5) *> put x
-| .dprj x => put (Tag4.mk 0xB 0x6) *> put x
-| .inds xs => put (Tag4.mk 0xC xs.length.toUInt64) *> putMany put xs
-| .defs xs => put (Tag4.mk 0xD xs.length.toUInt64) *> putMany put xs
-| .meta x => put (Tag4.mk 0xE 0x0) *> put x
-| .prof x => put (Tag4.mk 0xE 0x1) *> put x
-| .eval x => put (Tag4.mk 0xE 0x2) *> put x
-| .chck x => put (Tag4.mk 0xE 0x3) *> put x
-| .comm x => put (Tag4.mk 0xE 0x4) *> put x
-| .envn x => put (Tag4.mk 0xE 0x5) *> put x
+-- serialization typeclass
+class Serialize (α : Type) where
+  put : α → PutM Unit
+  get : GetM α
 
-def getIxon : GetM Ixon := do
-  let st ← MonadState.get
-  go (st.bytes.size - st.idx)
-  where
-    go : Nat → GetM Ixon
-    | 0 => throw "Out of fuel"
-    | Nat.succ f => do
-      let tag <- getTag4
-      match tag with
-      | ⟨0x0, x⟩ => pure <| .vari x
-      | ⟨0x9, 0⟩ => .sort <$> getUniv
-      | ⟨0x1, x⟩ => .refr <$> get <*> getMany x getUniv
-      | ⟨0x2, x⟩ => .recr <$> pure x <*> get
-      | ⟨0x3, x⟩ => .apps <$> go f <*> go f <*> getMany x (go f)
-      | ⟨0x4, x⟩ => .lams <$> getMany x (go f) <*> go f
-      | ⟨0x5, x⟩ => .alls <$> getMany x (go f) <*> go f
-      | ⟨0x9, 1⟩ => .letE true <$> go f <*> go f <*> go f
-      | ⟨0x9, 2⟩ => .letE false <$> go f <*> go f <*> go f
-      | ⟨0x6, x⟩ => .proj <$> get <*> pure x <*> go f
-      | ⟨0x7, _⟩ => .strl <$> getString' tag
-      | ⟨0x8, _⟩ => .natl <$> getNat' tag
-      | ⟨0xA, x⟩ => .list <$> getMany x (go f)
-      | ⟨0xB, 0x0⟩ => .defn <$> get
-      | ⟨0xB, 0x1⟩ => .axio <$> get
-      | ⟨0xB, 0x2⟩ => .quot <$> get
-      | ⟨0xB, 0x3⟩ => .cprj <$> get
-      | ⟨0xB, 0x4⟩ => .rprj <$> get
-      | ⟨0xB, 0x5⟩ => .iprj <$> get
-      | ⟨0xB, 0x6⟩ => .dprj <$> get
-      | ⟨0xC, x⟩ => .inds <$> getMany x get
-      | ⟨0xD, x⟩ => .defs <$> getMany x get
-      | ⟨0xE, 0x0⟩ => .meta <$> get
-      | ⟨0xE, 0x1⟩ => .prof <$> get
-      | ⟨0xE, 0x2⟩ => .eval <$> get
-      | ⟨0xE, 0x3⟩ => .chck <$> get
-      | ⟨0xE, 0x4⟩ => .comm <$> get
-      | ⟨0xE, 0x5⟩ => .envn <$> get
-      | x => throw s!"Unknown Ixon tag {repr x}"
+def runPut (p: PutM Unit) : ByteArray := (p.run ByteArray.empty).2
 
-instance : Serialize Ixon where
-  put := putIxon
-  get := getIxon
+def runGet (getm: GetM A) (bytes: ByteArray) : Except String A :=
+  match getm.run { idx := 0, bytes } with
+  | .ok a _ => .ok a
+  | .error e _ => .error e
+
+def ser [Serialize α] (a: α): ByteArray := runPut (Serialize.put a)
+def de [Serialize α] (bytes: ByteArray): Except String α := 
+  runGet Serialize.get bytes
+
+def putUInt8 (x: UInt8) : PutM Unit :=
+  StateT.modifyGet (fun s => ((), s.push x))
+
+def getUInt8 : GetM UInt8 := do
+  let st ← get
+  if st.idx < st.bytes.size then
+    let b := st.bytes[st.idx]!
+    set { st with idx := st.idx + 1 }
+    return b
+  else
+    throw "EOF"
+
+instance : Serialize UInt8 where
+  put := putUInt8
+  get := getUInt8
+
+def putUInt16LE (x: UInt16) : PutM Unit := do
+  List.forM (List.range 2) fun i =>
+    let b := UInt16.toUInt8 (x >>> (i.toUInt16 * 8))
+    putUInt8 b
+  pure ()
+
+def getUInt16LE : GetM UInt16 := do
+  let mut x : UInt16 := 0
+  for i in List.range 2 do
+    let b ← getUInt8
+    x := x + (UInt8.toUInt16 b) <<< ((UInt16.ofNat i) * 8)
+  pure x
+
+instance : Serialize UInt16 where
+  put := putUInt16LE
+  get := getUInt16LE
+
+def putUInt32LE (x: UInt32) : PutM Unit := do
+  List.forM (List.range 4) fun i =>
+    let b := UInt32.toUInt8 (x >>> (i.toUInt32 * 8))
+    putUInt8 b
+  pure ()
+
+def getUInt32LE : GetM UInt32 := do
+  let mut x : UInt32 := 0
+  for i in List.range 4 do
+    let b ← getUInt8
+    x := x + (UInt8.toUInt32 b) <<< ((UInt32.ofNat i) * 8)
+  pure x
+
+instance : Serialize UInt32 where
+  put := putUInt32LE
+  get := getUInt32LE
+
+def putUInt64LE (x: UInt64) : PutM Unit := do
+  List.forM (List.range 8) fun i =>
+    let b := UInt64.toUInt8 (x >>> (i.toUInt64 * 8))
+    putUInt8 b
+  pure ()
+
+def getUInt64LE : GetM UInt64 := do
+  let mut x : UInt64 := 0
+  for i in List.range 8 do
+    let b ← getUInt8
+    x := x + (UInt8.toUInt64 b) <<< ((UInt64.ofNat i) * 8)
+  pure x
+
+instance : Serialize UInt64 where
+  put := putUInt64LE
+  get := getUInt64LE
+
+def putBytes (x: ByteArray) : PutM Unit :=
+  StateT.modifyGet (fun s => ((), s.append x))
+
+def getBytesToEnd : GetM ByteArray := do
+  let st ← get
+  return st.bytes
+
+def getBytes (len: Nat) : GetM ByteArray := do
+  let st ← get
+  if st.idx + len <= st.bytes.size then
+    let chunk := st.bytes.extract st.idx (st.idx + len)
+    set { st with idx := st.idx + len }
+    return chunk
+  else throw s!"EOF: need {len} bytes at index {st.idx}, but size is {st.bytes.size}"
+
+
+--  F := flag, L := large-bit, X := small-field, A := large_field
+-- 0xFFFF_LXXX {AAAA_AAAA, ...}
+-- "Tag" means the whole thing
+-- "Head" means the first byte of the tag
+-- "Flag" means the first nibble of the head
+structure Tag4 where
+  flag: Fin 16
+  size: UInt64
+  deriving Inhabited, Repr, BEq, Hashable
+
+def Tag4.encodeHead (tag: Tag4): UInt8 :=
+  let t := UInt8.shiftLeft (UInt8.ofNat tag.flag.val) 4
+  if tag.size < 8
+  then t + tag.size.toUInt8
+  else t + 0b1000 + (tag.size.byteCount - 1)
+
+def flag4_to_Fin16 (x: UInt8) : Fin 16 :=
+  ⟨ x.toNat / 16, by
+      have h256 : x.toNat < 256 := UInt8.toNat_lt x
+      have h : x.toNat < 16 * 16 := by simpa using h256
+      exact (Nat.div_lt_iff_lt_mul (by decide)).mpr h
+  ⟩
+
+def Tag4.decodeHead (head: UInt8) : (Fin 16 × Bool × UInt8) :=
+  let flag : Fin 16 := flag4_to_Fin16 head
+  let largeBit := UInt8.land head 0b1000 != 0
+  let small := if flag == 0xC then head % 0b10000 else head % 0b1000
+  (flag, largeBit, small)
+
+def getTagSize (large: Bool) (small: UInt8) : GetM UInt64 := do
+  if large then (UInt64.fromTrimmedLE ·.data) <$> getBytes (small.toNat + 1)
+  else return small.toNat.toUInt64
+
+def putTag4 (tag: Tag4) : PutM Unit := do
+  putUInt8 (Tag4.encodeHead tag)
+  if tag.size < 8
+  then pure ()
+  else putBytes (.mk (UInt64.trimmedLE tag.size))
+
+def getTag4 : GetM Tag4 := do
+  let (flag, largeBit, small) <- Tag4.decodeHead <$> getUInt8
+  let size <- getTagSize largeBit small
+  pure (Tag4.mk flag size)
+
+instance : Serialize Tag4 where
+  put := putTag4
+  get := getTag4
+
+def putList [Serialize A] (xs : List A) : PutM Unit := do
+  Serialize.put (Tag4.mk 0xA (UInt64.ofNat xs.length))
+  List.forM xs Serialize.put
+
+def getList [Serialize A] : GetM (List A) := do
+  let tag : Tag4 <- Serialize.get
+  match tag with
+  | ⟨0xA, size⟩ => do
+    List.mapM (λ _ => Serialize.get) (List.range size.toNat)
+  | e => throw s!"expected List with tag 0xA, got {repr e}"
+
+instance [Serialize A] : Serialize (List A) where
+  put := putList
+  get := getList
+
+def putBytesTagged (x: ByteArray) : PutM Unit := Serialize.put x.toList
+def getBytesTagged : GetM ByteArray := (.mk ∘ .mk) <$> Serialize.get
+
+instance : Serialize ByteArray where
+  put := putBytesTagged
+  get := getBytesTagged
+
+def putMany {A: Type} (put : A -> PutM Unit) (xs: List A) : PutM Unit := 
+  List.forM xs put
+
+def getMany {A: Type} (x: Nat) (getm : GetM A) : GetM (List A) :=
+  (List.range x).mapM (fun _ => getm)
+
+def puts {A: Type} [Serialize A] (xs: List A) : PutM Unit := 
+  putMany Serialize.put xs
+
+def gets {A: Type} [Serialize A] (x: Nat) : GetM (List A) :=
+  getMany x Serialize.get
+
+-- parameterized on a way to put a ByteArray
+def putString (put: ByteArray -> PutM Unit) (x: String) : PutM Unit :=
+  put x.toUTF8
+
+def getString (get: GetM ByteArray) : GetM String := do
+  let bytes <- get
+  match String.fromUTF8? bytes with
+  | .some s => return s
+  | .none => throw s!"invalid UTF8 bytes {bytes}"
+
+instance : Serialize String where
+  put := putString putBytesTagged
+  get := getString getBytesTagged
+
+-- parameterized on a way to put a ByteArray
+def putNat (put: ByteArray -> PutM Unit) (x: Nat) : PutM Unit :=
+  let bytes := x.toBytesLE
+  put { data := bytes }
+
+def getNat (get: GetM ByteArray) : GetM Nat := do
+  let bytes <- get
+  return Nat.fromBytesLE bytes.data
+
+instance : Serialize Nat where
+  put := putNat putBytesTagged
+  get := getNat getBytesTagged
+
+def putBool : Bool → PutM Unit
+| .false => putUInt8 0
+| .true => putUInt8 1
+
+def getBool : GetM Bool := do
+  match (← getUInt8) with
+  | 0 => return .false
+  | 1 => return .true
+  | e => throw s!"expected Bool encoding between 0 and 1, got {e}"
+
+instance : Serialize Bool where
+  put := putBool
+  get := getBool
+
+def packBools (bools : List Bool) : UInt8 :=
+  List.foldl
+    (λ acc (b, i) => acc ||| (if b then 1 <<< UInt8.ofNat i else 0))
+    0
+    ((bools.take 8).zipIdx 0)
+
+def unpackBools (n: Nat) (b: UInt8) : List Bool :=
+  ((List.range 8).map (λ i => (b &&& (1 <<< UInt8.ofNat i)) != 0)).take n
+
+def putBools: List Bool → PutM Unit := putUInt8 ∘ packBools
+def getBools (n: Nat): GetM (List Bool) := unpackBools n <$> getUInt8
+
+instance (priority := default + 100) : Serialize (Bool × Bool) where
+  put := fun (a, b) => putBools [a, b]
+  get := do match (<- getBools 2) with
+    | [a, b] => pure (a, b)
+    | e => throw s!"expected packed (Bool × Bool), got {e}" 
+
+instance (priority := default + 101): Serialize (Bool × Bool × Bool) where
+  put := fun (a, b, c) => putBools [a, b, c]
+  get := do match (<- getBools 3) with
+    | [a, b, c] => pure (a, b, c)
+    | e => throw s!"expected packed (Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 102): Serialize (Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c,d) => putBools [a, b, c, d]
+  get := do match (<- getBools 4) with
+    | [a, b, c, d] => pure (a, b, c, d)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 103): Serialize (Bool × Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c, d, e) => putBools [a, b, c, d, e]
+  get := do match (<- getBools 5) with
+    | [a, b, c, d, e] => pure (a, b, c, d, e)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 104)
+  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c, d, e, f) => putBools [a, b, c, d, e, f]
+  get := do match (<- getBools 6) with
+    | [a, b, c, d, e, f] => pure (a, b, c, d, e, f)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 106)
+  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c, d, e, f, g) => putBools [a, b, c, d, e, f, g]
+  get := do match (<- getBools 7) with
+    | [a, b, c, d, e, f, g] => pure (a, b, c, d, e, f, g)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+
+instance (priority := default + 105)
+  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool) where
+  put := fun (a, b, c, d, e, f, g, h) => putBools [a, b, c, d, e, f, g, h]
+  get := do match (<- getBools 8) with
+    | [a, b, c, d, e, f, g, h] => pure (a, b, c, d, e, f, g, h)
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+
+def putQuotKind : Lean.QuotKind → PutM Unit
+| .type => putUInt8 0
+| .ctor => putUInt8 1
+| .lift => putUInt8 2
+| .ind => putUInt8 3
+
+def getQuotKind : GetM Lean.QuotKind := do
+  match (← getUInt8) with
+  | 0 => return .type
+  | 1 => return .ctor
+  | 2 => return .lift
+  | 3 => return .ind
+  | e => throw s!"expected QuotKind encoding between 0 and 3, got {e}"
+
+instance : Serialize Lean.QuotKind where
+  put := putQuotKind
+  get := getQuotKind
+
+def putDefKind : Ix.DefKind → PutM Unit
+| .«definition» => putUInt8 0
+| .«opaque» => putUInt8 1
+| .«theorem» => putUInt8 2
+
+def getDefKind : GetM Ix.DefKind := do
+  match (← getUInt8) with
+  | 0 => return .definition
+  | 1 => return .opaque
+  | 2 => return .theorem
+  | e => throw s!"expected DefKind encoding between 0 and 3, got {e}"
+
+instance : Serialize Ix.DefKind where
+  put := putDefKind
+  get := getDefKind
+
+def putBinderInfo : Lean.BinderInfo → PutM Unit
+| .default => putUInt8 0
+| .implicit => putUInt8 1
+| .strictImplicit => putUInt8 2
+| .instImplicit => putUInt8 3
+
+def getBinderInfo : GetM Lean.BinderInfo := do
+  match (← getUInt8) with
+  | 0 => return .default
+  | 1 => return .implicit
+  | 2 => return .strictImplicit
+  | 3 => return .instImplicit
+  | e => throw s!"expected BinderInfo encoding between 0 and 3, got {e}"
+
+instance : Serialize Lean.BinderInfo where
+  put := putBinderInfo
+  get := getBinderInfo
+
+def putReducibilityHints : Lean.ReducibilityHints → PutM Unit
+| .«opaque» => putUInt8 0
+| .«abbrev» => putUInt8 1
+| .regular x => putUInt8 2 *> putUInt32LE x
+
+def getReducibilityHints : GetM Lean.ReducibilityHints := do
+  match (← getUInt8) with
+  | 0 => return .«opaque»
+  | 1 => return .«abbrev» 
+  | 2 => .regular <$> getUInt32LE
+  | e => throw s!"expected ReducibilityHints encoding between 0 and 2, got {e}"
 
-section FFI
+instance : Serialize Lean.ReducibilityHints where
+  put := putReducibilityHints
+  get := getReducibilityHints
 
-/--
-# Ixon FFI types
+def putDefinitionSafety : Lean.DefinitionSafety → PutM Unit
+| .«unsafe» => putUInt8 0
+| .«safe» => putUInt8 1
+| .«partial» => putUInt8 2
 
-This section defines FFI-friendly versions of the original Ixon datatypes by
-* Replacing `Nat` by `ByteArray` containing the corresponding bytes in LE
-* Replacing `List` by `Array`
-* Replacing maps by `Array`s of pairs
--/
+def getDefinitionSafety : GetM Lean.DefinitionSafety := do
+  match (← getUInt8) with
+  | 0 => return .«unsafe»
+  | 1 => return .«safe»
+  | 2 => return .«partial» 
+  | e => throw s!"expected DefinitionSafety encoding between 0 and 2, got {e}"
 
-@[inline] def nat2Bytes (n : Nat) : ByteArray :=
-  ⟨natToBytesLE n⟩
+instance : Serialize Lean.DefinitionSafety where
+  put := putDefinitionSafety
+  get := getDefinitionSafety
 
-structure DefinitionFFI where
-  kind: Ix.DefKind
+instance [Serialize A] [Serialize B] : Serialize (A × B) where
+  put := fun (a, b) => Serialize.put a *> Serialize.put b
+  get := (·,·) <$> Serialize.get <*> Serialize.get
+
+def putOption [Serialize A]: Option A → PutM Unit
+| .none => Serialize.put ([] : List A)
+| .some x => Serialize.put [x]
+
+def getOption [Serialize A] : GetM (Option A) := do
+  match ← Serialize.get with
+  | [] => return .none
+  | [x] => return .some x
+  | _ => throw s!"Expected Option"
+
+instance [Serialize A] : Serialize (Option A) where
+  put := putOption
+  get := getOption
+
+instance: Serialize Unit where
+  put _ := pure ()
+  get := pure ()
+
+instance : Serialize Address where
+  put x := putBytes x.hash
+  get := Address.mk <$> getBytes 32
+
+instance : Serialize MetaAddress where
+  put x := Serialize.put x.data *> Serialize.put x.meta
+  get := MetaAddress.mk <$> Serialize.get <*> Serialize.get
+
+structure Quotient where
+  kind : Lean.QuotKind
+  lvls : Nat
+  type : Address
+  deriving BEq, Repr
+
+instance : Serialize Quotient where
+  put := fun x => Serialize.put (x.kind, x.lvls, x.type)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
+structure Axiom where
+  isUnsafe: Bool
+  lvls : Nat
+  type : Address
+  deriving BEq, Repr
+
+instance : Serialize Axiom where
+  put := fun x => Serialize.put (x.isUnsafe, x.lvls, x.type)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
+structure Definition where
+  kind : Ix.DefKind
   safety : Lean.DefinitionSafety
-  lvls : ByteArray
+  lvls : Nat
   type : Address
   value : Address
+  deriving BEq, Repr
 
-def Definition.toFFI : Definition → DefinitionFFI
-  | ⟨kind, safety, lvls, type, value⟩ =>
-    ⟨kind, safety, nat2Bytes lvls, type, value⟩
+instance : Serialize Definition where
+  put x := Serialize.put (x.kind, x.safety, x.lvls, x.type, x.value)
+  get := (fun (a,b,c,d,e) => .mk a b c d e) <$> Serialize.get
 
-structure AxiomFFI where
-  lvls : ByteArray
+structure Constructor where
+  isUnsafe: Bool
+  lvls : Nat
+  cidx : Nat
+  params : Nat
+  fields : Nat
   type : Address
+  deriving BEq, Repr
+
+instance : Serialize Constructor where
+  put x := Serialize.put (x.isUnsafe, x.lvls, x.cidx, x.params, x.fields, x.type)
+  get := (fun (a,b,c,d,e,f) => .mk a b c d e f) <$> Serialize.get
+
+structure RecursorRule where
+  fields : Nat
+  rhs : Address
+  deriving BEq, Repr
+
+instance : Serialize RecursorRule where
+  put x := Serialize.put (x.fields, x.rhs)
+  get := (fun (a,b) => .mk a b) <$> Serialize.get
+
+structure Recursor where
+  k : Bool
   isUnsafe: Bool
+  lvls : Nat
+  params : Nat
+  indices : Nat
+  motives : Nat
+  minors : Nat
+  type : Address
+  rules : List RecursorRule
+  deriving BEq, Repr
 
-def Axiom.toFFI : Axiom → AxiomFFI
-  | ⟨isUnsafe, lvls, type⟩ => ⟨nat2Bytes lvls, type, isUnsafe⟩
+instance : Serialize Recursor where
+  put x := Serialize.put ((x.k, x.isUnsafe), x.lvls, x.params, x.indices, x.motives, x.minors, x.type, x.rules)
+  get := (fun ((a,b),c,d,e,f,g,h,i) => .mk a b c d e f g h i) <$> Serialize.get
 
-structure QuotientFFI where
-  lvls : ByteArray
+structure Inductive where
+  recr : Bool
+  refl : Bool
+  isUnsafe: Bool
+  lvls : Nat
+  params : Nat
+  indices : Nat
+  nested : Nat
   type : Address
-  kind : Lean.QuotKind
+  ctors : List Constructor
+  recrs : List Recursor
+  deriving BEq, Repr
 
-def Quotient.toFFI : Quotient → QuotientFFI
-  | ⟨kind, lvls, type⟩ => ⟨nat2Bytes lvls, type, kind⟩
+instance : Serialize Inductive where
+  put x := Serialize.put ((x.recr,x.refl,x.isUnsafe), x.lvls, x.params, x.indices, x.nested, x.type, x.ctors, x.recrs)
+  get := (fun ((a,b,c),d,e,f,g,h,i,j) => .mk a b c d e f g h i j) <$> Serialize.get
 
-structure ConstructorProjFFI where
+structure InductiveProj where
+  idx : Nat
   block : Address
-  idx : ByteArray
-  cidx : ByteArray
+  deriving BEq, Repr
 
-def ConstructorProj.toFFI : ConstructorProj → ConstructorProjFFI
-  | ⟨idx, cidx, block⟩ => ⟨block, nat2Bytes idx, nat2Bytes cidx⟩
+instance : Serialize InductiveProj where
+  put := fun x => Serialize.put (x.idx, x.block)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
 
-structure RecursorProjFFI where
+structure ConstructorProj where
+  idx : Nat
+  cidx : Nat
   block : Address
-  idx : ByteArray
-  ridx : ByteArray
+  deriving BEq, Repr
 
-def RecursorProj.toFFI : RecursorProj → RecursorProjFFI
-  | ⟨idx, ridx, block⟩ => ⟨block, nat2Bytes idx, nat2Bytes ridx⟩
+instance : Serialize ConstructorProj where
+  put := fun x => Serialize.put (x.idx, x.cidx, x.block)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
 
-structure InductiveProjFFI where
+structure RecursorProj where
+  idx : Nat
+  ridx : Nat
   block : Address
-  idx : ByteArray
+  deriving BEq, Repr
 
-def InductiveProj.toFFI : InductiveProj → InductiveProjFFI
-  | ⟨idx, block⟩ => ⟨block, nat2Bytes idx⟩
+instance : Serialize RecursorProj where
+  put := fun x => Serialize.put (x.idx, x.ridx, x.block)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
 
-structure DefinitionProjFFI where
+structure DefinitionProj where
+  idx : Nat
   block : Address
-  idx : ByteArray
+  deriving BEq, Repr
 
-def DefinitionProj.toFFI : DefinitionProj → DefinitionProjFFI
-  | ⟨idx, block⟩ => ⟨block, nat2Bytes idx⟩
+instance : Serialize DefinitionProj where
+  put := fun x => Serialize.put (x.idx, x.block)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
 
-structure RecursorRuleFFI where
-  fields : ByteArray
-  rhs : Address
+structure Comm where
+  secret : Address
+  payload : Address
+  deriving BEq, Repr
 
-def RecursorRule.toFFI : RecursorRule → RecursorRuleFFI
-  | ⟨fields, rhs⟩ => ⟨nat2Bytes fields, rhs⟩
+instance : Serialize Comm where
+  put := fun x => Serialize.put (x.secret, x.payload)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
 
-structure RecursorFFI where
-  lvls : ByteArray
-  type : Address
-  params : ByteArray
-  indices : ByteArray
-  motives : ByteArray
-  minors : ByteArray
-  rules : Array RecursorRuleFFI
-  k : Bool
-  isUnsafe: Bool
+structure Env where
+  env : List MetaAddress
+  deriving BEq, Repr
 
-def Recursor.toFFI : Recursor → RecursorFFI
-  | ⟨k, isUnsafe, lvls, params, indices, motives, minors, type, rules⟩ =>
-    ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
-      nat2Bytes motives, nat2Bytes minors, rules.toArray.map RecursorRule.toFFI,
-      k, isUnsafe⟩
+instance : Serialize Env where
+  put x := Serialize.put x.env
+  get := .mk <$> Serialize.get
 
-structure ConstructorFFI where
-  lvls : ByteArray
+structure EvalClaim where
+  lvls : Address
+  input: Address
+  output: Address
   type : Address
-  cidx : ByteArray
-  params : ByteArray
-  fields : ByteArray
-  isUnsafe: Bool
-
-def Constructor.toFFI : Constructor → ConstructorFFI
-  | ⟨isUnsafe, lvls, cidx, params, fields, type⟩ =>
-    ⟨nat2Bytes lvls, type, nat2Bytes cidx, nat2Bytes params, nat2Bytes fields, isUnsafe⟩
+deriving BEq, Repr, Inhabited
 
-structure InductiveFFI where
-  lvls : ByteArray
+structure CheckClaim where
+  lvls : Address
   type : Address
-  params : ByteArray
-  indices : ByteArray
-  ctors : Array ConstructorFFI
-  recrs : Array RecursorFFI
-  nested : ByteArray
-  recr : Bool
-  refl : Bool
-  isUnsafe: Bool
+  value : Address
+deriving BEq, Repr, Inhabited
+
+inductive Claim where
+| evals : EvalClaim -> Claim
+| checks : CheckClaim -> Claim
+deriving BEq, Repr, Inhabited
+
+instance : ToString CheckClaim where
+  toString x := s!"#{x.value} : #{x.type} @ #{x.lvls}"
+
+instance : ToString EvalClaim where
+  toString x := s!"#{x.input} ~> #{x.output} : #{x.type} @ #{x.lvls}"
+
+instance : ToString Claim where
+  toString
+  | .checks x => toString x
+  | .evals x => toString x
+
+
+instance : Serialize CheckClaim where
+  put x := Serialize.put (x.lvls, x.type, x.value)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
+instance : Serialize EvalClaim where
+  put x := Serialize.put (x.lvls, x.input, x.output, x.type)
+  get := (fun (w,x,y,z) => .mk w x y z) <$> Serialize.get
+
+instance : Serialize Claim where
+  put
+  | .evals x => putTag4 ⟨0xE, 1⟩ *> Serialize.put x
+  | .checks x => putTag4 ⟨0xE, 2⟩ *> Serialize.put x
+  get := do match <- getTag4 with
+  | ⟨0xE,1⟩ => .evals <$> Serialize.get
+  | ⟨0xE,2⟩ => .checks <$> Serialize.get
+  | e => throw s!"expected Claim with tag 0xE2 or 0xE3, got {repr e}"
+
+structure Proof where
+  claim: Claim
+  /-- Bytes of the Binius proof -/
+  bin : ByteArray
+  deriving Inhabited, BEq
+
+instance : ToString Proof where
+  toString p := s!"<{toString p.claim} := {hexOfBytes p.bin}>"
+
+instance : Repr Proof where
+  reprPrec p _ := toString p
+
+instance : Serialize Proof where
+  put := fun x => Serialize.put (x.claim, x.bin)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
+
+inductive Metadatum where
+| name : Address -> Metadatum
+| info : Lean.BinderInfo -> Metadatum
+| link : Address -> Metadatum
+| hints : Lean.ReducibilityHints -> Metadatum
+| all : List Address -> Metadatum
+| mutCtx : List (List Address) -> Metadatum
+| kvmap : Address -> Metadatum
+deriving BEq, Repr, Ord, Inhabited
+
+structure Metadata where
+  nodes: List Metadatum
+  deriving BEq, Repr, Inhabited
+
+open Serialize
+
+def putMetadatum : Metadatum → PutM Unit
+| .name n => putUInt8 0 *> put n
+| .info i => putUInt8 1 *> putBinderInfo i
+| .link l => putUInt8 2 *> putBytes l.hash
+| .hints h => putUInt8 3 *> putReducibilityHints h
+| .all ns => putUInt8 4 *> put ns
+| .mutCtx ctx => putUInt8 5 *> put ctx
+| .kvmap ctx => putUInt8 6 *> put ctx
+
+def getMetadatum : GetM Metadatum := do
+  match (<- getUInt8) with
+  | 0 => .name <$> get
+  | 1 => .info <$> get
+  | 2 => .link <$> (.mk <$> getBytes 32)
+  | 3 => .hints <$> get
+  | 4 => .all <$> get
+  | 5 => .mutCtx <$> get
+  | 6 => .kvmap <$> get
+  | e => throw s!"expected Metadatum encoding between 0 and 6, got {e}"
+
+instance : Serialize Metadatum where
+  put := putMetadatum
+  get := getMetadatum
+
+instance : Serialize Metadata where
+  put m := put (Tag4.mk 0xF m.nodes.length.toUInt64) *> putMany put m.nodes
+  get := do
+    let tag <- getTag4
+    match tag with
+    | ⟨0xF, x⟩ => do
+      let nodes <- getMany x.toNat Serialize.get
+      return ⟨nodes⟩
+    | x => throw s!"Expected metadata tag, got {repr x}"
+
+-- TODO: update docs
+/-- The core content-addressing datatype. The wire format is divided into
+several sections:
+1. 0x00 through 0x3F are dynamic expression objects with variable size. The
+   low nibble in the byte changes depending on the size of the expression.
+2. 0x40 through 0x8F are reserved for future dynamic objects
+3. 0x90 through 0x97 are static expression objects
+4. 0x98 through 0x9F are reserved for future static expression objects
+5. 0xA0 through 0xAF are dynamic lists of objects
+6. 0xB0 through 0xB7 are static constant (as in Lean.ConstantInfo) objects
+6. 0xC0 through 0xDf are dynamic constant objects
+7. 0xE0 through 0xE7 are addtional static objects
+8. 0xF0 thtrouh 0xFF are reserved for future objects
+--/
+inductive Ixon where
+| nanon : Ixon                                          -- 0x00 anon name
+| nstr  : Address -> Address -> Ixon                    -- 0x01 str name
+| nnum  : Address -> Address -> Ixon                    -- 0x02 num name
+| uzero : Ixon                                          -- 0x03 univ zero
+| usucc : Address -> Ixon                               -- 0x04 univ succ
+| umax  : Address -> Address -> Ixon                    -- 0x05 univ max
+| uimax : Address -> Address -> Ixon                    -- 0x06 univ imax
+| uvar  : Nat -> Ixon                                   -- 0x1X
+| evar  : Nat -> Ixon                                   -- 0x2X, variables
+| eref  : Address -> List Address -> Ixon               -- 0x3X, global reference
+| erec  : Nat -> List Address -> Ixon                   -- 0x4X, local recursion
+| eprj  : Address -> Nat -> Address -> Ixon             -- 0x5X, structure projection
+| esort : Address -> Ixon                               -- 0x90, universes
+| estr  : Address -> Ixon                               -- 0x91, utf8 string
+| enat  : Address -> Ixon                               -- 0x92, natural number
+| eapp  : Address -> Address -> Ixon                    -- 0x93, application
+| elam  : Address -> Address -> Ixon                    -- 0x94, lambda
+| eall  : Address -> Address -> Ixon                    -- 0x95, forall
+| elet  : Bool -> Address -> Address -> Address -> Ixon -- 0x96, 0x97, let
+| list : List Ixon -> Ixon                              -- 0xAX, list
+| defn : Definition -> Ixon                             -- 0xB0, definition
+| axio : Axiom -> Ixon                                  -- 0xB1, axiom
+| quot : Quotient -> Ixon                               -- 0xB2, quotient
+| cprj : ConstructorProj -> Ixon                        -- 0xB3, ctor projection
+| rprj : RecursorProj -> Ixon                           -- 0xB4, recr projection
+| iprj : InductiveProj -> Ixon                          -- 0xB5, indc projection
+| dprj : DefinitionProj -> Ixon                         -- 0xB6, defn projection
+| inds : List Inductive -> Ixon                         -- 0xCX, mutual inductive types
+| defs : List Definition -> Ixon                        -- 0xDX, mutual definitions
+| prof : Proof -> Ixon                                  -- 0xE0, zero-knowledge proof
+| eval : EvalClaim -> Ixon                              -- 0xE1, cryptographic claim
+| chck : CheckClaim -> Ixon                             -- 0xE2, cryptographic claim
+| comm : Comm -> Ixon                                   -- 0xE3, cryptographic commitment
+| envn : Env -> Ixon                                    -- 0xE4, Lean4 environment
+| meta : Metadata -> Ixon                               -- 0xFX, Lean4 metadata
+deriving BEq, Repr, Inhabited
+
+--abbrev Store := Std.HashMap Address ByteArray
+
+partial def putIxon : Ixon -> PutM Unit
+| .nanon => put (Tag4.mk 0x0 0)
+| .nstr n s => put (Tag4.mk 0x0 1) *> put n *> put s
+| .nnum n i => put (Tag4.mk 0x0 2) *> put n *> put i
+| .uzero => put (Tag4.mk 0x0 3)
+| .usucc u => put (Tag4.mk 0x0 4) *> put u
+| .umax x y => put (Tag4.mk 0x0 5) *> put x *> put y
+| .uimax x y => put (Tag4.mk 0x0 6) *> put x *> put y
+| .uvar x => 
+  let bytes := x.toBytesLE
+  put (Tag4.mk 0x1 bytes.size.toUInt64) *> putBytes ⟨bytes⟩
+| .evar x =>
+  let bytes := x.toBytesLE
+  put (Tag4.mk 0x2 bytes.size.toUInt64) *> putBytes ⟨bytes⟩
+| .eref a ls => put (Tag4.mk 0x3 ls.length.toUInt64) *> put a *> puts ls
+| .erec i ls =>
+  let bytes := i.toBytesLE
+  put (Tag4.mk 0x4 bytes.size.toUInt64) *> putBytes ⟨bytes⟩ *> putList ls
+| .eprj t n x =>
+  let bytes := n.toBytesLE
+  put (Tag4.mk 0x5 bytes.size.toUInt64) *> putBytes ⟨bytes⟩ *> putBytes t.hash *> put x
+| .esort u => put (Tag4.mk 0x9 0x0) *> put u
+| .estr s => put (Tag4.mk 0x9 0x1) *> put s
+| .enat n => put (Tag4.mk 0x9 0x2) *> put n
+| .eapp f a => put (Tag4.mk 0x9 0x3) *> put f *> put a
+| .elam t b => put (Tag4.mk 0x9 0x4) *> put t *> put b
+| .eall t b => put (Tag4.mk 0x9 0x5) *> put t *> put b
+| .elet nD t d b => if nD
+  then put (Tag4.mk 0x9 0x6) *> put t *> put d *> put b
+  else put (Tag4.mk 0x9 0x7) *> put t *> put d *> put b
+| .list xs => put (Tag4.mk 0xA xs.length.toUInt64) *> (List.forM xs putIxon)
+| .defn x => put (Tag4.mk 0xB 0x0) *> put x
+| .axio x => put (Tag4.mk 0xB 0x1) *> put x
+| .quot x => put (Tag4.mk 0xB 0x2) *> put x
+| .cprj x => put (Tag4.mk 0xB 0x3) *> put x
+| .rprj x => put (Tag4.mk 0xB 0x4) *> put x
+| .iprj x => put (Tag4.mk 0xB 0x5) *> put x
+| .dprj x => put (Tag4.mk 0xB 0x6) *> put x
+| .inds xs => put (Tag4.mk 0xC xs.length.toUInt64) *> puts xs
+| .defs xs => put (Tag4.mk 0xD xs.length.toUInt64) *> puts xs
+| .prof x => put (Tag4.mk 0xE 0x1) *> put x
+| .eval x => put (Tag4.mk 0xE 0x2) *> put x
+| .chck x => put (Tag4.mk 0xE 0x3) *> put x
+| .comm x => put (Tag4.mk 0xE 0x4) *> put x
+| .envn x => put (Tag4.mk 0xE 0x5) *> put x
+| .meta m => put m
+
+def getIxon : GetM Ixon := do
+  let st ← MonadState.get
+  go (st.bytes.size - st.idx)
+  where
+    go : Nat → GetM Ixon
+    | 0 => throw "Out of fuel"
+    | Nat.succ f => do
+      let tag <- getTag4
+      match tag with
+      | ⟨0x0, 0⟩ => pure <| .nanon
+      | ⟨0x0, 1⟩ => .nstr <$> get <*> get
+      | ⟨0x0, 2⟩ => .nnum <$> get <*> get
+      | ⟨0x0, 3⟩ => pure <| .uzero
+      | ⟨0x0, 4⟩ => .usucc <$> get
+      | ⟨0x0, 5⟩ => .umax <$> get <*> get
+      | ⟨0x0, 6⟩ => .uimax <$> get <*> get
+      | ⟨0x1, x⟩ => .uvar <$> getNat (getBytes x.toNat)
+      | ⟨0x2, x⟩ => .evar <$> getNat (getBytes x.toNat)
+      | ⟨0x3, x⟩ => .eref <$> get <*> gets x.toNat
+      | ⟨0x4, x⟩ => .erec <$> getNat (getBytes x.toNat) <*> get
+      | ⟨0x5, x⟩ => .eprj <$> get <*> getNat (getBytes x.toNat) <*> get
+      | ⟨0x9, 0⟩ => .esort <$> get
+      | ⟨0x9, 1⟩ => .estr <$> get
+      | ⟨0x9, 2⟩ => .enat <$> get
+      | ⟨0x9, 3⟩ => .eapp <$> get <*> get
+      | ⟨0x9, 4⟩ => .elam <$> get <*> get
+      | ⟨0x9, 5⟩ => .eall <$> get <*> get
+      | ⟨0x9, 6⟩ => .elet true <$> get <*> get <*> get
+      | ⟨0x9, 7⟩ => .elet false <$> get <*> get <*> get
+      | ⟨0xA, x⟩ => .list <$> getMany x.toNat (go f)
+      | ⟨0xB, 0x0⟩ => .defn <$> get
+      | ⟨0xB, 0x1⟩ => .axio <$> get
+      | ⟨0xB, 0x2⟩ => .quot <$> get
+      | ⟨0xB, 0x3⟩ => .cprj <$> get
+      | ⟨0xB, 0x4⟩ => .rprj <$> get
+      | ⟨0xB, 0x5⟩ => .iprj <$> get
+      | ⟨0xB, 0x6⟩ => .dprj <$> get
+      | ⟨0xC, x⟩ => .inds <$> getMany x.toNat get
+      | ⟨0xD, x⟩ => .defs <$> getMany x.toNat get
+      | ⟨0xE, 0x0⟩ => .prof <$> get
+      | ⟨0xE, 0x1⟩ => .eval <$> get
+      | ⟨0xE, 0x2⟩ => .chck <$> get
+      | ⟨0xE, 0x3⟩ => .comm <$> get
+      | ⟨0xE, 0x4⟩ => .envn <$> get
+      | ⟨0xF, x⟩ => do
+        let nodes <- getMany x.toNat Serialize.get
+        return .meta ⟨nodes⟩
+      | x => throw s!"Unknown Ixon tag {repr x}"
+
+instance : Serialize Ixon where
+  put := putIxon
+  get := getIxon
 
-def Inductive.toFFI : Inductive → InductiveFFI
-  | ⟨recr, refl, isUnsafe, lvls, params, indices, nested, type, ctors, recrs⟩ =>
-    ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
-      ctors.toArray.map Constructor.toFFI, recrs.toArray.map Recursor.toFFI,
-      nat2Bytes nested, recr, refl, isUnsafe⟩
-
-inductive NameFFI
-  | anonymous
-  | str : NameFFI → String → NameFFI
-  | num : NameFFI → ByteArray → NameFFI
-
-def _root_.Lean.Name.toFFI : Lean.Name → NameFFI
-  | .anonymous => .anonymous
-  | .str name s => .str name.toFFI s
-  | .num name n => .num name.toFFI (nat2Bytes n)
-
-inductive MetadatumFFI where
-| name : NameFFI -> MetadatumFFI
-| info : Lean.BinderInfo -> MetadatumFFI
-| link : Address -> MetadatumFFI
-| hints : Lean.ReducibilityHints -> MetadatumFFI
-| all : Array NameFFI -> MetadatumFFI
-| mutCtx : Array (Array NameFFI) -> MetadatumFFI
-
-def Metadatum.toFFI : Metadatum → MetadatumFFI
-  | .name n => .name n.toFFI
-  | .info i => .info i
-  | .link addr => .link addr
-  | .hints h => .hints h
-  | .all ns => .all (ns.toArray.map Lean.Name.toFFI)
-  | .mutCtx ctx => .mutCtx $ ctx.toArray.map (·.toArray.map Lean.Name.toFFI)
-
-inductive IxonFFI where
-| vari : UInt64 -> IxonFFI
-| sort : Univ -> IxonFFI
-| refr : Address -> Array Univ -> IxonFFI
-| recr : UInt64 -> Array Univ -> IxonFFI
-| apps : IxonFFI -> IxonFFI -> Array IxonFFI -> IxonFFI
-| lams : Array IxonFFI -> IxonFFI -> IxonFFI
-| alls : Array IxonFFI -> IxonFFI -> IxonFFI
-| proj : Address -> UInt64 -> IxonFFI -> IxonFFI
-| strl : String -> IxonFFI
-| natl : ByteArray -> IxonFFI
-| letE : Bool -> IxonFFI -> IxonFFI -> IxonFFI -> IxonFFI
-| list : Array IxonFFI -> IxonFFI
-| defn : DefinitionFFI -> IxonFFI
-| axio : AxiomFFI -> IxonFFI
-| quot : QuotientFFI -> IxonFFI
-| cprj : ConstructorProjFFI -> IxonFFI
-| rprj : RecursorProjFFI -> IxonFFI
-| iprj : InductiveProjFFI -> IxonFFI
-| dprj : DefinitionProjFFI -> IxonFFI
-| inds : Array InductiveFFI -> IxonFFI
-| defs : Array DefinitionFFI -> IxonFFI
-| meta : Array (ByteArray × (Array MetadatumFFI)) -> IxonFFI
-| prof : Proof -> IxonFFI
-| eval : EvalClaim -> IxonFFI
-| chck : CheckClaim -> IxonFFI
-| comm : Comm -> IxonFFI
-| envn : Array (Address × Address) -> IxonFFI
-
-def Ixon.toFFI : Ixon → IxonFFI
-  | .vari i => .vari i
-  | .sort u => .sort u
-  | .refr addr univs => .refr addr univs.toArray
-  | .recr i us => .recr i us.toArray
-  | .apps f a as => .apps f.toFFI a.toFFI (as.map Ixon.toFFI).toArray
-  | .lams xs b => .lams (xs.map Ixon.toFFI).toArray b.toFFI
-  | .alls xs x => .alls (xs.map Ixon.toFFI).toArray x.toFFI
-  | .proj addr i x => .proj addr i x.toFFI
-  | .strl s => .strl s
-  | .natl n => .natl (nat2Bytes n)
-  | .letE x v t b => .letE x v.toFFI t.toFFI b.toFFI
-  | .list xs => .list (xs.map Ixon.toFFI).toArray
-  | .defn d => .defn d.toFFI
-  | .axio a => .axio a.toFFI
-  | .quot q => .quot q.toFFI
-  | .cprj c => .cprj c.toFFI
-  | .rprj r => .rprj r.toFFI
-  | .iprj i => .iprj i.toFFI
-  | .dprj d => .dprj d.toFFI
-  | .inds is => .inds (is.map Inductive.toFFI).toArray
-  | .defs d => .defs (d.map Definition.toFFI).toArray
-  | .meta ⟨map⟩ => .meta $ map.toArray.map
-      fun (x, y) => (nat2Bytes x, y.toArray.map Metadatum.toFFI)
-  | .prof p => .prof p
-  | .eval x => .eval x
-  | .chck x => .chck x
-  | .comm x => .comm x
-  | .envn x => .envn x.env.toArray
-
-end FFI
+def Ixon.address (ixon: Ixon): Address := Address.blake3 (ser ixon)
 
+--
+----section FFI
+----
+----/--
+----# Ixon FFI types
+----
+----This section defines FFI-friendly versions of the original Ixon datatypes by
+----* Replacing `Nat` by `ByteArray` containing the corresponding bytes in LE
+----* Replacing `List` by `Array`
+----* Replacing maps by `Array`s of pairs
+-----/
+----
+----@[inline] def nat2Bytes (n : Nat) : ByteArray :=
+----  ⟨natToBytesLE n⟩
+----
+----structure DefinitionFFI where
+----  kind: Ix.DefKind
+----  safety : Lean.DefinitionSafety
+----  lvls : ByteArray
+----  type : Address
+----  value : Address
+----
+----def Definition.toFFI : Definition → DefinitionFFI
+----  | ⟨kind, safety, lvls, type, value⟩ =>
+----    ⟨kind, safety, nat2Bytes lvls, type, value⟩
+----
+----structure AxiomFFI where
+----  lvls : ByteArray
+----  type : Address
+----  isUnsafe: Bool
+----
+----def Axiom.toFFI : Axiom → AxiomFFI
+----  | ⟨isUnsafe, lvls, type⟩ => ⟨nat2Bytes lvls, type, isUnsafe⟩
+----
+----structure QuotientFFI where
+----  lvls : ByteArray
+----  type : Address
+----  kind : Lean.QuotKind
+----
+----def Quotient.toFFI : Quotient → QuotientFFI
+----  | ⟨kind, lvls, type⟩ => ⟨nat2Bytes lvls, type, kind⟩
+----
+----structure ConstructorProjFFI where
+----  block : Address
+----  idx : ByteArray
+----  cidx : ByteArray
+----
+----def ConstructorProj.toFFI : ConstructorProj → ConstructorProjFFI
+----  | ⟨idx, cidx, block⟩ => ⟨block, nat2Bytes idx, nat2Bytes cidx⟩
+----
+----structure RecursorProjFFI where
+----  block : Address
+----  idx : ByteArray
+----  ridx : ByteArray
+----
+----def RecursorProj.toFFI : RecursorProj → RecursorProjFFI
+----  | ⟨idx, ridx, block⟩ => ⟨block, nat2Bytes idx, nat2Bytes ridx⟩
+----
+----structure InductiveProjFFI where
+----  block : Address
+----  idx : ByteArray
+----
+----def InductiveProj.toFFI : InductiveProj → InductiveProjFFI
+----  | ⟨idx, block⟩ => ⟨block, nat2Bytes idx⟩
+----
+----structure DefinitionProjFFI where
+----  block : Address
+----  idx : ByteArray
+----
+----def DefinitionProj.toFFI : DefinitionProj → DefinitionProjFFI
+----  | ⟨idx, block⟩ => ⟨block, nat2Bytes idx⟩
+----
+----structure RecursorRuleFFI where
+----  fields : ByteArray
+----  rhs : Address
+----
+----def RecursorRule.toFFI : RecursorRule → RecursorRuleFFI
+----  | ⟨fields, rhs⟩ => ⟨nat2Bytes fields, rhs⟩
+----
+----structure RecursorFFI where
+----  lvls : ByteArray
+----  type : Address
+----  params : ByteArray
+----  indices : ByteArray
+----  motives : ByteArray
+----  minors : ByteArray
+----  rules : Array RecursorRuleFFI
+----  k : Bool
+----  isUnsafe: Bool
+----
+----def Recursor.toFFI : Recursor → RecursorFFI
+----  | ⟨k, isUnsafe, lvls, params, indices, motives, minors, type, rules⟩ =>
+----    ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
+----      nat2Bytes motives, nat2Bytes minors, rules.toArray.map RecursorRule.toFFI,
+----      k, isUnsafe⟩
+----
+----structure ConstructorFFI where
+----  lvls : ByteArray
+----  type : Address
+----  cidx : ByteArray
+----  params : ByteArray
+----  fields : ByteArray
+----  isUnsafe: Bool
+----
+----def Constructor.toFFI : Constructor → ConstructorFFI
+----  | ⟨isUnsafe, lvls, cidx, params, fields, type⟩ =>
+----    ⟨nat2Bytes lvls, type, nat2Bytes cidx, nat2Bytes params, nat2Bytes fields, isUnsafe⟩
+----
+----structure InductiveFFI where
+----  lvls : ByteArray
+----  type : Address
+----  params : ByteArray
+----  indices : ByteArray
+----  ctors : Array ConstructorFFI
+----  recrs : Array RecursorFFI
+----  nested : ByteArray
+----  recr : Bool
+----  refl : Bool
+----  isUnsafe: Bool
+----
+----def Inductive.toFFI : Inductive → InductiveFFI
+----  | ⟨recr, refl, isUnsafe, lvls, params, indices, nested, type, ctors, recrs⟩ =>
+----    ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
+----      ctors.toArray.map Constructor.toFFI, recrs.toArray.map Recursor.toFFI,
+----      nat2Bytes nested, recr, refl, isUnsafe⟩
+----
+----inductive NameFFI
+----  | anonymous
+----  | str : NameFFI → String → NameFFI
+----  | num : NameFFI → ByteArray → NameFFI
+----
+----def _root_.Lean.Name.toFFI : Lean.Name → NameFFI
+----  | .anonymous => .anonymous
+----  | .str name s => .str name.toFFI s
+----  | .num name n => .num name.toFFI (nat2Bytes n)
+----
+----inductive MetadatumFFI where
+----| name : NameFFI -> MetadatumFFI
+----| info : Lean.BinderInfo -> MetadatumFFI
+----| link : Address -> MetadatumFFI
+----| hints : Lean.ReducibilityHints -> MetadatumFFI
+----| all : Array NameFFI -> MetadatumFFI
+----| mutCtx : Array (Array NameFFI) -> MetadatumFFI
+----
+----def Metadatum.toFFI : Metadatum → MetadatumFFI
+----  | .name n => .name n.toFFI
+----  | .info i => .info i
+----  | .link addr => .link addr
+----  | .hints h => .hints h
+----  | .all ns => .all (ns.toArray.map Lean.Name.toFFI)
+----  | .mutCtx ctx => .mutCtx $ ctx.toArray.map (·.toArray.map Lean.Name.toFFI)
+----
+----inductive IxonFFI where
+----| vari : UInt64 -> IxonFFI
+----| refr : Address -> Array Univ -> IxonFFI
+----| recr : UInt64 -> Array Univ -> IxonFFI
+----| proj : Address -> UInt64 -> Address -> IxonFFI
+----| sort : Univ -> IxonFFI
+----| strl : Address -> IxonFFI
+----| natl : Address -> IxonFFI
+----| appl : Address -> Address -> IxonFFI
+----| lamb : Address -> Address -> IxonFFI
+----| allE : Address -> Address -> IxonFFI
+----| letE : Address -> Address -> Address -> IxonFFI
+----| letD : Address -> Address -> Address -> IxonFFI
+----| list : Array IxonFFI -> IxonFFI
+----| defn : DefinitionFFI -> IxonFFI
+----| axio : AxiomFFI -> IxonFFI
+----| quot : QuotientFFI -> IxonFFI
+----| cprj : ConstructorProjFFI -> IxonFFI
+----| rprj : RecursorProjFFI -> IxonFFI
+----| iprj : InductiveProjFFI -> IxonFFI
+----| dprj : DefinitionProjFFI -> IxonFFI
+----| inds : Array InductiveFFI -> IxonFFI
+----| defs : Array DefinitionFFI -> IxonFFI
+----| meta : Array (ByteArray × (Array MetadatumFFI)) -> IxonFFI
+----| prof : Proof -> IxonFFI
+----| eval : EvalClaim -> IxonFFI
+----| chck : CheckClaim -> IxonFFI
+----| comm : Comm -> IxonFFI
+----| envn : Array (Address × Address) -> IxonFFI
+----
+----def Ixon.toFFI : Ixon → IxonFFI
+----  | .vari i => .vari i
+----  | .sort u => .sort u
+----  | .refr addr univs => .refr addr univs.toArray
+----  | .recr i us => .recr i us.toArray
+----  | .appl f a => .appl f a
+----  | .lamb t b => .lamb t b
+----  | .allE t b => .allE t b
+----  | .proj addr i x => .proj addr i x
+----  | .strl s => .strl s
+----  | .natl n => .natl n
+----  | .letE v t b => .letE v t b
+----  | .letD v t b => .letD v t b
+----  | .list xs => .list (xs.map Ixon.toFFI).toArray
+----  | .defn d => .defn d.toFFI
+----  | .axio a => .axio a.toFFI
+----  | .quot q => .quot q.toFFI
+----  | .cprj c => .cprj c.toFFI
+----  | .rprj r => .rprj r.toFFI
+----  | .iprj i => .iprj i.toFFI
+----  | .dprj d => .dprj d.toFFI
+----  | .inds is => .inds (is.map Inductive.toFFI).toArray
+----  | .defs d => .defs (d.map Definition.toFFI).toArray
+----  | .meta ⟨map⟩ => .meta $ map.toArray.map
+----      fun (x, y) => (nat2Bytes x, y.toArray.map Metadatum.toFFI)
+----  | .prof p => .prof p
+----  | .eval x => .eval x
+----  | .chck x => .chck x
+----  | .comm x => .comm x
+----  | .envn x => .envn x.env.toArray
+----
+----end FFI
+--
 end Ixon
diff --git a/Ix/Ixon/Const.lean b/Ix/Ixon/Const.lean
deleted file mode 100644
index c2269e30..00000000
--- a/Ix/Ixon/Const.lean
+++ /dev/null
@@ -1,175 +0,0 @@
-import Ix.Common
-import Ix.Address
-import Ix.Prove
-import Ix.Claim
-import Lean.Declaration
-import Ix.Ixon.Serialize
-import Ix.Ixon.Metadata
-import Ix.Ixon.Expr
-
-namespace Ixon
-
-structure Quotient where
-  kind : Lean.QuotKind
-  lvls : Nat
-  type : Address
-  deriving BEq, Repr
-
-instance : Serialize Quotient where
-  put := fun x => Serialize.put (x.kind, x.lvls, x.type)
-  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
-
-structure Axiom where
-  isUnsafe: Bool
-  lvls : Nat
-  type : Address
-  deriving BEq, Repr
-
-instance : Serialize Axiom where
-  put := fun x => Serialize.put (x.isUnsafe, x.lvls, x.type)
-  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
-
-structure Definition where
-  kind : Ix.DefKind
-  safety : Lean.DefinitionSafety
-  lvls : Nat
-  type : Address
-  value : Address
-  deriving BEq, Repr
-
-instance : Serialize Definition where
-  put := fun x => Serialize.put (x.kind, x.safety, x.lvls, x.type, x.value)
-  get := (fun (a,b,c,d,e) => .mk a b c d e) <$> Serialize.get
-
-structure Constructor where
-  isUnsafe: Bool
-  lvls : Nat
-  cidx : Nat
-  params : Nat
-  fields : Nat
-  type : Address
-  deriving BEq, Repr
-
-instance : Serialize Constructor where
-  put := fun x => Serialize.put (x.isUnsafe, x.lvls, x.cidx, x.params, x.fields, x.type)
-  get := (fun (a,b,c,d,e,f) => .mk a b c d e f) <$> Serialize.get
-
-structure RecursorRule where
-  fields : Nat
-  rhs : Address
-  deriving BEq, Repr
-
-instance : Serialize RecursorRule where
-  put := fun x => Serialize.put (x.fields, x.rhs)
-  get := (fun (a,b) => .mk a b) <$> Serialize.get
-
-structure Recursor where
-  k : Bool
-  isUnsafe: Bool
-  lvls : Nat
-  params : Nat
-  indices : Nat
-  motives : Nat
-  minors : Nat
-  type : Address
-  rules : List RecursorRule
-  deriving BEq, Repr
-
-instance : Serialize Recursor where
-  put := fun x => Serialize.put ((x.k, x.isUnsafe), x.lvls, x.params, x.indices, x.motives, x.minors, x.type, x.rules)
-  get := (fun ((a,b),c,d,e,f,g,h,i) => .mk a b c d e f g h i) <$> Serialize.get
-
-structure Inductive where
-  recr : Bool
-  refl : Bool
-  isUnsafe: Bool
-  lvls : Nat
-  params : Nat
-  indices : Nat
-  nested : Nat
-  type : Address
-  ctors : List Constructor
-  recrs : List Recursor
-  deriving BEq, Repr
-
-instance : Serialize Inductive where
-  put := fun x => Serialize.put ((x.recr,x.refl,x.isUnsafe), x.lvls, x.params, x.indices, x.nested, x.type, x.ctors, x.recrs)
-  get := (fun ((a,b,c),d,e,f,g,h,i,j) => .mk a b c d e f g h i j) <$> Serialize.get
-
-structure InductiveProj where
-  idx : Nat
-  block : Address
-  deriving BEq, Repr
-
-instance : Serialize InductiveProj where
-  put := fun x => Serialize.put (x.idx, x.block)
-  get := (fun (x,y) => .mk x y) <$> Serialize.get
-
-structure ConstructorProj where
-  idx : Nat
-  cidx : Nat
-  block : Address
-  deriving BEq, Repr
-
-instance : Serialize ConstructorProj where
-  put := fun x => Serialize.put (x.idx, x.cidx, x.block)
-  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
-
-structure RecursorProj where
-  idx : Nat
-  ridx : Nat
-  block : Address
-  deriving BEq, Repr
-
-instance : Serialize RecursorProj where
-  put := fun x => Serialize.put (x.idx, x.ridx, x.block)
-  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
-
-structure DefinitionProj where
-  idx : Nat
-  block : Address
-  deriving BEq, Repr
-
-instance : Serialize DefinitionProj where
-  put := fun x => Serialize.put (x.idx, x.block)
-  get := (fun (x,y) => .mk x y) <$> Serialize.get
-
-structure Comm where
-  secret : Address
-  payload : Address
-  deriving BEq, Repr
-
-structure Env where
-  env : List (Address × Address)
-  deriving BEq, Repr
-
-instance : Serialize Env where
-  put x := Serialize.put x.env
-  get := .mk <$> Serialize.get
-
-instance : Serialize Comm where
-  put := fun x => Serialize.put (x.secret, x.payload)
-  get := (fun (x,y) => .mk x y) <$> Serialize.get
-
-instance : Serialize CheckClaim where
-  put x := Serialize.put (x.lvls, x.type, x.value)
-  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
-
-instance : Serialize EvalClaim where
-  put x := Serialize.put (x.lvls, x.input, x.output, x.type)
-  get := (fun (w,x,y,z) => .mk w x y z) <$> Serialize.get
-
-instance : Serialize Claim where
-  put
-  | .evals x => putTag4 ⟨0xE, 2⟩ *> Serialize.put x
-  | .checks x => putTag4 ⟨0xE, 3⟩ *> Serialize.put x
-  get := do match <- getTag4 with
-  | ⟨0xE,2⟩ => .evals <$> Serialize.get
-  | ⟨0xE,3⟩ => .checks <$> Serialize.get
-  | e => throw s!"expected Claim with tag 0xE2 or 0xE3, got {repr e}"
-
-instance : Serialize Proof where
-  put := fun x => Serialize.put (x.claim, x.bin)
-  get := (fun (x,y) => .mk x y) <$> Serialize.get
-
-end Ixon
diff --git a/Ix/Ixon/Expr.lean b/Ix/Ixon/Expr.lean
deleted file mode 100644
index 28feb8b7..00000000
--- a/Ix/Ixon/Expr.lean
+++ /dev/null
@@ -1,174 +0,0 @@
-import Ix.Address
-import Ix.Ixon.Serialize
-import Ix.Ixon.Univ
-
-namespace Ixon
-
----- 0xTTTT_LXXX
---inductive Expr where
---  -- 0x0, ^1
---  | vari (idx: UInt64) : Expr
---  -- 0x1, {max (add 1 2) (var 1)}
---  | sort (univ: Univ) : Expr
---  -- 0x2 #dead_beef_cafe_babe {u1, u2, ... }
---  | cnst (adr: Address) (lvls: List Univ) : Expr
---  -- 0x3 #1.{u1, u2, u3}
---  | rec_ (idx: UInt64) (lvls: List Univ) : Expr
---  -- 0x4 (f x y z)
---  | apps (func: Expr) (arg: Expr) (args: List Expr) : Expr
---  -- 0x5 (λ A B C => body)
---  | lams (types: List Expr) (body: Expr) : Expr
---  -- 0x6 (∀ A B C -> body)
---  | alls (types: List Expr) (body: Expr) : Expr
---  -- 0x7 (let d : A in b)
---  | let_ (nonDep: Bool) (type: Expr) (defn: Expr) (body: Expr) : Expr
---  -- 0x8 .1
---  | proj (type: Address) (idx: UInt64) (struct: Expr): Expr
---  -- 0x9 "foobar"
---  | strl (lit: String) : Expr
---  -- 0xA 0xdead_beef
---  | natl (lit: Nat): Expr
---  deriving Inhabited, Repr, BEq
----- array: 0xB
----- const: 0xC
---
---
---def putExprTag (tag: UInt8) (val: UInt64) : PutM :=
---  let t := UInt8.shiftLeft tag 4
---  if val < 8
---  then putUInt8 (UInt8.lor t (UInt64.toUInt8 val)) *> pure ()
---  else do
---    putUInt8 (UInt8.lor (UInt8.lor t 0b1000) (byteCount val - 1))
---    putTrimmedLE val
---
---partial def putExpr : Expr -> PutM
---| .vari i => putExprTag 0x0 i
---| .sort u => putExprTag 0x1 0 *> putUniv u
---| .cnst a lvls => do
---  putExprTag 0x2 (Nat.toUInt64 lvls.length)
---  putBytes a.hash *> putList putUniv lvls
---| .rec_ i lvls => do
---  putExprTag 0x3 (Nat.toUInt64 lvls.length)
---  putUInt64LE i *> putList putUniv lvls
---| .apps f a as => do
---  putExprTag 0x4 (Nat.toUInt64 as.length)
---  putExpr f *> putExpr a *> putList putExpr as
---| .lams ts b => do
---  putExprTag 0x5 (Nat.toUInt64 ts.length)
---  putList putExpr ts *> putExpr b
---| .alls ts b => do
---  putExprTag 0x6 (Nat.toUInt64 ts.length) *>
---  putList putExpr ts *> putExpr b
---| .let_ nD t d b => do
---  if nD then putExprTag 0x7 1 else putExprTag 0x7 0
---  putExpr t *> putExpr d *> putExpr b
---| .proj t n x => do
---  putExprTag 0x8 n
---  putBytes t.hash
---  putExpr x
---| .strl l => do
---  let bytes := l.toUTF8
---  putExprTag 0x9 (UInt64.ofNat bytes.size)
---  putBytes bytes
---| .natl l => do
---  let bytes := natToBytesLE l
---  putExprTag 0xA (UInt64.ofNat bytes.size)
---  putBytes { data := bytes }
---
---def getExprTag (isLarge: Bool) (small: UInt8) : GetM UInt64 := do
---  if isLarge then (fromTrimmedLE ·.data) <$> getBytes (UInt8.toNat small + 1)
---  else return Nat.toUInt64 (UInt8.toNat small)
---
---def getExpr : GetM Expr := do
---  let st ← get
---  go (st.bytes.size - st.index)
---  where
---    go : Nat → GetM Expr
---    | 0 => throw "Out of fuel"
---    | Nat.succ f => do
---      let tagByte ← getUInt8
---      let tag := UInt8.shiftRight tagByte 4
---      let small := UInt8.land tagByte 0b111
---      let isLarge := UInt8.land tagByte 0b1000 != 0
---      match tag with
---      | 0x0 => .vari <$> getExprTag isLarge small
---      | 0x1 => .sort <$> getUniv
---      | 0x2 => do
---        let n ← getExprTag isLarge small
---        .cnst <$> (Address.mk <$> getBytes 32) <*> getList n getUniv
---      | 0x3 => do
---        let n ← getExprTag isLarge small
---        .rec_ <$> getUInt64LE <*> getList n getUniv
---      | 0x4 => do
---        let n ← getExprTag isLarge small
---        .apps <$> go f <*> go f <*> getList n (go f)
---      | 0x5 => do
---        let n ← getExprTag isLarge small
---        .lams <$> getList n (go f) <*> go f
---      | 0x6 => do
---        let n ← getExprTag isLarge small
---        .alls <$> getList n (go f) <*> go f
---      | 0x7 => do
---        let n ← getExprTag isLarge small
---        if n == 0 then
---          .let_ .false <$> go f <*> go f <*> go f
---        else
---          .let_ .true <$> go f <*> go f <*> go f
---      | 0x8 => do
---        let n ← getExprTag isLarge small
---        .proj <$> (Address.mk <$> getBytes 32) <*> pure n <*> go f
---      | 0x9 => do
---        let n ← getExprTag isLarge small
---        let bs ← getBytes n.toNat
---        match String.fromUTF8? bs with
---        | .some s => return .strl s
---        | .none => throw s!"invalid UTF8 bytes {bs}"
---      | 0xA => do
---        let n ← getExprTag isLarge small
---        let bs ← getBytes n.toNat
---        return .natl (natFromBytesLE bs.data)
---      | x => throw s!"Unknown Ixon Expr tag {x}"
---
---instance : Serialize Expr where
---  put := runPut ∘ putExpr
---  get := runGet getExpr
---
---
---def putArray {A: Type} (putM : A -> PutM) (xs : List A) : PutM := do
---  putExprTag 0xB (UInt64.ofNat xs.length)
---  List.forM xs putM
---
----- useful for arrays of non-uniform type, such as encoding tuples, although that
----- requires a custom getArray equivalent
---def putArray' (xs : List PutM) : PutM := do
---  putExprTag 0xB (UInt64.ofNat xs.length)
---  List.forM xs id
---
---def putByteArray (x: ByteArray) : PutM := do
---  putExprTag 0xB (UInt64.ofNat x.size)
---  x.toList.forM putUInt8
---
---def getArray (getM: GetM A) : GetM (List A) := do
---  let tagByte ← getUInt8
---  let tag := UInt8.shiftRight tagByte 4
---  let small := UInt8.land tagByte 0b111
---  let isLarge := (UInt8.land tagByte 0b1000 != 0)
---  match tag with
---  | 0xB => do
---    let len <- UInt64.toNat <$> getExprTag isLarge small
---    List.mapM (λ _ => getM) (List.range len)
---  | e => throw s!"expected Array with tag 0xB, got {e}"
---
---def getByteArray : GetM ByteArray := do
---  let xs <- getArray getUInt8
---  return ⟨xs.toArray⟩
---
---
---
---def putNatl (x: Nat) : PutM := putExpr (.natl x)
---def getNatl : GetM Nat := do
---  match (← getExpr) with
---  | .natl n => return n
---  | x => throw s!"expected Expr.Nat, got {repr x}"
-
-end Ixon
diff --git a/Ix/Ixon/Metadata.lean b/Ix/Ixon/Metadata.lean
deleted file mode 100644
index ef0f2c93..00000000
--- a/Ix/Ixon/Metadata.lean
+++ /dev/null
@@ -1,85 +0,0 @@
-import Ix.Common
-import Ix.Ixon.Serialize
-import Ix.Address
-import Batteries.Data.RBMap
-
-namespace Ixon
-
-inductive Metadatum where
-| name : Lean.Name -> Metadatum
-| info : Lean.BinderInfo -> Metadatum
-| link : Address -> Metadatum
-| hints : Lean.ReducibilityHints -> Metadatum
-| all : List Lean.Name -> Metadatum
-| mutCtx : List (List Lean.Name) -> Metadatum
-deriving BEq, Repr, Ord, Inhabited
-
-structure Metadata where
-  map: List (Nat × (List Metadatum))
-  deriving BEq, Repr
-
-inductive NamePart where
-| str (s: String)
-| num (n: Nat)
-deriving Inhabited
-
-def nameToParts: Lean.Name → List NamePart
-| .anonymous => []
-| .str n s => NamePart.str s :: nameToParts n
-| .num n i => NamePart.num i :: nameToParts n
-
-def nameFromParts: List NamePart → Lean.Name
-| [] => .anonymous
-| (.str n)::ns => .str (nameFromParts ns) n
-| (.num i)::ns => .num (nameFromParts ns) i
-
-open Serialize
-
-def putNamePart : NamePart → PutM Unit
-| .str s => put s
-| .num i => put i
-
-def getNamePart : GetM NamePart := do
-  match (← getTag4) with
-  | ⟨0x7, x⟩ => .str <$> getString' ⟨0x7, x⟩
-  | ⟨0x8, x⟩ => .num <$> getNat' ⟨0x8, x⟩
-  | e => throw s!"expected NamePart from 0x7 or 0x8 got {repr e}"
-
-instance : Serialize NamePart where
-  put := putNamePart
-  get := getNamePart
-
-def putName (n: Lean.Name): PutM Unit := put (List.reverse $ nameToParts n)
-def getName: GetM Lean.Name := (nameFromParts ∘ List.reverse) <$> get
-
-instance : Serialize Lean.Name where
-  put := putName
-  get := getName
-
-def putMetadatum : Metadatum → PutM Unit
-| .name n => putUInt8 0 *> putName n
-| .info i => putUInt8 1 *> putBinderInfo i
-| .link l => putUInt8 2 *> putBytes l.hash
-| .hints h => putUInt8 3 *> putReducibilityHints h
-| .all ns => putUInt8 4 *> put ns
-| .mutCtx ctx => putUInt8 5 *> put ctx
-
-def getMetadatum : GetM Metadatum := do
-  match (<- getUInt8) with
-  | 0 => .name <$> get
-  | 1 => .info <$> get
-  | 2 => .link <$> (.mk <$> getBytes 32)
-  | 3 => .hints <$> get
-  | 4 => .all <$> get
-  | 5 => .mutCtx <$> get
-  | e => throw s!"expected Metadatum encoding between 0 and 4, got {e}"
-
-instance : Serialize Metadatum where
-  put := putMetadatum
-  get := getMetadatum
-
-instance : Serialize Metadata where
-  put m := put m.map
-  get := .mk <$> get
-
-end Ixon
diff --git a/Ix/Ixon/Serialize.lean b/Ix/Ixon/Serialize.lean
deleted file mode 100644
index d8be32b3..00000000
--- a/Ix/Ixon/Serialize.lean
+++ /dev/null
@@ -1,408 +0,0 @@
-import Ix.Common
-import Lean.Declaration
-import Ix.Address
-import Ix.Ixon.Tag
-
-namespace Ixon
-
-abbrev PutM := StateM ByteArray
-
-structure GetState where
-  idx : Nat := 0
-  bytes : ByteArray := .empty
-
-abbrev GetM := EStateM String GetState
-
-class Serialize (α : Type) where
-  put : α → PutM Unit
-  get : GetM α
-
-def runPut (p: PutM Unit) : ByteArray := (p.run ByteArray.empty).2
-
-def runGet (getm: GetM A) (bytes: ByteArray) : Except String A :=
-  match getm.run { idx := 0, bytes } with
-  | .ok a _ => .ok a
-  | .error e _ => .error e
-
-def putUInt8 (x: UInt8) : PutM Unit :=
-  StateT.modifyGet (fun s => ((), s.push x))
-
-def getUInt8 : GetM UInt8 := do
-  let st ← get
-  if st.idx < st.bytes.size then
-    let b := st.bytes[st.idx]!
-    set { st with idx := st.idx + 1 }
-    return b
-  else
-    throw "EOF"
-
-instance : Serialize UInt8 where
-  put := putUInt8
-  get := getUInt8
-
-def putUInt16LE (x: UInt16) : PutM Unit := do
-  List.forM (List.range 2) fun i =>
-    let b := UInt16.toUInt8 (x >>> (i.toUInt16 * 8))
-    putUInt8 b
-  pure ()
-
-def getUInt16LE : GetM UInt16 := do
-  let mut x : UInt16 := 0
-  for i in List.range 2 do
-    let b ← getUInt8
-    x := x + (UInt8.toUInt16 b) <<< ((UInt16.ofNat i) * 8)
-  pure x
-
-instance : Serialize UInt16 where
-  put := putUInt16LE
-  get := getUInt16LE
-
-def putUInt32LE (x: UInt32) : PutM Unit := do
-  List.forM (List.range 4) fun i =>
-    let b := UInt32.toUInt8 (x >>> (i.toUInt32 * 8))
-    putUInt8 b
-  pure ()
-
-def getUInt32LE : GetM UInt32 := do
-  let mut x : UInt32 := 0
-  for i in List.range 4 do
-    let b ← getUInt8
-    x := x + (UInt8.toUInt32 b) <<< ((UInt32.ofNat i) * 8)
-  pure x
-
-instance : Serialize UInt32 where
-  put := putUInt32LE
-  get := getUInt32LE
-
-def putUInt64LE (x: UInt64) : PutM Unit := do
-  List.forM (List.range 8) fun i =>
-    let b := UInt64.toUInt8 (x >>> (i.toUInt64 * 8))
-    putUInt8 b
-  pure ()
-
-def getUInt64LE : GetM UInt64 := do
-  let mut x : UInt64 := 0
-  for i in List.range 8 do
-    let b ← getUInt8
-    x := x + (UInt8.toUInt64 b) <<< ((UInt64.ofNat i) * 8)
-  pure x
-
-instance : Serialize UInt64 where
-  put := putUInt64LE
-  get := getUInt64LE
-
-def putBytes (x: ByteArray) : PutM Unit :=
-  StateT.modifyGet (fun s => ((), s.append x))
-
-def getBytes (len: Nat) : GetM ByteArray := do
-  let st ← get
-  if st.idx + len <= st.bytes.size then
-    let chunk := st.bytes.extract st.idx (st.idx + len)
-    set { st with idx := st.idx + len }
-    return chunk
-  else throw s!"EOF: need {len} bytes at index {st.idx}, but size is {st.bytes.size}"
-
-def putTag2 (tag: Tag2) : PutM Unit := do
-  putUInt8 (encodeTag2Head tag)
-  if tag.size < 32
-  then pure ()
-  else putBytes (.mk (trimmedLE tag.size))
-
-def getTagSize (large: Bool) (small: UInt8) : GetM UInt64 := do
-  if large then (fromTrimmedLE ·.data) <$> getBytes (small.toNat + 1)
-  else return small.toNat.toUInt64
-
-def getTag2 : GetM Tag2 := do
-  let (flag, largeBit, small) <- decodeTag2Head <$> getUInt8
-  let size <- getTagSize largeBit small
-  pure (Tag2.mk flag size)
-
-instance : Serialize Tag2 where
-  put := putTag2
-  get := getTag2
-
-def putTag4 (tag: Tag4) : PutM Unit := do
-  putUInt8 (encodeTag4Head tag)
-  if tag.size < 8
-  then pure ()
-  else putBytes (.mk (trimmedLE tag.size))
-
-def getTag4 : GetM Tag4 := do
-  let (flag, largeBit, small) <- decodeTag4Head <$> getUInt8
-  let size <- getTagSize largeBit small
-  pure (Tag4.mk flag size)
-
-instance : Serialize Tag4 where
-  put := putTag4
-  get := getTag4
-
-def putList [Serialize A] (xs : List A) : PutM Unit := do
-  Serialize.put (Tag4.mk 0xA (UInt64.ofNat xs.length))
-  List.forM xs Serialize.put
-
-def getList [Serialize A] : GetM (List A) := do
-  let tag : Tag4 <- Serialize.get
-  match tag with
-  | ⟨0xA, size⟩ => do
-    List.mapM (λ _ => Serialize.get) (List.range size.toNat)
-  | e => throw s!"expected List with tag 0xA, got {repr e}"
-
-instance [Serialize A] : Serialize (List A) where
-  put := putList
-  get := getList
-
-instance : Serialize ByteArray where
-  put x := putList x.toList
-  get := ByteArray.mk <$> Array.mk <$> getList
-
-def putMany {A: Type} (put : A -> PutM Unit) (xs: List A) : PutM Unit := 
-  List.forM xs put
-
-def getMany {A: Type} (x: UInt64) (getm : GetM A) : GetM (List A) :=
-  (List.range x.toNat).mapM (fun _ => getm)
-
-def putString (x: String) : PutM Unit := do
-  let bytes := x.toUTF8
-  Serialize.put (Tag4.mk 0x7 bytes.size.toUInt64)
-  putBytes bytes
-
-def getString' (tag: Tag4) : GetM String := do
-  match tag with
-  | ⟨0x7, size⟩ => do
-    let bs ← getBytes size.toNat
-    match String.fromUTF8? bs with
-    | .some s => return s
-    | .none => throw s!"invalid UTF8 bytes {bs}"
-  | e => throw s!"expected String with tag 0x7, got {repr e}"
-
-def getString : GetM String := getTag4 >>= getString'
-
-instance : Serialize String where
-  put := putString
-  get := getString
-
-def natToBytesLE (x: Nat) : Array UInt8 :=
-  if x == 0 then Array.mkArray1 0 else List.toArray (go x x)
-  where
-    go : Nat -> Nat -> List UInt8
-    | _, 0 => []
-    | 0, _ => []
-    | Nat.succ f, x => Nat.toUInt8 x:: go f (x / 256)
-
-def natFromBytesLE (xs: Array UInt8) : Nat :=
-  (xs.toList.zipIdx 0).foldl (fun acc (b, i) => acc + (UInt8.toNat b) * 256 ^ i) 0
-
-def putNat (x: Nat) : PutM Unit := do
-  let bytes := natToBytesLE x
-  putTag4 (Tag4.mk 0x8 bytes.size.toUInt64)
-  putBytes { data := bytes }
-
-def getNat' (tag: Tag4) : GetM Nat := do
-  match tag with
-  | ⟨0x8, size⟩ => do
-    let bs ← getBytes size.toNat
-    return natFromBytesLE bs.data
-  | e => throw s!"expected Nat with tag 0x8, got {repr e}"
-
-def getNat : GetM Nat := getTag4 >>= getNat'
-
-instance : Serialize Nat where
-  put := putNat
-  get := getNat
-
-def natPackAsAddress (x: Nat) : Option Address := 
-  let bytes := natToBytesLE x
-  if bytes.size > 32 then .none
-  else .some (Address.mk ⟨bytes.append (Array.replicate (32 - bytes.size) 0)⟩)
-
-def natUnpackFromAddress (x: Address) : Nat := 
-  natFromBytesLE x.hash.data
-
-def putBool : Bool → PutM Unit
-| .false => putUInt8 0
-| .true => putUInt8 1
-
-def getBool : GetM Bool := do
-  match (← getUInt8) with
-  | 0 => return .false
-  | 1 => return .true
-  | e => throw s!"expected Bool encoding between 0 and 1, got {e}"
-
-instance : Serialize Bool where
-  put := putBool
-  get := getBool
-
-def packBools (bools : List Bool) : UInt8 :=
-  List.foldl
-    (λ acc (b, i) => acc ||| (if b then 1 <<< UInt8.ofNat i else 0))
-    0
-    ((bools.take 8).zipIdx 0)
-
-def unpackBools (n: Nat) (b: UInt8) : List Bool :=
-  ((List.range 8).map (λ i => (b &&& (1 <<< UInt8.ofNat i)) != 0)).take n
-
-def putBools: List Bool → PutM Unit := putUInt8 ∘ packBools
-def getBools (n: Nat): GetM (List Bool) := unpackBools n <$> getUInt8
-
-instance (priority := default + 100) : Serialize (Bool × Bool) where
-  put := fun (a, b) => putBools [a, b]
-  get := do match (<- getBools 2) with
-    | [a, b] => pure (a, b)
-    | e => throw s!"expected packed (Bool × Bool), got {e}" 
-
-instance (priority := default + 101): Serialize (Bool × Bool × Bool) where
-  put := fun (a, b, c) => putBools [a, b, c]
-  get := do match (<- getBools 3) with
-    | [a, b, c] => pure (a, b, c)
-    | e => throw s!"expected packed (Bool × Bool × Bool), got {e}" 
-
-instance (priority := default + 102): Serialize (Bool × Bool × Bool × Bool) where
-  put := fun (a, b, c,d) => putBools [a, b, c, d]
-  get := do match (<- getBools 4) with
-    | [a, b, c, d] => pure (a, b, c, d)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool), got {e}" 
-
-instance (priority := default + 103): Serialize (Bool × Bool × Bool × Bool × Bool) where
-  put := fun (a, b, c, d, e) => putBools [a, b, c, d, e]
-  get := do match (<- getBools 5) with
-    | [a, b, c, d, e] => pure (a, b, c, d, e)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool), got {e}" 
-
-instance (priority := default + 104)
-  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool) where
-  put := fun (a, b, c, d, e, f) => putBools [a, b, c, d, e, f]
-  get := do match (<- getBools 6) with
-    | [a, b, c, d, e, f] => pure (a, b, c, d, e, f)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
-
-instance (priority := default + 106)
-  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool × Bool) where
-  put := fun (a, b, c, d, e, f, g) => putBools [a, b, c, d, e, f, g]
-  get := do match (<- getBools 7) with
-    | [a, b, c, d, e, f, g] => pure (a, b, c, d, e, f, g)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
-
-instance (priority := default + 105)
-  : Serialize (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool) where
-  put := fun (a, b, c, d, e, f, g, h) => putBools [a, b, c, d, e, f, g, h]
-  get := do match (<- getBools 8) with
-    | [a, b, c, d, e, f, g, h] => pure (a, b, c, d, e, f, g, h)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
-
-def putQuotKind : Lean.QuotKind → PutM Unit
-| .type => putUInt8 0
-| .ctor => putUInt8 1
-| .lift => putUInt8 2
-| .ind => putUInt8 3
-
-def getQuotKind : GetM Lean.QuotKind := do
-  match (← getUInt8) with
-  | 0 => return .type
-  | 1 => return .ctor
-  | 2 => return .lift
-  | 3 => return .ind
-  | e => throw s!"expected QuotKind encoding between 0 and 3, got {e}"
-
-instance : Serialize Lean.QuotKind where
-  put := putQuotKind
-  get := getQuotKind
-
-def putDefKind : Ix.DefKind → PutM Unit
-| .«definition» => putUInt8 0
-| .«opaque» => putUInt8 1
-| .«theorem» => putUInt8 2
-
-def getDefKind : GetM Ix.DefKind := do
-  match (← getUInt8) with
-  | 0 => return .definition
-  | 1 => return .opaque
-  | 2 => return .theorem
-  | e => throw s!"expected DefKind encoding between 0 and 3, got {e}"
-
-instance : Serialize Ix.DefKind where
-  put := putDefKind
-  get := getDefKind
-
-def putBinderInfo : Lean.BinderInfo → PutM Unit
-| .default => putUInt8 0
-| .implicit => putUInt8 1
-| .strictImplicit => putUInt8 2
-| .instImplicit => putUInt8 3
-
-def getBinderInfo : GetM Lean.BinderInfo := do
-  match (← getUInt8) with
-  | 0 => return .default
-  | 1 => return .implicit
-  | 2 => return .strictImplicit
-  | 3 => return .instImplicit
-  | e => throw s!"expected BinderInfo encoding between 0 and 3, got {e}"
-
-instance : Serialize Lean.BinderInfo where
-  put := putBinderInfo
-  get := getBinderInfo
-
-def putReducibilityHints : Lean.ReducibilityHints → PutM Unit
-| .«opaque» => putUInt8 0
-| .«abbrev» => putUInt8 1
-| .regular x => putUInt8 2 *> putUInt32LE x
-
-def getReducibilityHints : GetM Lean.ReducibilityHints := do
-  match (← getUInt8) with
-  | 0 => return .«opaque»
-  | 1 => return .«abbrev» 
-  | 2 => .regular <$> getUInt32LE
-  | e => throw s!"expected ReducibilityHints encoding between 0 and 2, got {e}"
-
-instance : Serialize Lean.ReducibilityHints where
-  put := putReducibilityHints
-  get := getReducibilityHints
-
-def putDefinitionSafety : Lean.DefinitionSafety → PutM Unit
-| .«unsafe» => putUInt8 0
-| .«safe» => putUInt8 1
-| .«partial» => putUInt8 2
-
-def getDefinitionSafety : GetM Lean.DefinitionSafety := do
-  match (← getUInt8) with
-  | 0 => return .«unsafe»
-  | 1 => return .«safe»
-  | 2 => return .«partial» 
-  | e => throw s!"expected DefinitionSafety encoding between 0 and 2, got {e}"
-
-instance : Serialize Lean.DefinitionSafety where
-  put := putDefinitionSafety
-  get := getDefinitionSafety
-
-instance [Serialize A] [Serialize B] : Serialize (A × B) where
-  put := fun (a, b) => Serialize.put a *> Serialize.put b
-  get := (·,·) <$> Serialize.get <*> Serialize.get
-
-def putOption [Serialize A]: Option A → PutM Unit
-| .none => Serialize.put ([] : List A)
-| .some x => Serialize.put [x]
-
-def getOption [Serialize A] : GetM (Option A) := do
-  match ← Serialize.get with
-  | [] => return .none
-  | [x] => return .some x
-  | _ => throw s!"Expected Option"
-
-instance [Serialize A] : Serialize (Option A) where
-  put := putOption
-  get := getOption
-
-instance: Serialize Unit where
-  put _ := pure ()
-  get := pure ()
-
-instance : Serialize Address where
-  put x := putBytes x.hash
-  get := Address.mk <$> getBytes 32
-
-def serialize {A: Type} [Serialize A] (x: A) : ByteArray :=
-  runPut <| Serialize.put x
-
-def deserialize {A: Type} [Serialize A] (bs: ByteArray) : Except String A :=
-  runGet Serialize.get bs
-
-end Ixon
diff --git a/Ix/Ixon/Tag.lean b/Ix/Ixon/Tag.lean
deleted file mode 100644
index 89783550..00000000
--- a/Ix/Ixon/Tag.lean
+++ /dev/null
@@ -1,83 +0,0 @@
-namespace Ixon
-
-def byteCount (x: UInt64) : UInt8 :=
-  if      x < 0x0000000000000100 then 1
-  else if x < 0x0000000000010000 then 2
-  else if x < 0x0000000001000000 then 3
-  else if x < 0x0000000100000000 then 4
-  else if x < 0x0000010000000000 then 5
-  else if x < 0x0001000000000000 then 6
-  else if x < 0x0100000000000000 then 7
-  else 8
-
-def trimmedLE (x: UInt64) : Array UInt8 :=
-  if x == 0 then Array.mkArray1 0 else List.toArray (go 8 x)
-  where
-    go : Nat → UInt64 → List UInt8
-    | _, 0 => []
-    | 0, _ => []
-    | Nat.succ f, x =>
-      Nat.toUInt8 (UInt64.toNat x) :: go f (UInt64.shiftRight x 8)
-
-def fromTrimmedLE (xs: Array UInt8) : UInt64 := List.foldr step 0 xs.toList
-  where
-    step byte acc := UInt64.shiftLeft acc 8 + (UInt8.toUInt64 byte)
-
---  F := flag, L := large-bit, X := small-field, A := large_field
--- 0xFFLX_XXXX {AAAA_AAAA, ...}
-structure Tag2 where
-  flag: Fin 4
-  size: UInt64
-  deriving Inhabited, Repr, BEq, Hashable
-
-def encodeTag2Head (tag: Tag2) : UInt8 := 
-  let t := UInt8.shiftLeft (UInt8.ofNat tag.flag.val) 6
-  if tag.size < 32
-  then t + (UInt64.toUInt8 tag.size)
-  else t + 0b10_0000 + (byteCount tag.size - 1)
-
-def flag2_to_Fin4 (x: UInt8) : Fin 4 :=
-  ⟨ x.toNat / 64, by
-      have h256 : x.toNat < 256 := UInt8.toNat_lt x
-      have h : x.toNat < 64 * 4 := by simpa using h256
-      exact (Nat.div_lt_iff_lt_mul (by decide)).mpr h
-  ⟩
-
-def decodeTag2Head (head: UInt8) : (Fin 4 × Bool × UInt8) :=
-  let flag : Fin 4 := flag2_to_Fin4 head
-  let largeBit := (UInt8.land head 0b10_0000 != 0)
-  let small := head % 0b10_0000
-  (flag, largeBit, small)
-
---  F := flag, L := large-bit, X := small-field, A := large_field
--- 0xFFFF_LXXX {AAAA_AAAA, ...}
--- "Tag" means the whole thing
--- "Head" means the first byte of the tag
--- "Flag" means the first nibble of the head
-structure Tag4 where
-  flag: Fin 16
-  size: UInt64
-  deriving Inhabited, Repr, BEq, Hashable
-
--- 0xC is a hardcoded exception without small size
-def encodeTag4Head (tag: Tag4): UInt8 :=
-  let t := UInt8.shiftLeft (UInt8.ofNat tag.flag.val) 4
-  if tag.size < 8
-  then t + tag.size.toUInt8
-  else t + 0b1000 + (byteCount tag.size - 1)
-
-def flag4_to_Fin16 (x: UInt8) : Fin 16 :=
-  ⟨ x.toNat / 16, by
-      have h256 : x.toNat < 256 := UInt8.toNat_lt x
-      have h : x.toNat < 16 * 16 := by simpa using h256
-      exact (Nat.div_lt_iff_lt_mul (by decide)).mpr h
-  ⟩
-
--- 0xC is a hardcoded exception without small size
-def decodeTag4Head (head: UInt8) : (Fin 16 × Bool × UInt8) :=
-  let flag : Fin 16 := flag4_to_Fin16 head
-  let largeBit := UInt8.land head 0b1000 != 0
-  let small := if flag == 0xC then head % 0b10000 else head % 0b1000
-  (flag, largeBit, small)
-
-end Ixon
diff --git a/Ix/Ixon/Univ.lean b/Ix/Ixon/Univ.lean
deleted file mode 100644
index d00b9272..00000000
--- a/Ix/Ixon/Univ.lean
+++ /dev/null
@@ -1,48 +0,0 @@
-import Ix.Ixon.Serialize
-
-namespace Ixon
-
--- 0xTTLX_XXXX
-inductive Univ where
-  -- 0x0X 1
-  | const : UInt64 -> Univ
-  -- 0x1X ^1
-  | var : UInt64 -> Univ
-  -- 0x2X (+ x y)
-  | add : UInt64 -> Univ -> Univ
-  -- 0x30 (max x y)
-  | max : Univ -> Univ -> Univ
-  -- 0x31 (imax x y)
-  | imax : Univ -> Univ -> Univ
-  deriving Repr, Inhabited, BEq
-
-open Serialize
-
-def putUniv : Univ -> PutM Unit
-  | .const i => put (Tag2.mk 0x0 i)
-  | .var i => put (Tag2.mk 0x1 i)
-  | .add i x => put (Tag2.mk 0x2 i) *> putUniv x
-  | .max x y => put (Tag2.mk 0x3 0) *> putUniv x *> putUniv y
-  | .imax x y => put (Tag2.mk 0x3 1) *> putUniv x *> putUniv y
-
-def getUniv : GetM Univ := do
-  let st ← get
-  go (st.bytes.size - st.idx)
-  where
-    go : Nat → GetM Univ
-    | 0 => throw "Out of fuel"
-    | Nat.succ f => do
-      let tag ← getTag2
-      match tag with
-      | ⟨0x0, x⟩ => pure (.const x)
-      | ⟨0x1, x⟩ => pure (.var x)
-      | ⟨0x2, x⟩ => .add x <$> go f
-      | ⟨0x3, 0⟩ => .max <$> go f <*> go f
-      | ⟨0x3, 1⟩ => .imax <$> go f <*> go f
-      | x => throw s!"Unknown Ixon Universe tag {repr x}"
-
-instance : Serialize Univ where
-  put := putUniv
-  get := getUniv
-
-end Ixon
diff --git a/Ix/Prove.lean b/Ix/Prove.lean
deleted file mode 100644
index bb45d038..00000000
--- a/Ix/Prove.lean
+++ /dev/null
@@ -1,26 +0,0 @@
-import Ix.Address
-import Ix.Ixon.Serialize
-import Ix.Claim
-import Ix.Common
-
---inductive ProveError
---  | todo
---
---instance : ToString ProveError := ⟨fun _ => "TODO"⟩
---
---abbrev ProveM := ExceptT ProveError IO
-
-structure Proof where
-  claim: Claim
-  /-- Bytes of the Binius proof -/
-  bin : ByteArray
-  deriving Inhabited, BEq
-
-instance : ToString Proof where
-  toString p := s!"<{toString p.claim} := {hexOfBytes p.bin}>"
-
-instance : Repr Proof where
-  reprPrec p _ := toString p
---
---def prove (claim : Claim) : ProveM Proof :=
---  default -- TODO
diff --git a/Ix/Store.lean b/Ix/Store.lean
index 6ec0b5e8..2c356020 100644
--- a/Ix/Store.lean
+++ b/Ix/Store.lean
@@ -1,6 +1,5 @@
 import Ix.Address
 import Ix.Ixon
-import Ix.Ixon.Serialize
 
 import Init.System.FilePath
 import Init.System.IO
diff --git a/Ix/TransportM.lean b/Ix/TransportM.lean
deleted file mode 100644
index f97095e4..00000000
--- a/Ix/TransportM.lean
+++ /dev/null
@@ -1,479 +0,0 @@
-import Std.Data.HashMap
-import Ix.IR
-import Ix.Ixon.Univ
-import Ix.Ixon
-import Ix.Common
-import Ix.Address
-import Ix.Ixon.Metadata
-import Ix.Ixon.Serialize
-import Ix.Prove
-import Batteries.Data.RBMap
-
-namespace Ix.TransportM
-
-open Ixon
-
-structure DematState where
-  idx: Nat
-  store: Store
-  meta: Std.HashMap Nat (List Metadatum)
-  deriving Repr
-
-def emptyDematState : DematState := { idx := 0, store := {}, meta := {} }
-
-inductive TransportError
-| natTooBig (idx: Nat) (x: Nat)
-| unknownIndex (idx: Nat) (m: List (Nat × List Metadatum))
-| unknownAddress (adr: Address)
-| unexpectedNode (idx: Nat) (m: List (Nat × List Metadatum))
-| nonExprIxon (x: Ixon) (m: List (Nat × List Metadatum))
-| nonConstIxon (x: Ixon) (m: List (Nat × List Metadatum))
-| rawMetadata (m: Ixon.Metadata)
-| expectedMetadata (m: Ixon.Ixon)
-| rawProof (m: Proof)
-| rawComm (m: Ixon.Comm)
-| emptyEquivalenceClass
-deriving BEq, Repr
-
-instance : ToString TransportError where toString
-| .natTooBig idx x => s!"At index {idx}, natural number {x} too big to fit in UInt64"
-| .unknownIndex idx x => s!"Unknown index {idx} with metadata {repr x}"
-| .unknownAddress x => s!"Unknown address {x}"
-| .nonExprIxon x m => s!"Tried to rematerialize {repr x} with metadata {repr m} as expression"
-| .nonConstIxon x m => s!"Tried to rematerialize {repr x} with metadata {repr m} as constant"
-| .unexpectedNode idx x => s!"Unexpected node at {idx} with metadata {repr x}"
-| .rawMetadata x => s!"Can't rematerialize raw metadata {repr x}"
-| .expectedMetadata x => s!"Expected metadata, got {repr x}"
-| .rawProof x => s!"Can't rematerialize raw proof {repr x}"
-| .rawComm x => s!"Can't rematerialize raw commitment {repr x}"
-| .emptyEquivalenceClass => s!"empty equivalence class, should be unreachable"
-
-abbrev DematM := EStateM TransportError DematState
-
-structure RematState where
-  idx: Nat
-  store: Store
-
-def emptyRematState : RematState := { idx := 0, store := {} }
-
-def rematStateWithStore (store: Std.HashMap Address Ixon) : RematState := 
-  { idx := 0, store }
-
-structure RematCtx where
-  meta: Std.HashMap Nat (List Metadatum)
-
-abbrev RematM := ReaderT RematCtx (EStateM TransportError RematState)
-
-def countSucc : Ix.Level -> Nat -> (Nat × Ix.Level)
-| .succ x, i => countSucc x (.succ i)
-| n, i => (i, n)
-
-def unrollSucc : Nat -> Ix.Level -> Ix.Level
-| 0, x => x
-| .succ i, x => unrollSucc i (.succ x)
-
-def dematNat (x: Nat): DematM UInt64 :=
-  if x > UInt64.MAX.toNat then
-    get >>= fun stt => throw (.natTooBig stt.idx x)
-    else return x.toUInt64
-
-def dematIncrN (x: Nat) : DematM Nat := do
-  let n <- (·.idx) <$> get
-  modify fun stt => { stt with idx := n + x }
-  return n + x
-
-def dematIncr : DematM Nat := dematIncrN 1
-
-def dematMeta (node: List Ixon.Metadatum): DematM Unit := do
-  let n <- (·.idx) <$> get
-  modify fun stt =>
-    { stt with meta := stt.meta.insert n node  }
-
-partial def dematUniv : Ix.Level -> DematM Ixon.Univ
-| .zero => dematIncr *> return .const 0
-| .succ x => match countSucc x 1 with
-  | (i, .zero) => dematIncrN (i + 1) *> .const <$> dematNat i
-  | (i, x) => dematIncrN (i + 1) *> .add <$> dematNat i <*> dematUniv x
-| .max x y => dematIncr *> .max <$> dematUniv x <*> dematUniv y
-| .imax x y => dematIncr *> .imax <$> dematUniv x <*> dematUniv y
-| .param n i => do
-  let _ <- dematIncr
-  dematMeta [.name n]
-  .var <$> dematNat i
-
-partial def dematLevels (lvls: List Lean.Name): DematM Nat :=
-  go 0 lvls
-  where
-    go (acc: Nat) : List Lean.Name -> DematM Nat
-    | n::ns => do
-      let _ <- dematIncr
-      dematMeta [.name n]
-      go (acc+1) ns
-    | [] => pure acc
-
-def rematIncrN (x: Nat) : RematM Nat := do
-  let n <- (·.idx) <$> get
-  modify fun stt => { stt with idx := n + x }
-  return n + x
-
-def rematIncr : RematM Nat := rematIncrN 1
-
-def rematMeta : RematM (List Ixon.Metadatum) := do
-  let n <- (·.idx) <$> get
-  let m <- (·.meta) <$> read
-  match m.get? n with
-  | .some n => return n
-  | .none => throw (.unknownIndex n m.toList)
-
-def rematThrowUnexpected : RematM α := do
-  let n <- (·.idx) <$> get
-  let m <- (·.meta) <$> read
-  throw (.unexpectedNode n m.toList)
-
-partial def rematLevels (lvls: Nat): RematM (List Lean.Name) := do
-  go [] lvls
-  where
-    go (acc: List Lean.Name): Nat -> RematM (List Lean.Name)
-    | 0 => pure acc.reverse
-    | i => do
-      let _ <- rematIncr
-      match (<- rematMeta) with
-      | [.name n] => go (n::acc) (i - 1)
-      | _ => rematThrowUnexpected
-
-def rematBindMeta : RematM (Lean.Name × Lean.BinderInfo) := do
-  match (<- rematMeta) with
-  | [.name n, .info i] => return (n, i)
-  | _ => rematThrowUnexpected
-
-def rematUniv : Ixon.Univ -> RematM Ix.Level
-| .const i => do
-  let i' := UInt64.toNat i
-  rematIncrN (i' + 1) *> return (unrollSucc i') .zero
-| .add i x => do
-  let i' := UInt64.toNat i
-  rematIncrN (i' + 1) *> (unrollSucc i') <$> rematUniv x
-| .max x y => rematIncr *> .max <$> rematUniv x <*> rematUniv y
-| .imax x y => rematIncr *> .imax <$> rematUniv x <*> rematUniv y
-| .var x => do
-  let _ <- rematIncr
-  match (<- rematMeta) with
-  | [.name name] => return .param name (UInt64.toNat x)
-  | _ => rematThrowUnexpected
-
-partial def dematExpr : Ix.Expr -> DematM Ixon
-| .var i => dematIncr *> .vari <$> dematNat i
-| .sort u => dematIncr *> .sort <$> dematUniv u
-| .const n r m us => do
-  let _ <- dematIncr
-  dematMeta [.name n, .link m ]
-  .refr r <$> (us.mapM dematUniv)
-| .rec_ n i us => do
-  let _ <- dematIncr
-  dematMeta [.name n]
-  .recr <$> dematNat i <*> (us.mapM dematUniv)
-| .app f a => apps f a []
-| .lam n i t b => lams (.lam n i t b) []
-| .pi n i t b => alls (.pi n i t b) []
-| .letE n t v b nD => do
-  let _ <- dematIncr
-  dematMeta [.name n]
-  .letE nD <$> dematExpr t <*> dematExpr v <*> dematExpr b
-| .lit l => dematIncr *> match l with
-  | .strVal s => return .strl s
-  | .natVal n => return .natl n
-| .proj n t tM i s => do
-  let _ <- dematIncr
-  dematMeta [.name n, .link tM ]
-  .proj t <$> dematNat i <*> dematExpr s
-  where
-    apps : Ix.Expr -> Ix.Expr -> List Ix.Expr -> DematM Ixon
-    | .app ff fa, a, as => apps ff fa (a::as)
-    | f, a, as => do
-      let as' <- as.reverse.mapM (fun a => dematIncr *> dematExpr a)
-      .apps <$> dematExpr f <*> dematExpr a <*> pure (as'.reverse)
-    lams : Ix.Expr -> List Ixon -> DematM Ixon
-    | .lam n i t b, ts => do
-      let _ <- dematIncr
-      dematMeta [.name n, .info i]
-      let t' <- dematExpr t
-      lams b (t'::ts)
-    | x, ts => .lams ts.reverse <$> dematExpr x
-    alls : Ix.Expr -> List Ixon -> DematM Ixon
-    | .pi n i t b, ts => do
-      let _ <- dematIncr
-      dematMeta [.name n, .info i]
-      let t' <- dematExpr t
-      alls b (t'::ts)
-    | x, ts => .alls ts.reverse <$> dematExpr x
-
-partial def rematExpr : Ixon -> RematM Ix.Expr
-| .vari i => rematIncr *> pure (.var i.toNat)
-| .sort u => rematIncr *> .sort <$> rematUniv u
-| .refr adr us => do
-  let _ <- rematIncr
-  let node <- rematMeta
-  let us' <- us.mapM rematUniv
-  match node with
-  | [.name name, .link link] => return (.const name adr link us')
-  | _ => rematThrowUnexpected
-| .recr i us => do 
-  let _ <- rematIncr
-  let node <- rematMeta
-  let us' <- us.mapM rematUniv
-  match node with
-  | [.name name] => return (.rec_ name i.toNat us')
-  | _ => rematThrowUnexpected
-| .apps f a as => do
-  let as' <- as.reverse.mapM (fun e => rematIncr *> rematExpr e)
-  let f' <- rematExpr f
-  let a' <- rematExpr a
-  return as'.reverse.foldl .app (.app f' a')
-| .lams ts b => do
-  let ts' <- ts.mapM 
-    (fun e => rematIncr *> Prod.mk <$> rematBindMeta <*> rematExpr e)
-  let b' <- rematExpr b
-  return ts'.foldr (fun (m, t) b => Expr.lam m.fst m.snd t b) b'
-| .alls ts b => do
-  let ts' <- ts.mapM
-    (fun e => rematIncr *> Prod.mk <$> rematBindMeta <*> rematExpr e)
-  let b' <- rematExpr b
-  return ts'.foldr (fun (m, t) b => Expr.pi m.fst m.snd t b) b'
-| .letE nD t d b => do
-  let _ <- rematIncr
-  let node <- rematMeta
-  let name <- match node with
-    | [.name n] => pure n
-    | _ => rematThrowUnexpected
-  .letE name <$> rematExpr t <*> rematExpr d <*> rematExpr b <*> pure nD
-| .proj t i s => do
-  let _ <- rematIncr
-  let node <- rematMeta
-  let (name, link) <- match node with
-    | [.name n, .link l] => pure (n, l)
-    | _ => rematThrowUnexpected
-  .proj name t link i.toNat <$> rematExpr s
-| .strl s => rematIncr *> return .lit (.strVal s)
-| .natl n => rematIncr *> return .lit (.natVal n)
-| e => do throw (.nonExprIxon e (<- read).meta.toList)
-
-def dematStore (ixon: Ixon): DematM Address :=
-  let addr := Address.blake3 (Ixon.runPut (Ixon.Serialize.put ixon))
-  modifyGet fun stt => (addr, { stt with
-    store := stt.store.insert addr ixon
-  })
-
-partial def dematConst : Ix.Const -> DematM Ixon
-| .«axiom» x => do
-  dematMeta [.name x.name]
-  let lvls <- dematLevels x.levelParams
-  let type <- dematExpr x.type >>= dematStore
-  return .axio (.mk x.isUnsafe lvls type)
-| .«definition» x => .defn <$> dematDefn x
-| .quotient x => do
-  dematMeta [.name x.name]
-  let lvls <- dematLevels x.levelParams
-  let type <- dematExpr x.type >>= dematStore
-  return .quot (.mk x.kind lvls type)
-| .inductiveProj x => do
-  dematMeta [.name x.name, .link x.blockMeta]
-  return .iprj (.mk x.idx x.blockCont)
-| .constructorProj x => do
-  dematMeta [.name x.name, .link x.blockMeta, .name x.induct]
-  return .cprj (.mk x.idx x.cidx x.blockCont)
-| .recursorProj x => do
-  dematMeta [.name x.name, .link x.blockMeta, .name x.induct]
-  return .rprj (.mk x.idx x.ridx x.blockCont)
-| .definitionProj x => do
-  dematMeta [.name x.name, .link x.blockMeta]
-  return .dprj (.mk x.idx x.blockCont)
-| .mutual x => do
-  dematMeta [.mutCtx x.ctx]
-  let defs <- x.defs.mapM fun ds => ds.mapM dematDefn
-  let ds <- defs.mapM fun d => match d.head? with
-    | .some a => pure a
-    | .none => throw .emptyEquivalenceClass
-  return .defs ds
-| .inductive x => do
-  dematMeta [.mutCtx x.ctx]
-  let inds <- x.inds.mapM fun is => is.mapM dematIndc
-  let is <- inds.mapM fun i => match i.head? with
-    | .some a => pure a
-    | .none => throw .emptyEquivalenceClass
-  return .inds is
-  where
-    dematDefn (x: Ix.Definition): DematM Ixon.Definition := do
-      let _ <- dematIncr
-      dematMeta [.name x.name, .hints x.hints, .all x.all]
-      let lvls <- dematLevels x.levelParams
-      let type <- dematExpr x.type >>= dematStore
-      let value <- dematExpr x.value >>= dematStore
-      return .mk x.kind x.safety lvls type value
-    dematCtor (x: Ix.Constructor): DematM Ixon.Constructor := do
-      let _ <- dematIncr
-      dematMeta [.name x.name]
-      let lvls <- dematLevels x.levelParams
-      let t <- dematExpr x.type >>= dematStore
-      return .mk x.isUnsafe lvls x.cidx x.numParams x.numFields t
-    dematRecrRule (x: Ix.RecursorRule): DematM Ixon.RecursorRule := do
-      let _ <- dematIncr
-      dematMeta [.name x.ctor]
-      let rhs <- dematExpr x.rhs >>= dematStore
-      return ⟨x.nfields, rhs⟩
-    dematRecr (x: Ix.Recursor): DematM Ixon.Recursor := do
-      let _ <- dematIncr
-      dematMeta [.name x.name]
-      let lvls <- dematLevels x.levelParams
-      let t <- dematExpr x.type >>= dematStore
-      let rrs <- x.rules.mapM dematRecrRule
-      return ⟨x.k, x.isUnsafe, lvls, x.numParams, x.numIndices, x.numMotives, 
-        x.numMinors, t, rrs⟩
-    dematIndc (x: Ix.Inductive): DematM Ixon.Inductive := do
-      let _ <- dematIncr
-      dematMeta [.name x.name, .all x.all]
-      let lvls <- dematLevels x.levelParams
-      let type <- dematExpr x.type >>= dematStore
-      let ctors <- x.ctors.mapM dematCtor
-      let recrs <- x.recrs.mapM dematRecr
-      return ⟨x.isRec, x.isReflexive, x.isUnsafe,
-        lvls, x.numParams, x.numIndices,x.numNested, type, ctors, recrs,
-        ⟩
-
-def dematerialize (x: Ix.Const) : Except TransportError (Ixon × DematState) :=
-  dbg_trace "dematerialize"
-  match EStateM.run (dematConst x) emptyDematState with
-  | .ok ix stt => .ok (ix, stt)
-  | .error e _ => .error e
-
-def rematAddress (adr: Address): RematM Ixon := do
-  match (<- get).store.get? adr with
-  | .some x => return x
-  | .none => throw (.unknownAddress adr)
-
-def rematExprAddress (adr: Address): RematM Ix.Expr := do
-  match (<- get).store.get? adr with
-  | .some x => rematExpr x
-  | .none => throw (.unknownAddress adr)
-
-partial def rematConst : Ixon -> RematM Ix.Const
-| .defn x => .«definition» <$> rematDefn x
-| .axio x => do
-  let name <- match (<- rematMeta) with
-    | [.name x] => pure x
-    | _ => rematThrowUnexpected
-  let lvls <- rematLevels x.lvls
-  let type <- rematExprAddress x.type
-  return .«axiom» ⟨name, lvls, type, x.isUnsafe⟩
-| .quot x => do
-  let name <- match (<- rematMeta) with
-    | [.name x] => pure x
-    | _ => rematThrowUnexpected
-  let lvls <- rematLevels x.lvls
-  let type <- rematExprAddress x.type
-  return .quotient ⟨name, lvls, type, x.kind⟩
-| .iprj x => do
-  let (name, link) <- match (<- rematMeta) with
-    | [.name n, .link x] => pure (n, x)
-    | _ => rematThrowUnexpected
-  return .inductiveProj ⟨name, x.block, link, x.idx⟩
-| .cprj x => do
-  let (name, link, induct) <- match (<- rematMeta) with
-    | [.name n, .link x, .name i] => pure (n, x, i)
-    | _ => rematThrowUnexpected
-  return .constructorProj ⟨name, x.block, link, x.idx, induct, x.cidx⟩
-| .rprj x => do
-  let (name, link, induct) <- match (<- rematMeta) with
-    | [.name n, .link x, .name i] => pure (n, x, i)
-    | _ => rematThrowUnexpected
-  return .recursorProj ⟨name, x.block, link, x.idx, induct, x.ridx⟩
-| .dprj x => do
-  let (name, link) <- match (<- rematMeta) with
-    | [.name n, .link x] => pure (n, x)
-    | _ => rematThrowUnexpected
-  return .definitionProj ⟨name, x.block, link, x.idx⟩
-| .defs xs => do
-  let ctx <- match (<- rematMeta) with
-    | [.mutCtx x] => pure x
-    | _ => rematThrowUnexpected
-  let mut defs := #[]
-  for (x, ns) in List.zip xs ctx do
-    let mut ds := #[]
-    for _ in ns do
-      let d <- rematDefn x
-      ds := ds.push d
-    defs := defs.push ds.toList
-  return .mutual ⟨defs.toList⟩
-| .inds xs => do
-  let ctx <- match (<- rematMeta) with
-    | [.mutCtx x] => pure x
-    | _ => rematThrowUnexpected
-  let mut inds := #[]
-  for (x, ns) in List.zip xs ctx do
-    let mut is := #[]
-    for _ in ns do
-      let i <- rematIndc x
-      is := is.push i
-    inds := inds.push is.toList
-  return .inductive ⟨inds.toList⟩
-| .meta m => throw (.rawMetadata m)
--- TODO: This could return a Proof inductive, since proofs have no metadata
-| .prof p => throw (.rawProof p)
-| .comm p => throw (.rawComm p)
-| e => do throw (.nonConstIxon e (<- read).meta.toList)
-  where
-    rematDefn (x: Ixon.Definition) : RematM Ix.Definition := do
-      let _ <- rematIncr
-      let (name, hints, all) <- match (<- rematMeta) with
-        | [.name n, .hints h, .all as] => pure (n, h, as)
-        | _ => rematThrowUnexpected
-      let lvls <- rematLevels x.lvls
-      let type <- rematExprAddress x.type
-      let value <- rematExprAddress x.value
-      return .mk name lvls type x.kind value hints x.safety all
-    rematCtor (x: Ixon.Constructor) : RematM Ix.Constructor := do
-      let _ <- rematIncr
-      let name <- match (<- rematMeta) with
-        | [.name n] => pure n
-        | _ => rematThrowUnexpected
-      let lvls <- rematLevels x.lvls
-      let t <- rematExprAddress x.type
-      return .mk name lvls t x.cidx x.params x.fields x.isUnsafe
-    rematRecrRule (x: Ixon.RecursorRule) : RematM Ix.RecursorRule := do
-      let _ <- rematIncr
-      let ctor <- match (<- rematMeta) with
-        | [.name n] => pure n
-        | _ => rematThrowUnexpected
-      let rhs <- rematExprAddress x.rhs
-      return ⟨ctor, x.fields, rhs⟩
-    rematRecr (x: Ixon.Recursor) : RematM Ix.Recursor := do
-      let _ <- rematIncr
-      let name <- match (<- rematMeta) with
-        | [.name n] => pure n
-        | _ => rematThrowUnexpected
-      let lvls <- rematLevels x.lvls
-      let t <- rematExprAddress x.type
-      let rs <- x.rules.mapM rematRecrRule
-      return ⟨name, lvls, t, x.params, x.indices, x.motives, x.minors, rs, x.k, x.isUnsafe⟩
-    rematIndc (x: Ixon.Inductive) : RematM Ix.Inductive := do
-      let _ <- rematIncr
-      let (name, all) <- match (<- rematMeta) with
-        | [.name n, .all as] => pure (n, as)
-        | _ => rematThrowUnexpected
-      let lvls <- rematLevels x.lvls
-      let t <- rematExprAddress x.type
-      let cs <- x.ctors.mapM rematCtor
-      let rs <- x.recrs.mapM rematRecr
-      return ⟨name, lvls, t, x.params, x.indices, all, cs, rs, x.nested, x.recr,
-        x.refl, x.isUnsafe⟩
-
-def rematerialize (c m: Ixon) : Except TransportError Ix.Const := do
-  dbg_trace "rematerialize"
-  let m <- match m with
-  | .meta m => pure m
-  | x => throw <| .expectedMetadata x
-  let m := Std.HashMap.ofList m.map
-  match ((rematConst c).run { meta := m }).run emptyRematState with
-    | .ok a _ => return a
-    | .error e _ => throw e
-
-end Ix.TransportM

From 3e78ae1390cd630d2bdcc97298758a9095fdcbdf Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 6 Oct 2025 19:08:45 -0400
Subject: [PATCH 47/74] compiler refactored

---
 Ix.lean          |    4 +-
 Ix/Address.lean  |    3 +
 Ix/Common.lean   |    4 +
 Ix/CompileM.lean | 1899 ++++++++++++++++++++++------------------------
 Ix/IR.lean       |   54 +-
 Ix/Ixon.lean     |  150 +++-
 Ix/Meta.lean     |    6 +-
 7 files changed, 1054 insertions(+), 1066 deletions(-)

diff --git a/Ix.lean b/Ix.lean
index 0d370956..740fe99c 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -2,8 +2,6 @@
 -- Import modules here that should be built as part of the library.
 import Ix.Ixon
 import Ix.IR
---import Ix.Meta
+import Ix.Meta
 import Ix.CompileM
 --import Ix.DecompileM
---import Ix.Claim
---import Ix.Prove
diff --git a/Ix/Address.lean b/Ix/Address.lean
index 20d19d1a..7200f84a 100644
--- a/Ix/Address.lean
+++ b/Ix/Address.lean
@@ -114,3 +114,6 @@ structure MetaAddress where
   meta : Address
   deriving Inhabited, Lean.ToExpr, BEq, Hashable, Repr, Ord
 
+instance : ToString MetaAddress where
+  toString adr := s!"{hexOfBytes adr.data.hash}:{hexOfBytes adr.meta.hash}"
+
diff --git a/Ix/Common.lean b/Ix/Common.lean
index d3336ac8..8448942e 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -47,6 +47,10 @@ deriving instance BEq, Repr, Hashable for Lean.RecursorVal
 deriving instance BEq, Repr, Hashable for Lean.ConstructorVal
 deriving instance BEq, Repr, Hashable for Lean.InductiveVal
 deriving instance BEq, Repr, Hashable for Lean.ConstantInfo
+deriving instance BEq, Repr, Hashable for Substring
+deriving instance BEq, Repr, Hashable for Lean.SourceInfo
+deriving instance BEq, Repr, Hashable for Lean.Syntax.Preresolved
+deriving instance BEq, Repr, Hashable for Lean.Syntax
 deriving instance BEq, Repr for Ordering
 
 def UInt8.MAX : UInt64 := 0xFF
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index ec6a55f1..4d9c8e7d 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -11,7 +11,7 @@ open Std (HashMap)
 --open Ix.TransportM
 
 namespace Ix
-open Ixon
+open Ixon hiding Substring
 
 structure CompileEnv where
   univCtx : List Lean.Name
@@ -26,13 +26,16 @@ structure CompileState where
   env: Lean.Environment
   prng: StdGen
   store: HashMap Address ByteArray
-  names: HashMap Lean.Name Address
   univCache: HashMap Lean.Level Ix.Level
   univAddrs: HashMap Ix.Level MetaAddress
+  constNames: HashMap Lean.Name MetaAddress
   constCache: HashMap Lean.ConstantInfo Ix.Const
   constAddrs : HashMap Ix.Const MetaAddress
   exprCache: HashMap Lean.Expr Ix.Expr
   exprAddrs: HashMap Ix.Expr MetaAddress
+  synCache: HashMap Lean.Syntax Ixon.Syntax
+  nameCache: HashMap Lean.Name Address
+  strCache: HashMap String Address
   comms: HashMap Lean.Name MetaAddress
   constCmp: HashMap (Lean.Name × Lean.Name) Ordering
   exprCmp: HashMap (CompileEnv × Lean.Expr × Lean.Expr) Ordering
@@ -40,56 +43,54 @@ structure CompileState where
   blocks: Std.HashSet MetaAddress
   cronos: Cronos
 
-def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize) : CompileState :=
+def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize) 
+  : CompileState :=
   ⟨maxHeartBeats, env, mkStdGen seed, default, default, default, default,
   default, default, default, default, default, default, default, default,
-  default, default⟩
+  default, default, default, default, default⟩
 
 inductive CompileError where
-| unknownConstant : Lean.Name → CompileError
-| unfilledLevelMetavariable : Lean.Level → CompileError
---| unfilledExprMetavariable : Lean.Expr → CompileError
---| invalidBVarIndex : Nat → CompileError
---| freeVariableExpr : Lean.Expr → CompileError
---| metaVariableExpr : Lean.Expr → CompileError
---| metaDataExpr : Lean.Expr → CompileError
-| levelNotFound : Lean.Name → List Lean.Name -> String → CompileError
---| invalidConstantKind : Lean.Name → String → String → CompileError
---| constantNotContentAddressed : Lean.Name → CompileError
+| unknownConstant : Lean.Name -> CompileError
+| levelMetavariable : Lean.Level -> CompileError
+| exprMetavariable : Lean.Expr -> CompileError
+| exprFreeVariable : Lean.Expr -> CompileError
+| invalidBVarIndex : Nat -> CompileError
+| levelNotFound : Lean.Name -> List Lean.Name -> String -> CompileError
+| invalidConstantKind : Lean.Name -> String -> String -> CompileError
+| compileMutualBlockMissingProjection : Lean.Name -> CompileError
+| compileInductiveBlockMissingProjection : Lean.Name -> CompileError
 --| nonRecursorExtractedFromChildren : Lean.Name → CompileError
---| cantFindMutDefIndex : Lean.Name → CompileError
-----| transportError : TransportError → CompileError
---| kernelException : Lean.Kernel.Exception → CompileError
+| cantFindMutDefIndex : Lean.Name -> CompileError
+| kernelException : Lean.Kernel.Exception → CompileError
 --| cantPackLevel : Nat → CompileError
---| nonCongruentInductives : PreInductive -> PreInductive -> CompileError
---| alphaInvarianceFailure : Ix.Const -> Address -> Ix.Const -> Address -> CompileError
---| emptyDefsEquivalenceClass: List (List PreDefinition) -> CompileError
---| emptyIndsEquivalenceClass: List (List PreInductive) -> CompileError
---
---def CompileError.pretty : CompileError -> IO String
---| .unknownConstant n => pure s!"Unknown constant '{n}'"
---| .unfilledLevelMetavariable l => pure s!"Unfilled level metavariable on universe '{l}'"
---| .unfilledExprMetavariable e => pure s!"Unfilled level metavariable on expression '{e}'"
---| .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
---| .freeVariableExpr e => pure s!"Free variable in expression '{e}'"
---| .metaVariableExpr e => pure s!"Metavariable in expression '{e}'"
---| .metaDataExpr e => pure s!"Meta data in expression '{e}'"
---| .levelNotFound n ns msg => pure s!"'Level {n}' not found in '{ns}', {msg}"
---| .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
---| .constantNotContentAddressed n => pure s!"Constant '{n}' wasn't content-addressed"
---| .nonRecursorExtractedFromChildren n => pure
---  s!"Non-recursor '{n}' extracted from children"
---| .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
-----| .transportError n => pure s!"compiler transport error '{repr n}'"
---| .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
---| .cantPackLevel n => pure s!"Can't pack level {n} greater than 2^256'"
---| .nonCongruentInductives a b => pure s!"noncongruent inductives {a.name} {b.name}'"
---| .alphaInvarianceFailure x xa y ya => 
---  pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
---| .emptyDefsEquivalenceClass dss => 
---  pure s!"empty equivalence class while sorting definitions {dss.map fun ds => ds.map (·.name)}"
---| .emptyIndsEquivalenceClass dss => 
---  pure s!"empty equivalence class while sorting inductives {dss.map fun ds => ds.map (·.name)}"
+--| nonCongruentInductives : PreInd -> PreInd -> CompileError
+| alphaInvarianceFailure : Ix.Const -> MetaAddress -> Ix.Const -> MetaAddress -> CompileError
+| dematBadMutualBlock: MutualBlock -> CompileError
+| dematBadInductiveBlock: InductiveBlock -> CompileError
+| emptyDefsClass: List (List PreDef) -> CompileError
+| emptyIndsClass: List (List PreInd) -> CompileError
+--| emptyIndsEquivalenceClass: List (List PreInd) -> CompileError
+
+def CompileError.pretty : CompileError -> IO String
+| .unknownConstant n => pure s!"Unknown constant '{n}'"
+| .levelMetavariable l => pure s!"Unfilled level metavariable on universe '{l}'"
+| .exprMetavariable e => pure s!"Unfilled level metavariable on expression '{e}'"
+| .exprFreeVariable e => pure s!"Free variable in expression '{e}'"
+| .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
+| .levelNotFound n ns msg => pure s!"'Level {n}' not found in '{ns}', {msg}"
+| .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
+| .compileMutualBlockMissingProjection n => pure s!"Constant '{n}' wasn't content-addressed in mutual block"
+| .compileInductiveBlockMissingProjection n => pure s!"Constant '{n}' wasn't content-addressed in inductive block"
+| .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
+| .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
+| .alphaInvarianceFailure x xa y ya => 
+  pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
+| .dematBadMutualBlock block => pure s!"bad mutual block while dematerializing {repr block}"
+| .dematBadInductiveBlock block => pure s!"bad mutual block while dematerializing {repr block}"
+| .emptyDefsClass dss => 
+  pure s!"empty equivalence class while sorting definitions {dss.map fun ds => ds.map (·.name)}"
+| .emptyIndsClass dss => 
+  pure s!"empty equivalence class while sorting inductives {dss.map fun ds => ds.map (·.name)}"
 
 abbrev CompileM :=
   ReaderT CompileEnv <| ExceptT CompileError <| StateT CompileState IO
@@ -145,11 +146,15 @@ def storeIxon (ixon: Ixon): CompileM Address := do
   })
 
 def storeString (str: String): CompileM Address := do
-  let bytes := str.toUTF8
-  let addr := Address.blake3 bytes
-  modifyGet fun stt => (addr, { stt with
-    store := stt.store.insert addr bytes
-  })
+  match (<- get).strCache.get? str with
+  | some addr => pure addr
+  | none => do
+    let bytes := str.toUTF8
+    let addr := Address.blake3 bytes
+    modifyGet fun stt => (addr, { stt with
+      strCache := stt.strCache.insert str addr
+      store := stt.store.insert addr bytes
+    })
 
 def storeNat (nat: Nat): CompileM Address := do
   let bytes := nat.toBytesLE
@@ -158,6 +163,13 @@ def storeNat (nat: Nat): CompileM Address := do
     store := stt.store.insert addr ⟨bytes⟩
   })
 
+def storeSerial [Serialize A] (a: A): CompileM Address := do
+  let bytes := Ixon.ser a
+  let addr := Address.blake3 bytes
+  modifyGet fun stt => (addr, { stt with
+    store := stt.store.insert addr bytes
+  })
+
 def storeMetadata (meta: Metadata): CompileM Address := do
   let bytes := Ixon.ser meta
   let addr := Address.blake3 bytes
@@ -166,12 +178,12 @@ def storeMetadata (meta: Metadata): CompileM Address := do
   })
 
 def dematerializeName (name: Lean.Name): CompileM Address := do
-  match (<- get).names.get? name with
+  match (<- get).nameCache.get? name with
   | some addr => pure addr
   | none => do
     let addr <- go name
     modifyGet fun stt => (addr, { stt with
-      names := stt.names.insert name addr
+      nameCache := stt.nameCache.insert name addr
     })
   where
     go : Lean.Name -> CompileM Address
@@ -188,8 +200,8 @@ def dematerializeName (name: Lean.Name): CompileM Address := do
 /-- Defines an ordering for Lean universes -/
 def compareLevel (xctx yctx: List Lean.Name)
   : Lean.Level -> Lean.Level -> CompileM SOrder
-  | x@(.mvar ..), _ => throw $ .unfilledLevelMetavariable x
-  | _, y@(.mvar ..) => throw $ .unfilledLevelMetavariable y
+  | x@(.mvar ..), _ => throw $ .levelMetavariable x
+  | _, y@(.mvar ..) => throw $ .levelMetavariable y
   | .zero, .zero => return ⟨true, .eq⟩
   | .zero, _ => return ⟨true, .lt⟩
   | _, .zero => return ⟨true, .gt⟩
@@ -262,7 +274,7 @@ def compileLevel (lvl: Lean.Level): CompileM Ix.Level := do
       match lvls.idxOf? name with
       | some n => pure $ .param name n
       | none   => throw $ .levelNotFound name lvls s!"compileLevel"
-    | l@(.mvar ..) => throw $ .unfilledLevelMetavariable l
+    | l@(.mvar ..) => throw $ .levelMetavariable l
 
 def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
   match (<- get).exprAddrs.get? expr with
@@ -277,59 +289,59 @@ def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
     })
   where
     go : Ix.Expr -> CompileM (Ixon × Ixon)
-    | .var kvs idx => pure (.evar idx, .meta ⟨kvs.map .kvmap⟩)
-    | .sort kvs univ => do
+    | .var md idx => pure (.evar idx, .meta ⟨[.link md]⟩)
+    | .sort md univ => do
       let ⟨udata, umeta⟩ <- dematerializeLevel univ
       let data := .esort udata
-      let meta := .meta { nodes := [.link umeta] ++ kvs.map .kvmap}
+      let meta := .meta ⟨[.link md, .link umeta]⟩
       pure (data, meta)
-    | .const kvs name ref univs => do
+    | .const md name ref univs => do
       let n <- dematerializeName name
       let us <- univs.mapM dematerializeLevel
       let data := .eref ref.data (us.map (·.data))
-      let meta := .meta ⟨[.name n, .link ref.meta] ++ us.map (.name ·.meta) ++ kvs.map .kvmap⟩
+      let meta := .meta ⟨[.link md, .name n, .link ref.meta] ++ us.map (.name ·.meta)⟩
       pure (data, meta)
-    | .rec_ kvs name idx univs => do
+    | .rec_ md name idx univs => do
       let n <- dematerializeName name
       let us <- univs.mapM dematerializeLevel
       let data := .erec idx (us.map (·.data))
-      let meta := .meta ⟨[.name n] ++ us.map (.name ·.meta) ++ kvs.map .kvmap⟩
+      let meta := .meta ⟨[.link md, .name n] ++ us.map (.name ·.meta)⟩
       pure (data, meta)
-    | .app kvs func argm => do
+    | .app md func argm => do
       let f' <- dematerializeExpr func
       let a' <- dematerializeExpr argm
       let data := .eapp f'.data a'.data
-      let meta := .meta ⟨[.link f'.meta, .link a'.meta] ++ kvs.map .kvmap⟩
+      let meta := .meta ⟨[.link md, .link f'.meta, .link a'.meta]⟩
       pure (data, meta)
-    | .lam kvs name info type body => do
+    | .lam md name info type body => do
       let n <- dematerializeName name
       let t' <- dematerializeExpr type
       let b' <- dematerializeExpr body
       let data := .elam t'.data b'.data
-      let meta := .meta ⟨[.name n, .info info, .link t'.meta, .link b'.meta] ++ kvs.map .kvmap⟩
+      let meta := .meta ⟨[.link md, .name n, .info info, .link t'.meta, .link b'.meta]⟩
       pure (data, meta)
-    | .pi kvs name info type body => do
+    | .pi md name info type body => do
       let n <- dematerializeName name
       let t' <- dematerializeExpr type
       let b' <- dematerializeExpr body
       let data := .eall t'.data b'.data
-      let meta := .meta ⟨[.name n, .info info, .link t'.meta, .link b'.meta] ++ kvs.map .kvmap⟩
+      let meta := .meta ⟨[.link md, .name n, .info info, .link t'.meta, .link b'.meta]⟩
       pure (data, meta)
-    | .letE kvs name type value body nD => do
+    | .letE md name type value body nD => do
       let n <- dematerializeName name
       let t' <- dematerializeExpr type
       let v' <- dematerializeExpr value
       let b' <- dematerializeExpr body
       let data := .elet nD t'.data v'.data b'.data
-      let meta := .meta ⟨[.name n, .link t'.meta, .link v'.meta, .link b'.meta] ++ kvs.map .kvmap⟩
+      let meta := .meta ⟨[.link md, .name n, .link t'.meta, .link v'.meta, .link b'.meta]⟩
       pure (data, meta)
-    | .lit kvs (.natVal n) => do pure (.enat (<- storeNat n), .meta ⟨kvs.map .kvmap⟩)
-    | .lit kvs (.strVal s) => do pure (.enat (<- storeString s), .meta ⟨kvs.map .kvmap⟩)
-    | .proj kvs typeName type idx struct => do
+    | .lit md (.natVal n) => do pure (.enat (<- storeNat n), .meta ⟨[.link md]⟩)
+    | .lit md (.strVal s) => do pure (.enat (<- storeString s), .meta ⟨[.link md]⟩)
+    | .proj md typeName type idx struct => do
       let n <- dematerializeName typeName
       let s' <- dematerializeExpr struct
       let data := .eprj type.data idx s'.data
-      let meta := .meta ⟨[.name n, .link type.meta, .link s'.meta] ++ kvs.map .kvmap⟩
+      let meta := .meta ⟨[.link md, .name n, .link type.meta, .link s'.meta]⟩
       pure (data, meta)
 
 def dematerializeConst (const: Ix.Const): CompileM MetaAddress := do
@@ -347,20 +359,20 @@ def dematerializeConst (const: Ix.Const): CompileM MetaAddress := do
     goDef : Ix.Definition -> CompileM (Ixon.Definition × Ixon.Metadata)
     | ⟨name, lvls, type, kind, value, hints, safety, all⟩ => do
       let n <- dematerializeName name
-      let ls <- lvls.mapM (fun n => .name <$> dematerializeName n)
+      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
       let t <- dematerializeExpr type
       let v <- dematerializeExpr value
-      let as <- all.mapM (fun n => .name <$> dematerializeName n)
+      let as <- storeMetadata ⟨<- all.mapM (.name <$> dematerializeName ·)⟩
       let data := ⟨kind, safety, lvls.length, t.data, v.data⟩
-      let meta := ⟨[.name n] ++ ls ++ [.link t.meta, .link v.meta] ++ as⟩
+      let meta := ⟨[.name n, .link ls, .hints hints, .link t.meta, .link v.meta, .link as]⟩
       pure (data, meta)
     goCtor : Ix.Constructor -> CompileM (Ixon.Constructor × Ixon.Metadata)
     | ⟨name, lvls, type, cidx, params, fields, usafe⟩ => do
       let n <- dematerializeName name
-      let ls <- lvls.mapM (fun n => .name <$> dematerializeName n)
+      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
       let t <- dematerializeExpr type
       let ctor := ⟨usafe, lvls.length, cidx, params, fields, t.data⟩
-      let meta := ⟨[.name n] ++ ls ++ [.link t.meta]⟩
+      let meta := ⟨[.name n, .link ls, .link t.meta]⟩
       pure (ctor, meta)
     goRecrRule : Ix.RecursorRule -> CompileM (Ixon.RecursorRule × Ixon.Metadata)
     | ⟨ctor, fields, rhs⟩ => do
@@ -372,931 +384,806 @@ def dematerializeConst (const: Ix.Const): CompileM MetaAddress := do
     goRecr : Ix.Recursor -> CompileM (Ixon.Recursor × Ixon.Metadata)
     | ⟨name, lvls, type, params, indices, motives, minors, rules, k, usafe⟩ => do
       let n <- dematerializeName name
-      let ls <- lvls.mapM (fun n => .name <$> dematerializeName n)
+      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
       let t <- dematerializeExpr type
       let rules <- rules.mapM goRecrRule
       let rulesData := rules.map (·.1)
-      let rulesMeta <- rules.mapM (fun x => .link <$> storeMetadata x.2)
+      let rulesMeta <- storeMetadata ⟨<- rules.mapM (.link <$> storeMetadata ·.2)⟩
       let recr := ⟨k, usafe, lvls.length, params, indices, motives, minors, t.data, rulesData⟩
-      let meta := ⟨[.name n] ++ ls ++ [.link t.meta] ++ rulesMeta⟩
+      let meta := ⟨[.name n, .link ls, .link t.meta, .link rulesMeta]⟩
       pure (recr, meta)
     goInd : Ix.Inductive -> CompileM (Ixon.Inductive × Ixon.Metadata)
     | ⟨name, lvls, type, params, indices, all, ctors, recrs, nested, recr, refl, usafe⟩ => do
       let n <- dematerializeName name
-      let ls <- lvls.mapM (fun n => Metadatum.name <$> dematerializeName n)
+      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
       let t <- dematerializeExpr type
       let cs <- ctors.mapM goCtor
       let ctorsData := cs.map (·.1)
-      let ctorsMeta <- cs.mapM (fun x=> Metadatum.link <$> storeMetadata x.2)
+      let ctorsMeta <- storeMetadata ⟨<- cs.mapM (.link <$> storeMetadata ·.2)⟩
       let rs <- recrs.mapM goRecr
       let recrsData := rs.map (·.1)
-      let recrsMeta <- rs.mapM (fun x=> Metadatum.link <$> storeMetadata x.2)
-      let as <- all.mapM (fun n => Metadatum.name <$> dematerializeName n)
+      let recrsMeta <- storeMetadata ⟨<- rs.mapM (.link <$> storeMetadata ·.2)⟩
+      let as <- storeMetadata ⟨<- all.mapM (.name <$> dematerializeName ·)⟩
       let data := ⟨recr, refl, usafe, lvls.length, params, indices, nested, t.data, ctorsData, recrsData⟩
-      let meta := ⟨[.name n] ++ ls ++ [.link t.meta] ++ ctorsMeta ++ recrsMeta⟩
+      let meta := ⟨[.name n, .link ls, .link t.meta, .link as, .link ctorsMeta, .link recrsMeta]⟩
       pure (data, meta)
     go : Ix.Const -> CompileM (Ixon × Ixon)
     | .axiom ⟨name, lvls, type, isUnsafe⟩ => do
       let n <- dematerializeName name
-      let ls <- lvls.mapM (fun n => Metadatum.name <$> dematerializeName n)
+      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
       let t <- dematerializeExpr type
       let data := .axio ⟨isUnsafe, lvls.length, t.data⟩
-      let meta := .meta ⟨[.name n] ++ ls⟩
+      let meta := .meta ⟨[.name n, .link ls]⟩
       pure (data, meta)
     | .quotient ⟨name, lvls, type, kind⟩ => do
       let n <- dematerializeName name
-      let ls <- lvls.mapM (fun n => Metadatum.name <$> dematerializeName n)
+      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
       let t <- dematerializeExpr type
       let data := .quot ⟨kind, lvls.length, t.data⟩
-      let meta := .meta ⟨[.name n] ++ ls ++ [.link t.meta]⟩
+      let meta := .meta ⟨[.name n, .link ls, .link t.meta]⟩
       pure (data, meta)
     | .definition d => (fun (d, m) => (.defn d, .meta m)) <$> goDef d
-    | .inductiveProj _ => sorry
-    | .constructorProj _ => sorry
-    | .recursorProj _ => sorry
-    | .definitionProj _ => sorry
-    | .mutual ds => sorry
-    | .inductive _ => sorry
-
-
---mutual
---/--
---Content-addresses a Lean expressio
----/
---partial def compileExpr (expr: Lean.Expr): CompileM Ix.Expr := do
---  match (<- get).exprCache.get? expr with
---  | some x => pure x
---  | none => do
---    let expr' <- go expr
---    let _ <- dematerializeExpr expr'
---    modifyGet fun stt => (lvl', { stt with
---      exprCache := stt.exprCache.insert expr expr'
---    })
---  where
---    go : Lean.Expr -> CompileM Ix.Expr
---    | .bvar idx => do match (← read).bindCtx[idx]? with
---      -- Bound variables must be in the bind context
---      | some _ => return .var idx
---      | none => throw $ .invalidBVarIndex idx
---    | .sort lvl => return .sort $ ← compileLevel lvl
---    | .const name lvls => do
---      let univs ← lvls.mapM compileLevel
---      match (← read).mutCtx.get? name with
---      -- recursing!
---      | some i => return .rec_ name i univs
---      | none => match (<- get).comms.get? name with
---        | some (commAddr, metaAddr) => do
---          return .const name commAddr metaAddr univs
---        | none => do
---          let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
---          return .const name contAddr metaAddr univs
---    | .app fnc arg => return .app (← compileExpr fnc) (← compileExpr arg)
---    | .lam name typ bod info =>
---      return .lam name info (← compileExpr typ) (← withBinder name $ compileExpr bod)
---    | .forallE name dom img info =>
---      return .pi name info (← compileExpr dom) (← withBinder name $ compileExpr img)
---    | .letE name typ exp bod nD =>
---      return .letE name (← compileExpr typ) (← compileExpr exp)
---        (← withBinder name $ compileExpr bod) nD
---    | .lit lit => return .lit lit
---    | .proj name idx exp => do
---      let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
---      return .proj name contAddr metaAddr idx (← compileExpr exp)
---    | expr@(.fvar ..)  => throw $ .freeVariableExpr expr
---    | expr@(.mvar ..)  => throw $ .metaVariableExpr expr
---    -- TODO: cursed
---    | (.mdata _ x) => compileExpr x
---
---/-- compile Lean Constant --/
---partial def compileConst (const : Lean.ConstantInfo) : CompileM Ix.Const := do
---  -- first check if we've already compiled this const
---  match (← get).names.get? const.name with
---  -- if we have, returned the cached address
---  | some (anonAddr, metaAddr) => do
---    pure (anonAddr, metaAddr)
---  -- if not, pattern match on the const
---  | none => do
---    dbg_trace "-> compileConst {const.name}";
---    let cronTag := s!"compileConst {const.name}"
---    cron cronTag
---    let cronTag2 := s!"constSize {const.name}"
---    dbg_trace "-> constSize {const.name}";
---    cron cronTag2
---    let size := const.size
---    cron cronTag2
---    dbg_trace "✓ {(<- getCron cronTag2)} {size}";
---    let addrs <- compileInner const
---    cron cronTag
---    let timing <- getCron cronTag
---    dbg_trace "✓ {timing}";
---    return addrs
---  where
---    compileInner (const: Lean.ConstantInfo) := resetCtx $ withCurrent const.name $ match const with
---    -- convert possible mutual block elements to PreDefinitions
---    | .defnInfo val => do
---      compileDefinition (mkPreDefinition val)
---    | .thmInfo val => do
---      compileDefinition (mkPreTheorem val)
---    | .opaqueInfo val => do
---      compileDefinition (mkPreOpaque val)
---    -- compile possible mutual inductive block elements
---    | .inductInfo val => do
---      compileInductive val
---    -- compile constructors through their parent inductive
---    | .ctorInfo val => do
---      match ← findLeanConst val.induct with
---      | .inductInfo ind => do
---        let _ <- compileInductive ind
---        compileConst (.ctorInfo val)
---      | const =>
---        throw $ .invalidConstantKind const.name "inductive" const.ctorName
---    -- compile recursors through their parent inductive
---    | .recInfo val => do
---      match ← findLeanConst val.getMajorInduct with
---      | .inductInfo ind => do
---        let _ <- compileInductive ind
---        compileConst (.recInfo val)
---      | const =>
---        throw $ .invalidConstantKind const.name "inductive" const.ctorName
---    -- The rest adds the constants to the cache one by one
---    | .axiomInfo val => resetCtxWithLevels const.levelParams do
---      let c := .axiom ⟨val.name, val.levelParams, ← compileExpr val.type, val.isUnsafe⟩
---      let (anonAddr, metaAddr) ← hashConst c
---      modify fun stt => { stt with
---        axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
---        names := stt.names.insert const.name (anonAddr, metaAddr)
---      }
---      return (anonAddr, metaAddr)
---    | .quotInfo val => resetCtxWithLevels const.levelParams do
---      let type <- compileExpr val.type
---      let c := .quotient ⟨val.name, val.levelParams, type, val.kind⟩
---      let (anonAddr, metaAddr) ← hashConst c
---      modify fun stt => { stt with
---        axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
---        names := stt.names.insert const.name (anonAddr, metaAddr)
---      }
---      return (anonAddr, metaAddr)
---
---end
---def dematerializeConst (x: Ix.Const) : CompileM (Ixon × Ixon) :=
---  match dematerialize x with
---  | .ok (ix, tstt) => do
---    for (addr, ixon) in tstt.store do
---      let _ <- liftM (Store.forceWriteConst addr ixon).toIO
---    return (ix, Ixon.meta ⟨tstt.meta.toList⟩)
---  | .error e => throw (.transportError e)
---
---def cron (tag: String) : CompileM Unit := do
---  let stt <- get
---  let c <- liftM <| Cronos.clock stt.cronos tag
---  modify fun stt => { stt with cronos := c }
---
---def getCron (tag: String) : CompileM String := do
---  return (<- get).cronos.tagSummary tag
-
---def hashConst (const: Ix.Const) : CompileM MetaAddress := do
---  match (<- get).constAddrs.get? const with
---  | some m => pure m
---  | none => do
---    let (anonIxon, metaIxon) <- dematerializeConst const
---    let anonAddr <- storeConst anonIxon
---    let metaAddr <- storeConst metaIxon
---    let timing <- getCron cronTag
---    modifyGet fun stt => (⟨anonAddr, metaAddr⟩, { stt with
---      cache := stt.cache.insert const (anonAddr, metaAddr)
---    })
-
-
--- lookup or compute the addresses of a constant
---def hashConst (const: Ix.Const) : CompileM MetaAddress := do
---  match (<- get).constAddrs.get? const with
---  | some (anonAddr, metaAddr) => pure (anonAddr, metaAddr)
---  | none => do
---    let cronTag := s!"hashConst {const.name}"
---    dbg_trace "-> hashConst {const.name}";
---    cron cronTag
---    let (anonIxon, metaIxon) <- dematerializeConst const
---    let anonAddr <- storeConst anonIxon
---    let metaAddr <- storeConst metaIxon
---    cron cronTag
---    let timing <- getCron cronTag
---    dbg_trace "✓ {timing}";
---    dbg_trace "names: {(<- get).names.size}";
---    dbg_trace "cache: {(<- get).cache.size}";
---    dbg_trace "eqConst: {(<- get).eqConst.size}";
---    dbg_trace "blocks: {(<- get).blocks.size}";
---    modifyGet fun stt => ((anonAddr, metaAddr), { stt with
---      cache := stt.cache.insert const (anonAddr, metaAddr)
---    })
+    | .inductiveProj ⟨name, block, idx⟩ => do
+      let n <- dematerializeName name
+      let data := .iprj ⟨idx, block.data⟩
+      let meta := .meta ⟨[.name n, .link block.meta]⟩
+      pure (data, meta)
+    | .constructorProj ⟨name, block, idx, induct, cidx⟩ => do
+      let n <- dematerializeName name
+      let ind <- dematerializeName induct
+      let data := .cprj ⟨idx, cidx, block.data⟩
+      let meta := .meta ⟨[.name n, .link block.meta, .name ind]⟩
+      pure (data, meta)
+    | .recursorProj ⟨name, block, idx, induct, ridx⟩ => do
+      let n <- dematerializeName name
+      let ind <- dematerializeName induct
+      let data := .rprj ⟨idx, ridx, block.data⟩
+      let meta := .meta ⟨[.name n, .link block.meta, .name ind]⟩
+      pure (data, meta)
+    | .definitionProj ⟨name, block, idx⟩ => do
+      let n <- dematerializeName name
+      let data := .dprj ⟨idx, block.data⟩
+      let meta := .meta ⟨[.name n, .link block.meta]⟩
+      pure (data, meta)
+    | .mutual block => do
+      let mut data := #[]
+      let mut meta := #[]
+      -- iterate through each equivalence class
+      for defsClass in block.defs do
+        let mut classData := #[]
+        let mut classMeta := #[]
+        -- dematerialize each def in a class
+        for defn in defsClass do
+          let (defn', meta') <- goDef defn
+          classData := classData.push defn'
+          -- build up the class metadata as a list of links to the def metadata
+          classMeta := classMeta.push (.link (<- storeMetadata meta'))
+        -- make sure we have no empty classes and all defs in a class are equal
+        match classData.toList with
+          | [] => throw (.dematBadMutualBlock block)
+          | [x] => data := data.push x
+          | x::xs =>
+            if xs.foldr (fun y acc => (y == x) && acc) true
+            then data := data.push x
+            else throw (.dematBadMutualBlock block)
+        -- build up the block metadata as a list of links to the class metadata
+        meta := meta.push (.link (<- storeMetadata ⟨classMeta.toList⟩))
+      pure (.defs data.toList, .meta ⟨meta.toList⟩)
+    | .inductive block => do
+      let mut data := #[]
+      let mut meta := #[]
+      -- iterate through each equivalence class
+      for indsClass in block.inds do
+        let mut classData := #[]
+        let mut classMeta := #[]
+        -- dematerialize each inductive in a class
+        for indc in indsClass do
+          let (indc', meta') <- goInd indc
+          classData := classData.push indc'
+          -- build up the class metadata as a list of links to the indc metadata
+          classMeta := classMeta.push (.link (<- storeMetadata meta'))
+        -- make sure we have no empty classes and all defs in a class are equal
+        match classData.toList with
+          | [] => throw (.dematBadInductiveBlock block)
+          | [x] => data := data.push x
+          | x::xs =>
+            if xs.foldr (fun y acc => (y == x) && acc) true
+            then data := data.push x
+            else throw (.dematBadInductiveBlock block)
+        -- build up the block metadata as a list of links to the class metadata
+        meta := meta.push (.link (<- storeMetadata ⟨classMeta.toList⟩))
+      pure (.inds data.toList, .meta ⟨meta.toList⟩)
 
-end Ix
+def dematerializeSubstring : Substring -> CompileM Ixon.Substring
+| ⟨str, startPos, stopPos⟩ => do
+    pure ⟨<- storeString str, startPos.byteIdx, stopPos.byteIdx⟩
+
+def dematerializeSourceInfo : Lean.SourceInfo -> CompileM Ixon.SourceInfo
+| .original l p t e => do
+  let l' <- dematerializeSubstring l
+  let t' <- dematerializeSubstring t
+  pure <| .original l' p.byteIdx t' e.byteIdx
+| .synthetic p e c => pure (.synthetic p.byteIdx e.byteIdx c)
+| .none => pure .none
+
+def dematerializePreresolved : Lean.Syntax.Preresolved -> CompileM Ixon.Preresolved
+| .namespace ns => .namespace <$> dematerializeName ns
+| .decl n fs => .decl <$> dematerializeName n <*> fs.mapM storeString
+
+partial def dematerializeSyntax (syn: Lean.Syntax) : CompileM Ixon.Syntax := do
+  match (<- get).synCache.get? syn with
+  | some x => pure x
+  | none => do
+    let syn' <- go syn
+    modifyGet fun stt => (syn', { stt with
+      synCache := stt.synCache.insert syn syn'
+    })
+  where
+    go : Lean.Syntax -> CompileM Ixon.Syntax
+    | .missing => pure .missing
+    | .node info kind args => do
+      let info' <- dematerializeSourceInfo info
+      let kind' <- dematerializeName kind
+      let args' <- args.toList.mapM (dematerializeSyntax · >>= storeSerial)
+      pure <| .node info' kind' args'
+    | .atom info val => do
+      let info' <- dematerializeSourceInfo info 
+      let val' <- storeString val
+      pure <| .atom info' val'
+    | .ident info rawVal val preresolved => do
+      let info' <- dematerializeSourceInfo info
+      let rawVal' <- dematerializeSubstring rawVal
+      let val' <- dematerializeName val
+      let ps' <- preresolved.mapM dematerializePreresolved
+      pure <| .ident info' rawVal' val' ps'
+
+def dematerializeDataValue : Lean.DataValue -> CompileM Ixon.DataValue
+| .ofString s => .ofString <$> storeString s
+| .ofBool b => pure (.ofBool b)
+| .ofName n => .ofName <$> dematerializeName n
+| .ofNat i => .ofName <$> storeNat i
+| .ofInt i => .ofInt <$> storeSerial i
+| .ofSyntax s => .ofSyntax <$> (dematerializeSyntax s >>= storeSerial)
+
+def dematerializeKVMaps (maps: List Lean.KVMap): CompileM Address := do
+  storeIxon (.meta ⟨<- maps.mapM go⟩)
+  where
+    go (map: Lean.KVMap): CompileM Metadatum := do
+    let mut list := #[]
+    for (name, dataValue) in map do
+      let n <- dematerializeName name
+      let d <- dematerializeDataValue dataValue
+      list := list.push (n, d)
+    pure <| .kvmap list.toList
+
+def findLeanConst (name : Lean.Name) : CompileM Lean.ConstantInfo := do
+  match (← get).env.constants.find? name with
+  | some const => pure const
+  | none => throw $ .unknownConstant name
+
+def isInternalRec (expr : Lean.Expr) (name : Lean.Name) : Bool :=
+  match expr with
+  | .forallE _ t e _  => match e with
+    | .forallE ..  => isInternalRec e name
+    | _ => isInternalRec t name -- t is the major premise
+  | .app e .. => isInternalRec e name
+  | .const n .. => n == name
+  | _ => false
+
+
+mutual
+
+partial def compileExpr (kvs: List Lean.KVMap) (expr: Lean.Expr): CompileM Ix.Expr := do
+  match (<- get).exprCache.get? expr with
+  | some x => pure x
+  | none => do
+    let expr' <- go expr
+    let _ <- dematerializeExpr expr'
+    modifyGet fun stt => (expr', { stt with
+      exprCache := stt.exprCache.insert expr expr'
+    })
+  where
+    kv := dematerializeKVMaps kvs
+    go : Lean.Expr -> CompileM Ix.Expr
+    | (.mdata kv x) => compileExpr (kv::kvs) x
+    | .bvar idx => do match (← read).bindCtx[idx]? with
+      -- Bound variables must be in the bind context
+      | some _ => return .var (<- kv) idx
+      | none => throw $ .invalidBVarIndex idx
+    | .sort lvl => .sort <$> kv <*> compileLevel lvl
+    | .const name lvls => do
+      let univs ← lvls.mapM compileLevel
+      match (← read).mutCtx.get? name with
+      | some i => return .rec_ (<- kv) name i univs
+      | none => match (<- get).comms.get? name with
+        | some addr => return .const (<- kv) name addr univs
+        | none => do
+          let addr <- findLeanConst name >>= compileConst >>= dematerializeConst
+          return .const (<- kv) name addr univs
+    | .app fnc arg => .app <$> kv <*> compileExpr [] fnc <*> compileExpr [] arg
+    | .lam name typ bod info => do
+      let t <- compileExpr [] typ
+      let b <- withBinder name <| compileExpr [] bod
+      return .lam (<- kv) name info t b
+    | .forallE name dom img info => do
+      let d <- compileExpr [] dom
+      let i <- withBinder name <| compileExpr [] img
+      return .pi (<- kv) name info d i
+    | .letE name typ val bod nD => do
+      let t <- compileExpr [] typ
+      let v <- compileExpr [] val
+      let b <- withBinder name <| compileExpr [] bod
+      return .letE (<- kv) name t v b nD
+    | .lit lit => return .lit (<- kv) lit
+    | .proj name idx exp => do
+      let addr <- findLeanConst name >>= compileConst >>= dematerializeConst
+      return .proj (<- kv) name addr idx (<- compileExpr [] exp)
+    | expr@(.fvar ..)  => throw $ .exprFreeVariable expr
+    | expr@(.mvar ..)  => throw $ .exprMetavariable expr
+
+partial def compileConst (const : Lean.ConstantInfo) : CompileM Ix.Const := do
+  match (<- get).constCache.get? const with
+  | some x => pure x
+  | none => do
+    let const' <- resetCtx $ go const
+    let addr <- dematerializeConst const'
+    modifyGet fun stt => (const', { stt with
+      constNames := stt.constNames.insert const.name addr
+      constCache := stt.constCache.insert const const'
+    })
+  where
+    go : Lean.ConstantInfo -> CompileM Ix.Const
+    | .defnInfo val => compileDefinition (mkPreDef val)
+    | .thmInfo val => compileDefinition (mkPreTheorem val)
+    | .opaqueInfo val => compileDefinition (mkPreOpaque val)
+    | .inductInfo val => compileInductive val
+    -- compile constructors through their parent inductive
+    | .ctorInfo val => do match <- findLeanConst val.induct with
+      | .inductInfo ind => do
+        let _ <- compileInductive ind
+        compileConst (.ctorInfo val)
+      | c => throw $ .invalidConstantKind c.name "inductive" c.ctorName
+    -- compile recursors through their parent inductive
+    | .recInfo val => do
+      match ← findLeanConst val.getMajorInduct with
+      | .inductInfo ind => do
+        let _ <- compileInductive ind
+        compileConst (.recInfo val)
+      | c => throw $ .invalidConstantKind c.name "inductive" c.ctorName
+    | .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => resetCtxWithLevels lvls do
+      return .axiom ⟨name, lvls, <- compileExpr [] type, isUnsafe⟩
+    | .quotInfo ⟨⟨name, lvls, type⟩, kind⟩ => resetCtxWithLevels lvls do
+      return .quotient ⟨name, lvls, <- compileExpr [] type, kind⟩
+
+partial def preDefinitionToIR (d: PreDef) : CompileM Ix.Definition :=
+  withLevels d.levelParams do
+    let typ <- compileExpr [] d.type
+    let val <- compileExpr [] d.value
+    return ⟨d.name, d.levelParams, typ, d.kind, val, d.hints, d.safety, d.all⟩
+
+partial def compileDefinition: PreDef -> CompileM Ix.Const
+| defn => do
+  -- single definition outside a mutual block
+  if defn.all matches [_] then
+    return .definition (<- withMutCtx {(defn.name,0)} <| preDefinitionToIR defn)
+  else do
+  -- collecting and sorting all definitions in the mutual block
+  let mut defs : Array PreDef := #[]
+  for name in defn.all do
+    match <- findLeanConst name with
+    | .defnInfo x => defs := defs.push (mkPreDef x)
+    | .opaqueInfo x => defs := defs.push (mkPreOpaque x)
+    | .thmInfo x => defs := defs.push (mkPreTheorem x)
+    | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
+  let mutDefs <- sortDefs defs.toList
+  let mutCtx := defMutCtx mutDefs
+  let definitions ← withMutCtx mutCtx <| mutDefs.mapM (·.mapM preDefinitionToIR)
+  -- add top-level mutual block to our state
+  let block ← dematerializeConst <| .mutual ⟨definitions⟩
+  modify fun stt => { stt with blocks := stt.blocks.insert block }
+  -- then add all the projections, returning the def we started with
+  let mut ret? : Option Ix.Const := none
+  for name in defn.all do
+    let idx <- do match mutCtx.get? name with
+    | some idx => pure idx
+    | none => throw $ .cantFindMutDefIndex name
+    let const <- findLeanConst name
+    let const' := .definitionProj ⟨name, block, idx⟩
+    let addr <- dematerializeConst const'
+    modify fun stt => { stt with
+      constNames := stt.constNames.insert name addr
+      constCache := stt.constCache.insert const const'
+    }
+    if name == defn.name then ret? := some const'
+  match ret? with
+  | some ret => return ret
+  | none => throw $ .compileMutualBlockMissingProjection defn.name
+
+/-- A name-irrelevant ordering of Lean expressions --/
+partial def compareExpr (ctx: Std.HashMap Lean.Name Nat)
+  (xlvls ylvls: List Lean.Name) : Lean.Expr → Lean.Expr → CompileM SOrder
+  | e@(.mvar ..), _ => throw $ .exprMetavariable e
+  | _, e@(.mvar ..) => throw $ .exprMetavariable e
+  | e@(.fvar ..), _ => throw $ .exprFreeVariable e
+  | _, e@(.fvar ..) => throw $ .exprFreeVariable e
+  | .mdata _ x, .mdata _ y  => compareExpr ctx xlvls ylvls x y
+  | .mdata _ x, y  => compareExpr ctx xlvls ylvls x y
+  | x, .mdata _ y  => compareExpr ctx xlvls ylvls x y
+  | .bvar x, .bvar y => return ⟨true, compare x y⟩
+  | .bvar .., _ => return ⟨true, .lt⟩
+  | _, .bvar .. => return ⟨true, .gt⟩
+  | .sort x, .sort y => compareLevel xlvls ylvls x y
+  | .sort .., _ => return ⟨true, .lt⟩
+  | _, .sort .. => return ⟨true, .gt⟩
+  | .const x xls, .const y yls => do
+    let univs ← SOrder.zipM (compareLevel xlvls ylvls) xls yls
+    if univs.ord != .eq then return univs
+    match ctx.get? x, ctx.get? y with
+    | some nx, some ny => return ⟨false, compare nx ny⟩
+    | none, some _ => return ⟨true, .gt⟩
+    | some _, none => return ⟨true, .lt⟩
+    | none, none =>
+      if x == y then return ⟨true, .eq⟩
+      else do
+        let x' <- compileConst $ ← findLeanConst x
+        let y' <- compileConst $ ← findLeanConst y
+        return ⟨true, compare x' y'⟩
+  | .const .., _ => return ⟨true, .lt⟩
+  | _, .const .. => return ⟨true, .gt⟩
+  | .app xf xa, .app yf ya =>
+    SOrder.cmpM
+      (compareExpr ctx xlvls ylvls xf yf) 
+      (compareExpr ctx xlvls ylvls xa ya)
+  | .app .., _ => return ⟨true, .lt⟩
+  | _, .app .. => return ⟨true, .gt⟩
+  | .lam _ xt xb _, .lam _ yt yb _ =>
+    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
+  | .lam .., _ => return ⟨true, .lt⟩
+  | _, .lam .. => return ⟨true, .gt⟩
+  | .forallE _ xt xb _, .forallE _ yt yb _ => 
+    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
+  | .forallE .., _ => return ⟨true, .lt⟩
+  | _, .forallE .. => return ⟨true, .gt⟩
+  | .letE _ xt xv xb _, .letE _ yt yv yb _ =>
+    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) <|
+    SOrder.cmpM (compareExpr ctx xlvls ylvls xv yv)
+      (compareExpr ctx xlvls ylvls xb yb)
+  | .letE .., _ => return ⟨true, .lt⟩
+  | _, .letE .. => return ⟨true, .gt⟩
+  | .lit x, .lit y => return ⟨true, compare x y⟩
+  | .lit .., _ => return ⟨true, .lt⟩
+  | _, .lit .. => return ⟨true, .gt⟩
+  | .proj _ nx tx, .proj _ ny ty => 
+    SOrder.cmpM (pure ⟨true, compare nx ny⟩) 
+      (compareExpr ctx xlvls ylvls tx ty)
+
+/-- AST comparison of two Lean definitions. --/
+partial def compareDef (ctx: HashMap Lean.Name Nat) (x y: PreDef)
+  : CompileM Ordering := do
+  let key := match compare x.name y.name with
+    | .lt => (x.name, y.name)
+    | _ => (y.name, x.name)
+  match (<- get).constCmp.get? key with
+  | some o => return o
+  | none => do
+    let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
+    if sorder.strong then modify fun stt => { stt with
+        constCmp := stt.constCmp.insert key sorder.ord
+      }
+    return sorder.ord
+
+partial def eqDef (ctx: HashMap Lean.Name Nat) (x y: PreDef) : CompileM Bool :=
+  (fun o => o == .eq) <$> compareDef ctx x y
+
+/--
+`sortDefs` recursively sorts a list of mutual definitions into equivalence classes.
+At each stage, we take as input the current best known equivalence
+classes (held in the `mutCtx` of the CompileEnv). For most cases, equivalence
+can be determined by syntactic differences which are invariant to the current
+best known classification. For example:
+
+```
+mutual
+  def : Nat := 1
+  def bar : Nat := 2
+end
+```
+
+are both different due to the different values in the definition. We call this a
+"strong" ordering, and comparisons between defintions that produce strong
+orderings are cached across compilation.
+
+However, there are also weak orderings, where the order of definitions in a
+mutual block depends on itself.
+
+```
+mutual
+  def A : Nat → Nat
+  | 0 => 0
+  | n + 1 => B n + C n + 1
+
+  def B : Nat → Nat
+  | 0 => 0
+  | n + 1 => C n + 1
+
+  def C : Nat → Nat
+  | 0 => 0
+  | n + 1 => A n + 1
+end
+```
+
+Here since any reference to A, B, C has to be compiled into an index, the
+ordering chosen for A, B, C will effect itself, since we compile into
+something that looks, with order [A, B, C] like:
+
+```
+mutual
+  def #1 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #2 n + #3 n + 1
+
+  def #2 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #3 n + 1
+
+  def #3 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #1 n + 1
+end
+```
+
+This is all well and good, but if we chose order `[C, B, A]` then the block
+would compile as
+
+```
+mutual
+  def #1 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #3 n + 1
+
+  def #2 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #1 n + 1
+
+  def #3 : Nat → Nat
+  | 0 => 0
+  | n + 1 => #2 n + #1 n + 1
+end
+```
+
+with completely different hashes. So we need to figure out a canonical order for
+such mutual blocks.
+
+We start by assuming that all definitions in a mutual block are equal and then
+recursively refining this assumption through successive sorting passes, similar
+to partition refinement:
+```
+classes₀ := [startDefs]
+classes₁ := sortDefs classes₀
+classes₂ := sortDefs classes₁
+classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
+```
+Initially, `startDefs` is simply the list of definitions we receive from
+`DefinitionVal.all`, sorted by name. We assume that at we will reach some
+fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no further refinement is
+possible (we have not rigourously proven such a fixed point exists, but
+it seams reasonable given that after the first pass to find the strongly ordered
+definitions, the algorithm should only separate partitions into smaller ones)
+-/
+partial def sortDefs (classes : List PreDef) : CompileM (List (List PreDef)) :=
+  go [List.sortBy (compare ·.name ·.name) classes]
+  where
+    go (cs: List (List PreDef)): CompileM (List (List PreDef)) := do
+      let ctx := defMutCtx cs
+      let cs' <- cs.mapM fun ds =>
+        match ds with
+        | []  => throw <| .emptyDefsClass cs
+        | [d] => pure [[d]]
+        | ds  => ds.sortByM (compareDef ctx) >>= List.groupByM (eqDef ctx)
+      let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
+      if cs == cs' then return cs' else go cs'
+
+partial def makePreInd (ind: Lean.InductiveVal) : CompileM Ix.PreInd := do
+  let ctors <- ind.ctors.mapM getCtor
+  let recrs := (<- get).env.constants.fold getRecrs []
+  return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices,
+    ind.all, ctors, recrs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
+  where
+    getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
+      match (<- findLeanConst name) with
+      | .ctorInfo c => pure c
+      | _ => throw <| .invalidConstantKind name "constructor" ""
+    getRecrs (acc: List Lean.RecursorVal) : Lean.Name -> Lean.ConstantInfo -> List Lean.RecursorVal
+    | .str n .., .recInfo r
+    | .num n .., .recInfo r => if n == ind.name then r::acc else acc
+    | _, _ => acc
+
+/--
+Content-addresses an inductive and all inductives in the mutual block as a
+mutual block, even if the inductive itself is not in a mutual block.
+
+Content-addressing an inductive involves content-addressing its associated
+constructors and recursors, hence the complexity of this function.
+-/
+partial def compileInductive: Lean.InductiveVal -> CompileM Ix.Const
+| ind => do
+  let mut preInds := #[]
+  let mut ctorNames : HashMap Lean.Name (List Lean.Name × List Lean.Name) := {}
+  -- collect all mutual inductives as Ix.PreInds
+  for n in ind.all do
+    match <- findLeanConst n with
+    | .inductInfo ind =>
+      let preInd <- makePreInd ind
+      preInds := preInds.push preInd
+      ctorNames := ctorNames.insert n (ind.ctors, preInd.recrs.map (·.name))
+    | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
+  -- sort PreInds into equivalence classes
+  let mutInds <- sortInds preInds.toList
+  let mutCtx := indMutCtx mutInds
+  -- compile each preinductive with the mutCtx
+  let inds ← withMutCtx mutCtx <| mutInds.mapM (·.mapM preInductiveToIR)
+  -- add top-level mutual block to our state
+  let block <- dematerializeConst <| .inductive ⟨inds⟩
+  modify fun stt => { stt with blocks := stt.blocks.insert block }
+  -- then add all projections, returning the inductive we started with
+  let mut ret? : Option Ix.Const := none
+  for (name, idx) in ind.all.zipIdx do
+    let const <- findLeanConst name
+    let const' := .inductiveProj ⟨name, block, idx⟩
+    let addr <- dematerializeConst const'
+    modify fun stt => { stt with
+      constNames := stt.constNames.insert name addr
+      constCache := stt.constCache.insert const const'
+    }
+    if name == ind.name then ret? := some const'
+    let some (ctors, recrs) := ctorNames.get? ind.name
+      | throw $ .cantFindMutDefIndex ind.name
+    for (cname, cidx) in ctors.zipIdx do
+      -- Store and cache constructor projections
+      let cconst <- findLeanConst cname
+      let cconst' := .constructorProj ⟨cname, block, idx, name, cidx⟩
+      let caddr <- dematerializeConst cconst'
+      modify fun stt => { stt with
+        constNames := stt.constNames.insert cname caddr
+        constCache := stt.constCache.insert cconst cconst'
+      }
+    for (rname, ridx) in recrs.zipIdx do
+      -- Store and cache recursor projections
+      let rconst <- findLeanConst rname
+      let rconst' := .recursorProj ⟨rname, block, idx, name, ridx⟩
+      let raddr <- dematerializeConst rconst'
+      modify fun stt => { stt with
+        constNames := stt.constNames.insert rname raddr
+        constCache := stt.constCache.insert rconst rconst'
+      }
+  match ret? with
+  | some ret => return ret
+  | none => throw $ .compileInductiveBlockMissingProjection ind.name
+
+partial def preInductiveToIR (ind : Ix.PreInd) : CompileM Ix.Inductive 
+  := withLevels ind.levelParams $ do
+  let (recs, ctors) := <- ind.recrs.foldrM (init := ([], [])) collectRecsCtors
+  let type <- compileExpr [] ind.type
+    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
+    -- match the order used in `mutCtx`
+  return ⟨ind.name, ind.levelParams, type, ind.numParams, ind.numIndices,
+    ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
+  where
+    collectRecsCtors : Lean.RecursorVal -> List Recursor × List Constructor
+    -> CompileM (List Recursor × List Constructor)
+    | r, (recs, ctors) =>
+      if isInternalRec r.type ind.name then do
+        let (thisRec, thisCtors) <- internalRecToIR (ind.ctors.map (·.name)) r
+        pure (thisRec :: recs, thisCtors)
+      else do
+        let thisRec ← externalRecToIR r
+        pure (thisRec :: recs, ctors)
+
+partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
+  : CompileM (Ix.Recursor × List Ix.Constructor) 
+  := withLevels recr.levelParams do
+    let typ ← compileExpr [] recr.type
+    let (retCtors, retRules) ← recr.rules.foldrM (init := ([], []))
+      fun r (retCtors, retRules) => do
+        if ctors.contains r.ctor then
+          let (ctor, rule) ← recRuleToIR r
+          pure $ (ctor :: retCtors, rule :: retRules)
+        else pure (retCtors, retRules) -- this is an external recursor rule
+    let recr := ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
+      recr.numMotives, recr.numMinors, retRules, recr.k, recr.isUnsafe⟩
+    return (recr, retCtors)
+
+partial def externalRecToIR: Lean.RecursorVal -> CompileM Recursor
+| recr => withLevels recr.levelParams do
+    let typ ← compileExpr [] recr.type
+    let rules ← recr.rules.mapM externalRecRuleToIR
+    return ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
+      recr.numMotives, recr.numMinors, rules, recr.k, recr.isUnsafe⟩
+
+partial def recRuleToIR: Lean.RecursorRule -> CompileM (Ix.Constructor × Ix.RecursorRule)
+| rule => do
+  let rhs ← compileExpr [] rule.rhs
+  match ← findLeanConst rule.ctor with
+  | .ctorInfo ctor => withLevels ctor.levelParams do
+    let typ ← compileExpr [] ctor.type
+    let ctor := ⟨ctor.name, ctor.levelParams, typ, ctor.cidx,
+      ctor.numParams, ctor.numFields, ctor.isUnsafe⟩
+    pure (ctor, ⟨rule.ctor, rule.nfields, rhs⟩)
+  | const =>
+    throw $ .invalidConstantKind const.name "constructor" const.ctorName
+
+partial def externalRecRuleToIR: Lean.RecursorRule -> CompileM RecursorRule
+| rule => do return ⟨rule.ctor, rule.nfields, <- compileExpr [] rule.rhs⟩
+
+/-- AST comparison of two Lean inductives. --/
+partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInd) 
+  : CompileM Ordering := do
+  let key := match compare x.name y.name with
+    | .lt => (x.name, y.name)
+    | _ => (y.name, x.name)
+  match (<- get).constCmp.get? key with
+  | some o => return o
+  | none => do
+    let sorder <- do
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.numIndices y.numIndices⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.ctors.length y.ctors.length⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.recrs.length y.recrs.length⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+      SOrder.cmpM (SOrder.zipM compareCtor x.ctors y.ctors)
+        (SOrder.zipM compareRecr x.recrs y.recrs)
+    if sorder.strong then modify fun stt => { stt with
+        constCmp := stt.constCmp.insert key sorder.ord
+    }
+    return sorder.ord
+  where
+    compareCtor (x y: Lean.ConstructorVal) : CompileM SOrder := do
+      let key := match compare x.name y.name with
+        | .lt => (x.name, y.name)
+        | _ => (y.name, x.name)
+      match (<- get).constCmp.get? key with
+      | some o => return ⟨true, o⟩
+      | none => do
+      let sorder <- do
+        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.cidx y.cidx⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.numFields y.numFields⟩) <|
+          (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+      if sorder.strong then modify fun stt => { stt with
+          constCmp := stt.constCmp.insert key sorder.ord
+        }
+      return sorder
+    compareRecr (x y: Lean.RecursorVal) : CompileM SOrder := do
+      let key := match compare x.name y.name with
+        | .lt => (x.name, y.name)
+        | _ => (y.name, x.name)
+      match (<- get).constCmp.get? key with
+      | some o => return ⟨true, o⟩
+      | none => do
+      let sorder <- do
+        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+        SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
+        SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
+        SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
+        SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+          (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
+      if sorder.strong then modify fun stt => { stt with
+          constCmp := stt.constCmp.insert key sorder.ord
+        }
+      return sorder
+    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
+      : CompileM SOrder := do
+        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
+          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
+
+partial def eqInd (ctx: HashMap Lean.Name Nat) (x y: PreInd) : CompileM Bool :=
+  (fun o => o == .eq) <$> compareInd ctx x y
+
+/-- `sortInds` recursively sorts a list of inductive datatypes into equivalence
+classes, analogous to `sortDefs` --/
+partial def sortInds (classes : List PreInd) : CompileM (List (List PreInd)) :=
+  go [List.sortBy (compare ·.name ·.name) classes]
+  where
+    go (cs: List (List PreInd)): CompileM (List (List PreInd)) := do
+      let ctx := indMutCtx cs
+      let cs' <- cs.mapM fun ds =>
+        match ds with
+        | []  => throw <| .emptyIndsClass cs
+        | [d] => pure [[d]]
+        | ds  => ds.sortByM (compareInd ctx) >>= List.groupByM (eqInd ctx)
+      let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
+      if cs == cs' then return cs' else go cs'
+end
+
+partial def makeLeanDef
+  (name: Lean.Name) (levelParams: List Lean.Name) (type value: Lean.Expr) 
+  : Lean.DefinitionVal :=
+  { name, levelParams, type, value, hints := .opaque, safety := .safe }
+
+partial def tryAddLeanDef (defn: Lean.DefinitionVal) : CompileM Unit := do
+  match (<- get).env.constants.find? defn.name with
+  | some _ => pure ()
+  | none => do
+    let env <- (·.env) <$> get
+    let maxHeartBeats <- (·.maxHeartBeats) <$> get
+    let decl := Lean.Declaration.defnDecl defn
+    match Lean.Environment.addDeclCore env maxHeartBeats decl .none with
+    | .ok e => do
+      modify fun stt => { stt with env := e }
+      return ()
+    | .error e => throw $ .kernelException e
+
+partial def addDef (lvls: List Lean.Name) (typ val: Lean.Expr) : CompileM MetaAddress := do
+  let typ' <- compileExpr [] typ
+  let val' <- compileExpr [] val
+  let anon := .definition ⟨.anonymous, lvls, typ', .definition, val', .opaque, .safe, []⟩
+  let anonAddr <- dematerializeConst anon
+  let name := anonAddr.data.toUniqueName
+  let const := .definition ⟨name, lvls, typ', .definition, val', .opaque, .safe, []⟩
+  let addr <- dematerializeConst const
+  if addr.data != anonAddr.data then
+    throw <| .alphaInvarianceFailure anon anonAddr const addr
+  else
+    tryAddLeanDef (makeLeanDef name lvls typ val)
+    return addr
+
+partial def commitConst (addr: MetaAddress) (secret: Address) : CompileM MetaAddress := do
+  let comm := Ixon.comm ⟨secret, addr.data⟩
+  let commAddr <- storeIxon comm
+  let commMeta := Ixon.comm ⟨secret, addr.meta⟩
+  let commMetaAddr <- storeIxon commMeta
+  let addr' := ⟨commAddr, commMetaAddr⟩
+  modify fun stt => { stt with
+    comms := stt.comms.insert commAddr.toUniqueName addr'
+  }
+  return addr'
+
+partial def commitDef (lvls: List Lean.Name) (typ val: Lean.Expr) (secret: Address): CompileM MetaAddress := do
+  let addr <- addDef lvls typ val
+  let addr' <- commitConst addr secret
+  tryAddLeanDef (makeLeanDef addr'.data.toUniqueName lvls typ val)
+  --tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ (mkConst a.toUniqueName []))
+  return addr'
+
+partial def storeLevel (lvls: Nat) (secret: Option Address): CompileM Address := do
+  let addr <- storeNat lvls
+  match secret with
+  | some secret => do
+    let comm := .comm ⟨secret, addr⟩
+    let commAddr <- storeIxon comm
+    modify fun stt => { stt with
+      comms := stt.comms.insert commAddr.toUniqueName ⟨commAddr, commAddr⟩
+    }
+    return commAddr
+  | none => return addr
 
---mutual
---
---/-- compile Lean Constant --/
---partial def compileConst (const : Lean.ConstantInfo)
---  : CompileM (Address × Address) := do
---  -- first check if we've already compiled this const
---  match (← get).names.get? const.name with
---  -- if we have, returned the cached address
---  | some (anonAddr, metaAddr) => do
---    pure (anonAddr, metaAddr)
---  -- if not, pattern match on the const
---  | none => do
---    dbg_trace "-> compileConst {const.name}";
---    let cronTag := s!"compileConst {const.name}"
---    cron cronTag
---    let cronTag2 := s!"constSize {const.name}"
---    dbg_trace "-> constSize {const.name}";
---    cron cronTag2
---    let size := const.size
---    cron cronTag2
---    dbg_trace "✓ {(<- getCron cronTag2)} {size}";
---    let addrs <- compileInner const
---    cron cronTag
---    let timing <- getCron cronTag
---    dbg_trace "✓ {timing}";
---    return addrs
---  where
---    compileInner (const: Lean.ConstantInfo) := resetCtx $ withCurrent const.name $ match const with
---    -- convert possible mutual block elements to PreDefinitions
---    | .defnInfo val => do
---      compileDefinition (mkPreDefinition val)
---    | .thmInfo val => do
---      compileDefinition (mkPreTheorem val)
---    | .opaqueInfo val => do
---      compileDefinition (mkPreOpaque val)
---    -- compile possible mutual inductive block elements
---    | .inductInfo val => do
---      compileInductive val
---    -- compile constructors through their parent inductive
---    | .ctorInfo val => do
---      match ← findLeanConst val.induct with
---      | .inductInfo ind => do
---        let _ <- compileInductive ind
---        compileConst (.ctorInfo val)
---      | const =>
---        throw $ .invalidConstantKind const.name "inductive" const.ctorName
---    -- compile recursors through their parent inductive
---    | .recInfo val => do
---      match ← findLeanConst val.getMajorInduct with
---      | .inductInfo ind => do
---        let _ <- compileInductive ind
---        compileConst (.recInfo val)
---      | const =>
---        throw $ .invalidConstantKind const.name "inductive" const.ctorName
---    -- The rest adds the constants to the cache one by one
---    | .axiomInfo val => resetCtxWithLevels const.levelParams do
---      let c := .axiom ⟨val.name, val.levelParams, ← compileExpr val.type, val.isUnsafe⟩
---      let (anonAddr, metaAddr) ← hashConst c
---      modify fun stt => { stt with
---        axioms := stt.axioms.insert const.name (anonAddr, metaAddr)
---        names := stt.names.insert const.name (anonAddr, metaAddr)
---      }
---      return (anonAddr, metaAddr)
---    | .quotInfo val => resetCtxWithLevels const.levelParams do
---      let type <- compileExpr val.type
---      let c := .quotient ⟨val.name, val.levelParams, type, val.kind⟩
---      let (anonAddr, metaAddr) ← hashConst c
---      modify fun stt => { stt with
---        axioms := (stt.axioms.insert const.name (anonAddr, metaAddr))
---        names := stt.names.insert const.name (anonAddr, metaAddr)
---      }
---      return (anonAddr, metaAddr)
---
---/-- compile possibly mutual Lean definition --/
---partial def compileDefinition (struct: PreDefinition)
---  : CompileM (Address × Address) := do
---  dbg_trace "compileDefinition {struct.name}"
---  -- If the mutual size is one, simply content address the single definition
---  if struct.all matches [_] then
---    let defn <- withMutCtx ({(struct.name,0)}) $ preDefinitionToIR struct
---    let (anonAddr, metaAddr) <- hashConst $ .definition defn
---    modify fun stt => { stt with
---      names := stt.names.insert struct.name (anonAddr, metaAddr)
---    }
---    return (anonAddr, metaAddr)
---  -- Collecting and sorting all definitions in the mutual block
---  let mut mutDefs : Array PreDefinition := #[]
---  for n in struct.all do
---    match <- findLeanConst n with
---      | .defnInfo x => mutDefs := mutDefs.push (mkPreDefinition x)
---      | .opaqueInfo x => mutDefs := mutDefs.push (mkPreOpaque x)
---      | .thmInfo x => mutDefs := mutDefs.push (mkPreTheorem x)
---      | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
---  let mutualDefs <- sortDefs mutDefs.toList
---  let mutCtx := defMutCtx mutualDefs
---  let definitions ← withMutCtx mutCtx <|
---    mutualDefs.mapM (·.mapM preDefinitionToIR)
---  -- Building and storing the block
---  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .mutual ⟨definitions⟩
---  modify fun stt =>
---    { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
---  -- While iterating on the definitions from the mutual block, we need to track
---  -- the correct objects to return
---  let mut ret? : Option (Address × Address) := none
---  for name in struct.all do
---    -- Storing and caching the definition projection
---    -- Also adds the constant to the array of constants
---    let some idx := mutCtx.get? name | throw $ .cantFindMutDefIndex name
---    let (anonAddr, metaAddr) ←
---      hashConst $ .definitionProj ⟨name, blockAnonAddr, blockMetaAddr, idx⟩
---    modify fun stt => { stt with
---      names := stt.names.insert name (anonAddr, metaAddr)
---    }
---    if struct.name == name then ret? := some (anonAddr, metaAddr)
---  match ret? with
---  | some ret => return ret
---  | none => throw $ .constantNotContentAddressed struct.name
---
---partial def preDefinitionToIR (d: PreDefinition)
---  : CompileM Ix.Definition := withCurrent d.name $ withLevels d.levelParams do
---  dbg_trace "preDefinitionToIR {d.name}"
---  let typ <- compileExpr d.type
---  let val <- compileExpr d.value
---  return ⟨d.name, d.levelParams, typ, d.kind, val, d.hints, d.safety, d.all⟩
---
---partial def getRecursors (ind : Lean.InductiveVal) 
---  : CompileM (List Lean.RecursorVal) := do
---    return (<- get).env.constants.fold accRecr []
---    where
---      accRecr (acc: List Lean.RecursorVal) (n: Lean.Name) (c: Lean.ConstantInfo)
---        : List Lean.RecursorVal :=
---        match n with
---        | .str n ..
---        | .num n .. =>
---          if n == ind.name then match c with
---            | .recInfo r => r :: acc
---            | _ => acc
---          else acc
---        | _ => acc
---
---partial def makePreInductive (ind: Lean.InductiveVal) 
---  : CompileM Ix.PreInductive := do
---    dbg_trace "-> makePreInductive {ind.name}";
---    let ctors <- ind.ctors.mapM getCtor
---    let recrs <- getRecursors ind
---    return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices,
---      ind.all, ctors, recrs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
---    where
---      getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
---        match (<- findLeanConst name) with
---        | .ctorInfo c => pure c
---        | _ => throw <| .invalidConstantKind name "constructor" ""
---
---/--
---Content-addresses an inductive and all inductives in the mutual block as a
---mutual block, even if the inductive itself is not in a mutual block.
---
---Content-addressing an inductive involves content-addressing its associated
---constructors and recursors, hence the complexity of this function.
----/
---partial def compileInductive (initInd: Lean.InductiveVal) 
---  : CompileM (Address × Address) := do
---  dbg_trace "-> compileInductive {initInd.name}";
---  let mut preInds := #[]
---  let mut nameData : Std.HashMap Lean.Name (List Lean.Name × List Lean.Name) := {}
---  -- collect all mutual inductives as Ix.PreInductives
---  for indName in initInd.all do
---    match ← findLeanConst indName with
---    | .inductInfo ind =>
---      let preInd <- makePreInductive ind
---      preInds := preInds.push preInd
---      nameData := nameData.insert indName (ind.ctors, preInd.recrs.map (·.name))
---    | const => throw $ .invalidConstantKind const.name "inductive" const.ctorName
---  -- sort PreInductives into equivalence classes
---  let mutualInds <- sortInds preInds.toList
---  let mutCtx := indMutCtx mutualInds
---  -- compile each preinductive with the mutCtx
---  let irInds ← withMutCtx mutCtx $ mutualInds.mapM (·.mapM preInductiveToIR)
---  let (blockAnonAddr, blockMetaAddr) ← hashConst $ .inductive ⟨irInds⟩
---  modify fun stt =>
---    { stt with blocks := stt.blocks.insert (blockAnonAddr, blockMetaAddr) }
---  -- While iterating on the inductives from the mutual block, we need to track
---  -- the correct objects to return
---  let mut ret? : Option (Address × Address) := none
---  for (indName, indIdx) in initInd.all.zipIdx do
---    -- Store and cache inductive projections
---    let name := indName
---    let (anonAddr, metaAddr) ←
---      hashConst $ .inductiveProj ⟨name, blockAnonAddr, blockMetaAddr, indIdx⟩
---    modify fun stt => { stt with
---      names := stt.names.insert name (anonAddr, metaAddr)
---    }
---    if name == initInd.name then ret? := some (anonAddr, metaAddr)
---    let some (ctors, recrs) := nameData.get? indName
---      | throw $ .cantFindMutDefIndex indName
---    for (ctorName, ctorIdx) in ctors.zipIdx do
---      -- Store and cache constructor projections
---      let (anonAddr, metaAddr) ←
---        hashConst $ .constructorProj
---          ⟨ctorName, blockAnonAddr, blockMetaAddr, indIdx, indName, ctorIdx⟩
---      modify fun stt => { stt with
---        names := stt.names.insert ctorName (anonAddr, metaAddr)
---      }
---    for (recrName, recrIdx) in recrs.zipIdx do
---      -- Store and cache recursor projections
---      let (anonAddr, metaAddr) ←
---        hashConst $ .recursorProj
---          ⟨recrName, blockAnonAddr, blockMetaAddr, indIdx, indName, recrIdx⟩
---      modify fun stt => { stt with
---        names := stt.names.insert recrName (anonAddr, metaAddr)
---      }
---  match ret? with
---  | some ret => return ret
---  | none => throw $ .constantNotContentAddressed initInd.name
---
---partial def preInductiveToIR (ind : Ix.PreInductive) : CompileM Ix.Inductive 
---  := withCurrent ind.name $ withLevels ind.levelParams $ do
---  dbg_trace "-> preInductiveToIR {ind.name}";
---  let (recs, ctors) := <- ind.recrs.foldrM (init := ([], [])) collectRecsCtors
---  let type <- compileExpr ind.type
---    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
---    -- match the order used in `mutCtx`
---  return ⟨ind.name, ind.levelParams, type, ind.numParams, ind.numIndices,
---    ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
---  where
---    collectRecsCtors
---      : Lean.RecursorVal
---      -> List Recursor × List Constructor 
---      -> CompileM (List Recursor × List Constructor)
---      | r, (recs, ctors) =>
---        if isInternalRec r.type ind.name then do
---          let (thisRec, thisCtors) <- internalRecToIR (ind.ctors.map (·.name)) r
---          pure (thisRec :: recs, thisCtors)
---        else do
---          let thisRec ← externalRecToIR r
---          pure (thisRec :: recs, ctors)
---
---partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
---  : CompileM (Ix.Recursor × List Ix.Constructor) :=
---  withCurrent recr.name $ withLevels recr.levelParams do
---    dbg_trace s!"internalRecToIR"
---    let typ ← compileExpr recr.type
---    let (retCtors, retRules) ← recr.rules.foldrM (init := ([], []))
---      fun r (retCtors, retRules) => do
---        if ctors.contains r.ctor then
---          let (ctor, rule) ← recRuleToIR r
---          pure $ (ctor :: retCtors, rule :: retRules)
---        else pure (retCtors, retRules) -- this is an external recursor rule
---    let recr := ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
---      recr.numMotives, recr.numMinors, retRules, recr.k, recr.isUnsafe⟩
---    return (recr, retCtors)
---
---partial def externalRecToIR (recr: Lean.RecursorVal): CompileM Recursor :=
---  withCurrent recr.name $ withLevels recr.levelParams do
---    dbg_trace s!"externalRecToIR"
---    let typ ← compileExpr recr.type
---    let rules ← recr.rules.mapM externalRecRuleToIR
---    return ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
---      recr.numMotives, recr.numMinors, rules, recr.k, recr.isUnsafe⟩
---
---partial def recRuleToIR (rule : Lean.RecursorRule)
---  : CompileM (Ix.Constructor × Ix.RecursorRule) := do
---  dbg_trace s!"recRuleToIR"
---  let rhs ← compileExpr rule.rhs
---  match ← findLeanConst rule.ctor with
---  | .ctorInfo ctor => withCurrent ctor.name $ withLevels ctor.levelParams do
---    let typ ← compileExpr ctor.type
---    let ctor :=
---      ⟨ctor.name, ctor.levelParams, typ, ctor.cidx, ctor.numParams, ctor.numFields, ctor.isUnsafe⟩
---    pure (ctor, ⟨rule.ctor, rule.nfields, rhs⟩)
---  | const =>
---    throw $ .invalidConstantKind const.name "constructor" const.ctorName
---
---partial def externalRecRuleToIR (rule : Lean.RecursorRule) 
---  : CompileM RecursorRule :=
---  return ⟨rule.ctor, rule.nfields, ← compileExpr rule.rhs⟩
---
---/--
---Content-addresses a Lean expression and adds it to the store.
---
---Constants are the tricky case, for which there are two possibilities:
---* The constant belongs to `mutCtx`, representing a recursive call. Those are
---encoded as `.rec_` with indexes based on order in the mutual definition
---* The constant doesn't belong to `mutCtx`, meaning that it's not a recursion
---and thus we can canon the actual constant right away
----/
---partial def compileExpr : Lean.Expr → CompileM Expr
---| .bvar idx => do match (← read).bindCtx[idx]? with
---  -- Bound variables must be in the bind context
---  | some _ => return .var idx
---  | none => throw $ .invalidBVarIndex idx
---| .sort lvl => return .sort $ ← compileLevel lvl
---| .const name lvls => do
---  let univs ← lvls.mapM compileLevel
---  match (← read).mutCtx.get? name with
---  -- recursing!
---  | some i => return .rec_ name i univs
---  | none => match (<- get).comms.get? name with
---    | some (commAddr, metaAddr) => do
---      return .const name commAddr metaAddr univs
---    | none => do
---      let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
---      return .const name contAddr metaAddr univs
---| .app fnc arg => return .app (← compileExpr fnc) (← compileExpr arg)
---| .lam name typ bod info =>
---  return .lam name info (← compileExpr typ) (← withBinder name $ compileExpr bod)
---| .forallE name dom img info =>
---  return .pi name info (← compileExpr dom) (← withBinder name $ compileExpr img)
---| .letE name typ exp bod nD =>
---  return .letE name (← compileExpr typ) (← compileExpr exp)
---    (← withBinder name $ compileExpr bod) nD
---| .lit lit => return .lit lit
---| .proj name idx exp => do
---  let (contAddr, metaAddr) ← compileConst (← findLeanConst name)
---  return .proj name contAddr metaAddr idx (← compileExpr exp)
---| expr@(.fvar ..)  => throw $ .freeVariableExpr expr
---| expr@(.mvar ..)  => throw $ .metaVariableExpr expr
----- TODO: cursed
---| (.mdata _ x) => compileExpr x
---
---/--
---A name-irrelevant ordering of Lean expressions.
----/
---partial def compareExpr (ctx: Std.HashMap Lean.Name Nat)
---  (xlvls ylvls: List Lean.Name)
---  --: Lean.Expr → Lean.Expr → CompileM SOrder
---  (x y: Lean.Expr) : CompileM SOrder := do
---  --dbg_trace "compareExpr {repr xlvls} {repr ylvls} {repr x} {repr y}"
---  --let mutCtx := (<- read).mutCtx
---  --dbg_trace "mutCtx {repr mutCtx}";
---  match x, y with
---  | e@(.mvar ..), _ => throw $ .unfilledExprMetavariable e
---  | _, e@(.mvar ..) => throw $ .unfilledExprMetavariable e
---  | e@(.fvar ..), _ => throw $ .freeVariableExpr e
---  | _, e@(.fvar ..) => throw $ .freeVariableExpr e
---  | .mdata _ anonmdata _ y  => compareExpr ctx xlvls ylvls x y
---  | .mdata _ x, y  => compareExpr ctx xlvls ylvls x y
---  | x, .mdata _ y  => compareExpr ctx xlvls ylvls x y
---  | .bvar x, .bvar y => return ⟨true, compare x y⟩
---  | .bvar .., _ => return ⟨true, .lt⟩
---  | _, .bvar .. => return ⟨true, .gt⟩
---  | .sort x, .sort y => compareLevel xlvls ylvls x y
---  | .sort .., _ => return ⟨true, .lt⟩
---  | _, .sort .. => return ⟨true, .gt⟩
---  | .const x xls, .const y yls => do
---    --dbg_trace "compare const {x} {y}";
---    let univs ← SOrder.zipM (compareLevel xlvls ylvls) xls yls
---    if univs.ord != .eq then return univs
---    --dbg_trace "compare const {x} {y} {repr ctx}";
---    match ctx.get? x, ctx.get? y with
---    | some nx, some ny => return ⟨false, compare nx ny⟩
---    | none, some _ => do
---      return ⟨true, .gt⟩
---    | some _, none =>
---      return ⟨true, .lt⟩
---    | none, none =>
---      if x == y then 
---        return ⟨true, .eq⟩
---      else do
---        let x' <- compileConst $ ← findLeanConst x
---        let y' <- compileConst $ ← findLeanConst y
---        return ⟨true, compare x' y'⟩
---  | .const .., _ => return ⟨true, .lt⟩
---  | _, .const .. => return ⟨true, .gt⟩
---  | .app xf xa, .app yf ya =>
---    SOrder.cmpM 
---      (compareExpr ctx xlvls ylvls xf yf) 
---      (compareExpr ctx xlvls ylvls xa ya)
---  | .app .., _ => return ⟨true, .lt⟩
---  | _, .app .. => return ⟨true, .gt⟩
---  | .lam _ xt xb _, .lam _ yt yb _ => 
---    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
---  | .lam .., _ => return ⟨true, .lt⟩
---  | _, .lam .. => return ⟨true, .gt⟩
---  | .forallE _ xt xb _, .forallE _ yt yb _ => 
---    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) (compareExpr ctx xlvls ylvls xb yb)
---  | .forallE .., _ => return ⟨true, .lt⟩
---  | _, .forallE .. => return ⟨true, .gt⟩
---  | .letE _ xt xv xb _, .letE _ yt yv yb _ =>
---    SOrder.cmpM (compareExpr ctx xlvls ylvls xt yt) <|
---    SOrder.cmpM (compareExpr ctx xlvls ylvls xv yv)
---      (compareExpr ctx xlvls ylvls xb yb)
---  | .letE .., _ => return ⟨true, .lt⟩
---  | _, .letE .. => return ⟨true, .gt⟩
---  | .lit x, .lit y => return ⟨true, compare x y⟩
---  | .lit .., _ => return ⟨true, .lt⟩
---  | _, .lit .. => return ⟨true, .gt⟩
---  | .proj _ nx tx, .proj _ ny ty => 
---    SOrder.cmpM (pure ⟨true, compare nx ny⟩) 
---      (compareExpr ctx xlvls ylvls tx ty)
---
---/-- AST comparison of two Lean definitions. --/
---partial def compareDef (ctx: Std.HashMap Lean.Name Nat) (x y: PreDefinition) : CompileM Ordering := do
---  let key := match compare x.name y.name with
---    | .lt => (x.name, y.name)
---    | _ => (y.name, x.name)
---  match (<- get).eqConst.get? key with
---  | some o => return o
---  | none => do
---    let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
---      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
---      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
---        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
---    if sorder.strong then modify fun stt => { stt with
---        eqConst := stt.eqConst.insert key sorder.ord
---      }
---    return sorder.ord
---
---/--
---`sortDefs` recursively sorts a list of mutual definitions into equivalence classes.
---At each stage, we take as input the current best known equivalence
---classes (held in the `mutCtx` of the CompileEnv). For most cases, equivalence
---can be determined by syntactic differences which are invariant to the current
---best known classification. For example:
---
---```
---mutual
---  def : Nat := 1
---  def bar : Nat := 2
---end
---```
---
---are both different due to the different values in the definition. We call this a
---"strong" ordering, and comparisons between defintions that produce strong
---orderings are cached across compilation.
---
---However, there are also weak orderings, where the order of definitions in a
---mutual block depends on itself.
---
---```
---mutual
---  def A : Nat → Nat
---  | 0 => 0
---  | n + 1 => B n + C n + 1
---
---  def B : Nat → Nat
---  | 0 => 0
---  | n + 1 => C n + 1
---
---  def C : Nat → Nat
---  | 0 => 0
---  | n + 1 => A n + 1
---end
---```
---
---Here since any reference to A, B, C has to be compiled into an index, the
---ordering chosen for A, B, C will effect itself, since we compile into
---something that looks, with order [A, B, C] like:
---
---```
---mutual
---  def #1 : Nat → Nat
---  | 0 => 0
---  | n + 1 => #2 n + #3 n + 1
---
---  def #2 : Nat → Nat
---  | 0 => 0
---  | n + 1 => #3 n + 1
---
---  def #3 : Nat → Nat
---  | 0 => 0
---  | n + 1 => #1 n + 1
---end
---```
---
---This is all well and good, but if we chose order `[C, B, A]` then the block
---would compile as
---
---```
---mutual
---  def #1 : Nat → Nat
---  | 0 => 0
---  | n + 1 => #3 n + 1
---
---  def #2 : Nat → Nat
---  | 0 => 0
---  | n + 1 => #1 n + 1
---
---  def #3 : Nat → Nat
---  | 0 => 0
---  | n + 1 => #2 n + #1 n + 1
---end
---```
---
---with completely different hashes. So we need to figure out a canonical order for
---such mutual blocks.
---
---We start by assuming that all definitions in a mutual block are equal and then 
---recursively refining this assumption through successive sorting passes. This
---algorithm bears some similarity to partition refinement:
---```
---classes₀ := [startDefs]
---classes₁ := sortDefs classes₀
---classes₂ := sortDefs classes₁
---classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
---```
---Initially, `startDefs` is simply the list of definitions we receive from
---`DefinitionVal.all`, sorted by name. We assume that at we will reach some
---fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no further refinement is
---possible (we have not rigourously proven such a fixed point exists, but
---it seams reasonable given that after the first pass to find the strongly ordered
---definitions, the algorithm should only separate partitions into smaller ones)
----/
---partial def sortDefs (classes : List PreDefinition)
---  : CompileM (List (List PreDefinition)) := do
---    sortDefsInner [List.sortBy (compare ·.name ·.name) classes] 0
---  where
---    eqDef (ctx: Std.HashMap Lean.Name Nat) (x y: PreDefinition) 
---      : CompileM Bool := (· == .eq) <$> compareDef ctx x y
---    sortDefsInner (classes: List (List PreDefinition)) (iter: Nat)
---      : CompileM (List (List PreDefinition)) := do
---      let ctx := defMutCtx classes
---      dbg_trace "sortdefs {iter} classes {repr (classes.map (·.map (·.name)))}";
---      let newClasses ← classes.mapM fun ds =>
---        match ds with
---        | []  => unreachable!
---        | [d] => pure [[d]]
---        | ds  => do pure $ (← List.groupByM (eqDef ctx) $ ← ds.sortByM (compareDef ctx))
---      let newClasses := newClasses.flatten.map (List.sortBy (compare ·.name ·.name))
---      if classes == newClasses then return newClasses
---      else sortDefsInner newClasses (iter + 1)
---
---/-- AST comparison of two Lean inductives. --/
---partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInductive) 
---  : CompileM Ordering := do
---  --dbg_trace "compareInd {x.name} {y.name}";
---  let key := match compare x.name y.name with
---    | .lt => (x.name, y.name)
---    | _ => (y.name, x.name)
---  match (<- get).eqConst.get? key with
---  | some o => return o
---  | none => do
---    let sorder <- do
---      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
---      SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
---      SOrder.cmpM (pure ⟨true, compare x.numIndices y.numIndices⟩) <|
---      SOrder.cmpM (pure ⟨true, compare x.ctors.length y.ctors.length⟩) <|
---      SOrder.cmpM (pure ⟨true, compare x.recrs.length y.recrs.length⟩) <|
---      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
---      SOrder.cmpM (SOrder.zipM compareCtor x.ctors y.ctors)
---        (SOrder.zipM compareRecr x.recrs y.recrs)
---    if sorder.strong then modify fun stt => { stt with
---        eqConst := stt.eqConst.insert key sorder.ord
---      }
---    --dbg_trace "compareInd {x.name} {y.name} -> {repr sorder.ord}";
---    return sorder.ord
---  where
---    compareCtor (x y: Lean.ConstructorVal) : CompileM SOrder := do
---     --dbg_trace "compareCtor {x.name} {y.name}";
---      let key := match compare x.name y.name with
---        | .lt => (x.name, y.name)
---        | _ => (y.name, x.name)
---      match (<- get).eqConst.get? key with
---      | some o => return ⟨true, o⟩
---      | none => do
---      let sorder <- do
---        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
---        SOrder.cmpM (pure ⟨true, compare x.cidx y.cidx⟩) <|
---        SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
---        SOrder.cmpM (pure ⟨true, compare x.numFields y.numFields⟩) <|
---          (compareExpr ctx x.levelParams y.levelParams x.type y.type)
---      if sorder.strong then modify fun stt => { stt with
---          eqConst := stt.eqConst.insert key sorder.ord
---        }
---      return sorder
---    compareRecr (x y: Lean.RecursorVal) : CompileM SOrder := do
---      --dbg_trace "compareRecr {x.name} {y.name}";
---      let key := match compare x.name y.name with
---        | .lt => (x.name, y.name)
---        | _ => (y.name, x.name)
---      match (<- get).eqConst.get? key with
---      | some o => return ⟨true, o⟩
---      | none => do
---      let sorder <- do
---        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
---        SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
---        SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
---        SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
---        SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
---        SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
---        SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
---          (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
---      if sorder.strong then modify fun stt => { stt with
---          eqConst := stt.eqConst.insert key sorder.ord
---        }
---      return sorder
---    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
---      : CompileM SOrder := do
---        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
---          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
---
-----#check List.sortBy (compare ·.name ·.name) [`Test.Ix.Inductives.C, `Test.Ix.Inductives.A, `Test.Ix.Inductives.B]
---
---/-- `sortInds` recursively sorts a list of inductive datatypes into equivalence
---classes, analogous to `sortDefs`
-----/
---partial def sortInds (classes : (List PreInductive)) 
---  : CompileM (List (List PreInductive)) := do
---    sortIndsInner [List.sortBy (compare ·.name ·.name) classes] 0
---  where
---    eqInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInductive) : CompileM Bool
---      := (· == .eq) <$> compareInd ctx x y
---    sortIndsInner (classes: List (List PreInductive)) (iter: Nat)
---      : CompileM (List (List PreInductive)) := do
---      dbg_trace "sortInds {iter} classes {repr (classes.map (·.map (·.name)))}";
---      let ctx := indMutCtx classes
---      let newClasses ← classes.mapM fun ds =>
---        match ds with
---        | []  => unreachable!
---        | [d] => pure [[d]]
---        | ds  => do pure $ (← List.groupByM (eqInd ctx) $ ← ds.sortByM (compareInd ctx))
---      let newClasses := newClasses.flatten.map (List.sortBy (compare ·.name ·.name))
---      if classes == newClasses then return newClasses
---      else sortIndsInner newClasses (iter + 1)
---
---end
---
---partial def makeLeanDef
---  (name: Lean.Name) (levelParams: List Lean.Name) (type value: Lean.Expr) 
---  : Lean.DefinitionVal :=
---  { name, levelParams, type, value, hints := .opaque, safety := .safe }
---
---partial def tryAddLeanDef (defn: Lean.DefinitionVal) : CompileM Unit := do
---  match (<- get).env.constants.find? defn.name with
---  | some _ => pure ()
---  | none => do
---    let env <- (·.env) <$> get
---    let maxHeartBeats <- (·.maxHeartBeats) <$> read
---    let decl := Lean.Declaration.defnDecl defn
---    match Lean.Environment.addDeclCore env maxHeartBeats decl .none with
---    | .ok e => do
---      modify fun stt => { stt with env := e }
---      return ()
---    | .error e => throw $ .kernelException e
---
---partial def addDef
---  (lvls: List Lean.Name)
---  (typ val: Lean.Expr)
---  : CompileM (Address × Address) := do
---  let typ' <- compileExpr typ
---  let val' <- compileExpr val
---  let anonConst := Ix.Const.definition 
---    ⟨.anonymous, lvls, typ', .definition, val', .opaque, .safe, []⟩
---  let (anonIxon,_) <- dematerializeConst anonConst
---  let anonAddr <- storeConst anonIxon
---  let name := anonAddr.toUniqueName
---  let const := 
---    Ix.Const.definition ⟨name, lvls, typ', .definition, val', .opaque, .safe, []⟩
---  let (a, m) <- hashConst const
---  if a != anonAddr then
---    throw <| .alphaInvarianceFailure anonConst anonAddr const a
---  else
---    tryAddLeanDef (makeLeanDef a.toUniqueName lvls typ val)
---    return (a, m)
---
---partial def commitConst (anon meta: Address)
---  : CompileM (Address × Address) := do
---  let secret <- freshSecret
---  let comm := .comm ⟨secret, anon⟩
---  let commAddr <- storeConst comm
---  let commMeta := .comm ⟨secret, meta⟩
---  let commMetaAddr <- storeConst commMeta
---  modify fun stt => { stt with
---    comms := stt.comms.insert commAddr.toUniqueName (commAddr, commMetaAddr)
---  }
---  return (commAddr, commMetaAddr)
---
---partial def commitDef 
---  (lvls: List Lean.Name) 
---  (typ val: Lean.Expr)
---  : CompileM (Address × Address) := do
---  let (a, m) <- addDef lvls typ val
---  let (ca, cm) <- commitConst a m
---  tryAddLeanDef (makeLeanDef ca.toUniqueName lvls typ val)
---  --tryAddLeanDecl (makeLeanDef ca.toUniqueName lvls typ (mkConst a.toUniqueName []))
---  return (ca, cm)
---
---
---partial def packLevel (lvls: Nat) (commit: Bool): CompileM Address :=
---  match Ixon.natPackAsAddress lvls with
---  | some lvlsAddr => do
---    if commit then
---      let secret <- freshSecret
---      let comm := .comm (Ixon.Comm.mk secret lvlsAddr)
---      let commAddr <- storeConst comm
---      modify fun stt => { stt with
---        comms := stt.comms.insert commAddr.toUniqueName (commAddr, commAddr)
---      }
---      return commAddr
---    else return lvlsAddr
---  | .none => throw $ .cantPackLevel lvls
---
 --partial def checkClaim
 --  (const: Lean.Name)
 --  (type: Lean.Expr)
 --  (sort: Lean.Expr)
 --  (lvls: List Lean.Name)
---  (commit: Bool)
+--  (secret: Option Address)
 --  : CompileM (Claim × Address × Address) := do
 --  let leanConst <- findLeanConst const
---  let (value, valMeta) <- compileConst leanConst >>= comm
---  let (type, typeMeta) <- addDef lvls sort type >>= comm
+--  let valAddr <- compileConst leanConst >>= comm
+--  let typeAddr <- addDef lvls sort type >>= comm
 --  let lvls <- packLevel lvls.length commit
 --  return (Claim.checks (CheckClaim.mk lvls type value), typeMeta, valMeta)
 --  where
---    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
+--    commit (c: Ix.Const) : MetaAddress := do
+--      match commit with
+--      | none => dematerializeConst c
+--      | some secret => 
+--
+--    if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
+
 --
 --partial def evalClaim
 --  (lvls: List Lean.Name)
@@ -1313,42 +1200,44 @@ end Ix
 --  return (Claim.evals (EvalClaim.mk lvlsAddr input output type), inputMeta, outputMeta, typeMeta)
 --  where
 --    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
---
---/--
---Content-addresses the "delta" of an environment, that is, the content that is
---added on top of the imports.
---
---Important: constants with open references in their expressions are filtered out.
---Open references are variables that point to names which aren't present in the
---`Lean.ConstMap`.
----/
---def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
---  : CompileM Unit := delta.forM fun _ c => discard $ compileConst c
---
---def compileEnv (env: Lean.Environment)
---  : CompileM Unit := do
---  compileDelta env.getDelta
---  env.getConstMap.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
---
---def CompileM.runIO (c : CompileM α) 
---  (env: Lean.Environment)
---  (maxHeartBeats: USize := 200000)
---  (seed : Option Nat := .none)
---  : IO (α × CompileState) := do
---  let seed <- match seed with
---    | .none => IO.monoNanosNow
---    | .some s => pure s
---  match <- c.run (.init maxHeartBeats) (.init env seed) with
---  | (.ok a, stt) => return (a, stt)
---  | (.error e, _) => throw (IO.userError (<- e.pretty))
---
---def CompileM.runIO' (c : CompileM α) 
---  (stt: CompileState)
---  (maxHeartBeats: USize := 200000)
---  : IO (α × CompileState) := do
---  match <- c.run (.init maxHeartBeats) stt with
---  | (.ok a, stt) => return (a, stt)
---  | (.error e, _) => throw (IO.userError (<- e.pretty))
---
---def compileEnvIO (env: Lean.Environment) : IO (CompileState):= do
---  Prod.snd <$> (compileDelta env.getDelta).runIO env
+
+
+/--
+Content-addresses the "delta" of an environment, that is, the content that is
+added on top of the imports.
+
+Important: constants with open references in their expressions are filtered out.
+Open references are variables that point to names which aren't present in the
+`Lean.ConstMap`.
+-/
+def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
+  : CompileM Unit := delta.forM fun _ c => discard $ compileConst c
+
+def compileEnv (env: Lean.Environment)
+  : CompileM Unit := do
+  compileDelta env.getDelta
+  env.getConstMap.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
+
+def CompileM.runIO (c : CompileM α) 
+  (env: Lean.Environment)
+  (maxHeartBeats: USize := 200000)
+  (seed : Option Nat := .none)
+  : IO (α × CompileState) := do
+  let seed <- match seed with
+    | .none => IO.monoNanosNow
+    | .some s => pure s
+  match <- c.run .init (.init env seed maxHeartBeats) with
+  | (.ok a, stt) => return (a, stt)
+  | (.error e, _) => throw (IO.userError (<- e.pretty))
+
+def CompileM.runIO' (c : CompileM α) 
+  (stt: CompileState)
+  : IO (α × CompileState) := do
+  match <- c.run .init stt with
+  | (.ok a, stt) => return (a, stt)
+  | (.error e, _) => throw (IO.userError (<- e.pretty))
+
+def compileEnvIO (env: Lean.Environment) : IO (CompileState):= do
+  Prod.snd <$> (compileDelta env.getDelta).runIO env
+
+end Ix
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 54c6de80..ea86cc07 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -94,16 +94,16 @@ and metavariables, and annotate global constant references with Ix.Address
 content-addresses
 --/
 inductive Expr
-  | var   (mdata: List Address) (idx: Nat)
-  | sort  (mdata: List Address) (univ: Level)
-  | const (mdata: List Address) (name: Lean.Name) (ref: MetaAddress) (univs: List Level)
-  | rec_  (mdata: List Address) (name: Lean.Name) (idx: Nat) (univs: List Level)
-  | app   (mdata: List Address) (func: Expr) (argm: Expr)
-  | lam   (mdata: List Address) (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
-  | pi    (mdata: List Address) (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
-  | letE  (mdata: List Address) (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
-  | lit   (mdata: List Address) (lit: Lean.Literal)
-  | proj  (mdata: List Address) (typeName: Lean.Name) (type: MetaAddress) (idx: Nat) (struct: Expr)
+  | var   (mdata: Address) (idx: Nat)
+  | sort  (mdata: Address) (univ: Level)
+  | const (mdata: Address) (name: Lean.Name) (ref: MetaAddress) (univs: List Level)
+  | rec_  (mdata: Address) (name: Lean.Name) (idx: Nat) (univs: List Level)
+  | app   (mdata: Address) (func: Expr) (argm: Expr)
+  | lam   (mdata: Address) (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
+  | pi    (mdata: Address) (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
+  | letE  (mdata: Address) (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
+  | lit   (mdata: Address) (lit: Lean.Literal)
+  | proj  (mdata: Address) (typeName: Lean.Name) (type: MetaAddress) (idx: Nat) (struct: Expr)
   deriving Inhabited, Ord, BEq, Repr, Hashable
 
 /--
@@ -117,7 +117,7 @@ structure Quotient where
   deriving Ord, BEq, Hashable, Repr, Nonempty
 
 /--
-Ix.Axiom axioms are analogous to Lean.AxiomVal
+Ix.Axiom axioms are analogous to Lean.AxiomVal, differing only in not including
 --/
 structure Axiom where
   name: Lean.Name
@@ -126,7 +126,7 @@ structure Axiom where
   isUnsafe: Bool
   deriving Ord, BEq, Hashable, Repr, Nonempty
 
-structure PreDefinition where
+structure PreDef where
   name: Lean.Name
   levelParams : List Lean.Name
   type : Lean.Expr
@@ -137,17 +137,17 @@ structure PreDefinition where
   all : List Lean.Name
   deriving BEq, Repr, Nonempty, Hashable, Inhabited
 
-def mkPreDefinition (x: Lean.DefinitionVal) : PreDefinition := 
+def mkPreDef (x: Lean.DefinitionVal) : PreDef := 
   ⟨x.name, x.levelParams, x.type, .definition, x.value, x.hints, x.safety, x.all⟩
 
-def mkPreTheorem (x: Lean.TheoremVal) : PreDefinition := 
+def mkPreTheorem (x: Lean.TheoremVal) : PreDef := 
   ⟨x.name, x.levelParams, x.type, .theorem, x.value, .opaque, .safe, x.all⟩
 
-def mkPreOpaque (x: Lean.OpaqueVal) : PreDefinition := 
+def mkPreOpaque (x: Lean.OpaqueVal) : PreDef := 
   ⟨x.name, x.levelParams, x.type, .opaque, x.value, .opaque,
     if x.isUnsafe then .unsafe else .safe, x.all⟩
 
-def defMutCtx (defss: List (List PreDefinition)) : Std.HashMap Lean.Name Nat 
+def defMutCtx (defss: List (List PreDef)) : Std.HashMap Lean.Name Nat 
   := Id.run do
   let mut mutCtx := default
   let mut i := 0
@@ -248,10 +248,10 @@ structure Recursor where
   deriving BEq, Ord, Hashable, Repr, Nonempty
 
 /--
-Ix.PreInductive is used to capture a Lean.InductiveVal along with their
+Ix.PreInd is used to capture a Lean.InductiveVal along with their
 constructors and recursors, in order to perform structural sorting
 --/
-structure PreInductive where
+structure PreInd where
   name: Lean.Name
   levelParams : List Lean.Name
   type : Lean.Expr
@@ -293,7 +293,7 @@ structure PreInductive where
 -- and an inductive with 3 ctors and 2 recrs, then the whole class will reserve
 -- 8 indices (one for the inductive type itself plus 3 ctors and 4 recrs).
 
-def indMutCtx (indss: List (List PreInductive))
+def indMutCtx (indss: List (List PreInd))
   : Std.HashMap Lean.Name Nat := Id.run do
   let mut mutCtx := default
   let mut idx := 0
@@ -337,9 +337,7 @@ structure InductiveProj where
   /-- name of an inductive within a mutual inductive block --/
   name: Lean.Name
   /-- content-address of a mutual inductive block --/
-  blockCont : Address
-  /-- metadata content-address a mutual inductive block --/
-  blockMeta : Address
+  block: MetaAddress
   /-- index of the specific inductive datatype within the block --/
   idx   : Nat
   deriving BEq, Ord, Hashable, Repr, Nonempty
@@ -348,9 +346,7 @@ structure ConstructorProj where
   /-- name of a specific constructor within an inductive --/
   name: Lean.Name
   /-- content-address of a mutual inductive block --/
-  blockCont : Address
-  /-- metadata content-address a mutual inductive block --/
-  blockMeta : Address
+  block: MetaAddress
   /-- index of a specific inductive datatype within the block --/
   idx   : Nat
   /-- name of a specific inductive datatype within the block --/
@@ -363,9 +359,7 @@ structure RecursorProj where
   /-- name of a specific recursor within the inductive --/
   name: Lean.Name
   /-- content-address of a mutual inductive block --/
-  blockCont : Address
-  /-- metadata content-address of a mutual inductive block --/
-  blockMeta : Address
+  block: MetaAddress
   /-- index of a specific inductive datatype within the block --/
   idx : Nat
   /-- name of a specific inductive datatype within the block --/
@@ -377,9 +371,7 @@ structure RecursorProj where
 structure DefinitionProj where
   name: Lean.Name
   /-- content-address of a mutual definition block --/
-  blockCont : Address
-  /-- metadata content-address of a mutual definition block --/
-  blockMeta : Address
+  block: MetaAddress
   /-- index of a specific definition within the block --/
   idx : Nat
   deriving BEq, Ord, Hashable, Repr, Nonempty
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index e8056ee8..2228d73e 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -579,7 +579,6 @@ instance : ToString Claim where
   | .checks x => toString x
   | .evals x => toString x
 
-
 instance : Serialize CheckClaim where
   put x := Serialize.put (x.lvls, x.type, x.value)
   get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
@@ -613,30 +612,144 @@ instance : Serialize Proof where
   put := fun x => Serialize.put (x.claim, x.bin)
   get := (fun (x,y) => .mk x y) <$> Serialize.get
 
+structure Substring where
+  str: Address
+  startPos: Nat
+  stopPos: Nat
+
+instance : Serialize Substring where
+  put := fun x => Serialize.put (x.str, x.startPos, x.stopPos)
+  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+
+inductive SourceInfo where
+| original (leading: Substring) (pos: Nat) (trailing: Substring) (endPos: Nat)
+| synthetic (pos endPos: Nat) (canonical: Bool)
+| none
+
+open Serialize
+def putSourceInfo : SourceInfo → PutM Unit
+| .original l p t e => putUInt8 0 *> put l *> put p *> put t *> put e
+| .synthetic p e c => putUInt8 1 *> put p *> put e *> put c
+| .none => putUInt8 2
+
+def getSourceInfo : GetM SourceInfo := do
+  match (← getUInt8) with
+  | 0 => .original <$> get <*> get <*> get <*> get
+  | 1 => .synthetic <$> get <*> get <*> get
+  | 2 => pure .none
+  | e => throw s!"expected SourceInfo encoding between 0 and 2, got {e}"
+
+instance : Serialize SourceInfo where
+  put := putSourceInfo
+  get := getSourceInfo
+
+inductive Preresolved where
+| «namespace» (ns: Address)
+| decl (n: Address) (fields: List Address)
+
+def putPreresolved : Preresolved → PutM Unit
+| .namespace ns => putUInt8 0 *> put ns
+| .decl n fs => putUInt8 1 *> put n *> put fs
+
+def getPreresolved : GetM Preresolved := do
+  match (← getUInt8) with
+  | 0 => .namespace <$> get
+  | 1 => .decl <$> get <*> get
+  | e => throw s!"expected Preresolved encoding between 0 and 2, got {e}"
+
+instance : Serialize Preresolved where
+  put := putPreresolved
+  get := getPreresolved
+
+inductive Syntax where
+| missing
+| node (info: SourceInfo) (kind: Address) (args: List Address)
+| atom (info: SourceInfo) (val: Address)
+| ident (info: SourceInfo) (rawVal: Substring) (val: Address) (preresolved: List Preresolved)
+
+def putSyntax : Syntax → PutM Unit
+| .missing => putUInt8 0
+| .node i k as => putUInt8 1 *> put i *> put k *> put as
+| .atom i v => putUInt8 2 *> put i *> put v
+| .ident i r v ps => putUInt8 3 *> put i *> put r *> put v *> put ps
+
+def getSyntax : GetM Syntax := do
+  match (← getUInt8) with
+  | 0 => pure .missing
+  | 1 => .node <$> get <*> get <*> get
+  | 2 => .atom <$> get <*> get
+  | 3 => .ident <$> get <*> get <*> get <*> get
+  | e => throw s!"expected Syntax encoding between 0 and 2, got {e}"
+
+instance : Serialize Syntax where
+  put := putSyntax
+  get := getSyntax
+
+def putInt : Int -> PutM Unit
+| .ofNat n => putUInt8 0 *> put n
+| .negSucc n => putUInt8 1 *> put n
+
+def getInt : GetM Int := do
+  match (<- getUInt8) with
+  | 0 => .ofNat <$> get
+  | 1 => .negSucc <$> get
+  | e => throw s!"expected Int encoding between 0 and 1, got {e}"
+
+instance : Serialize Int where
+  put := putInt
+  get := getInt
+
+inductive DataValue where
+| ofString (v: Address)
+| ofBool (v: Bool)
+| ofName (v: Address)
+| ofNat (v: Address)
+| ofInt (v: Address)
+| ofSyntax (v: Address)
+deriving BEq, Repr, Ord, Inhabited
+
+def putDataValue : DataValue → PutM Unit
+| .ofString v => putUInt8 0 *> put v
+| .ofBool v => putUInt8 1 *> put v
+| .ofName v => putUInt8 2 *> put v
+| .ofNat v => putUInt8 3 *> put v
+| .ofInt v => putUInt8 4 *> put v
+| .ofSyntax v => putUInt8 5 *> put v
+
+def getDataValue : GetM DataValue := do
+  match (← getUInt8) with
+  | 0 => .ofString <$> get
+  | 1 => .ofBool <$> get
+  | 2 => .ofName <$> get
+  | 3 => .ofNat <$> get
+  | 4 => .ofInt <$> get
+  | 5 => .ofSyntax <$> get
+  | e => throw s!"expected DataValue encoding between 0 and 5, got {e}"
+
+instance : Serialize DataValue where
+  put := putDataValue
+  get := getDataValue
+
 inductive Metadatum where
 | name : Address -> Metadatum
 | info : Lean.BinderInfo -> Metadatum
 | link : Address -> Metadatum
 | hints : Lean.ReducibilityHints -> Metadatum
 | all : List Address -> Metadatum
-| mutCtx : List (List Address) -> Metadatum
-| kvmap : Address -> Metadatum
+| kvmap : List (Address × DataValue) -> Metadatum
 deriving BEq, Repr, Ord, Inhabited
 
 structure Metadata where
   nodes: List Metadatum
   deriving BEq, Repr, Inhabited
 
-open Serialize
-
 def putMetadatum : Metadatum → PutM Unit
 | .name n => putUInt8 0 *> put n
 | .info i => putUInt8 1 *> putBinderInfo i
 | .link l => putUInt8 2 *> putBytes l.hash
 | .hints h => putUInt8 3 *> putReducibilityHints h
 | .all ns => putUInt8 4 *> put ns
-| .mutCtx ctx => putUInt8 5 *> put ctx
-| .kvmap ctx => putUInt8 6 *> put ctx
+| .kvmap map => putUInt8 5 *> put map
 
 def getMetadatum : GetM Metadatum := do
   match (<- getUInt8) with
@@ -645,9 +758,8 @@ def getMetadatum : GetM Metadatum := do
   | 2 => .link <$> (.mk <$> getBytes 32)
   | 3 => .hints <$> get
   | 4 => .all <$> get
-  | 5 => .mutCtx <$> get
-  | 6 => .kvmap <$> get
-  | e => throw s!"expected Metadatum encoding between 0 and 6, got {e}"
+  | 5 => .kvmap <$> get
+  | e => throw s!"expected Metadatum encoding between 0 and 5, got {e}"
 
 instance : Serialize Metadatum where
   put := putMetadatum
@@ -663,20 +775,7 @@ instance : Serialize Metadata where
       return ⟨nodes⟩
     | x => throw s!"Expected metadata tag, got {repr x}"
 
--- TODO: update docs
-/-- The core content-addressing datatype. The wire format is divided into
-several sections:
-1. 0x00 through 0x3F are dynamic expression objects with variable size. The
-   low nibble in the byte changes depending on the size of the expression.
-2. 0x40 through 0x8F are reserved for future dynamic objects
-3. 0x90 through 0x97 are static expression objects
-4. 0x98 through 0x9F are reserved for future static expression objects
-5. 0xA0 through 0xAF are dynamic lists of objects
-6. 0xB0 through 0xB7 are static constant (as in Lean.ConstantInfo) objects
-6. 0xC0 through 0xDf are dynamic constant objects
-7. 0xE0 through 0xE7 are addtional static objects
-8. 0xF0 thtrouh 0xFF are reserved for future objects
---/
+-- TODO: docs
 inductive Ixon where
 | nanon : Ixon                                          -- 0x00 anon name
 | nstr  : Address -> Address -> Ixon                    -- 0x01 str name
@@ -819,6 +918,9 @@ instance : Serialize Ixon where
 
 def Ixon.address (ixon: Ixon): Address := Address.blake3 (ser ixon)
 
+
+
+
 --
 ----section FFI
 ----
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index 2bfb1a7b..bba67563 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -38,9 +38,9 @@ elab "this_file!" : term => do
 macro "get_env!" : term =>
   `(getFileEnv this_file!)
 
-def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO Address := do
-  let ((a, _), _) <- (Ix.Compile.compileConst const).runIO env
-  return a
+def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO MetaAddress := do
+  let (addr, _) <- (Ix.compileConst const >>= Ix.dematerializeConst).runIO env
+  return addr
 
 def runCore (f : CoreM α) (env : Environment) : IO α :=
   Prod.fst <$> f.toIO { fileName := default, fileMap := default } { env }

From 63b5e0c921e3a38cb5c6dd8fc4db154ca6630a75 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Mon, 6 Oct 2025 11:41:28 -0300
Subject: [PATCH 48/74] proptest for `Ixon` serde

---
 Ix/Ixon.lean       |  38 +--
 Tests/Ix/Ixon.lean | 568 +++++++++++++++++++++++++++++----------------
 Tests/Main.lean    |  38 +--
 3 files changed, 407 insertions(+), 237 deletions(-)

diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 2228d73e..5e99d69c 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -28,7 +28,7 @@ def runGet (getm: GetM A) (bytes: ByteArray) : Except String A :=
   | .error e _ => .error e
 
 def ser [Serialize α] (a: α): ByteArray := runPut (Serialize.put a)
-def de [Serialize α] (bytes: ByteArray): Except String α := 
+def de [Serialize α] (bytes: ByteArray): Except String α :=
   runGet Serialize.get bytes
 
 def putUInt8 (x: UInt8) : PutM Unit :=
@@ -184,13 +184,13 @@ instance : Serialize ByteArray where
   put := putBytesTagged
   get := getBytesTagged
 
-def putMany {A: Type} (put : A -> PutM Unit) (xs: List A) : PutM Unit := 
+def putMany {A: Type} (put : A -> PutM Unit) (xs: List A) : PutM Unit :=
   List.forM xs put
 
 def getMany {A: Type} (x: Nat) (getm : GetM A) : GetM (List A) :=
   (List.range x).mapM (fun _ => getm)
 
-def puts {A: Type} [Serialize A] (xs: List A) : PutM Unit := 
+def puts {A: Type} [Serialize A] (xs: List A) : PutM Unit :=
   putMany Serialize.put xs
 
 def gets {A: Type} [Serialize A] (x: Nat) : GetM (List A) :=
@@ -253,46 +253,46 @@ instance (priority := default + 100) : Serialize (Bool × Bool) where
   put := fun (a, b) => putBools [a, b]
   get := do match (<- getBools 2) with
     | [a, b] => pure (a, b)
-    | e => throw s!"expected packed (Bool × Bool), got {e}" 
+    | e => throw s!"expected packed (Bool × Bool), got {e}"
 
 instance (priority := default + 101): Serialize (Bool × Bool × Bool) where
   put := fun (a, b, c) => putBools [a, b, c]
   get := do match (<- getBools 3) with
     | [a, b, c] => pure (a, b, c)
-    | e => throw s!"expected packed (Bool × Bool × Bool), got {e}" 
+    | e => throw s!"expected packed (Bool × Bool × Bool), got {e}"
 
 instance (priority := default + 102): Serialize (Bool × Bool × Bool × Bool) where
   put := fun (a, b, c,d) => putBools [a, b, c, d]
   get := do match (<- getBools 4) with
     | [a, b, c, d] => pure (a, b, c, d)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool), got {e}" 
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool), got {e}"
 
 instance (priority := default + 103): Serialize (Bool × Bool × Bool × Bool × Bool) where
   put := fun (a, b, c, d, e) => putBools [a, b, c, d, e]
   get := do match (<- getBools 5) with
     | [a, b, c, d, e] => pure (a, b, c, d, e)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool), got {e}" 
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool), got {e}"
 
 instance (priority := default + 104)
   : Serialize (Bool × Bool × Bool × Bool × Bool × Bool) where
   put := fun (a, b, c, d, e, f) => putBools [a, b, c, d, e, f]
   get := do match (<- getBools 6) with
     | [a, b, c, d, e, f] => pure (a, b, c, d, e, f)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool), got {e}"
 
 instance (priority := default + 106)
   : Serialize (Bool × Bool × Bool × Bool × Bool × Bool × Bool) where
   put := fun (a, b, c, d, e, f, g) => putBools [a, b, c, d, e, f, g]
   get := do match (<- getBools 7) with
     | [a, b, c, d, e, f, g] => pure (a, b, c, d, e, f, g)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}"
 
 instance (priority := default + 105)
   : Serialize (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool) where
   put := fun (a, b, c, d, e, f, g, h) => putBools [a, b, c, d, e, f, g, h]
   get := do match (<- getBools 8) with
     | [a, b, c, d, e, f, g, h] => pure (a, b, c, d, e, f, g, h)
-    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}" 
+    | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}"
 
 def putQuotKind : Lean.QuotKind → PutM Unit
 | .type => putUInt8 0
@@ -354,7 +354,7 @@ def putReducibilityHints : Lean.ReducibilityHints → PutM Unit
 def getReducibilityHints : GetM Lean.ReducibilityHints := do
   match (← getUInt8) with
   | 0 => return .«opaque»
-  | 1 => return .«abbrev» 
+  | 1 => return .«abbrev»
   | 2 => .regular <$> getUInt32LE
   | e => throw s!"expected ReducibilityHints encoding between 0 and 2, got {e}"
 
@@ -371,7 +371,7 @@ def getDefinitionSafety : GetM Lean.DefinitionSafety := do
   match (← getUInt8) with
   | 0 => return .«unsafe»
   | 1 => return .«safe»
-  | 2 => return .«partial» 
+  | 2 => return .«partial»
   | e => throw s!"expected DefinitionSafety encoding between 0 and 2, got {e}"
 
 instance : Serialize Lean.DefinitionSafety where
@@ -824,7 +824,7 @@ partial def putIxon : Ixon -> PutM Unit
 | .usucc u => put (Tag4.mk 0x0 4) *> put u
 | .umax x y => put (Tag4.mk 0x0 5) *> put x *> put y
 | .uimax x y => put (Tag4.mk 0x0 6) *> put x *> put y
-| .uvar x => 
+| .uvar x =>
   let bytes := x.toBytesLE
   put (Tag4.mk 0x1 bytes.size.toUInt64) *> putBytes ⟨bytes⟩
 | .evar x =>
@@ -836,7 +836,7 @@ partial def putIxon : Ixon -> PutM Unit
   put (Tag4.mk 0x4 bytes.size.toUInt64) *> putBytes ⟨bytes⟩ *> putList ls
 | .eprj t n x =>
   let bytes := n.toBytesLE
-  put (Tag4.mk 0x5 bytes.size.toUInt64) *> putBytes ⟨bytes⟩ *> putBytes t.hash *> put x
+  put (Tag4.mk 0x5 bytes.size.toUInt64) *> put t *> putBytes ⟨bytes⟩ *> put x
 | .esort u => put (Tag4.mk 0x9 0x0) *> put u
 | .estr s => put (Tag4.mk 0x9 0x1) *> put s
 | .enat n => put (Tag4.mk 0x9 0x2) *> put n
@@ -856,11 +856,11 @@ partial def putIxon : Ixon -> PutM Unit
 | .dprj x => put (Tag4.mk 0xB 0x6) *> put x
 | .inds xs => put (Tag4.mk 0xC xs.length.toUInt64) *> puts xs
 | .defs xs => put (Tag4.mk 0xD xs.length.toUInt64) *> puts xs
-| .prof x => put (Tag4.mk 0xE 0x1) *> put x
-| .eval x => put (Tag4.mk 0xE 0x2) *> put x
-| .chck x => put (Tag4.mk 0xE 0x3) *> put x
-| .comm x => put (Tag4.mk 0xE 0x4) *> put x
-| .envn x => put (Tag4.mk 0xE 0x5) *> put x
+| .prof x => put (Tag4.mk 0xE 0x0) *> put x
+| .eval x => put (Tag4.mk 0xE 0x1) *> put x
+| .chck x => put (Tag4.mk 0xE 0x2) *> put x
+| .comm x => put (Tag4.mk 0xE 0x3) *> put x
+| .envn x => put (Tag4.mk 0xE 0x4) *> put x
 | .meta m => put m
 
 def getIxon : GetM Ixon := do
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 06c9a7fe..a8c209a2 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -1,241 +1,409 @@
 import Ix.Ixon
-import Ix.Claim
-import Ix.Ixon.Serialize
-import Ix.Ixon.Univ
-import LSpec.SlimCheck.Gen
-import LSpec
-
 import Tests.Common
-import Tests.Ix.Common
-
-open LSpec
-open SlimCheck
-open SlimCheck.Gen
-open Ixon
-
--- Univ
-namespace Ixon
-
-def genUniv : Gen Ixon.Univ := getSize >>= go
-  where
-    go : Nat -> Gen Ixon.Univ
-    | 0 => return .const 0
-    | Nat.succ f =>
-      frequency [
-        (100, .const <$> genUInt64),
-        (100, .var <$> genUInt64),
-        (50, .add <$> genUInt64 <*> go f),
-        (25, .max <$> go f <*> go f),
-        (25, .imax <$> go f <*> go f)
-      ]
-
-instance : Shrinkable Univ where
-  shrink _ := []
 
-instance : SampleableExt Univ := SampleableExt.mkSelfContained genUniv
-
--- Expr
-
-def genExpr : SlimCheck.Gen Ixon := getSize >>= go
-  where
-    go : Nat -> SlimCheck.Gen Ixon
-    | 0 => return .vari 0
-    | Nat.succ f =>
-      frequency [
-        (100, .vari <$> genUInt64),
-        (100, .sort <$> genUniv),
-        (100, .refr <$> genAddress <*> genList genUniv),
-        (100, .recr <$> genUInt64 <*> genList genUniv),
-        (15, .apps <$> go f <*> go f <*> genList (go f)),
-        (15, .lams <$> genList (go f) <*> go f),
-        (15, .alls <$> genList (go f) <*> go f),
-        (15, .letE .true <$> go f <*> go f <*> go f),
-        (15, .letE .false <$> go f <*> go f <*> go f),
-        (50, .proj <$> genAddress <*> genUInt64 <*> go f),
-        (100, .strl <$> genString),
-        (100, .natl <$> chooseAny Nat)
-      ]
-
-structure IxonExpr where
-  ixon : Ixon
-deriving BEq, Repr
-
-instance : Serialize IxonExpr where
-  put x := Serialize.put x.ixon
-  get := .mk <$> Serialize.get
-
--- TODO: useful shrinking
-instance : Shrinkable IxonExpr where
-  shrink _ := []
+open LSpec SlimCheck Gen
 
-instance : SampleableExt IxonExpr :=
-  SampleableExt.mkSelfContained (IxonExpr.mk <$> genExpr)
+def genAddress : Gen Address :=
+  pure (Address.mk (Blake3.hash "foobar".toUTF8).val)
 
--- Metadata
-def genMetadatum : Gen Ixon.Metadatum :=
-  frequency [
-    (50, .name <$> genName),
-    (100, .info <$> genBinderInfo),
-    (100, .link <$> genAddress),
-    (100, .hints <$> genReducibilityHints),
-    (10, .all <$> genList genName),
-  ]
+def genNat : Gen Nat := USize.toNat <$> genUSize
 
-instance : Shrinkable Metadatum where
-  shrink _ := []
+def genBool : Gen Bool := choose Bool .false true
 
-instance : SampleableExt Metadatum :=
-  SampleableExt.mkSelfContained genMetadatum
+-- aggressively reduce size parameter to avoid tree blow-up
+def genList (n: Gen α) : Gen (List α) :=
+  resize (fun s => if s > 8 then 8 else s / 2) $ listOf n
 
-def genMetaNode : Gen (List Metadatum) := genList genMetadatum
+def genDefKind : Gen Ix.DefKind :=
+  elements #[.definition, .opaque, .theorem]
 
-def genMetadata : Gen Metadata := do
-  let xs ← genList genMetaNode
-  return .mk ((List.range xs.length).zip xs)
+def genDefinitionSafety : Gen Lean.DefinitionSafety :=
+  elements #[.unsafe, .safe, .partial]
 
-instance : Shrinkable Metadata where
-  shrink _ := []
+def genDefinition : Gen Ixon.Definition :=
+  .mk <$> genDefKind <*> genDefinitionSafety <*> genNat <*> genAddress <*> genAddress
 
-instance : SampleableExt Metadata :=
-  SampleableExt.mkSelfContained genMetadata
+def genAxiom : Gen Ixon.Axiom :=
+  .mk <$> genBool <*> genNat <*> genAddress
 
--- Const
-def genAxiom : Gen Axiom := .mk <$> genBool <*> genNat <*> genAddress
+def genQuotKind : Gen Lean.QuotKind :=
+  elements #[.type, .ctor, .lift, .ind]
 
--- TODO: useful shrinking
-instance : Shrinkable Axiom where
-  shrink _ := []
+def genQuotient : Gen Ixon.Quotient :=
+  .mk <$> genQuotKind <*> genNat <*> genAddress
+
+def genConstructorProj : Gen Ixon.ConstructorProj :=
+  .mk <$> genNat <*> genNat <*> genAddress
+
+def genRecursorProj : Gen Ixon.RecursorProj :=
+  .mk <$> genNat <*> genNat <*> genAddress
 
-instance : SampleableExt Axiom
-  := SampleableExt.mkSelfContained genAxiom
+def genInductiveProj : Gen Ixon.InductiveProj :=
+  .mk <$> genNat <*> genAddress
+
+def genDefinitionProj : Gen Ixon.DefinitionProj :=
+  .mk <$> genNat <*> genAddress
 
-def genDefinition : Gen Definition := do
-  let lvls <- genNat
-  let type <- genAddress
-  let kind <- genDefKind
-  let value <- genAddress
-  let safety <- oneOf #[pure .safe, pure .unsafe, pure .partial]
-  return .mk kind safety lvls type value
+def genRecursorRule : Gen Ixon.RecursorRule :=
+  .mk <$> genNat <*> genAddress
 
-def genConstructor : Gen Constructor :=
+def genRecursor : Gen Ixon.Recursor :=
+  .mk <$> genBool <*> genBool <*> genNat <*> genNat <*> genNat <*> genNat <*> genNat
+    <*> genAddress <*> genList genRecursorRule
+
+def genConstructor : Gen Ixon.Constructor :=
   .mk <$> genBool <*> genNat <*> genNat <*> genNat <*> genNat <*> genAddress
 
--- TODO: useful shrinking
-instance : Shrinkable Constructor where
-  shrink _ := []
+def genInductive : Gen Ixon.Inductive :=
+  .mk <$> genBool <*> genBool <*> genBool <*> genNat <*> genNat <*> genNat <*> genNat
+    <*> genAddress <*> genList genConstructor <*> genList genRecursor
 
-instance : SampleableExt Constructor
-  := SampleableExt.mkSelfContained genConstructor
+def genEvalClaim : Gen Ixon.EvalClaim :=
+  .mk <$> genAddress <*> genAddress <*> genAddress <*> genAddress
 
-def genRecursorRule : Gen RecursorRule := .mk <$> genNat <*> genAddress
+def genCheckClaim : Gen Ixon.CheckClaim :=
+  .mk <$> genAddress <*> genAddress <*> genAddress
 
--- TODO: useful shrinking
-instance : Shrinkable RecursorRule where
-  shrink _ := []
+def genClaim : Gen Ixon.Claim :=
+  frequency [(10, .evals <$> genEvalClaim), (10, .checks <$> genCheckClaim)]
 
-instance : SampleableExt RecursorRule
-  := SampleableExt.mkSelfContained genRecursorRule
+def genProof : Gen Ixon.Proof :=
+  .mk <$> genClaim <*> pure "foobar".toUTF8
 
-def genRecursor : Gen Recursor :=
-  .mk <$> genBool <*> genBool <*> genNat <*> genNat <*> genNat <*> genNat
-    <*> genNat <*> genAddress <*> genList genRecursorRule
+def genComm : Gen Ixon.Comm :=
+  .mk <$> genAddress <*> genAddress
 
--- TODO: useful shrinking
-instance : Shrinkable Recursor where
-  shrink _ := []
+def genMetaAddress : Gen MetaAddress :=
+  .mk <$> genAddress <*> genAddress
 
-instance : SampleableExt Recursor
-  := SampleableExt.mkSelfContained genRecursor
+def genEnv : Gen Ixon.Env :=
+  .mk <$> genList genMetaAddress
 
-def genInductive : Gen Inductive :=
-  .mk <$> genBool <*> genBool <*> genBool
-    <*> genNat <*> genNat <*> genNat <*> genNat
-    <*> genAddress <*> genList genConstructor <*> genList genRecursor
+def genBinderInfo : Gen Lean.BinderInfo :=
+  elements #[.default, .implicit, .strictImplicit, .instImplicit]
+
+def genReducibilityHints : Gen Lean.ReducibilityHints :=
+  frequency [
+    (10, pure .opaque),
+    (10, pure .abbrev),
+    (10, .regular <$> genUInt32),
+  ]
+
+def genDataValue : Gen Ixon.DataValue :=
+  frequency [
+    (10, .ofString <$> genAddress),
+    (10, .ofBool <$> genBool),
+    (10, .ofName <$> genAddress),
+    (10, .ofNat <$> genAddress),
+    (10, .ofInt <$> genAddress),
+    (10, .ofSyntax <$> genAddress),
+  ]
+
+def genMetadatum : Gen Ixon.Metadatum :=
+  frequency [
+    (10, .name <$> genAddress),
+    (10, .info <$> genBinderInfo),
+    (10, .link <$> genAddress),
+    (10, .hints <$> genReducibilityHints),
+    (10, .all <$> genList genAddress),
+    (10, .kvmap <$> genList (Prod.mk <$> genAddress <*> genDataValue)),
+  ]
+
+def genMetadata : Gen Ixon.Metadata :=
+  .mk <$> genList genMetadatum
+
+partial def genIxon : Gen Ixon.Ixon :=
+  frequency [
+    (10, pure .nanon),
+    (10, .nstr <$> genAddress <*> genAddress),
+    (10, .nnum <$> genAddress <*> genAddress),
+    (10, pure .uzero),
+    (10, .usucc <$> genAddress),
+    (10, .umax <$> genAddress <*> genAddress),
+    (10, .uimax <$> genAddress <*> genAddress),
+    (10, .uvar <$> genNat),
+    (10, .evar <$> genNat),
+    (10, .eref <$> genAddress <*> genList genAddress),
+    (10, .erec <$> genNat <*> genList genAddress),
+    (10, .eprj <$> genAddress <*> genNat <*> genAddress),
+    (10, .esort <$> genAddress),
+    (10, .estr <$> genAddress),
+    (10, .enat <$> genAddress),
+    (10, .eapp <$> genAddress <*> genAddress),
+    (10, .elam <$> genAddress <*> genAddress),
+    (10, .eall <$> genAddress <*> genAddress),
+    (10, .elet <$> genBool <*> genAddress <*> genAddress <*> genAddress),
+    (10, .list <$> genList genIxon),
+    (10, .defn <$> genDefinition),
+    (10, .axio <$> genAxiom),
+    (10, .quot <$> genQuotient),
+    (10, .cprj <$> genConstructorProj),
+    (10, .rprj <$> genRecursorProj),
+    (10, .iprj <$> genInductiveProj),
+    (10, .dprj <$> genDefinitionProj),
+    (10, .inds <$> genList genInductive),
+    (10, .defs <$> genList genDefinition),
+    (10, .prof <$> genProof),
+    (10, .eval <$> genEvalClaim),
+    (10, .chck <$> genCheckClaim),
+    (10, .comm <$> genComm),
+    (10, .envn <$> genEnv),
+    (10, .meta <$> genMetadata),
+  ]
 
--- TODO: useful shrinking
-instance : Shrinkable Inductive where
+instance : Shrinkable Ixon.Ixon where
   shrink _ := []
 
-instance : SampleableExt Inductive
-  := SampleableExt.mkSelfContained genInductive
+instance : SampleableExt Ixon.Ixon := SampleableExt.mkSelfContained genIxon
+
+def ixonSerde (ixon : Ixon.Ixon) : Bool :=
+  let bytes := Ixon.ser ixon
+  match Ixon.de bytes with
+  | .ok ixon' => ixon == ixon'
+  | .error _ => false
+
+def Tests.Ixon.suite := [
+  check "Ixon serde roundtrips" (∀ ixon : Ixon.Ixon, ixonSerde ixon)
+]
+
+-- import Ix.Ixon
+-- import Ix.Claim
+-- import Ix.Ixon.Serialize
+-- import Ix.Ixon.Univ
+-- import LSpec.SlimCheck.Gen
+-- import LSpec
+
+-- import Tests.Common
+-- import Tests.Ix.Common
+
+-- open LSpec
+-- open SlimCheck
+-- open SlimCheck.Gen
+-- open Ixon
+
+-- -- Univ
+-- namespace Ixon
+
+-- def genUniv : Gen Ixon.Univ := getSize >>= go
+--   where
+--     go : Nat -> Gen Ixon.Univ
+--     | 0 => return .const 0
+--     | Nat.succ f =>
+--       frequency [
+--         (100, .const <$> genUInt64),
+--         (100, .var <$> genUInt64),
+--         (50, .add <$> genUInt64 <*> go f),
+--         (25, .max <$> go f <*> go f),
+--         (25, .imax <$> go f <*> go f)
+--       ]
+
+-- instance : Shrinkable Univ where
+--   shrink _ := []
+
+-- instance : SampleableExt Univ := SampleableExt.mkSelfContained genUniv
+
+-- -- Expr
+
+-- def genExpr : SlimCheck.Gen Ixon := getSize >>= go
+--   where
+--     go : Nat -> SlimCheck.Gen Ixon
+--     | 0 => return .vari 0
+--     | Nat.succ f =>
+--       frequency [
+--         (100, .vari <$> genUInt64),
+--         (100, .sort <$> genUniv),
+--         (100, .refr <$> genAddress <*> genList genUniv),
+--         (100, .recr <$> genUInt64 <*> genList genUniv),
+--         (15, .apps <$> go f <*> go f <*> genList (go f)),
+--         (15, .lams <$> genList (go f) <*> go f),
+--         (15, .alls <$> genList (go f) <*> go f),
+--         (15, .letE .true <$> go f <*> go f <*> go f),
+--         (15, .letE .false <$> go f <*> go f <*> go f),
+--         (50, .proj <$> genAddress <*> genUInt64 <*> go f),
+--         (100, .strl <$> genString),
+--         (100, .natl <$> chooseAny Nat)
+--       ]
+
+-- structure IxonExpr where
+--   ixon : Ixon
+-- deriving BEq, Repr
+
+-- instance : Serialize IxonExpr where
+--   put x := Serialize.put x.ixon
+--   get := .mk <$> Serialize.get
+
+-- -- TODO: useful shrinking
+-- instance : Shrinkable IxonExpr where
+--   shrink _ := []
+
+-- instance : SampleableExt IxonExpr :=
+--   SampleableExt.mkSelfContained (IxonExpr.mk <$> genExpr)
+
+-- -- Metadata
+-- def genMetadatum : Gen Ixon.Metadatum :=
+--   frequency [
+--     (50, .name <$> genName),
+--     (100, .info <$> genBinderInfo),
+--     (100, .link <$> genAddress),
+--     (100, .hints <$> genReducibilityHints),
+--     (10, .all <$> genList genName),
+--   ]
+
+-- instance : Shrinkable Metadatum where
+--   shrink _ := []
+
+-- instance : SampleableExt Metadatum :=
+--   SampleableExt.mkSelfContained genMetadatum
+
+-- def genMetaNode : Gen (List Metadatum) := genList genMetadatum
+
+-- def genMetadata : Gen Metadata := do
+--   let xs ← genList genMetaNode
+--   return .mk ((List.range xs.length).zip xs)
+
+-- instance : Shrinkable Metadata where
+--   shrink _ := []
+
+-- instance : SampleableExt Metadata :=
+--   SampleableExt.mkSelfContained genMetadata
+
+-- -- Const
+-- def genAxiom : Gen Axiom := .mk <$> genBool <*> genNat <*> genAddress
+
+-- -- TODO: useful shrinking
+-- instance : Shrinkable Axiom where
+--   shrink _ := []
+
+-- instance : SampleableExt Axiom
+--   := SampleableExt.mkSelfContained genAxiom
+
+-- def genDefinition : Gen Definition := do
+--   let lvls <- genNat
+--   let type <- genAddress
+--   let kind <- genDefKind
+--   let value <- genAddress
+--   let safety <- oneOf #[pure .safe, pure .unsafe, pure .partial]
+--   return .mk kind safety lvls type value
+
+-- def genConstructor : Gen Constructor :=
+--   .mk <$> genBool <*> genNat <*> genNat <*> genNat <*> genNat <*> genAddress
+
+-- -- TODO: useful shrinking
+-- instance : Shrinkable Constructor where
+--   shrink _ := []
+
+-- instance : SampleableExt Constructor
+--   := SampleableExt.mkSelfContained genConstructor
+
+-- def genRecursorRule : Gen RecursorRule := .mk <$> genNat <*> genAddress
+
+-- -- TODO: useful shrinking
+-- instance : Shrinkable RecursorRule where
+--   shrink _ := []
+
+-- instance : SampleableExt RecursorRule
+--   := SampleableExt.mkSelfContained genRecursorRule
+
+-- def genRecursor : Gen Recursor :=
+--   .mk <$> genBool <*> genBool <*> genNat <*> genNat <*> genNat <*> genNat
+--     <*> genNat <*> genAddress <*> genList genRecursorRule
+
+-- -- TODO: useful shrinking
+-- instance : Shrinkable Recursor where
+--   shrink _ := []
+
+-- instance : SampleableExt Recursor
+--   := SampleableExt.mkSelfContained genRecursor
+
+-- def genInductive : Gen Inductive :=
+--   .mk <$> genBool <*> genBool <*> genBool
+--     <*> genNat <*> genNat <*> genNat <*> genNat
+--     <*> genAddress <*> genList genConstructor <*> genList genRecursor
+
+-- -- TODO: useful shrinking
+-- instance : Shrinkable Inductive where
+--   shrink _ := []
 
-def genConstructorProj : Gen ConstructorProj :=
-  .mk <$> genNat <*> genNat <*> genAddress
+-- instance : SampleableExt Inductive
+--   := SampleableExt.mkSelfContained genInductive
 
-def genRecursorProj : Gen RecursorProj :=
-  .mk <$> genNat <*> genNat <*> genAddress
+-- def genConstructorProj : Gen ConstructorProj :=
+--   .mk <$> genNat <*> genNat <*> genAddress
 
-def genDefinitionProj : Gen DefinitionProj :=
-  .mk <$> genNat <*> genAddress
+-- def genRecursorProj : Gen RecursorProj :=
+--   .mk <$> genNat <*> genNat <*> genAddress
 
-def genInductiveProj : Gen InductiveProj :=
-  .mk <$> genNat <*> genAddress
+-- def genDefinitionProj : Gen DefinitionProj :=
+--   .mk <$> genNat <*> genAddress
 
-def genCheckClaim : Gen CheckClaim :=
-  .mk <$> genAddress <*> genAddress <*> genAddress
+-- def genInductiveProj : Gen InductiveProj :=
+--   .mk <$> genNat <*> genAddress
 
-def genEvalClaim : Gen EvalClaim :=
-  .mk <$> genAddress <*> genAddress <*> genAddress <*> genAddress
+-- def genCheckClaim : Gen CheckClaim :=
+--   .mk <$> genAddress <*> genAddress <*> genAddress
 
-def genClaim: Gen Claim :=
-  oneOf #[.checks <$> genCheckClaim, .evals <$> genEvalClaim]
-
--- TODO: different dummy ByteArray perhaps
-def genProof: Gen Proof := .mk <$> genClaim <*> (Address.hash <$> genAddress)
-
-def genComm: Gen Comm := .mk <$> genAddress <*> genAddress
-
-def genEnvn: Gen Env := .mk <$> genList ((·,·) <$> genAddress <*> genAddress)
-
-def genConst : Gen Ixon := getSize >>= go
-  where
-    go : Nat -> Gen Ixon
-    | 0 => .axio <$> genAxiom
-    | Nat.succ _ =>
-      frequency [
-        (100, .axio <$> genAxiom),
-        (100, .defn <$> genDefinition),
-        (100, .cprj <$> genConstructorProj),
-        (100, .rprj <$> genRecursorProj),
-        (100, .iprj <$> genInductiveProj),
-        (100, .dprj <$> genDefinitionProj),
-        (100, .defs <$> genList genDefinition),
-        (100, .inds <$> genList genInductive),
-        (100, .meta <$> genMetadata),
-        (100, .prof <$> genProof),
-        (100, .eval <$> genEvalClaim),
-        (100, .chck <$> genCheckClaim),
-        (100, .comm <$> genComm),
-        (100, .envn <$> genEnvn),
-      ]
-
-structure IxonConst where
-  ixon : Ixon
-deriving BEq, Repr
-
-instance : Serialize IxonConst where
-  put x := Serialize.put x.ixon
-  get := .mk <$> Serialize.get
-
--- TODO: useful shrinking
-instance : Shrinkable IxonConst where
-  shrink _ := []
+-- def genEvalClaim : Gen EvalClaim :=
+--   .mk <$> genAddress <*> genAddress <*> genAddress <*> genAddress
 
-instance : SampleableExt IxonConst
-  := SampleableExt.mkSelfContained (IxonConst.mk <$> genConst)
+-- def genClaim: Gen Claim :=
+--   oneOf #[.checks <$> genCheckClaim, .evals <$> genEvalClaim]
 
--- TODO: useful shrinking
-instance : Shrinkable Claim where
-  shrink _ := []
+-- -- TODO: different dummy ByteArray perhaps
+-- def genProof: Gen Proof := .mk <$> genClaim <*> (Address.hash <$> genAddress)
+
+-- def genComm: Gen Comm := .mk <$> genAddress <*> genAddress
+
+-- def genEnvn: Gen Env := .mk <$> genList ((·,·) <$> genAddress <*> genAddress)
+
+-- def genConst : Gen Ixon := getSize >>= go
+--   where
+--     go : Nat -> Gen Ixon
+--     | 0 => .axio <$> genAxiom
+--     | Nat.succ _ =>
+--       frequency [
+--         (100, .axio <$> genAxiom),
+--         (100, .defn <$> genDefinition),
+--         (100, .cprj <$> genConstructorProj),
+--         (100, .rprj <$> genRecursorProj),
+--         (100, .iprj <$> genInductiveProj),
+--         (100, .dprj <$> genDefinitionProj),
+--         (100, .defs <$> genList genDefinition),
+--         (100, .inds <$> genList genInductive),
+--         (100, .meta <$> genMetadata),
+--         (100, .prof <$> genProof),
+--         (100, .eval <$> genEvalClaim),
+--         (100, .chck <$> genCheckClaim),
+--         (100, .comm <$> genComm),
+--         (100, .envn <$> genEnvn),
+--       ]
+
+-- structure IxonConst where
+--   ixon : Ixon
+-- deriving BEq, Repr
+
+-- instance : Serialize IxonConst where
+--   put x := Serialize.put x.ixon
+--   get := .mk <$> Serialize.get
 
-instance : SampleableExt Claim
-  := SampleableExt.mkSelfContained genClaim
+-- -- TODO: useful shrinking
+-- instance : Shrinkable IxonConst where
+--   shrink _ := []
 
-/--
-Whether the provided IxonFFI term, reconstructed and serialized in Rust, matches
-the provided bytes.
--/
-@[extern "rs_eq_lean_rust_serialization"]
-opaque eqLeanRustSerialization : @& IxonFFI -> @& ByteArray -> Bool
+-- instance : SampleableExt IxonConst
+--   := SampleableExt.mkSelfContained (IxonConst.mk <$> genConst)
 
-end Ixon
+-- -- TODO: useful shrinking
+-- instance : Shrinkable Claim where
+--   shrink _ := []
+
+-- instance : SampleableExt Claim
+--   := SampleableExt.mkSelfContained genClaim
+
+-- /--
+-- Whether the provided IxonFFI term, reconstructed and serialized in Rust, matches
+-- the provided bytes.
+-- -/
+-- @[extern "rs_eq_lean_rust_serialization"]
+-- opaque eqLeanRustSerialization : @& IxonFFI -> @& ByteArray -> Bool
+
+-- end Ixon
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 24aa1765..31844672 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -1,22 +1,24 @@
-import Tests.Aiur
-import Tests.FFIConsistency
-import Tests.ByteArray
-import Tests.Ix
-import Tests.Ix.Compile
-import Tests.Keccak
-import Tests.Cli
+-- import Tests.Aiur
+-- import Tests.FFIConsistency
+-- import Tests.ByteArray
+-- import Tests.Ix
+import Tests.Ix.Ixon
+-- import Tests.Ix.Compile
+-- import Tests.Keccak
+-- import Tests.Cli
 
 def main (args: List String) : IO UInt32 := do
-  if args.contains "compile"
-  then LSpec.lspecEachIO Tests.Ix.Compile.suiteIO id
-  else if args.contains "cli" then
-    Tests.Cli.suite
-  else
+  -- if args.contains "compile"
+  -- then LSpec.lspecEachIO Tests.Ix.Compile.suiteIO id
+  -- else if args.contains "cli" then
+  --   Tests.Cli.suite
+  -- else
     LSpec.lspecIO (.ofList [
-      ("aiur", Tests.Aiur.suite),
-      ("ffi-consistency", Tests.FFIConsistency.suite),
-    ("byte-array", Tests.ByteArray.suite),
-      ("ix", Tests.Ix.suite),
-      ("ixon", Tests.Ixon.units),
-      ("keccak", Tests.Keccak.suite),
+      -- ("aiur", Tests.Aiur.suite),
+      -- ("ffi-consistency", Tests.FFIConsistency.suite),
+      -- ("byte-array", Tests.ByteArray.suite),
+      -- ("ix", Tests.Ix.suite),
+      -- ("ixon", Tests.Ixon.units),
+      ("ixon", Tests.Ixon.suite),
+      -- ("keccak", Tests.Keccak.suite),
   ]) args

From 1b3b6e9f18bb83f709b78f5ca80d368eab9b9f5a Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 6 Oct 2025 23:17:13 -0400
Subject: [PATCH 49/74] try reverting caches to RBMap

---
 Ix/Common.lean        |  57 ++++---
 Ix/CompileM.lean      | 199 ++++++++++++++---------
 Ix/IR.lean            |  43 ++---
 Ix/Ixon.lean          |  48 +++---
 Tests/Ix.lean         | 355 +++++++++++++++++++++---------------------
 Tests/Ix/Canon.lean   |  60 +++----
 Tests/Ix/Common.lean  | 151 +++++++++---------
 Tests/Ix/Compile.lean | 107 ++++++-------
 Tests/Ix/IR.lean      | 214 ++++++++++++-------------
 Tests/Ix/Ixon.lean    | 241 ----------------------------
 Tests/Ix/Lean.lean    |   0
 Tests/Main.lean       |  38 +++--
 12 files changed, 660 insertions(+), 853 deletions(-)
 delete mode 100644 Tests/Ix/Lean.lean

diff --git a/Ix/Common.lean b/Ix/Common.lean
index 8448942e..1db5a4a4 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -1,5 +1,6 @@
 import Lean
 import Batteries
+import Batteries.Data.RBMap
 
 def compareList [Ord α] : List α -> List α -> Ordering
 | a::as, b::bs => match compare a b with
@@ -33,25 +34,34 @@ instance : Ord Lean.Name where
 deriving instance Ord for Lean.Literal
 --deriving instance Ord for Lean.Expr
 deriving instance Ord for Lean.BinderInfo
-deriving instance BEq, Repr, Hashable, Ord for Lean.QuotKind
-deriving instance Hashable, Repr for Lean.ReducibilityHints
-deriving instance BEq, Ord, Hashable, Repr for Lean.DefinitionSafety
-deriving instance BEq, Repr, Hashable for Lean.ConstantVal
-deriving instance BEq, Repr, Hashable for Lean.QuotVal
-deriving instance BEq, Repr, Hashable for Lean.AxiomVal
-deriving instance BEq, Repr, Hashable for Lean.TheoremVal
-deriving instance BEq, Repr, Hashable for Lean.DefinitionVal
-deriving instance BEq, Repr, Hashable for Lean.OpaqueVal
-deriving instance BEq, Repr, Hashable for Lean.RecursorRule
-deriving instance BEq, Repr, Hashable for Lean.RecursorVal
-deriving instance BEq, Repr, Hashable for Lean.ConstructorVal
-deriving instance BEq, Repr, Hashable for Lean.InductiveVal
-deriving instance BEq, Repr, Hashable for Lean.ConstantInfo
-deriving instance BEq, Repr, Hashable for Substring
-deriving instance BEq, Repr, Hashable for Lean.SourceInfo
-deriving instance BEq, Repr, Hashable for Lean.Syntax.Preresolved
-deriving instance BEq, Repr, Hashable for Lean.Syntax
+deriving instance BEq, Repr, Ord, Ord for Lean.QuotKind
+deriving instance Ord, Repr for Lean.ReducibilityHints
+deriving instance BEq, Ord, Ord, Repr for Lean.DefinitionSafety
+deriving instance BEq, Repr, Ord for ByteArray
+deriving instance BEq, Repr, Ord for String.Pos
+deriving instance BEq, Repr, Ord for Substring
+deriving instance BEq, Repr, Ord for Lean.SourceInfo
+deriving instance BEq, Repr, Ord for Lean.Syntax.Preresolved
+deriving instance BEq, Repr, Ord for Lean.Syntax
 deriving instance BEq, Repr for Ordering
+deriving instance BEq, Repr, Ord for Lean.FVarId
+deriving instance BEq, Repr, Ord for Lean.MVarId
+deriving instance BEq, Repr, Ord for Lean.DataValue
+deriving instance BEq, Repr, Ord for Lean.KVMap
+deriving instance BEq, Repr, Ord for Lean.LevelMVarId
+deriving instance BEq, Repr, Ord for Lean.Level
+deriving instance BEq, Repr, Ord for Lean.Expr
+deriving instance BEq, Repr, Ord for Lean.ConstantVal
+deriving instance BEq, Repr, Ord for Lean.QuotVal
+deriving instance BEq, Repr, Ord for Lean.AxiomVal
+deriving instance BEq, Repr, Ord for Lean.TheoremVal
+deriving instance BEq, Repr, Ord for Lean.DefinitionVal
+deriving instance BEq, Repr, Ord for Lean.OpaqueVal
+deriving instance BEq, Repr, Ord for Lean.RecursorRule
+deriving instance BEq, Repr, Ord for Lean.RecursorVal
+deriving instance BEq, Repr, Ord for Lean.ConstructorVal
+deriving instance BEq, Repr, Ord for Lean.InductiveVal
+deriving instance BEq, Repr, Ord for Lean.ConstantInfo
 
 def UInt8.MAX : UInt64 := 0xFF
 def UInt16.MAX : UInt64 := 0xFFFF
@@ -251,16 +261,17 @@ def sortGroupsByM [Monad μ] (xs: List (List α)) (cmp: α -> α -> μ Ordering)
 
 end List
 
-abbrev MutCtx := Std.HashMap Lean.Name Nat
+abbrev MutCtx := Batteries.RBMap Lean.Name Nat compare
 
 instance : BEq MutCtx where
-  beq a b := a.size == b.size && a.fold
-    (fun acc k v => acc && match b.get? k with
+  beq a b := a.size == b.size && a.foldl
+    (fun acc k v => acc && match b.find? k with
       | some v' => v == v'
       | none => false) true
 
-instance : Hashable MutCtx where
-  hash a := hash a.toList.sort
+-- TODO: incremental comparison with ForIn zip
+instance : Ord MutCtx where
+  compare a b := compare a.toList b.toList
 
 namespace Lean
 
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 4d9c8e7d..656e73cb 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -1,4 +1,4 @@
-import Std.Data.HashMap
+import Batteries.Data.RBMap
 import Ix.Ixon
 import Ix.Address
 import Ix.IR
@@ -7,8 +7,8 @@ import Ix.Common
 import Ix.SOrder
 import Ix.Cronos
 
-open Std (HashMap)
---open Ix.TransportM
+open Batteries (RBMap)
+open Batteries (RBSet)
 
 namespace Ix
 open Ixon hiding Substring
@@ -17,37 +17,39 @@ structure CompileEnv where
   univCtx : List Lean.Name
   bindCtx : List Lean.Name
   mutCtx  : MutCtx
-deriving BEq, Hashable
+  current : Lean.Name
+deriving BEq, Ord
 
-def CompileEnv.init: CompileEnv := ⟨default, default, default⟩
+def CompileEnv.init: CompileEnv := ⟨default, default, default, default⟩
 
 structure CompileState where
   maxHeartBeats: USize
   env: Lean.Environment
   prng: StdGen
-  store: HashMap Address ByteArray
-  univCache: HashMap Lean.Level Ix.Level
-  univAddrs: HashMap Ix.Level MetaAddress
-  constNames: HashMap Lean.Name MetaAddress
-  constCache: HashMap Lean.ConstantInfo Ix.Const
-  constAddrs : HashMap Ix.Const MetaAddress
-  exprCache: HashMap Lean.Expr Ix.Expr
-  exprAddrs: HashMap Ix.Expr MetaAddress
-  synCache: HashMap Lean.Syntax Ixon.Syntax
-  nameCache: HashMap Lean.Name Address
-  strCache: HashMap String Address
-  comms: HashMap Lean.Name MetaAddress
-  constCmp: HashMap (Lean.Name × Lean.Name) Ordering
-  exprCmp: HashMap (CompileEnv × Lean.Expr × Lean.Expr) Ordering
-  axioms: Std.HashMap Lean.Name MetaAddress
-  blocks: Std.HashSet MetaAddress
+  store: RBMap Address ByteArray compare
+  ixonCache: RBMap Ixon Address compare
+  univCache: RBMap Lean.Level Ix.Level compare
+  univAddrs: RBMap Ix.Level MetaAddress compare
+  constNames: RBMap Lean.Name MetaAddress compare
+  constCache: RBMap Lean.ConstantInfo Ix.Const compare
+  constAddrs : RBMap Ix.Const MetaAddress compare
+  exprCache: RBMap Lean.Expr Ix.Expr compare
+  exprAddrs: RBMap Ix.Expr MetaAddress compare
+  synCache: RBMap Lean.Syntax Ixon.Syntax compare
+  nameCache: RBMap Lean.Name Address compare
+  strCache: RBMap String Address compare
+  comms: RBMap Lean.Name MetaAddress compare
+  constCmp: RBMap (Lean.Name × Lean.Name) Ordering compare
+  exprCmp: RBMap (CompileEnv × Lean.Expr × Lean.Expr) Ordering compare
+  axioms: RBMap Lean.Name MetaAddress compare
+  blocks: RBSet MetaAddress compare
   cronos: Cronos
 
-def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize) 
+def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize := 200000)
   : CompileState :=
   ⟨maxHeartBeats, env, mkStdGen seed, default, default, default, default,
   default, default, default, default, default, default, default, default,
-  default, default, default, default, default⟩
+  default, default, default, default, default, default⟩
 
 inductive CompileError where
 | unknownConstant : Lean.Name -> CompileError
@@ -115,8 +117,8 @@ def freshSecret : CompileM Address := do
 --  liftM (Store.writeConst const).toIO
 
 -- add binding name to local context
---def withCurrent (name: Lean.Name) : CompileM α -> CompileM α :=
---  withReader $ fun c => { c with current := name }
+def withCurrent (name: Lean.Name) : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with current := name }
 
 -- add binding name to local context
 def withBinder (name: Lean.Name) : CompileM α -> CompileM α :=
@@ -127,26 +129,27 @@ def withLevels (lvls : List Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with univCtx := lvls }
 
 -- add mutual recursion info to local context
-def withMutCtx (mutCtx : Std.HashMap Lean.Name Nat)
-  : CompileM α -> CompileM α :=
+def withMutCtx (mutCtx : MutCtx) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with mutCtx := mutCtx }
 
 -- reset local context
-def resetCtx : CompileM α -> CompileM α :=
-  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {} }
-
-def resetCtxWithLevels (lvls: List Lean.Name) : CompileM α -> CompileM α :=
-  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := {} }
+def resetCtx (current: Lean.Name) : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {}, current }
 
 def storeIxon (ixon: Ixon): CompileM Address := do
-  let bytes := Ixon.ser ixon
-  let addr := Address.blake3 bytes
-  modifyGet fun stt => (addr, { stt with
-    store := stt.store.insert addr bytes
-  })
+  --dbg_trace "storeIxon ser {(<- get).store.size} {(<- read).current}"
+  match (<- get).ixonCache.find? ixon with
+  | some addr => pure addr
+  | none => do
+    let bytes := Ixon.ser ixon
+    let addr := Address.blake3 bytes
+    dbg_trace "storeIxon hash {addr} {(<- read).current}"
+    modifyGet fun stt => (addr, { stt with
+      store := stt.store.insert addr bytes
+    })
 
 def storeString (str: String): CompileM Address := do
-  match (<- get).strCache.get? str with
+  match (<- get).strCache.find? str with
   | some addr => pure addr
   | none => do
     let bytes := str.toUTF8
@@ -178,7 +181,7 @@ def storeMetadata (meta: Metadata): CompileM Address := do
   })
 
 def dematerializeName (name: Lean.Name): CompileM Address := do
-  match (<- get).nameCache.get? name with
+  match (<- get).nameCache.find? name with
   | some addr => pure addr
   | none => do
     let addr <- go name
@@ -225,9 +228,10 @@ def compareLevel (xctx yctx: List Lean.Name)
       throw $ .levelNotFound y yctx s!"compareLevel"
 
 def dematerializeLevel (lvl: Ix.Level): CompileM MetaAddress := do
-  match (<- get).univAddrs.get? lvl with
+  match (<- get).univAddrs.find? lvl with
   | some l => pure l
   | none => do
+    --dbg_trace "dematerializeLevel go {(<- get).univAddrs.size} {(<- read).current}"
     let (anon, meta) <- go lvl
     let anonAddr <- storeIxon anon
     let metaAddr <- storeIxon meta
@@ -255,11 +259,12 @@ def dematerializeLevel (lvl: Ix.Level): CompileM MetaAddress := do
 
 /-- Canonicalizes a Lean universe level --/
 def compileLevel (lvl: Lean.Level): CompileM Ix.Level := do
-  match (<- get).univCache.get? lvl with
+  match (<- get).univCache.find? lvl with
   | some l => pure l
   | none => do
+    --dbg_trace "compileLevel go {(<- get).univCache.size} {(<- read).current}"
     let lvl' <- go lvl
-    let _ <- dematerializeLevel lvl'
+    --let _ <- dematerializeLevel lvl'
     modifyGet fun stt => (lvl', { stt with
       univCache := stt.univCache.insert lvl lvl'
     })
@@ -277,10 +282,12 @@ def compileLevel (lvl: Lean.Level): CompileM Ix.Level := do
     | l@(.mvar ..) => throw $ .levelMetavariable l
 
 def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
-  match (<- get).exprAddrs.get? expr with
+  match (<- get).exprAddrs.find? expr with
   | some x => pure x
   | none => do
+    --dbg_trace "dematerializeExpr go {(<- get).exprAddrs.size} {(<- read).current}"
     let (anon, meta) <- go expr
+    --dbg_trace "dematerializeExpr store {(<- get).exprAddrs.size} {(<- read).current}"
     let anonAddr <- storeIxon anon
     let metaAddr <- storeIxon meta
     let maddr := ⟨anonAddr, metaAddr⟩
@@ -289,31 +296,38 @@ def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
     })
   where
     go : Ix.Expr -> CompileM (Ixon × Ixon)
-    | .var md idx => pure (.evar idx, .meta ⟨[.link md]⟩)
+    | .var md idx => do
+      --dbg_trace "dematExpr var {(<- get).exprAddrs.size} {(<- read).current}"
+      pure (.evar idx, .meta ⟨[.link md]⟩)
     | .sort md univ => do
+      --dbg_trace "dematExpr sort {(<- get).exprAddrs.size} {(<- read).current}"
       let ⟨udata, umeta⟩ <- dematerializeLevel univ
       let data := .esort udata
       let meta := .meta ⟨[.link md, .link umeta]⟩
       pure (data, meta)
     | .const md name ref univs => do
+      --dbg_trace "dematExpr const {(<- get).exprAddrs.size} {(<- read).current}"
       let n <- dematerializeName name
       let us <- univs.mapM dematerializeLevel
       let data := .eref ref.data (us.map (·.data))
       let meta := .meta ⟨[.link md, .name n, .link ref.meta] ++ us.map (.name ·.meta)⟩
       pure (data, meta)
     | .rec_ md name idx univs => do
+      --dbg_trace "dematExpr rec {(<- get).exprAddrs.size} {(<- read).current}"
       let n <- dematerializeName name
       let us <- univs.mapM dematerializeLevel
       let data := .erec idx (us.map (·.data))
       let meta := .meta ⟨[.link md, .name n] ++ us.map (.name ·.meta)⟩
       pure (data, meta)
     | .app md func argm => do
+      --dbg_trace "dematExpr app {(<- get).exprAddrs.size} {(<- read).current}"
       let f' <- dematerializeExpr func
       let a' <- dematerializeExpr argm
       let data := .eapp f'.data a'.data
       let meta := .meta ⟨[.link md, .link f'.meta, .link a'.meta]⟩
       pure (data, meta)
     | .lam md name info type body => do
+      --dbg_trace "dematExpr lam {(<- get).exprAddrs.size} {(<- read).current}"
       let n <- dematerializeName name
       let t' <- dematerializeExpr type
       let b' <- dematerializeExpr body
@@ -321,6 +335,7 @@ def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
       let meta := .meta ⟨[.link md, .name n, .info info, .link t'.meta, .link b'.meta]⟩
       pure (data, meta)
     | .pi md name info type body => do
+      --dbg_trace "dematExpr pi {(<- get).exprAddrs.size} {(<- read).current}"
       let n <- dematerializeName name
       let t' <- dematerializeExpr type
       let b' <- dematerializeExpr body
@@ -328,6 +343,7 @@ def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
       let meta := .meta ⟨[.link md, .name n, .info info, .link t'.meta, .link b'.meta]⟩
       pure (data, meta)
     | .letE md name type value body nD => do
+      --dbg_trace "dematExpr letE {(<- get).exprAddrs.size} {(<- read).current}"
       let n <- dematerializeName name
       let t' <- dematerializeExpr type
       let v' <- dematerializeExpr value
@@ -336,8 +352,9 @@ def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
       let meta := .meta ⟨[.link md, .name n, .link t'.meta, .link v'.meta, .link b'.meta]⟩
       pure (data, meta)
     | .lit md (.natVal n) => do pure (.enat (<- storeNat n), .meta ⟨[.link md]⟩)
-    | .lit md (.strVal s) => do pure (.enat (<- storeString s), .meta ⟨[.link md]⟩)
+    | .lit md (.strVal s) => do pure (.estr (<- storeString s), .meta ⟨[.link md]⟩)
     | .proj md typeName type idx struct => do
+      --dbg_trace "dematExpr proj {(<- get).exprAddrs.size} {(<- read).current}"
       let n <- dematerializeName typeName
       let s' <- dematerializeExpr struct
       let data := .eprj type.data idx s'.data
@@ -345,13 +362,15 @@ def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
       pure (data, meta)
 
 def dematerializeConst (const: Ix.Const): CompileM MetaAddress := do
-  match (<- get).constAddrs.get? const with
+  match (<- get).constAddrs.find? const with
   | some x => pure x
   | none => do
     let (anon, meta) <- go const
     let anonAddr <- storeIxon anon
     let metaAddr <- storeIxon meta
     let maddr := ⟨anonAddr, metaAddr⟩
+    dbg_trace "dematerializeConst exprAddrs {(<- get).exprAddrs.size} {(<- read).current}"
+    dbg_trace "dematerializeConst constAddrs {(<- get).constAddrs.size} {(<- read).current}"
     modifyGet fun stt => (maddr, { stt with
       constAddrs := stt.constAddrs.insert const maddr
     })
@@ -511,7 +530,8 @@ def dematerializePreresolved : Lean.Syntax.Preresolved -> CompileM Ixon.Preresol
 | .decl n fs => .decl <$> dematerializeName n <*> fs.mapM storeString
 
 partial def dematerializeSyntax (syn: Lean.Syntax) : CompileM Ixon.Syntax := do
-  match (<- get).synCache.get? syn with
+  dbg_trace "dematerializeSyntax {(<- read).current}"
+  match (<- get).synCache.find? syn with
   | some x => pure x
   | none => do
     let syn' <- go syn
@@ -574,59 +594,82 @@ def isInternalRec (expr : Lean.Expr) (name : Lean.Name) : Bool :=
 mutual
 
 partial def compileExpr (kvs: List Lean.KVMap) (expr: Lean.Expr): CompileM Ix.Expr := do
-  match (<- get).exprCache.get? expr with
+  match (<- get).exprCache.find? expr with
   | some x => pure x
   | none => do
+    --dbg_trace "compileExpr go {(<- get).exprCache.size} {(<- read).current}"
     let expr' <- go expr
-    let _ <- dematerializeExpr expr'
+    --let _ <- dematerializeExpr expr'
+    --dbg_trace "compileExpr exprCache {(<- get).exprCache.size} {(<- read).current}"
     modifyGet fun stt => (expr', { stt with
       exprCache := stt.exprCache.insert expr expr'
     })
   where
     kv := dematerializeKVMaps kvs
     go : Lean.Expr -> CompileM Ix.Expr
-    | (.mdata kv x) => compileExpr (kv::kvs) x
-    | .bvar idx => do match (← read).bindCtx[idx]? with
+    | (.mdata kv x) => do
+      --dbg_trace "compileExpr mdata {(<- read).current}"
+      compileExpr (kv::kvs) x
+    | .bvar idx => do 
+      --dbg_trace "compileExpr bvar {(<- read).current}"
+      match (← read).bindCtx[idx]? with
       -- Bound variables must be in the bind context
       | some _ => return .var (<- kv) idx
       | none => throw $ .invalidBVarIndex idx
     | .sort lvl => .sort <$> kv <*> compileLevel lvl
     | .const name lvls => do
+      --dbg_trace "compileExpr const {name} {(<- read).current}"
       let univs ← lvls.mapM compileLevel
-      match (← read).mutCtx.get? name with
+      match (← read).mutCtx.find? name with
       | some i => return .rec_ (<- kv) name i univs
-      | none => match (<- get).comms.get? name with
+      | none => match (<- get).comms.find? name with
         | some addr => return .const (<- kv) name addr univs
         | none => do
           let addr <- findLeanConst name >>= compileConst >>= dematerializeConst
           return .const (<- kv) name addr univs
-    | .app fnc arg => .app <$> kv <*> compileExpr [] fnc <*> compileExpr [] arg
+    | .app fnc arg => do
+      --dbg_trace "compileExpr app {(<- read).current}"
+      .app <$> kv <*> compileExpr [] fnc <*> compileExpr [] arg
     | .lam name typ bod info => do
+      --dbg_trace "compileExpr lam {(<- read).current}"
       let t <- compileExpr [] typ
       let b <- withBinder name <| compileExpr [] bod
       return .lam (<- kv) name info t b
     | .forallE name dom img info => do
+      --dbg_trace "compileExpr all {(<- read).current}"
       let d <- compileExpr [] dom
       let i <- withBinder name <| compileExpr [] img
       return .pi (<- kv) name info d i
     | .letE name typ val bod nD => do
+      --dbg_trace "compileExpr let {(<- read).current}"
       let t <- compileExpr [] typ
       let v <- compileExpr [] val
       let b <- withBinder name <| compileExpr [] bod
       return .letE (<- kv) name t v b nD
     | .lit lit => return .lit (<- kv) lit
     | .proj name idx exp => do
+      --dbg_trace "compileExpr proj {(<- read).current}"
       let addr <- findLeanConst name >>= compileConst >>= dematerializeConst
       return .proj (<- kv) name addr idx (<- compileExpr [] exp)
     | expr@(.fvar ..)  => throw $ .exprFreeVariable expr
     | expr@(.mvar ..)  => throw $ .exprMetavariable expr
 
 partial def compileConst (const : Lean.ConstantInfo) : CompileM Ix.Const := do
-  match (<- get).constCache.get? const with
+  match (<- get).constCache.find? const with
   | some x => pure x
-  | none => do
-    let const' <- resetCtx $ go const
+  | none => resetCtx const.name <| do
+    let const' <- go const
     let addr <- dematerializeConst const'
+    let stt <- get
+    dbg_trace "✓ compileConst {const.name}"
+    dbg_trace "store {stt.store.size}"
+    dbg_trace "constNames {stt.constNames.size}"
+    dbg_trace "constCache {stt.constCache.size}"
+    dbg_trace "exprCache {stt.exprCache.size}"
+    dbg_trace "nameCache {stt.nameCache.size}"
+    dbg_trace "synCache {stt.synCache.size}"
+    dbg_trace "strCache {stt.strCache.size}"
+    dbg_trace "univCache {stt.univCache.size}"
     modifyGet fun stt => (const', { stt with
       constNames := stt.constNames.insert const.name addr
       constCache := stt.constCache.insert const const'
@@ -650,12 +693,12 @@ partial def compileConst (const : Lean.ConstantInfo) : CompileM Ix.Const := do
         let _ <- compileInductive ind
         compileConst (.recInfo val)
       | c => throw $ .invalidConstantKind c.name "inductive" c.ctorName
-    | .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => resetCtxWithLevels lvls do
+    | .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => withLevels lvls do
       return .axiom ⟨name, lvls, <- compileExpr [] type, isUnsafe⟩
-    | .quotInfo ⟨⟨name, lvls, type⟩, kind⟩ => resetCtxWithLevels lvls do
+    | .quotInfo ⟨⟨name, lvls, type⟩, kind⟩ => withLevels lvls do
       return .quotient ⟨name, lvls, <- compileExpr [] type, kind⟩
 
-partial def preDefinitionToIR (d: PreDef) : CompileM Ix.Definition :=
+partial def preDefToIR (d: PreDef) : CompileM Ix.Definition :=
   withLevels d.levelParams do
     let typ <- compileExpr [] d.type
     let val <- compileExpr [] d.value
@@ -665,7 +708,7 @@ partial def compileDefinition: PreDef -> CompileM Ix.Const
 | defn => do
   -- single definition outside a mutual block
   if defn.all matches [_] then
-    return .definition (<- withMutCtx {(defn.name,0)} <| preDefinitionToIR defn)
+    return .definition (<- withMutCtx (.single defn.name 0) <| preDefToIR defn)
   else do
   -- collecting and sorting all definitions in the mutual block
   let mut defs : Array PreDef := #[]
@@ -677,14 +720,14 @@ partial def compileDefinition: PreDef -> CompileM Ix.Const
     | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
   let mutDefs <- sortDefs defs.toList
   let mutCtx := defMutCtx mutDefs
-  let definitions ← withMutCtx mutCtx <| mutDefs.mapM (·.mapM preDefinitionToIR)
+  let definitions ← withMutCtx mutCtx <| mutDefs.mapM (·.mapM preDefToIR)
   -- add top-level mutual block to our state
   let block ← dematerializeConst <| .mutual ⟨definitions⟩
   modify fun stt => { stt with blocks := stt.blocks.insert block }
   -- then add all the projections, returning the def we started with
   let mut ret? : Option Ix.Const := none
   for name in defn.all do
-    let idx <- do match mutCtx.get? name with
+    let idx <- do match mutCtx.find? name with
     | some idx => pure idx
     | none => throw $ .cantFindMutDefIndex name
     let const <- findLeanConst name
@@ -700,8 +743,8 @@ partial def compileDefinition: PreDef -> CompileM Ix.Const
   | none => throw $ .compileMutualBlockMissingProjection defn.name
 
 /-- A name-irrelevant ordering of Lean expressions --/
-partial def compareExpr (ctx: Std.HashMap Lean.Name Nat)
-  (xlvls ylvls: List Lean.Name) : Lean.Expr → Lean.Expr → CompileM SOrder
+partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
+  : Lean.Expr → Lean.Expr → CompileM SOrder
   | e@(.mvar ..), _ => throw $ .exprMetavariable e
   | _, e@(.mvar ..) => throw $ .exprMetavariable e
   | e@(.fvar ..), _ => throw $ .exprFreeVariable e
@@ -718,7 +761,7 @@ partial def compareExpr (ctx: Std.HashMap Lean.Name Nat)
   | .const x xls, .const y yls => do
     let univs ← SOrder.zipM (compareLevel xlvls ylvls) xls yls
     if univs.ord != .eq then return univs
-    match ctx.get? x, ctx.get? y with
+    match ctx.find? x, ctx.find? y with
     | some nx, some ny => return ⟨false, compare nx ny⟩
     | none, some _ => return ⟨true, .gt⟩
     | some _, none => return ⟨true, .lt⟩
@@ -758,12 +801,13 @@ partial def compareExpr (ctx: Std.HashMap Lean.Name Nat)
       (compareExpr ctx xlvls ylvls tx ty)
 
 /-- AST comparison of two Lean definitions. --/
-partial def compareDef (ctx: HashMap Lean.Name Nat) (x y: PreDef)
+partial def compareDef (ctx: MutCtx) (x y: PreDef)
   : CompileM Ordering := do
+  dbg_trace "compareDefs constCmp {(<- get).constCmp.size} {(<- read).current}"
   let key := match compare x.name y.name with
     | .lt => (x.name, y.name)
     | _ => (y.name, x.name)
-  match (<- get).constCmp.get? key with
+  match (<- get).constCmp.find? key with
   | some o => return o
   | none => do
     let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
@@ -775,7 +819,7 @@ partial def compareDef (ctx: HashMap Lean.Name Nat) (x y: PreDef)
       }
     return sorder.ord
 
-partial def eqDef (ctx: HashMap Lean.Name Nat) (x y: PreDef) : CompileM Bool :=
+partial def eqDef (ctx: MutCtx) (x y: PreDef) : CompileM Bool :=
   (fun o => o == .eq) <$> compareDef ctx x y
 
 /--
@@ -877,6 +921,7 @@ partial def sortDefs (classes : List PreDef) : CompileM (List (List PreDef)) :=
   go [List.sortBy (compare ·.name ·.name) classes]
   where
     go (cs: List (List PreDef)): CompileM (List (List PreDef)) := do
+      dbg_trace "sortDefs blocks {(<- get).blocks.size} {(<- read).current}"
       let ctx := defMutCtx cs
       let cs' <- cs.mapM fun ds =>
         match ds with
@@ -911,7 +956,7 @@ constructors and recursors, hence the complexity of this function.
 partial def compileInductive: Lean.InductiveVal -> CompileM Ix.Const
 | ind => do
   let mut preInds := #[]
-  let mut ctorNames : HashMap Lean.Name (List Lean.Name × List Lean.Name) := {}
+  let mut ctorNames : RBMap Lean.Name (List Lean.Name × List Lean.Name) compare := {}
   -- collect all mutual inductives as Ix.PreInds
   for n in ind.all do
     match <- findLeanConst n with
@@ -939,7 +984,7 @@ partial def compileInductive: Lean.InductiveVal -> CompileM Ix.Const
       constCache := stt.constCache.insert const const'
     }
     if name == ind.name then ret? := some const'
-    let some (ctors, recrs) := ctorNames.get? ind.name
+    let some (ctors, recrs) := ctorNames.find? ind.name
       | throw $ .cantFindMutDefIndex ind.name
     for (cname, cidx) in ctors.zipIdx do
       -- Store and cache constructor projections
@@ -1019,12 +1064,13 @@ partial def externalRecRuleToIR: Lean.RecursorRule -> CompileM RecursorRule
 | rule => do return ⟨rule.ctor, rule.nfields, <- compileExpr [] rule.rhs⟩
 
 /-- AST comparison of two Lean inductives. --/
-partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInd) 
+partial def compareInd (ctx: MutCtx) (x y: PreInd) 
   : CompileM Ordering := do
+  dbg_trace "compareInd constCmp {(<- get).constCmp.size} {(<- read).current}"
   let key := match compare x.name y.name with
     | .lt => (x.name, y.name)
     | _ => (y.name, x.name)
-  match (<- get).constCmp.get? key with
+  match (<- get).constCmp.find? key with
   | some o => return o
   | none => do
     let sorder <- do
@@ -1045,7 +1091,7 @@ partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInd)
       let key := match compare x.name y.name with
         | .lt => (x.name, y.name)
         | _ => (y.name, x.name)
-      match (<- get).constCmp.get? key with
+      match (<- get).constCmp.find? key with
       | some o => return ⟨true, o⟩
       | none => do
       let sorder <- do
@@ -1062,7 +1108,7 @@ partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInd)
       let key := match compare x.name y.name with
         | .lt => (x.name, y.name)
         | _ => (y.name, x.name)
-      match (<- get).constCmp.get? key with
+      match (<- get).constCmp.find? key with
       | some o => return ⟨true, o⟩
       | none => do
       let sorder <- do
@@ -1083,7 +1129,7 @@ partial def compareInd (ctx: Std.HashMap Lean.Name Nat) (x y: PreInd)
         SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
           (compareExpr ctx xlvls ylvls x.rhs y.rhs)
 
-partial def eqInd (ctx: HashMap Lean.Name Nat) (x y: PreInd) : CompileM Bool :=
+partial def eqInd (ctx: MutCtx) (x y: PreInd) : CompileM Bool :=
   (fun o => o == .eq) <$> compareInd ctx x y
 
 /-- `sortInds` recursively sorts a list of inductive datatypes into equivalence
@@ -1092,6 +1138,7 @@ partial def sortInds (classes : List PreInd) : CompileM (List (List PreInd)) :=
   go [List.sortBy (compare ·.name ·.name) classes]
   where
     go (cs: List (List PreInd)): CompileM (List (List PreInd)) := do
+      dbg_trace "sortInds blocks {(<- get).blocks.size} {(<- read).current}"
       let ctx := indMutCtx cs
       let cs' <- cs.mapM fun ds =>
         match ds with
diff --git a/Ix/IR.lean b/Ix/IR.lean
index ea86cc07..756df5f0 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -2,6 +2,9 @@ import Ix.Common
 import Ix.Address
 import Lean
 
+import Batteries.Data.RBMap
+open Batteries (RBMap)
+
 namespace Ix
 
 /-
@@ -86,7 +89,7 @@ inductive Level
   | max  : Level → Level → Level
   | imax : Level → Level → Level
   | param: Lean.Name → Nat → Level
-  deriving Inhabited, Ord, BEq, Hashable, Repr
+  deriving Inhabited, Ord, BEq, Repr
 
 /--
 Ix.Expr expressions are similar to Lean.Expr, except they exclude free variables
@@ -104,7 +107,7 @@ inductive Expr
   | letE  (mdata: Address) (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
   | lit   (mdata: Address) (lit: Lean.Literal)
   | proj  (mdata: Address) (typeName: Lean.Name) (type: MetaAddress) (idx: Nat) (struct: Expr)
-  deriving Inhabited, Ord, BEq, Repr, Hashable
+  deriving Inhabited, Ord, BEq, Repr
 
 /--
 Ix.Quotient quotients are analogous to Lean.QuotVal
@@ -114,7 +117,7 @@ structure Quotient where
   levelParams : List Lean.Name
   type : Expr
   kind : Lean.QuotKind
-  deriving Ord, BEq, Hashable, Repr, Nonempty
+  deriving Ord, BEq, Repr, Nonempty
 
 /--
 Ix.Axiom axioms are analogous to Lean.AxiomVal, differing only in not including
@@ -124,7 +127,7 @@ structure Axiom where
   levelParams : List Lean.Name
   type : Expr
   isUnsafe: Bool
-  deriving Ord, BEq, Hashable, Repr, Nonempty
+  deriving Ord, BEq, Repr, Nonempty
 
 structure PreDef where
   name: Lean.Name
@@ -135,7 +138,7 @@ structure PreDef where
   hints : Lean.ReducibilityHints
   safety : Lean.DefinitionSafety
   all : List Lean.Name
-  deriving BEq, Repr, Nonempty, Hashable, Inhabited
+  deriving BEq, Repr, Nonempty, Inhabited, Ord
 
 def mkPreDef (x: Lean.DefinitionVal) : PreDef := 
   ⟨x.name, x.levelParams, x.type, .definition, x.value, x.hints, x.safety, x.all⟩
@@ -147,7 +150,7 @@ def mkPreOpaque (x: Lean.OpaqueVal) : PreDef :=
   ⟨x.name, x.levelParams, x.type, .opaque, x.value, .opaque,
     if x.isUnsafe then .unsafe else .safe, x.all⟩
 
-def defMutCtx (defss: List (List PreDef)) : Std.HashMap Lean.Name Nat 
+def defMutCtx (defss: List (List PreDef)) : RBMap Lean.Name Nat compare
   := Id.run do
   let mut mutCtx := default
   let mut i := 0
@@ -178,7 +181,7 @@ structure Definition where
   hints : Lean.ReducibilityHints
   safety: Lean.DefinitionSafety
   all : List Lean.Name
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 def mkTheorem
   (name: Lean.Name)
@@ -216,7 +219,7 @@ structure Constructor where
   numParams : Nat
   numFields : Nat
   isUnsafe: Bool
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 /--
 Ix.RecursorRule is analogous to Lean.RecursorRule
@@ -225,7 +228,7 @@ structure RecursorRule where
   ctor : Lean.Name
   nfields : Nat
   rhs : Expr
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 /--
 Ix.Recursor represents inductive recursors and is analogous to Lean.RecursorVal.
@@ -245,7 +248,7 @@ structure Recursor where
   rules : List RecursorRule
   k : Bool
   isUnsafe: Bool
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 /--
 Ix.PreInd is used to capture a Lean.InductiveVal along with their
@@ -293,8 +296,8 @@ structure PreInd where
 -- and an inductive with 3 ctors and 2 recrs, then the whole class will reserve
 -- 8 indices (one for the inductive type itself plus 3 ctors and 4 recrs).
 
-def indMutCtx (indss: List (List PreInd))
-  : Std.HashMap Lean.Name Nat := Id.run do
+def indMutCtx (indss: List (List PreInd)) : RBMap Lean.Name Nat compare 
+  := Id.run do
   let mut mutCtx := default
   let mut idx := 0
   for inds in indss do
@@ -330,7 +333,7 @@ structure Inductive where
   isRec : Bool
   isReflexive : Bool
   isUnsafe: Bool
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 
 structure InductiveProj where
@@ -340,7 +343,7 @@ structure InductiveProj where
   block: MetaAddress
   /-- index of the specific inductive datatype within the block --/
   idx   : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 structure ConstructorProj where
   /-- name of a specific constructor within an inductive --/
@@ -353,7 +356,7 @@ structure ConstructorProj where
   induct: Lean.Name
   /-- index of a specific constructor within the inductive --/
   cidx  : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 structure RecursorProj where
   /-- name of a specific recursor within the inductive --/
@@ -366,7 +369,7 @@ structure RecursorProj where
   induct: Lean.Name
   /-- index of a specific recursor within the inductive --/
   ridx : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 structure DefinitionProj where
   name: Lean.Name
@@ -374,12 +377,12 @@ structure DefinitionProj where
   block: MetaAddress
   /-- index of a specific definition within the block --/
   idx : Nat
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 structure MutualBlock where
   defs : List (List Definition)
   --all: List Lean.Name
-  deriving BEq, Ord, Hashable, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty
 
 def MutualBlock.ctx (x: MutualBlock) : List (List Lean.Name) :=
   x.defs.map fun xs => xs.map fun x => x.name
@@ -387,7 +390,7 @@ def MutualBlock.ctx (x: MutualBlock) : List (List Lean.Name) :=
 structure InductiveBlock where
   inds : List (List Inductive)
   --all: List Lean.Name
-  deriving BEq, Ord, Hashable, Repr, Nonempty, Inhabited
+  deriving BEq, Ord, Repr, Nonempty, Inhabited
 
 def InductiveBlock.ctx (x: InductiveBlock) : List (List Lean.Name) :=
   x.inds.map fun xs => xs.map fun x => x.name
@@ -404,7 +407,7 @@ inductive Const where
   -- constants to represent mutual blocks
   | «mutual» : MutualBlock → Const
   | «inductive» : InductiveBlock → Const
-  deriving Ord, BEq, Inhabited, Repr, Nonempty, Hashable
+  deriving BEq, Ord, Inhabited, Repr, Nonempty
 
 def Const.isMutBlock : Const → Bool
   | .mutual _ | .inductive _ => true
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 5e99d69c..0bbf1bba 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -1,4 +1,3 @@
-import Std.Data.HashMap
 import Ix.Address
 import Lean.Declaration
 import Lean.Data.KVMap
@@ -122,7 +121,7 @@ def getBytes (len: Nat) : GetM ByteArray := do
 structure Tag4 where
   flag: Fin 16
   size: UInt64
-  deriving Inhabited, Repr, BEq, Hashable
+  deriving Inhabited, Repr, BEq, Ord
 
 def Tag4.encodeHead (tag: Tag4): UInt8 :=
   let t := UInt8.shiftLeft (UInt8.ofNat tag.flag.val) 4
@@ -412,7 +411,7 @@ structure Quotient where
   kind : Lean.QuotKind
   lvls : Nat
   type : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize Quotient where
   put := fun x => Serialize.put (x.kind, x.lvls, x.type)
@@ -422,7 +421,7 @@ structure Axiom where
   isUnsafe: Bool
   lvls : Nat
   type : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize Axiom where
   put := fun x => Serialize.put (x.isUnsafe, x.lvls, x.type)
@@ -434,7 +433,7 @@ structure Definition where
   lvls : Nat
   type : Address
   value : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize Definition where
   put x := Serialize.put (x.kind, x.safety, x.lvls, x.type, x.value)
@@ -447,7 +446,7 @@ structure Constructor where
   params : Nat
   fields : Nat
   type : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize Constructor where
   put x := Serialize.put (x.isUnsafe, x.lvls, x.cidx, x.params, x.fields, x.type)
@@ -456,7 +455,7 @@ instance : Serialize Constructor where
 structure RecursorRule where
   fields : Nat
   rhs : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize RecursorRule where
   put x := Serialize.put (x.fields, x.rhs)
@@ -472,7 +471,7 @@ structure Recursor where
   minors : Nat
   type : Address
   rules : List RecursorRule
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize Recursor where
   put x := Serialize.put ((x.k, x.isUnsafe), x.lvls, x.params, x.indices, x.motives, x.minors, x.type, x.rules)
@@ -489,7 +488,7 @@ structure Inductive where
   type : Address
   ctors : List Constructor
   recrs : List Recursor
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize Inductive where
   put x := Serialize.put ((x.recr,x.refl,x.isUnsafe), x.lvls, x.params, x.indices, x.nested, x.type, x.ctors, x.recrs)
@@ -498,7 +497,7 @@ instance : Serialize Inductive where
 structure InductiveProj where
   idx : Nat
   block : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize InductiveProj where
   put := fun x => Serialize.put (x.idx, x.block)
@@ -508,7 +507,7 @@ structure ConstructorProj where
   idx : Nat
   cidx : Nat
   block : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize ConstructorProj where
   put := fun x => Serialize.put (x.idx, x.cidx, x.block)
@@ -518,7 +517,7 @@ structure RecursorProj where
   idx : Nat
   ridx : Nat
   block : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize RecursorProj where
   put := fun x => Serialize.put (x.idx, x.ridx, x.block)
@@ -527,7 +526,7 @@ instance : Serialize RecursorProj where
 structure DefinitionProj where
   idx : Nat
   block : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize DefinitionProj where
   put := fun x => Serialize.put (x.idx, x.block)
@@ -536,7 +535,7 @@ instance : Serialize DefinitionProj where
 structure Comm where
   secret : Address
   payload : Address
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize Comm where
   put := fun x => Serialize.put (x.secret, x.payload)
@@ -544,7 +543,7 @@ instance : Serialize Comm where
 
 structure Env where
   env : List MetaAddress
-  deriving BEq, Repr
+  deriving BEq, Repr, Inhabited, Ord
 
 instance : Serialize Env where
   put x := Serialize.put x.env
@@ -555,18 +554,18 @@ structure EvalClaim where
   input: Address
   output: Address
   type : Address
-deriving BEq, Repr, Inhabited
+deriving BEq, Repr, Inhabited, Ord
 
 structure CheckClaim where
   lvls : Address
   type : Address
   value : Address
-deriving BEq, Repr, Inhabited
+deriving BEq, Repr, Inhabited, Ord
 
 inductive Claim where
 | evals : EvalClaim -> Claim
 | checks : CheckClaim -> Claim
-deriving BEq, Repr, Inhabited
+deriving BEq, Repr, Inhabited, Ord
 
 instance : ToString CheckClaim where
   toString x := s!"#{x.value} : #{x.type} @ #{x.lvls}"
@@ -600,7 +599,7 @@ structure Proof where
   claim: Claim
   /-- Bytes of the Binius proof -/
   bin : ByteArray
-  deriving Inhabited, BEq
+  deriving Inhabited, BEq, Ord
 
 instance : ToString Proof where
   toString p := s!"<{toString p.claim} := {hexOfBytes p.bin}>"
@@ -706,7 +705,7 @@ inductive DataValue where
 | ofNat (v: Address)
 | ofInt (v: Address)
 | ofSyntax (v: Address)
-deriving BEq, Repr, Ord, Inhabited
+deriving BEq, Repr, Ord, Inhabited, Ord
 
 def putDataValue : DataValue → PutM Unit
 | .ofString v => putUInt8 0 *> put v
@@ -737,11 +736,11 @@ inductive Metadatum where
 | hints : Lean.ReducibilityHints -> Metadatum
 | all : List Address -> Metadatum
 | kvmap : List (Address × DataValue) -> Metadatum
-deriving BEq, Repr, Ord, Inhabited
+deriving BEq, Repr, Ord, Inhabited, Ord
 
 structure Metadata where
   nodes: List Metadatum
-  deriving BEq, Repr, Inhabited
+  deriving BEq, Repr, Inhabited, Ord
 
 def putMetadatum : Metadatum → PutM Unit
 | .name n => putUInt8 0 *> put n
@@ -812,9 +811,8 @@ inductive Ixon where
 | comm : Comm -> Ixon                                   -- 0xE3, cryptographic commitment
 | envn : Env -> Ixon                                    -- 0xE4, Lean4 environment
 | meta : Metadata -> Ixon                               -- 0xFX, Lean4 metadata
-deriving BEq, Repr, Inhabited
+deriving BEq, Repr, Inhabited, Ord
 
---abbrev Store := Std.HashMap Address ByteArray
 
 partial def putIxon : Ixon -> PutM Unit
 | .nanon => put (Tag4.mk 0x0 0)
@@ -919,8 +917,6 @@ instance : Serialize Ixon where
 def Ixon.address (ixon: Ixon): Address := Address.blake3 (ser ixon)
 
 
-
-
 --
 ----section FFI
 ----
diff --git a/Tests/Ix.lean b/Tests/Ix.lean
index 877c2cb9..adce6e7d 100644
--- a/Tests/Ix.lean
+++ b/Tests/Ix.lean
@@ -1,11 +1,6 @@
 import LSpec
 import Ix.Ixon
-import Ix.Ixon.Metadata
 import Ix.Address
-import Ix.Ixon.Serialize
-import Ix.Ixon.Univ
-import Ix.Claim
-import Ix.TransportM
 import LSpec.SlimCheck.Gen
 import LSpec
 import Blake3
@@ -24,34 +19,34 @@ def serde [Ixon.Serialize A] [BEq A] (x: A) : Bool :=
   | .ok (y : A) => x == y
   | _ => false
 
-open Ix.TransportM
-
-def transportUniv (univ: Ix.Level): Bool :=
-  match EStateM.run (dematUniv univ) emptyDematState with
-  | .ok ixon stt =>
-    let remat := (ReaderT.run (rematUniv ixon) { meta := stt.meta})
-    match EStateM.run remat (rematStateWithStore stt.store) with
-    | .ok ix _ => univ == ix
-    | .error _ _ => .false
-  | .error _ _ => .false
-
-def transportExpr (x: Ix.Expr): Bool :=
-  match EStateM.run (dematExpr x) emptyDematState with
-  | .ok ixon stt =>
-    let remat := (ReaderT.run (rematExpr ixon) { meta := stt.meta})
-    match EStateM.run remat (rematStateWithStore stt.store) with
-    | .ok ix _ => x == ix
-    | .error _ _ => .false
-  | .error _ _ => .false
-
-def transportConst (x: Ix.Const): Bool :=
-  match EStateM.run (dematConst x) emptyDematState with
-  | .ok ixon stt =>
-    let remat := (ReaderT.run (rematConst ixon) { meta := stt.meta})
-    match EStateM.run remat (rematStateWithStore stt.store) with
-    | .ok ix _ => x == ix
-    | .error _ _ => .false
-  | .error _ _ => .false
+--open Ix.TransportM
+--
+--def transportUniv (univ: Ix.Level): Bool :=
+--  match EStateM.run (dematUniv univ) emptyDematState with
+--  | .ok ixon stt =>
+--    let remat := (ReaderT.run (rematUniv ixon) { meta := stt.meta})
+--    match EStateM.run remat (rematStateWithStore stt.store) with
+--    | .ok ix _ => univ == ix
+--    | .error _ _ => .false
+--  | .error _ _ => .false
+--
+--def transportExpr (x: Ix.Expr): Bool :=
+--  match EStateM.run (dematExpr x) emptyDematState with
+--  | .ok ixon stt =>
+--    let remat := (ReaderT.run (rematExpr ixon) { meta := stt.meta})
+--    match EStateM.run remat (rematStateWithStore stt.store) with
+--    | .ok ix _ => x == ix
+--    | .error _ _ => .false
+--  | .error _ _ => .false
+--
+--def transportConst (x: Ix.Const): Bool :=
+--  match EStateM.run (dematConst x) emptyDematState with
+--  | .ok ixon stt =>
+--    let remat := (ReaderT.run (rematConst ixon) { meta := stt.meta})
+--    match EStateM.run remat (rematStateWithStore stt.store) with
+--    | .ok ix _ => x == ix
+--    | .error _ _ => .false
+--  | .error _ _ => .false
 
 
 --def transportExpr' (x: Ix.Expr): Except TransportError Bool :=
@@ -63,13 +58,13 @@ def transportConst (x: Ix.Const): Bool :=
 --    | .error e _ => .error e
 --  | .error e _ => .error e
 
-def ffiConst (x: Ixon.IxonConst) : Bool := 
-  let bytes := (Ixon.runPut <| Ixon.Serialize.put x)
-  Ixon.eqLeanRustSerialization x.ixon.toFFI bytes
-
-def ffiExpr (x: Ixon.IxonExpr) : Bool := 
-  let bytes := (Ixon.runPut <| Ixon.Serialize.put x)
-  Ixon.eqLeanRustSerialization x.ixon.toFFI bytes
+--def ffiConst (x: Ixon.IxonConst) : Bool := 
+--  let bytes := (Ixon.runPut <| Ixon.Serialize.put x)
+--  Ixon.eqLeanRustSerialization x.ixon.toFFI bytes
+--
+--def ffiExpr (x: Ixon.IxonExpr) : Bool := 
+--  let bytes := (Ixon.runPut <| Ixon.Serialize.put x)
+--  Ixon.eqLeanRustSerialization x.ixon.toFFI bytes
 
 
 def myConfig : SlimCheck.Configuration where
@@ -80,9 +75,9 @@ def myConfig : SlimCheck.Configuration where
   traceShrink := true
   traceShrinkCandidates := true
 
-def dbg : IO UInt32 := do
-   SlimCheck.Checkable.check (∀ x: Ix.Const, transportConst x) myConfig
-   return 0
+--def dbg : IO UInt32 := do
+--   SlimCheck.Checkable.check (∀ x: Ix.Const, transportConst x) myConfig
+--   return 0
 
 --def Test.Ix.unitTransport : TestSeq :=
 --  testExprs.foldl (init := .done) fun tSeq x =>
@@ -91,20 +86,20 @@ def dbg : IO UInt32 := do
 
 def Tests.Ix.suite : List LSpec.TestSeq :=
   [
-    check "metadatum serde" (∀ x : Ixon.Metadatum, serde x),
-    check "metadata serde" (∀ x : Ixon.Metadata, serde x),
-    check "universe serde" (∀ x : Ixon.Univ, serde x),
-    check "universe transport" (∀ x : Ix.Level, transportUniv x),
-    check "expr serde" (∀ x : Ixon.IxonExpr, serde x),
-    check "expr transport" (∀ x : Ix.Expr, transportExpr x),
-    check "expr ffi with Rust" (∀ x : Ixon.IxonExpr, ffiExpr x),
+--    check "metadatum serde" (∀ x : Ixon.Metadatum, serde x),
+--    check "metadata serde" (∀ x : Ixon.Metadata, serde x),
+--    check "universe serde" (∀ x : Ixon.Univ, serde x),
+--    check "universe transport" (∀ x : Ix.Level, transportUniv x),
+--    check "expr serde" (∀ x : Ixon.IxonExpr, serde x),
+--    check "expr transport" (∀ x : Ix.Expr, transportExpr x),
+--    check "expr ffi with Rust" (∀ x : Ixon.IxonExpr, ffiExpr x),
     --check "axiom serde" (∀ x : Ixon.Axiom, serde x),
     --check "recursor rule serde" (∀ x : Ixon.RecursorRule, serde x),
     --check "recursor serde" (∀ x : Ixon.Recursor, serde x),
     --check "constructor serde" (∀ x : Ixon.Constructor, serde x),
-    check "claim serde" (∀ x : Claim, serde x),
-    check "const ffi with Rust" (∀ x : Ixon.IxonConst, ffiConst x),
-    check "const transport" (∀ x : Ix.Const, transportConst x),
+--    check "claim serde" (∀ x : Claim, serde x),
+--    check "const ffi with Rust" (∀ x : Ixon.IxonConst, ffiConst x),
+--    check "const transport" (∀ x : Ix.Const, transportConst x),
   ]
 
 
@@ -182,16 +177,16 @@ def test_serde [Ixon.Serialize A] [BEq A] [Repr A] (x: A) (expect: String): LSpe
 open Ixon
 
 
--- TODO
-def bad : Ixon := Ixon.meta <| .mk [
-  (0, [Metadatum.name `d, .link default, .hints (.regular 576554452), .link default]),
-  (1, [.info .instImplicit, .info .instImplicit, .info .strictImplicit]),
-  (2, [.all [.mkNum .anonymous 165851424810452359], .info .default]),
-  (3, []),
-  (4, []),
-  (5, [.hints .opaque]),
-  (6, [.name <| .mkNum .anonymous 871843802607008850]),
-  ]
+---- TODO
+--def bad : Ixon := Ixon.meta <| .mk [
+--  (0, [Metadatum.name `d, .link default, .hints (.regular 576554452), .link default]),
+--  (1, [.info .instImplicit, .info .instImplicit, .info .strictImplicit]),
+--  (2, [.all [.mkNum .anonymous 165851424810452359], .info .default]),
+--  (3, []),
+--  (4, []),
+--  (5, [.hints .opaque]),
+--  (6, [.name <| .mkNum .anonymous 871843802607008850]),
+--  ]
 
 --#eval printHex <| runPut <| Serialize.put bad
 --"0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
@@ -199,122 +194,122 @@ def bad : Ixon := Ixon.meta <| .mk [
 --#eval runGet (@Serialize.get Ixon _) (runPut (Serialize.put bad))
 
 
-def Tests.Ixon.units : List LSpec.TestSeq :=
-  [
-    test_serde (Ixon.vari 0x0) "0x00",
-    test_serde (Ixon.vari 0x7) "0x07",
-    test_serde (Ixon.vari 0x8) "0x0808",
-    test_serde (Ixon.vari 0xFF) "0x08FF",
-    test_serde (Ixon.vari 0x0100) "0x090001",
-    test_serde (Ixon.vari 0x0100) "0x090001",
-    test_serde (Ixon.vari 0xFFFF) "0x09FFFF",
-    test_serde (Ixon.vari 0x010000) "0x0A000001",
-    test_serde (Ixon.vari 0xFFFFFF) "0x0AFFFFFF",
-    test_serde (Ixon.vari 0x01000000) "0x0B00000001",
-    test_serde (Ixon.vari 0xFFFFFFFF) "0x0BFFFFFFFF",
-    test_serde (Ixon.vari 0x0100000000) "0x0C0000000001",
-    test_serde (Ixon.vari 0xFFFFFFFFFF) "0x0CFFFFFFFFFF",
-    test_serde (Ixon.vari 0x010000000000) "0x0D000000000001",
-    test_serde (Ixon.vari 0xFFFFFFFFFFFF) "0x0DFFFFFFFFFFFF",
-    test_serde (Ixon.vari 0x01000000000000) "0x0E00000000000001",
-    test_serde (Ixon.vari 0xFFFFFFFFFFFFFF) "0x0EFFFFFFFFFFFFFF",
-    test_serde (Ixon.vari 0x0100000000000000) "0x0F0000000000000001",
-    test_serde (Ixon.vari 0xFFFFFFFFFFFFFFFF) "0x0FFFFFFFFFFFFFFFFF",
-    test_serde (Ixon.sort <| .const 0x0) "0x9000",
-    test_serde (Ixon.sort <| .const 0x1F) "0x901F",
-    test_serde (Ixon.sort <| .const 0x20) "0x902020",
-    test_serde (Ixon.sort <| .const 0xFF) "0x9020FF",
-    test_serde (Ixon.sort <| .const 0x0100) "0x90210001",
-    test_serde (Ixon.sort <| .const 0xFFFF) "0x9021FFFF",
-    test_serde (Ixon.sort <| .const 0x010000) "0x9022000001",
-    test_serde (Ixon.sort <| .const 0xFFFFFF) "0x9022FFFFFF",
-    test_serde (Ixon.sort <| .const 0x01000000) "0x902300000001",
-    test_serde (Ixon.sort <| .const 0xFFFFFFFF) "0x9023FFFFFFFF",
-    test_serde (Ixon.sort <| .const 0x0100000000) "0x90240000000001",
-    test_serde (Ixon.sort <| .const 0xFFFFFFFFFF) "0x9024FFFFFFFFFF",
-    test_serde (Ixon.sort <| .const 0x010000000000) "0x9025000000000001",
-    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFF) "0x9025FFFFFFFFFFFF",
-    test_serde (Ixon.sort <| .const 0x01000000000000) "0x902600000000000001",
-    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFFFF) "0x9026FFFFFFFFFFFFFF",
-    test_serde (Ixon.sort <| .const 0x0100000000000000) "0x90270000000000000001",
-    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFFFFFF) "0x9027FFFFFFFFFFFFFFFF",
-    test_serde (Ixon.sort <| .var 0x0) "0x9040",
-    test_serde (Ixon.sort <| .var 0x1F) "0x905F",
-    test_serde (Ixon.sort <| .var 0x20) "0x906020",
-    test_serde (Ixon.sort <| .var 0xFF) "0x9060FF",
-    test_serde (Ixon.sort <| .var 0x0100) "0x90610001",
-    test_serde (Ixon.sort <| .var 0xFFFFFFFFFFFFFFFF) "0x9067FFFFFFFFFFFFFFFF",
-    test_serde (Ixon.sort <| .add 0x0 (.const 0x0)) "0x908000",
-    test_serde (Ixon.sort <| .add 0x0 (.var 0x0)) "0x908040",
-    test_serde (Ixon.sort <| .add 0x1F (.var 0x0)) "0x909F40",
-    test_serde (Ixon.sort <| .add 0x20 (.var 0x0)) "0x90A02040",
-    test_serde (Ixon.sort <| .add 0xFF (.var 0x0)) "0x90A0FF40",
-    test_serde (Ixon.sort <| .add 0xFFFF_FFFF_FFFF_FFFF (.var 0x0)) "0x90A7FFFFFFFFFFFFFFFF40",
-    test_serde (Ixon.sort <| .max (.var 0x0) (.var 0x0)) "0x90C04040",
-    test_serde (Ixon.sort <| .max (.var 0x0) (.var 0x1)) "0x90C04041",
-    test_serde (Ixon.sort <| .max (.var 0x1) (.var 0x0)) "0x90C04140",
-    test_serde (Ixon.sort <| .max (.var 0x1) (.var 0x1)) "0x90C04141",
-    test_serde (Ixon.sort <| .imax (.var 0x0) (.var 0x0)) "0x90C14040",
-    test_serde (Ixon.sort <| .imax (.var 0x0) (.var 0x1)) "0x90C14041",
-    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x0)) "0x90C14140",
-    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x1)) "0x90C14141",
-    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x1)) "0x90C14141",
-    test_serde (Ixon.refr (default) []) "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.refr (default) [.var 0x0]) "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240",
-    test_serde (Ixon.recr 0x0 [.var 0x0]) "0x20A140",
-    test_serde (Ixon.recr 0x0 [.var 0x0, .var 0x1]) "0x20A24041",
-    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1) []) "0x300001",
-    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1) [Ixon.vari 0x2]) "0x31000102",
-    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1)
-      [
-        Ixon.vari 0x2, Ixon.vari 0x3, Ixon.vari 0x4, Ixon.vari 0x5,
-        Ixon.vari 0x6, Ixon.vari 0x7, Ixon.vari 0x8, Ixon.vari 0x9,
-      ]) "0x3808000102030405060708080809",
-    test_serde (Ixon.lams [Ixon.vari 0x0] (Ixon.vari 0x1)) "0x410001",
-    test_serde (Ixon.lams
-      [
-        Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2, Ixon.vari 0x3, 
-        Ixon.vari 0x4, Ixon.vari 0x5, Ixon.vari 0x6, Ixon.vari 0x7,
-      ] (Ixon.vari 0x8)) "0x480800010203040506070808",
-    test_serde (Ixon.alls [Ixon.vari 0x0] (Ixon.vari 0x1)) "0x510001",
-    test_serde (Ixon.alls
-      [
-        Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2, Ixon.vari 0x3, 
-        Ixon.vari 0x4, Ixon.vari 0x5, Ixon.vari 0x6, Ixon.vari 0x7,
-      ] (Ixon.vari 0x8)) "0x580800010203040506070808",
-    test_serde (Ixon.proj (default) 0x0 (Ixon.vari 0x0)) "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200",
-    test_serde (Ixon.proj (default) 0x8 (Ixon.vari 0x0)) "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200",
-    test_serde (Ixon.strl "") "0x70",
-    test_serde (Ixon.strl "foobar") "0x76666f6f626172",
-    test_serde (Ixon.natl 0x0) "0x8100",
-    test_serde (Ixon.natl 0xFF) "0x81FF",
-    test_serde (Ixon.natl 0x100) "0x820001",
-    test_serde (Ixon.letE true (Ixon.vari 0x0) (Ixon.vari 0x1) (Ixon.vari 0x2)) "0x91000102",
-    test_serde (Ixon.list []) "0xA0",
-    test_serde (Ixon.list [Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2]) "0xA3000102",
-    test_serde (Ixon.defn (.mk .definition .unsafe 0 (default) (default))) "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.defn (.mk .opaque .safe 1 default default)) "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.axio ⟨true, 0, default⟩) "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.quot ⟨.type, 0, default⟩) "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.cprj ⟨0, 0, default⟩) "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.rprj ⟨0, 0, default⟩) "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.iprj ⟨0, default⟩) "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.dprj ⟨0, default⟩) "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.inds []) "0xC0",
-    test_serde (Ixon.inds [⟨false, false, false, 0, 0, 0, 0, default, [], []⟩]) "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0",
-    test_serde (Ixon.inds [⟨false, false, false, 0, 0, 0, 0, default, [⟨false, 0,0,0,0, default⟩], [⟨false, false, 0,0,0,0,0,default, [⟨0, default⟩]⟩]⟩]) "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.defs []) "0xD0",
-    test_serde (Ixon.defs [⟨.definition, .unsafe, 0, default, default⟩]) "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.meta ⟨[]⟩) "0xE0A0",
-    test_serde (Ixon.meta ⟨[(0, [])]⟩) "0xE0A18100A0",
-    test_serde (Ixon.meta ⟨[(0, [.name .anonymous])]⟩) "0xE0A18100A100A0",
-    test_serde (Ixon.meta ⟨[(0, [.name `a])]⟩) "0xE0A18100A100A17161",
-    test_serde (Ixon.meta ⟨[(0, [.name `a.b])]⟩) "0xE0A18100A100A271617162",
-    test_serde (Ixon.meta ⟨[(0, [.name `a.b.c])]⟩) "0xE0A18100A100A3716171627163",
-    test_serde (Ixon.meta ⟨[(0, [.name (.mkNum .anonymous 165851424810452359)])]⟩) "0xE0A18100A100A1880887C551FDFD384D02",
-    test_serde (Ixon.meta ⟨[(0, [Metadatum.name `d, .link default, .hints (.regular 576554452), .link default])]⟩) "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
-    test_serde (Ixon.meta ⟨[(0, [.hints (.regular 42)])]⟩) "0xe0a18100a103022a000000",
-    test_serde bad "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
-  ]
+--def Tests.Ixon.units : List LSpec.TestSeq :=
+--  [
+--    test_serde (Ixon.vari 0x0) "0x00",
+--    test_serde (Ixon.vari 0x7) "0x07",
+--    test_serde (Ixon.vari 0x8) "0x0808",
+--    test_serde (Ixon.vari 0xFF) "0x08FF",
+--    test_serde (Ixon.vari 0x0100) "0x090001",
+--    test_serde (Ixon.vari 0x0100) "0x090001",
+--    test_serde (Ixon.vari 0xFFFF) "0x09FFFF",
+--    test_serde (Ixon.vari 0x010000) "0x0A000001",
+--    test_serde (Ixon.vari 0xFFFFFF) "0x0AFFFFFF",
+--    test_serde (Ixon.vari 0x01000000) "0x0B00000001",
+--    test_serde (Ixon.vari 0xFFFFFFFF) "0x0BFFFFFFFF",
+--    test_serde (Ixon.vari 0x0100000000) "0x0C0000000001",
+--    test_serde (Ixon.vari 0xFFFFFFFFFF) "0x0CFFFFFFFFFF",
+--    test_serde (Ixon.vari 0x010000000000) "0x0D000000000001",
+--    test_serde (Ixon.vari 0xFFFFFFFFFFFF) "0x0DFFFFFFFFFFFF",
+--    test_serde (Ixon.vari 0x01000000000000) "0x0E00000000000001",
+--    test_serde (Ixon.vari 0xFFFFFFFFFFFFFF) "0x0EFFFFFFFFFFFFFF",
+--    test_serde (Ixon.vari 0x0100000000000000) "0x0F0000000000000001",
+--    test_serde (Ixon.vari 0xFFFFFFFFFFFFFFFF) "0x0FFFFFFFFFFFFFFFFF",
+--    test_serde (Ixon.sort <| .const 0x0) "0x9000",
+--    test_serde (Ixon.sort <| .const 0x1F) "0x901F",
+--    test_serde (Ixon.sort <| .const 0x20) "0x902020",
+--    test_serde (Ixon.sort <| .const 0xFF) "0x9020FF",
+--    test_serde (Ixon.sort <| .const 0x0100) "0x90210001",
+--    test_serde (Ixon.sort <| .const 0xFFFF) "0x9021FFFF",
+--    test_serde (Ixon.sort <| .const 0x010000) "0x9022000001",
+--    test_serde (Ixon.sort <| .const 0xFFFFFF) "0x9022FFFFFF",
+--    test_serde (Ixon.sort <| .const 0x01000000) "0x902300000001",
+--    test_serde (Ixon.sort <| .const 0xFFFFFFFF) "0x9023FFFFFFFF",
+--    test_serde (Ixon.sort <| .const 0x0100000000) "0x90240000000001",
+--    test_serde (Ixon.sort <| .const 0xFFFFFFFFFF) "0x9024FFFFFFFFFF",
+--    test_serde (Ixon.sort <| .const 0x010000000000) "0x9025000000000001",
+--    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFF) "0x9025FFFFFFFFFFFF",
+--    test_serde (Ixon.sort <| .const 0x01000000000000) "0x902600000000000001",
+--    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFFFF) "0x9026FFFFFFFFFFFFFF",
+--    test_serde (Ixon.sort <| .const 0x0100000000000000) "0x90270000000000000001",
+--    test_serde (Ixon.sort <| .const 0xFFFFFFFFFFFFFFFF) "0x9027FFFFFFFFFFFFFFFF",
+--    test_serde (Ixon.sort <| .var 0x0) "0x9040",
+--    test_serde (Ixon.sort <| .var 0x1F) "0x905F",
+--    test_serde (Ixon.sort <| .var 0x20) "0x906020",
+--    test_serde (Ixon.sort <| .var 0xFF) "0x9060FF",
+--    test_serde (Ixon.sort <| .var 0x0100) "0x90610001",
+--    test_serde (Ixon.sort <| .var 0xFFFFFFFFFFFFFFFF) "0x9067FFFFFFFFFFFFFFFF",
+--    test_serde (Ixon.sort <| .add 0x0 (.const 0x0)) "0x908000",
+--    test_serde (Ixon.sort <| .add 0x0 (.var 0x0)) "0x908040",
+--    test_serde (Ixon.sort <| .add 0x1F (.var 0x0)) "0x909F40",
+--    test_serde (Ixon.sort <| .add 0x20 (.var 0x0)) "0x90A02040",
+--    test_serde (Ixon.sort <| .add 0xFF (.var 0x0)) "0x90A0FF40",
+--    test_serde (Ixon.sort <| .add 0xFFFF_FFFF_FFFF_FFFF (.var 0x0)) "0x90A7FFFFFFFFFFFFFFFF40",
+--    test_serde (Ixon.sort <| .max (.var 0x0) (.var 0x0)) "0x90C04040",
+--    test_serde (Ixon.sort <| .max (.var 0x0) (.var 0x1)) "0x90C04041",
+--    test_serde (Ixon.sort <| .max (.var 0x1) (.var 0x0)) "0x90C04140",
+--    test_serde (Ixon.sort <| .max (.var 0x1) (.var 0x1)) "0x90C04141",
+--    test_serde (Ixon.sort <| .imax (.var 0x0) (.var 0x0)) "0x90C14040",
+--    test_serde (Ixon.sort <| .imax (.var 0x0) (.var 0x1)) "0x90C14041",
+--    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x0)) "0x90C14140",
+--    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x1)) "0x90C14141",
+--    test_serde (Ixon.sort <| .imax (.var 0x1) (.var 0x1)) "0x90C14141",
+--    test_serde (Ixon.refr (default) []) "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.refr (default) [.var 0x0]) "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240",
+--    test_serde (Ixon.recr 0x0 [.var 0x0]) "0x20A140",
+--    test_serde (Ixon.recr 0x0 [.var 0x0, .var 0x1]) "0x20A24041",
+--    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1) []) "0x300001",
+--    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1) [Ixon.vari 0x2]) "0x31000102",
+--    test_serde (Ixon.apps (Ixon.vari 0x0) (Ixon.vari 0x1)
+--      [
+--        Ixon.vari 0x2, Ixon.vari 0x3, Ixon.vari 0x4, Ixon.vari 0x5,
+--        Ixon.vari 0x6, Ixon.vari 0x7, Ixon.vari 0x8, Ixon.vari 0x9,
+--      ]) "0x3808000102030405060708080809",
+--    test_serde (Ixon.lams [Ixon.vari 0x0] (Ixon.vari 0x1)) "0x410001",
+--    test_serde (Ixon.lams
+--      [
+--        Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2, Ixon.vari 0x3, 
+--        Ixon.vari 0x4, Ixon.vari 0x5, Ixon.vari 0x6, Ixon.vari 0x7,
+--      ] (Ixon.vari 0x8)) "0x480800010203040506070808",
+--    test_serde (Ixon.alls [Ixon.vari 0x0] (Ixon.vari 0x1)) "0x510001",
+--    test_serde (Ixon.alls
+--      [
+--        Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2, Ixon.vari 0x3, 
+--        Ixon.vari 0x4, Ixon.vari 0x5, Ixon.vari 0x6, Ixon.vari 0x7,
+--      ] (Ixon.vari 0x8)) "0x580800010203040506070808",
+--    test_serde (Ixon.proj (default) 0x0 (Ixon.vari 0x0)) "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200",
+--    test_serde (Ixon.proj (default) 0x8 (Ixon.vari 0x0)) "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200",
+--    test_serde (Ixon.strl "") "0x70",
+--    test_serde (Ixon.strl "foobar") "0x76666f6f626172",
+--    test_serde (Ixon.natl 0x0) "0x8100",
+--    test_serde (Ixon.natl 0xFF) "0x81FF",
+--    test_serde (Ixon.natl 0x100) "0x820001",
+--    test_serde (Ixon.letE true (Ixon.vari 0x0) (Ixon.vari 0x1) (Ixon.vari 0x2)) "0x91000102",
+--    test_serde (Ixon.list []) "0xA0",
+--    test_serde (Ixon.list [Ixon.vari 0x0, Ixon.vari 0x1, Ixon.vari 0x2]) "0xA3000102",
+--    test_serde (Ixon.defn (.mk .definition .unsafe 0 (default) (default))) "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.defn (.mk .opaque .safe 1 default default)) "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.axio ⟨true, 0, default⟩) "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.quot ⟨.type, 0, default⟩) "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.cprj ⟨0, 0, default⟩) "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.rprj ⟨0, 0, default⟩) "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.iprj ⟨0, default⟩) "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.dprj ⟨0, default⟩) "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.inds []) "0xC0",
+--    test_serde (Ixon.inds [⟨false, false, false, 0, 0, 0, 0, default, [], []⟩]) "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0",
+--    test_serde (Ixon.inds [⟨false, false, false, 0, 0, 0, 0, default, [⟨false, 0,0,0,0, default⟩], [⟨false, false, 0,0,0,0,0,default, [⟨0, default⟩]⟩]⟩]) "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.defs []) "0xD0",
+--    test_serde (Ixon.defs [⟨.definition, .unsafe, 0, default, default⟩]) "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.meta ⟨[]⟩) "0xE0A0",
+--    test_serde (Ixon.meta ⟨[(0, [])]⟩) "0xE0A18100A0",
+--    test_serde (Ixon.meta ⟨[(0, [.name .anonymous])]⟩) "0xE0A18100A100A0",
+--    test_serde (Ixon.meta ⟨[(0, [.name `a])]⟩) "0xE0A18100A100A17161",
+--    test_serde (Ixon.meta ⟨[(0, [.name `a.b])]⟩) "0xE0A18100A100A271617162",
+--    test_serde (Ixon.meta ⟨[(0, [.name `a.b.c])]⟩) "0xE0A18100A100A3716171627163",
+--    test_serde (Ixon.meta ⟨[(0, [.name (.mkNum .anonymous 165851424810452359)])]⟩) "0xE0A18100A100A1880887C551FDFD384D02",
+--    test_serde (Ixon.meta ⟨[(0, [Metadatum.name `d, .link default, .hints (.regular 576554452), .link default])]⟩) "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262",
+--    test_serde (Ixon.meta ⟨[(0, [.hints (.regular 42)])]⟩) "0xe0a18100a103022a000000",
+--    test_serde bad "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
+--  ]
 
 
diff --git a/Tests/Ix/Canon.lean b/Tests/Ix/Canon.lean
index 28a4d3df..6de47583 100644
--- a/Tests/Ix/Canon.lean
+++ b/Tests/Ix/Canon.lean
@@ -1,33 +1,33 @@
-import LSpec
-
-import Ix.Ixon
-import Ix.Address
-import Ix.Common
-import Ix.CanonM
-import Ix.Meta
-import Lean
-import Tests.Ix.Fixtures
-
-@[specialize]
-def withExceptOkM 
-  [Monad m] (descr : String) (exc : Except ε α) [ToString ε] (f : α → m LSpec.TestSeq)
-  : m LSpec.TestSeq :=
-  match exc with
-  | .error e => return LSpec.test descr (LSpec.ExpectationFailure "ok _" s!"error {e}")
-  | .ok    a => return LSpec.test descr true $ ← f a
-
---abbrev CanonTest := Ix.CanonM.CanonMState → LSpec.TestSeq
---abbrev IOCanonTest := Ix.CanonM.CanonMState → IO LSpec.TestSeq
-
-
-def Test.Ix.Canon.wellfounded : IO LSpec.TestSeq := do
-  let env <- get_env!
-  let stt <- match <- Ix.CanonM.canonicalizeDelta env.constants env.getDelta with
-    | .error e => return LSpec.test "canonicalizeFailure" (LSpec.ExpectationFailure "ok _" s!"error {e}")
-    | .ok stt => pure stt
-  let (a,_) := stt.names.find! `WellFounded.A
-  let (b,_) := stt.names.find! `WellFounded.A'
-  return LSpec.test "A == A'" (a == b)
+--import LSpec
+--
+--import Ix.Ixon
+--import Ix.Address
+--import Ix.Common
+--import Ix.CanonM
+--import Ix.Meta
+--import Lean
+--import Tests.Ix.Fixtures
+--
+--@[specialize]
+--def withExceptOkM 
+--  [Monad m] (descr : String) (exc : Except ε α) [ToString ε] (f : α → m LSpec.TestSeq)
+--  : m LSpec.TestSeq :=
+--  match exc with
+--  | .error e => return LSpec.test descr (LSpec.ExpectationFailure "ok _" s!"error {e}")
+--  | .ok    a => return LSpec.test descr true $ ← f a
+--
+----abbrev CanonTest := Ix.CanonM.CanonMState → LSpec.TestSeq
+----abbrev IOCanonTest := Ix.CanonM.CanonMState → IO LSpec.TestSeq
+--
+--
+--def Test.Ix.Canon.wellfounded : IO LSpec.TestSeq := do
+--  let env <- get_env!
+--  let stt <- match <- Ix.CanonM.canonicalizeDelta env.constants env.getDelta with
+--    | .error e => return LSpec.test "canonicalizeFailure" (LSpec.ExpectationFailure "ok _" s!"error {e}")
+--    | .ok stt => pure stt
+--  let (a,_) := stt.names.find! `WellFounded.A
+--  let (b,_) := stt.names.find! `WellFounded.A'
+--  return LSpec.test "A == A'" (a == b)
 
 -- `WellFounded.A == `WellFounded.A'
 
diff --git a/Tests/Ix/Common.lean b/Tests/Ix/Common.lean
index 6f9339b9..4134269a 100644
--- a/Tests/Ix/Common.lean
+++ b/Tests/Ix/Common.lean
@@ -2,9 +2,6 @@ import LSpec
 import Ix.Common
 import Ix.Ixon
 import Ix.Address
-import Ix.Ixon.Serialize
-import Ix.Ixon.Univ
-import Ix.Ixon.Metadata
 import LSpec.SlimCheck.Gen
 import LSpec
 import Blake3
@@ -15,78 +12,78 @@ open SlimCheck
 open SlimCheck.Gen
 open Ixon
 
-def genAddress : SlimCheck.Gen Address := 
-  pure (Address.mk (Blake3.hash "foobar".toUTF8).val)
-
--- TODO: Bias char distribution towards ASCII to be more useful
-def genChar : SlimCheck.Gen Char :=
-  Char.ofNat <$> (choose Nat 0 0xd800)
-
-def genBool : Gen Bool := choose Bool .false true
-
-def genListSize (gen: Gen α) (lo hi: Nat): Gen (List α) := do
-  let n ← choose Nat lo hi
-  List.mapM (fun _ => gen) (List.range n)
-
--- aggressively reduce size parameter to avoid tree blow-up
-def genList (n: Gen α) : Gen (List α) := do
-  resize (fun s => if s > 8 then 8 else s / 2) $ listOf n
-
-def genString : SlimCheck.Gen String := do
-  let cs ← genList genChar
-  return String.mk cs
-
---def genNat' : Gen Nat := choose Nat 0 10
-
-def genNat : Gen Nat := USize.toNat <$> genUSize
-
---def genList' (gen: Gen α) : Gen (List α) := do
---  let n ← genNat'
+--def genAddress : SlimCheck.Gen Address := 
+--  pure (Address.mk (Blake3.hash "foobar".toUTF8).val)
+--
+---- TODO: Bias char distribution towards ASCII to be more useful
+--def genChar : SlimCheck.Gen Char :=
+--  Char.ofNat <$> (choose Nat 0 0xd800)
+--
+--def genBool : Gen Bool := choose Bool .false true
+--
+--def genListSize (gen: Gen α) (lo hi: Nat): Gen (List α) := do
+--  let n ← choose Nat lo hi
 --  List.mapM (fun _ => gen) (List.range n)
-
-def genOption (gen: Gen α) : Gen (Option α) :=
-  oneOf' [ pure .none, .some <$> gen]
-
-def genAlphaNum : Gen Char := do
-  let n <- frequency 
-    [ (50, choose Nat 48 57),
-      (50, choose Nat 65 90),
-      (100, choose Nat 97 122),
-    ]
-  return Char.ofNat n
-
-def genAlphaNumStr : Gen String := do
-  String.mk <$> genList genAlphaNum
-
-def genNamePart : Gen Ixon.NamePart :=
-  frequency [ (50, .str <$> genAlphaNumStr)
-  , (50, .num <$> genNat)
-  ]
-
-def genName : Gen Lean.Name := Ixon.nameFromParts <$> (fun x => [x]) <$> genNamePart
-
-def genBinderInfo : Gen Lean.BinderInfo := oneOf'
-   [ pure .default
-   , pure .instImplicit
-   , pure .strictImplicit
-   , pure .instImplicit
-   ]
-
-def genDefKind : Gen Ix.DefKind := oneOf'
-   [ pure .opaque
-   , pure .theorem
-   , pure .definition
-   ]
-
-def genReducibilityHints : Gen Lean.ReducibilityHints := oneOf'
-   [ pure .opaque
-   , pure .abbrev
-   --, (.regular ·.toUInt32) <$> genUSize
-   ]
-
-def genQuotKind : Gen Lean.QuotKind := oneOf'
-   [ pure .type
-   , pure .ctor
-   , pure .lift
-   , pure .ind
-   ]
+--
+---- aggressively reduce size parameter to avoid tree blow-up
+--def genList (n: Gen α) : Gen (List α) := do
+--  resize (fun s => if s > 8 then 8 else s / 2) $ listOf n
+--
+--def genString : SlimCheck.Gen String := do
+--  let cs ← genList genChar
+--  return String.mk cs
+--
+----def genNat' : Gen Nat := choose Nat 0 10
+--
+--def genNat : Gen Nat := USize.toNat <$> genUSize
+--
+----def genList' (gen: Gen α) : Gen (List α) := do
+----  let n ← genNat'
+----  List.mapM (fun _ => gen) (List.range n)
+--
+--def genOption (gen: Gen α) : Gen (Option α) :=
+--  oneOf' [ pure .none, .some <$> gen]
+--
+--def genAlphaNum : Gen Char := do
+--  let n <- frequency 
+--    [ (50, choose Nat 48 57),
+--      (50, choose Nat 65 90),
+--      (100, choose Nat 97 122),
+--    ]
+--  return Char.ofNat n
+--
+--def genAlphaNumStr : Gen String := do
+--  String.mk <$> genList genAlphaNum
+--
+--def genNamePart : Gen Ixon.NamePart :=
+--  frequency [ (50, .str <$> genAlphaNumStr)
+--  , (50, .num <$> genNat)
+--  ]
+--
+--def genName : Gen Lean.Name := Ixon.nameFromParts <$> (fun x => [x]) <$> genNamePart
+--
+--def genBinderInfo : Gen Lean.BinderInfo := oneOf'
+--   [ pure .default
+--   , pure .instImplicit
+--   , pure .strictImplicit
+--   , pure .instImplicit
+--   ]
+--
+--def genDefKind : Gen Ix.DefKind := oneOf'
+--   [ pure .opaque
+--   , pure .theorem
+--   , pure .definition
+--   ]
+--
+--def genReducibilityHints : Gen Lean.ReducibilityHints := oneOf'
+--   [ pure .opaque
+--   , pure .abbrev
+--   --, (.regular ·.toUInt32) <$> genUSize
+--   ]
+--
+--def genQuotKind : Gen Lean.QuotKind := oneOf'
+--   [ pure .type
+--   , pure .ctor
+--   , pure .lift
+--   , pure .ind
+--   ]
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index d422129f..14152839 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -4,7 +4,7 @@ import Ix.Ixon
 import Ix.Address
 import Ix.Common
 import Ix.CompileM
-import Ix.DecompileM
+--import Ix.DecompileM
 import Ix.Meta
 import Ix.IR
 import Ix.Store
@@ -14,8 +14,8 @@ import Tests.Ix.Fixtures.Mutual
 import Lean
 
 open LSpec
-open Ix.Compile
-open Ix.Decompile
+open Ix
+--open Ix.Decompile
 
 
 namespace Test.Ix.Inductives
@@ -71,11 +71,11 @@ def testMutual : IO TestSeq := do
   let mut cstt : CompileState := .init env 0
   let all := (env.getDelta.find! `Test.Ix.Mutual.A).all
   let predefs <- all.mapM fun n => match env.getDelta.find! n with
-    | .defnInfo d => pure <| Ix.mkPreDefinition d
+    | .defnInfo d => pure <| Ix.mkPreDef d
     | .opaqueInfo d => pure <| Ix.mkPreOpaque d
     | .thmInfo d => pure <| Ix.mkPreTheorem d
     | _ => throw (IO.userError "not a def")
-  let (dss, _) <- match (<- (sortDefs predefs).run (.init 200000) cstt) with
+  let (dss, _) <- match (<- (sortDefs predefs).run .init cstt) with
     | (.ok a, stt) => do
       pure (a, stt)
     | (.error e, _) => do
@@ -91,11 +91,11 @@ def testInductives : IO TestSeq := do
   --let consts := env.getConstMap.filter fun n _ => namesp.isPrefixOf n
   let all := (env.getDelta.find! `Test.Ix.Inductives.A).all
   let preinds <- all.mapM fun n => match env.getDelta.find! n with
-    | .inductInfo v => do match (<- (makePreInductive v).run (.init 200000) cstt) with
+    | .inductInfo v => do match (<- (makePreInd v).run .init cstt) with
       | (.ok a, _) => pure a
       | (.error e, _) => do throw (IO.userError (<- e.pretty))
     | _ => throw (IO.userError "not an inductive")
-  let (dss, _) <- do match (<- (sortInds preinds).run (.init 200000) cstt) with
+  let (dss, _) <- do match (<- (sortInds preinds).run .init cstt) with
     | (.ok a, stt) => do
       pure (a, stt)
     | (.error e, _) => do
@@ -117,9 +117,10 @@ def testDifficult : IO TestSeq := do
       | none => match env.getConstMap.get? name with
         | some c => pure c
         | none => throw (IO.userError s!"{name} not in env")
-    let (_, stt) <- do match (<- (compileConst const).run (.init 200000) cstt) with
+    let (addr, stt) <- do match (<- (compileConst const >>= dematerializeConst).run .init cstt) with
     | (.ok a, stt) => pure (a, stt)
     | (.error e, _) => IO.println s!"failed {const.name}" *> throw (IO.userError (<- e.pretty))
+    IO.println s!"{const.name} -> {addr}"
     --cstt := stt
     --let mut store : Ixon.Store := {}
     --for (_,(a, b)) in cstt.names do
@@ -159,67 +160,67 @@ def testRoundtripGetEnv : IO TestSeq := do
   let mut cstt : CompileState := .init env 0
   --IO.println s!"compiling env"
   for (_, c) in env.getDelta do
-    let (_, stt) <- do match (<- (compileConst c).run (.init 200000) cstt) with
+    let (_, stt) <- do match (<- (compileConst c).run .init cstt) with
     | (.ok a, stt) => do
       pure (a, stt)
     | (.error e, _) => do
       IO.println s!"failed {c.name}"
       throw (IO.userError (<- e.pretty))
-    let (anon, meta) <- match stt.names.get? c.name with
-    | .some (a, m) => pure (a, m)
+    let addr <- match stt.constNames.find? c.name with
+    | .some addr => pure addr
     | .none => throw (IO.userError "name {n} not in env")
-    IO.println s!"✓ {c.name} -> {anon}:{meta}"
+    IO.println s!"✓ {c.name} -> {addr}"
     cstt := stt
   for (_, c) in env.getConstMap do
-    let (_, stt) <- do match (<- (compileConst c).run (.init 200000) cstt) with
+    let (_, stt) <- do match (<- (compileConst c).run .init cstt) with
     | (.ok a, stt) => do
       pure (a, stt)
     | (.error e, _) => do
       IO.println s!"failed {c.name}"
       throw (IO.userError (<- e.pretty))
-    let (anon, meta) <- match stt.names.get? c.name with
-    | .some (a, m) => pure (a, m)
+    let addr <- match stt.constNames.find? c.name with
+    | .some addr => pure addr
     | .none => throw (IO.userError "name {n} not in env")
-    IO.println s!"✓ {c.name} -> {anon}:{meta}"
+    IO.println s!"✓ {c.name} -> {addr}"
     cstt := stt
   IO.println s!"compiled env"
-  IO.println s!"decompiling env"
-  let mut store : Ixon.Store := {}
-  for (_,(a, b)) in cstt.names do
-    let a_ixon <- (Store.readConst a).toIO
-    let b_ixon <- (Store.readConst b).toIO
-    store := store.insert a a_ixon
-    store := store.insert b b_ixon
-  let denv := DecompileEnv.init cstt.names store
-  let dstt <- match decompileEnv.run denv default with
-    | .ok _ s => pure s
-      --IO.println s!"✓ {n} @ {anon}:{meta}"
-    | .error e _ => do
-      throw (IO.userError e.pretty)
-  IO.println s!"decompiled env"
-  let mut res := true
-  for (n, (anon, meta)) in denv.names do
-    let c <- match env.constants.find? n with
-    | .some c => pure c
-    | .none => throw (IO.userError "name {n} not in env")
-    match dstt.constants.get? n with
-    | .some c2 =>
-      if c.stripMData == c2.stripMData
-      then
-        IO.println s!"✓ {n} @ {anon}:{meta}"
-      else
-        IO.println s!"× {n} @ {anon}:{meta}"
-        IO.FS.writeFile "c.out" s!"{repr c.stripMData}"
-        IO.FS.writeFile "c2.out" s!"{repr c2.stripMData}"
-        res := false
-        break
-    | .none => do
-      let e' := (DecompileError.unknownName default n).pretty
-      throw (IO.userError e')
-  IO.println s!"input delta: {env.getDelta.toList.length}"
-  IO.println s!"input env: {env.constants.toList.length}"
-  IO.println s!"output env: {dstt.constants.toList.length}"
-  return test "env compile roundtrip" (res == true)
+ -- IO.println s!"decompiling env"
+ -- let mut store : Ixon.Store := {}
+ -- for (_,(a, b)) in cstt.names do
+ --   let a_ixon <- (Store.readConst a).toIO
+ --   let b_ixon <- (Store.readConst b).toIO
+ --   store := store.insert a a_ixon
+ --   store := store.insert b b_ixon
+ -- let denv := DecompileEnv.init cstt.names store
+ -- let dstt <- match decompileEnv.run denv default with
+ --   | .ok _ s => pure s
+ --     --IO.println s!"✓ {n} @ {anon}:{meta}"
+ --   | .error e _ => do
+ --     throw (IO.userError e.pretty)
+ -- IO.println s!"decompiled env"
+ -- let mut res := true
+ -- for (n, (anon, meta)) in denv.names do
+ --   let c <- match env.constants.find? n with
+ --   | .some c => pure c
+ --   | .none => throw (IO.userError "name {n} not in env")
+ --   match dstt.constants.find? n with
+ --   | .some c2 =>
+ --     if c.stripMData == c2.stripMData
+ --     then
+ --       IO.println s!"✓ {n} @ {anon}:{meta}"
+ --     else
+ --       IO.println s!"× {n} @ {anon}:{meta}"
+ --       IO.FS.writeFile "c.out" s!"{repr c.stripMData}"
+ --       IO.FS.writeFile "c2.out" s!"{repr c2.stripMData}"
+ --       res := false
+ --       break
+ --   | .none => do
+ --     let e' := (DecompileError.unknownName default n).pretty
+ --     throw (IO.userError e')
+ -- IO.println s!"input delta: {env.getDelta.toList.length}"
+ -- IO.println s!"input env: {env.constants.toList.length}"
+ -- IO.println s!"output env: {dstt.constants.toList.length}"
+  return test "env compile roundtrip" true --(res == true)
 
 def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
    testMutual,
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index 03ebabb8..5fc244a0 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -13,110 +13,110 @@ open SlimCheck.Gen
 
 namespace Ix
 
-def genLevel : Gen Ix.Level := getSize >>= go
-  where
-    go : Nat -> Gen Ix.Level
-    | 0 => return .zero
-    | Nat.succ f =>
-      frequency [
-        (100, return .zero),
-        (100, .param <$> genName <*> genNat),
-        (50, .succ <$> go f),
-        (25, .max <$> go f <*> go f),
-        (25, .imax <$> go f <*> go f)
-      ]
-
-instance : Shrinkable Ix.Level where
-  shrink _ := []
-
-instance : SampleableExt Ix.Level := SampleableExt.mkSelfContained genLevel
-
-def genExpr : Gen Ix.Expr := getSize >>= go
-  where
-    go : Nat -> Gen Ix.Expr
-    | 0 => return .lit (.natVal 0)
-    | Nat.succ f =>
-      frequency [
-        (100, .var <$> genNat),
-        (100, .sort <$> genLevel),
-        (50, .const <$> genName <*> genAddress <*> genAddress <*> genList genLevel),
-        (50, .rec_ <$> genName <*> genNat <*> genList genLevel),
-        (50, .app <$> go f <*> go f),
-        (50, .lam <$> genName <*> genBinderInfo <*> go f <*> go f),
-        (50, .pi <$> genName <*> genBinderInfo <*> go f <*> go f),
-        (25, .letE <$> genName <*> go f <*> go f <*> go f <*> pure .true),
-        (25, .letE <$> genName <*> go f <*> go f <*> go f <*> pure .false),
-        (100, .lit <$> .strVal <$> genString),
-        (100, .lit <$> .natVal <$> chooseAny Nat),
-        (25, .proj <$> genName <*> genAddress <*> genAddress <*> genNat <*> go f),
-      ]
-
-instance : Shrinkable Ix.Expr where
-  shrink _ := []
-
-instance : SampleableExt Ix.Expr := SampleableExt.mkSelfContained genExpr
-
-def genConst : Gen Ix.Const := getSize >>= go
-  where
-    genNames : Gen (List Lean.Name) := genList genName
-    genDef : Gen Ix.Definition := do
-      let n <- genName
-      let lvls <- genNames
-      let type <- genExpr
-      let mode <- genDefKind
-      let value <- genExpr
-      let hints <- genReducibilityHints
-      let safety <- oneOf #[pure .safe, pure .partial, pure .unsafe]
-      let all <- genNames
-      return ⟨n, lvls, type, mode, value, hints, safety, all⟩
-    genCtor : Gen Ix.Constructor := 
-      .mk <$> genName <*> genNames <*> genExpr <*> genNat <*> genNat <*> genNat <*> genBool
-    genRecr : Gen Ix.Recursor := 
-      .mk <$> genName <*> genNames <*> genExpr <*> genNat <*> genNat <*> genNat <*> genNat
-        <*> genList (.mk <$> genName <*> genNat <*> genExpr)
-        <*> genBool <*> genBool
-    genInd : Gen Ix.Inductive := do
-      let n <- genName
-      let lvls <- genNames
-      let type <- genExpr
-      let params <- genNat
-      let indices <- genNat
-      let all <- genNames
-      let ctors <- genList genCtor
-      let recrs <- genList genRecr
-      let nested <- genNat
-      let (isRec, isRefl, isUnsafe) <- (·,·,·) <$> genBool <*> genBool <*> genBool
-      return ⟨n, lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl, isUnsafe⟩
-    genMutDef : Gen Ix.MutualBlock := do
-      let nns <- genList (genListSize genName 1 5)
-      let ds <- nns.mapM fun ns => do
-        let x <- genDef
-        ns.mapM (fun _ => pure x)
-      return .mk ds
-    genMutInd : Gen Ix.InductiveBlock := do
-      let nns <- genList (genListSize genName 1 5)
-      let ds <- nns.mapM fun ns => do
-        let x <- genInd
-        ns.mapM (fun _ => pure x)
-      return .mk ds
-    go : Nat -> Gen Ix.Const
-    | 0 => return .«axiom» (.mk .anonymous [] (Ix.Expr.sort (Ix.Level.zero)) false)
-    | Nat.succ _ =>
-      frequency [
-        (100, .«axiom» <$> (.mk <$> genName <*> genNames <*> genExpr <*> genBool)),
-        (100, .«definition» <$> genDef),
-        (100, .quotient <$> (.mk <$> genName <*> genNames <*> genExpr <*> genQuotKind)),
-        (100, .inductiveProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat)),
-        (100, .constructorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat <*> genName <*> genNat)),
-        (100, .recursorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat <*> genName <*> genNat)),
-        (100, .definitionProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat)),
-        (100, .mutual <$> genMutDef),
-        (100, .inductive <$> genMutInd),
-      ]
-
-instance : Shrinkable Ix.Const where
-  shrink _ := []
-
-instance : SampleableExt Ix.Const := SampleableExt.mkSelfContained genConst
-
-end Ix
+--def genLevel : Gen Ix.Level := getSize >>= go
+--  where
+--    go : Nat -> Gen Ix.Level
+--    | 0 => return .zero
+--    | Nat.succ f =>
+--      frequency [
+--        (100, return .zero),
+--        (100, .param <$> genName <*> genNat),
+--        (50, .succ <$> go f),
+--        (25, .max <$> go f <*> go f),
+--        (25, .imax <$> go f <*> go f)
+--      ]
+--
+--instance : Shrinkable Ix.Level where
+--  shrink _ := []
+--
+--instance : SampleableExt Ix.Level := SampleableExt.mkSelfContained genLevel
+--
+--def genExpr : Gen Ix.Expr := getSize >>= go
+--  where
+--    go : Nat -> Gen Ix.Expr
+--    | 0 => return .lit (.natVal 0)
+--    | Nat.succ f =>
+--      frequency [
+--        (100, .var <$> genNat),
+--        (100, .sort <$> genLevel),
+--        (50, .const <$> genName <*> genAddress <*> genAddress <*> genList genLevel),
+--        (50, .rec_ <$> genName <*> genNat <*> genList genLevel),
+--        (50, .app <$> go f <*> go f),
+--        (50, .lam <$> genName <*> genBinderInfo <*> go f <*> go f),
+--        (50, .pi <$> genName <*> genBinderInfo <*> go f <*> go f),
+--        (25, .letE <$> genName <*> go f <*> go f <*> go f <*> pure .true),
+--        (25, .letE <$> genName <*> go f <*> go f <*> go f <*> pure .false),
+--        (100, .lit <$> .strVal <$> genString),
+--        (100, .lit <$> .natVal <$> chooseAny Nat),
+--        (25, .proj <$> genName <*> genAddress <*> genAddress <*> genNat <*> go f),
+--      ]
+--
+--instance : Shrinkable Ix.Expr where
+--  shrink _ := []
+--
+--instance : SampleableExt Ix.Expr := SampleableExt.mkSelfContained genExpr
+--
+--def genConst : Gen Ix.Const := getSize >>= go
+--  where
+--    genNames : Gen (List Lean.Name) := genList genName
+--    genDef : Gen Ix.Definition := do
+--      let n <- genName
+--      let lvls <- genNames
+--      let type <- genExpr
+--      let mode <- genDefKind
+--      let value <- genExpr
+--      let hints <- genReducibilityHints
+--      let safety <- oneOf #[pure .safe, pure .partial, pure .unsafe]
+--      let all <- genNames
+--      return ⟨n, lvls, type, mode, value, hints, safety, all⟩
+--    genCtor : Gen Ix.Constructor := 
+--      .mk <$> genName <*> genNames <*> genExpr <*> genNat <*> genNat <*> genNat <*> genBool
+--    genRecr : Gen Ix.Recursor := 
+--      .mk <$> genName <*> genNames <*> genExpr <*> genNat <*> genNat <*> genNat <*> genNat
+--        <*> genList (.mk <$> genName <*> genNat <*> genExpr)
+--        <*> genBool <*> genBool
+--    genInd : Gen Ix.Inductive := do
+--      let n <- genName
+--      let lvls <- genNames
+--      let type <- genExpr
+--      let params <- genNat
+--      let indices <- genNat
+--      let all <- genNames
+--      let ctors <- genList genCtor
+--      let recrs <- genList genRecr
+--      let nested <- genNat
+--      let (isRec, isRefl, isUnsafe) <- (·,·,·) <$> genBool <*> genBool <*> genBool
+--      return ⟨n, lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl, isUnsafe⟩
+--    genMutDef : Gen Ix.MutualBlock := do
+--      let nns <- genList (genListSize genName 1 5)
+--      let ds <- nns.mapM fun ns => do
+--        let x <- genDef
+--        ns.mapM (fun _ => pure x)
+--      return .mk ds
+--    genMutInd : Gen Ix.InductiveBlock := do
+--      let nns <- genList (genListSize genName 1 5)
+--      let ds <- nns.mapM fun ns => do
+--        let x <- genInd
+--        ns.mapM (fun _ => pure x)
+--      return .mk ds
+--    go : Nat -> Gen Ix.Const
+--    | 0 => return .«axiom» (.mk .anonymous [] (Ix.Expr.sort (Ix.Level.zero)) false)
+--    | Nat.succ _ =>
+--      frequency [
+--        (100, .«axiom» <$> (.mk <$> genName <*> genNames <*> genExpr <*> genBool)),
+--        (100, .«definition» <$> genDef),
+--        (100, .quotient <$> (.mk <$> genName <*> genNames <*> genExpr <*> genQuotKind)),
+--        (100, .inductiveProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat)),
+--        (100, .constructorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat <*> genName <*> genNat)),
+--        (100, .recursorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat <*> genName <*> genNat)),
+--        (100, .definitionProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat)),
+--        (100, .mutual <$> genMutDef),
+--        (100, .inductive <$> genMutInd),
+--      ]
+--
+--instance : Shrinkable Ix.Const where
+--  shrink _ := []
+--
+--instance : SampleableExt Ix.Const := SampleableExt.mkSelfContained genConst
+--
+--end Ix
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index a8c209a2..61540019 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -166,244 +166,3 @@ def Tests.Ixon.suite := [
   check "Ixon serde roundtrips" (∀ ixon : Ixon.Ixon, ixonSerde ixon)
 ]
 
--- import Ix.Ixon
--- import Ix.Claim
--- import Ix.Ixon.Serialize
--- import Ix.Ixon.Univ
--- import LSpec.SlimCheck.Gen
--- import LSpec
-
--- import Tests.Common
--- import Tests.Ix.Common
-
--- open LSpec
--- open SlimCheck
--- open SlimCheck.Gen
--- open Ixon
-
--- -- Univ
--- namespace Ixon
-
--- def genUniv : Gen Ixon.Univ := getSize >>= go
---   where
---     go : Nat -> Gen Ixon.Univ
---     | 0 => return .const 0
---     | Nat.succ f =>
---       frequency [
---         (100, .const <$> genUInt64),
---         (100, .var <$> genUInt64),
---         (50, .add <$> genUInt64 <*> go f),
---         (25, .max <$> go f <*> go f),
---         (25, .imax <$> go f <*> go f)
---       ]
-
--- instance : Shrinkable Univ where
---   shrink _ := []
-
--- instance : SampleableExt Univ := SampleableExt.mkSelfContained genUniv
-
--- -- Expr
-
--- def genExpr : SlimCheck.Gen Ixon := getSize >>= go
---   where
---     go : Nat -> SlimCheck.Gen Ixon
---     | 0 => return .vari 0
---     | Nat.succ f =>
---       frequency [
---         (100, .vari <$> genUInt64),
---         (100, .sort <$> genUniv),
---         (100, .refr <$> genAddress <*> genList genUniv),
---         (100, .recr <$> genUInt64 <*> genList genUniv),
---         (15, .apps <$> go f <*> go f <*> genList (go f)),
---         (15, .lams <$> genList (go f) <*> go f),
---         (15, .alls <$> genList (go f) <*> go f),
---         (15, .letE .true <$> go f <*> go f <*> go f),
---         (15, .letE .false <$> go f <*> go f <*> go f),
---         (50, .proj <$> genAddress <*> genUInt64 <*> go f),
---         (100, .strl <$> genString),
---         (100, .natl <$> chooseAny Nat)
---       ]
-
--- structure IxonExpr where
---   ixon : Ixon
--- deriving BEq, Repr
-
--- instance : Serialize IxonExpr where
---   put x := Serialize.put x.ixon
---   get := .mk <$> Serialize.get
-
--- -- TODO: useful shrinking
--- instance : Shrinkable IxonExpr where
---   shrink _ := []
-
--- instance : SampleableExt IxonExpr :=
---   SampleableExt.mkSelfContained (IxonExpr.mk <$> genExpr)
-
--- -- Metadata
--- def genMetadatum : Gen Ixon.Metadatum :=
---   frequency [
---     (50, .name <$> genName),
---     (100, .info <$> genBinderInfo),
---     (100, .link <$> genAddress),
---     (100, .hints <$> genReducibilityHints),
---     (10, .all <$> genList genName),
---   ]
-
--- instance : Shrinkable Metadatum where
---   shrink _ := []
-
--- instance : SampleableExt Metadatum :=
---   SampleableExt.mkSelfContained genMetadatum
-
--- def genMetaNode : Gen (List Metadatum) := genList genMetadatum
-
--- def genMetadata : Gen Metadata := do
---   let xs ← genList genMetaNode
---   return .mk ((List.range xs.length).zip xs)
-
--- instance : Shrinkable Metadata where
---   shrink _ := []
-
--- instance : SampleableExt Metadata :=
---   SampleableExt.mkSelfContained genMetadata
-
--- -- Const
--- def genAxiom : Gen Axiom := .mk <$> genBool <*> genNat <*> genAddress
-
--- -- TODO: useful shrinking
--- instance : Shrinkable Axiom where
---   shrink _ := []
-
--- instance : SampleableExt Axiom
---   := SampleableExt.mkSelfContained genAxiom
-
--- def genDefinition : Gen Definition := do
---   let lvls <- genNat
---   let type <- genAddress
---   let kind <- genDefKind
---   let value <- genAddress
---   let safety <- oneOf #[pure .safe, pure .unsafe, pure .partial]
---   return .mk kind safety lvls type value
-
--- def genConstructor : Gen Constructor :=
---   .mk <$> genBool <*> genNat <*> genNat <*> genNat <*> genNat <*> genAddress
-
--- -- TODO: useful shrinking
--- instance : Shrinkable Constructor where
---   shrink _ := []
-
--- instance : SampleableExt Constructor
---   := SampleableExt.mkSelfContained genConstructor
-
--- def genRecursorRule : Gen RecursorRule := .mk <$> genNat <*> genAddress
-
--- -- TODO: useful shrinking
--- instance : Shrinkable RecursorRule where
---   shrink _ := []
-
--- instance : SampleableExt RecursorRule
---   := SampleableExt.mkSelfContained genRecursorRule
-
--- def genRecursor : Gen Recursor :=
---   .mk <$> genBool <*> genBool <*> genNat <*> genNat <*> genNat <*> genNat
---     <*> genNat <*> genAddress <*> genList genRecursorRule
-
--- -- TODO: useful shrinking
--- instance : Shrinkable Recursor where
---   shrink _ := []
-
--- instance : SampleableExt Recursor
---   := SampleableExt.mkSelfContained genRecursor
-
--- def genInductive : Gen Inductive :=
---   .mk <$> genBool <*> genBool <*> genBool
---     <*> genNat <*> genNat <*> genNat <*> genNat
---     <*> genAddress <*> genList genConstructor <*> genList genRecursor
-
--- -- TODO: useful shrinking
--- instance : Shrinkable Inductive where
---   shrink _ := []
-
--- instance : SampleableExt Inductive
---   := SampleableExt.mkSelfContained genInductive
-
--- def genConstructorProj : Gen ConstructorProj :=
---   .mk <$> genNat <*> genNat <*> genAddress
-
--- def genRecursorProj : Gen RecursorProj :=
---   .mk <$> genNat <*> genNat <*> genAddress
-
--- def genDefinitionProj : Gen DefinitionProj :=
---   .mk <$> genNat <*> genAddress
-
--- def genInductiveProj : Gen InductiveProj :=
---   .mk <$> genNat <*> genAddress
-
--- def genCheckClaim : Gen CheckClaim :=
---   .mk <$> genAddress <*> genAddress <*> genAddress
-
--- def genEvalClaim : Gen EvalClaim :=
---   .mk <$> genAddress <*> genAddress <*> genAddress <*> genAddress
-
--- def genClaim: Gen Claim :=
---   oneOf #[.checks <$> genCheckClaim, .evals <$> genEvalClaim]
-
--- -- TODO: different dummy ByteArray perhaps
--- def genProof: Gen Proof := .mk <$> genClaim <*> (Address.hash <$> genAddress)
-
--- def genComm: Gen Comm := .mk <$> genAddress <*> genAddress
-
--- def genEnvn: Gen Env := .mk <$> genList ((·,·) <$> genAddress <*> genAddress)
-
--- def genConst : Gen Ixon := getSize >>= go
---   where
---     go : Nat -> Gen Ixon
---     | 0 => .axio <$> genAxiom
---     | Nat.succ _ =>
---       frequency [
---         (100, .axio <$> genAxiom),
---         (100, .defn <$> genDefinition),
---         (100, .cprj <$> genConstructorProj),
---         (100, .rprj <$> genRecursorProj),
---         (100, .iprj <$> genInductiveProj),
---         (100, .dprj <$> genDefinitionProj),
---         (100, .defs <$> genList genDefinition),
---         (100, .inds <$> genList genInductive),
---         (100, .meta <$> genMetadata),
---         (100, .prof <$> genProof),
---         (100, .eval <$> genEvalClaim),
---         (100, .chck <$> genCheckClaim),
---         (100, .comm <$> genComm),
---         (100, .envn <$> genEnvn),
---       ]
-
--- structure IxonConst where
---   ixon : Ixon
--- deriving BEq, Repr
-
--- instance : Serialize IxonConst where
---   put x := Serialize.put x.ixon
---   get := .mk <$> Serialize.get
-
--- -- TODO: useful shrinking
--- instance : Shrinkable IxonConst where
---   shrink _ := []
-
--- instance : SampleableExt IxonConst
---   := SampleableExt.mkSelfContained (IxonConst.mk <$> genConst)
-
--- -- TODO: useful shrinking
--- instance : Shrinkable Claim where
---   shrink _ := []
-
--- instance : SampleableExt Claim
---   := SampleableExt.mkSelfContained genClaim
-
--- /--
--- Whether the provided IxonFFI term, reconstructed and serialized in Rust, matches
--- the provided bytes.
--- -/
--- @[extern "rs_eq_lean_rust_serialization"]
--- opaque eqLeanRustSerialization : @& IxonFFI -> @& ByteArray -> Bool
-
--- end Ixon
diff --git a/Tests/Ix/Lean.lean b/Tests/Ix/Lean.lean
deleted file mode 100644
index e69de29b..00000000
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 31844672..772f13b3 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -1,24 +1,22 @@
--- import Tests.Aiur
--- import Tests.FFIConsistency
--- import Tests.ByteArray
--- import Tests.Ix
+import Tests.Aiur
+import Tests.FFIConsistency
+import Tests.ByteArray
+import Tests.Ix
 import Tests.Ix.Ixon
--- import Tests.Ix.Compile
--- import Tests.Keccak
--- import Tests.Cli
+import Tests.Ix.Compile
+import Tests.Keccak
+import Tests.Cli
 
 def main (args: List String) : IO UInt32 := do
-  -- if args.contains "compile"
-  -- then LSpec.lspecEachIO Tests.Ix.Compile.suiteIO id
-  -- else if args.contains "cli" then
-  --   Tests.Cli.suite
-  -- else
+  if args.contains "compile" then LSpec.lspecEachIO Tests.Ix.Compile.suiteIO id
+  else if args.contains "cli" then Tests.Cli.suite
+  else
     LSpec.lspecIO (.ofList [
-      -- ("aiur", Tests.Aiur.suite),
-      -- ("ffi-consistency", Tests.FFIConsistency.suite),
-      -- ("byte-array", Tests.ByteArray.suite),
-      -- ("ix", Tests.Ix.suite),
-      -- ("ixon", Tests.Ixon.units),
-      ("ixon", Tests.Ixon.suite),
-      -- ("keccak", Tests.Keccak.suite),
-  ]) args
+       ("aiur", Tests.Aiur.suite),
+       ("ffi-consistency", Tests.FFIConsistency.suite),
+       ("byte-array", Tests.ByteArray.suite),
+       ("ix", Tests.Ix.suite),
+       --("ixon", Tests.Ixon.units),
+       ("ixon", Tests.Ixon.suite),
+       ("keccak", Tests.Keccak.suite),
+    ]) args

From 6df502d1014da48f97cee4084d3b1e7c9ac0821a Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 7 Oct 2025 17:42:59 -0400
Subject: [PATCH 50/74] bitblast now compiling

---
 Ix/Common.lean        |   49 +-
 Ix/CompileM.lean      | 1180 ++++++++++++++++-------------------------
 Ix/IR.lean            |   41 +-
 Ix/Ixon.lean          |   66 +--
 Ix/Meta.lean          |    2 +-
 Tests/Ix/Compile.lean |    8 +-
 Tests/Ix/Ixon.lean    |    4 +-
 7 files changed, 553 insertions(+), 797 deletions(-)

diff --git a/Ix/Common.lean b/Ix/Common.lean
index 1db5a4a4..64a3962f 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -34,15 +34,15 @@ instance : Ord Lean.Name where
 deriving instance Ord for Lean.Literal
 --deriving instance Ord for Lean.Expr
 deriving instance Ord for Lean.BinderInfo
-deriving instance BEq, Repr, Ord, Ord for Lean.QuotKind
-deriving instance Ord, Repr for Lean.ReducibilityHints
-deriving instance BEq, Ord, Ord, Repr for Lean.DefinitionSafety
-deriving instance BEq, Repr, Ord for ByteArray
-deriving instance BEq, Repr, Ord for String.Pos
-deriving instance BEq, Repr, Ord for Substring
-deriving instance BEq, Repr, Ord for Lean.SourceInfo
-deriving instance BEq, Repr, Ord for Lean.Syntax.Preresolved
-deriving instance BEq, Repr, Ord for Lean.Syntax
+deriving instance BEq, Repr, Ord, Hashable for Lean.QuotKind
+deriving instance BEq, Repr, Ord, Hashable for Lean.ReducibilityHints
+deriving instance BEq, Repr, Ord, Hashable for Lean.DefinitionSafety
+deriving instance BEq, Repr, Ord, Hashable for ByteArray
+deriving instance BEq, Repr, Ord, Hashable for String.Pos
+deriving instance BEq, Repr, Ord, Hashable for Substring
+deriving instance BEq, Repr, Ord, Hashable for Lean.SourceInfo
+deriving instance BEq, Repr, Ord, Hashable for Lean.Syntax.Preresolved
+deriving instance BEq, Repr, Ord, Hashable for Lean.Syntax
 deriving instance BEq, Repr for Ordering
 deriving instance BEq, Repr, Ord for Lean.FVarId
 deriving instance BEq, Repr, Ord for Lean.MVarId
@@ -51,17 +51,17 @@ deriving instance BEq, Repr, Ord for Lean.KVMap
 deriving instance BEq, Repr, Ord for Lean.LevelMVarId
 deriving instance BEq, Repr, Ord for Lean.Level
 deriving instance BEq, Repr, Ord for Lean.Expr
-deriving instance BEq, Repr, Ord for Lean.ConstantVal
-deriving instance BEq, Repr, Ord for Lean.QuotVal
-deriving instance BEq, Repr, Ord for Lean.AxiomVal
-deriving instance BEq, Repr, Ord for Lean.TheoremVal
-deriving instance BEq, Repr, Ord for Lean.DefinitionVal
-deriving instance BEq, Repr, Ord for Lean.OpaqueVal
-deriving instance BEq, Repr, Ord for Lean.RecursorRule
-deriving instance BEq, Repr, Ord for Lean.RecursorVal
-deriving instance BEq, Repr, Ord for Lean.ConstructorVal
-deriving instance BEq, Repr, Ord for Lean.InductiveVal
-deriving instance BEq, Repr, Ord for Lean.ConstantInfo
+deriving instance BEq, Repr, Ord, Hashable for Lean.ConstantVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.QuotVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.AxiomVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.TheoremVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.DefinitionVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.OpaqueVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.RecursorRule
+deriving instance BEq, Repr, Ord, Hashable for Lean.RecursorVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.ConstructorVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.InductiveVal
+deriving instance BEq, Repr, Ord, Hashable for Lean.ConstantInfo
 
 def UInt8.MAX : UInt64 := 0xFF
 def UInt16.MAX : UInt64 := 0xFFFF
@@ -261,10 +261,15 @@ def sortGroupsByM [Monad μ] (xs: List (List α)) (cmp: α -> α -> μ Ordering)
 
 end List
 
-abbrev MutCtx := Batteries.RBMap Lean.Name Nat compare
+def Std.HashMap.find? {A B} [BEq A] [Hashable A] (map: Std.HashMap A B) (a: A) 
+  := Std.HashMap.get? map a
+
+abbrev Ix.Map := Std.HashMap
+
+abbrev MutCtx := Ix.Map Lean.Name Nat
 
 instance : BEq MutCtx where
-  beq a b := a.size == b.size && a.foldl
+  beq a b := a.size == b.size && a.fold
     (fun acc k v => acc && match b.find? k with
       | some v' => v == v'
       | none => false) true
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 656e73cb..7f95c3bb 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -1,4 +1,4 @@
-import Batteries.Data.RBMap
+import Std.Data.HashMap
 import Ix.Ixon
 import Ix.Address
 import Ix.IR
@@ -7,8 +7,6 @@ import Ix.Common
 import Ix.SOrder
 import Ix.Cronos
 
-open Batteries (RBMap)
-open Batteries (RBSet)
 
 namespace Ix
 open Ixon hiding Substring
@@ -26,30 +24,26 @@ structure CompileState where
   maxHeartBeats: USize
   env: Lean.Environment
   prng: StdGen
-  store: RBMap Address ByteArray compare
-  ixonCache: RBMap Ixon Address compare
-  univCache: RBMap Lean.Level Ix.Level compare
-  univAddrs: RBMap Ix.Level MetaAddress compare
-  constNames: RBMap Lean.Name MetaAddress compare
-  constCache: RBMap Lean.ConstantInfo Ix.Const compare
-  constAddrs : RBMap Ix.Const MetaAddress compare
-  exprCache: RBMap Lean.Expr Ix.Expr compare
-  exprAddrs: RBMap Ix.Expr MetaAddress compare
-  synCache: RBMap Lean.Syntax Ixon.Syntax compare
-  nameCache: RBMap Lean.Name Address compare
-  strCache: RBMap String Address compare
-  comms: RBMap Lean.Name MetaAddress compare
-  constCmp: RBMap (Lean.Name × Lean.Name) Ordering compare
-  exprCmp: RBMap (CompileEnv × Lean.Expr × Lean.Expr) Ordering compare
-  axioms: RBMap Lean.Name MetaAddress compare
-  blocks: RBSet MetaAddress compare
+  store: Map Address ByteArray
+  ixonCache: Map Ixon Address
+  univCache: Map Lean.Level MetaAddress
+  constCache: Map Lean.Name MetaAddress
+  exprCache: Map Lean.Expr MetaAddress
+  synCache: Map Lean.Syntax Ixon.Syntax
+  nameCache: Map Lean.Name Address
+  strCache: Map String Address
+  comms: Map Lean.Name MetaAddress
+  constCmp: Map (Lean.Name × Lean.Name) Ordering
+  --exprCmp: Map (CompileEnv × Lean.Expr × Lean.Expr) Ordering
+  axioms: Map Lean.Name MetaAddress
+  blocks: Map MetaAddress Unit
   cronos: Cronos
 
 def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize := 200000)
   : CompileState :=
   ⟨maxHeartBeats, env, mkStdGen seed, default, default, default, default,
   default, default, default, default, default, default, default, default,
-  default, default, default, default, default, default⟩
+  default, default⟩
 
 inductive CompileError where
 | unknownConstant : Lean.Name -> CompileError
@@ -66,11 +60,13 @@ inductive CompileError where
 | kernelException : Lean.Kernel.Exception → CompileError
 --| cantPackLevel : Nat → CompileError
 --| nonCongruentInductives : PreInd -> PreInd -> CompileError
-| alphaInvarianceFailure : Ix.Const -> MetaAddress -> Ix.Const -> MetaAddress -> CompileError
-| dematBadMutualBlock: MutualBlock -> CompileError
-| dematBadInductiveBlock: InductiveBlock -> CompileError
-| emptyDefsClass: List (List PreDef) -> CompileError
-| emptyIndsClass: List (List PreInd) -> CompileError
+| alphaInvarianceFailure : Lean.ConstantInfo -> MetaAddress -> Lean.ConstantInfo -> MetaAddress -> CompileError
+--| dematBadMutualBlock: MutualBlock -> CompileError
+--| dematBadInductiveBlock: InductiveBlock -> CompileError
+| badMutualBlock: List (List PreDef) -> CompileError
+| badInductiveBlock: List (List PreInd) -> CompileError
+| badIxonDeserialization : Address -> String -> CompileError
+| unknownStoreAddress : Address -> CompileError
 --| emptyIndsEquivalenceClass: List (List PreInd) -> CompileError
 
 def CompileError.pretty : CompileError -> IO String
@@ -87,12 +83,10 @@ def CompileError.pretty : CompileError -> IO String
 | .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
 | .alphaInvarianceFailure x xa y ya => 
   pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
-| .dematBadMutualBlock block => pure s!"bad mutual block while dematerializing {repr block}"
-| .dematBadInductiveBlock block => pure s!"bad mutual block while dematerializing {repr block}"
-| .emptyDefsClass dss => 
-  pure s!"empty equivalence class while sorting definitions {dss.map fun ds => ds.map (·.name)}"
-| .emptyIndsClass dss => 
-  pure s!"empty equivalence class while sorting inductives {dss.map fun ds => ds.map (·.name)}"
+| .badMutualBlock block => pure s!"bad mutual block {repr block}"
+| .badInductiveBlock block => pure s!"bad mutual block {repr block}"
+| .badIxonDeserialization a s => pure s!"bad deserialization of ixon at {a}, error: {s}"
+| .unknownStoreAddress a => pure s!"unknown store address {a}"
 
 abbrev CompileM :=
   ReaderT CompileEnv <| ExceptT CompileError <| StateT CompileState IO
@@ -143,11 +137,18 @@ def storeIxon (ixon: Ixon): CompileM Address := do
   | none => do
     let bytes := Ixon.ser ixon
     let addr := Address.blake3 bytes
-    dbg_trace "storeIxon hash {addr} {(<- read).current}"
+    --dbg_trace "storeIxon hash {addr} {(<- read).current}"
     modifyGet fun stt => (addr, { stt with
       store := stt.store.insert addr bytes
     })
 
+def getIxon (addr: Address) : CompileM Ixon := do
+  match (<- get).store.find? addr with
+  | some bytes => match Ixon.de bytes with
+    | .ok ixon => pure ixon
+    | .error e => throw <| .badIxonDeserialization addr e
+  | none => throw <| .unknownStoreAddress addr
+
 def storeString (str: String): CompileM Address := do
   match (<- get).strCache.find? str with
   | some addr => pure addr
@@ -173,14 +174,14 @@ def storeSerial [Serialize A] (a: A): CompileM Address := do
     store := stt.store.insert addr bytes
   })
 
-def storeMetadata (meta: Metadata): CompileM Address := do
+def storeMeta (meta: Metadata): CompileM Address := do
   let bytes := Ixon.ser meta
   let addr := Address.blake3 bytes
   modifyGet fun stt => (addr, { stt with
     store := stt.store.insert addr bytes
   })
 
-def dematerializeName (name: Lean.Name): CompileM Address := do
+def compileName (name: Lean.Name): CompileM Address := do
   match (<- get).nameCache.find? name with
   | some addr => pure addr
   | none => do
@@ -192,11 +193,11 @@ def dematerializeName (name: Lean.Name): CompileM Address := do
     go : Lean.Name -> CompileM Address
     | .anonymous => pure <| Address.blake3 ⟨#[]⟩
     | .str n s => do
-      let n' <- dematerializeName n
+      let n' <- compileName n
       let s' <- storeString s
       storeIxon (.nstr n' s')
     | .num n i => do
-      let n' <- dematerializeName n
+      let n' <- compileName n
       let i' <- storeNat i
       storeIxon (.nnum n' i')
 
@@ -227,310 +228,58 @@ def compareLevel (xctx yctx: List Lean.Name)
     | _,       none    => 
       throw $ .levelNotFound y yctx s!"compareLevel"
 
-def dematerializeLevel (lvl: Ix.Level): CompileM MetaAddress := do
-  match (<- get).univAddrs.find? lvl with
+/-- Canonicalizes a Lean universe level --/
+def compileLevel (lvl: Lean.Level): CompileM MetaAddress := do
+  match (<- get).univCache.find? lvl with
   | some l => pure l
   | none => do
-    --dbg_trace "dematerializeLevel go {(<- get).univAddrs.size} {(<- read).current}"
+    --dbg_trace "compileLevel go {(<- get).univAddrs.size} {(<- read).current}"
     let (anon, meta) <- go lvl
     let anonAddr <- storeIxon anon
     let metaAddr <- storeIxon meta
     let maddr := ⟨anonAddr, metaAddr⟩
     modifyGet fun stt => (maddr, { stt with
-      univAddrs := stt.univAddrs.insert lvl maddr
+      univCache := stt.univCache.insert lvl maddr
     })
   where
-    go : Ix.Level -> CompileM (Ixon × Ixon)
+    go : Lean.Level -> CompileM (Ixon × Ixon)
     | .zero => pure (.uzero, .meta default)
     | .succ x => do
-      let ⟨a, m⟩ <- dematerializeLevel x
+      let ⟨a, m⟩ <- compileLevel x
       pure (.usucc a, .meta ⟨[.link m]⟩)
     | .max x y => do
-      let ⟨xa, xm⟩ <- dematerializeLevel x
-      let ⟨ya, ym⟩ <- dematerializeLevel y
+      let ⟨xa, xm⟩ <- compileLevel x
+      let ⟨ya, ym⟩ <- compileLevel y
       pure (.umax xa ya, .meta ⟨[.link xm, .link ym]⟩)
     | .imax x y => do
-      let ⟨xa, xm⟩ <- dematerializeLevel x
-      let ⟨ya, ym⟩ <- dematerializeLevel y
+      let ⟨xa, xm⟩ <- compileLevel x
+      let ⟨ya, ym⟩ <- compileLevel y
       pure (.uimax xa ya, .meta ⟨[.link xm, .link ym]⟩)
-    | .param n i => do
-      let n' <- dematerializeName n
-      pure (.uvar i, .meta ⟨[.name n']⟩)
-
-/-- Canonicalizes a Lean universe level --/
-def compileLevel (lvl: Lean.Level): CompileM Ix.Level := do
-  match (<- get).univCache.find? lvl with
-  | some l => pure l
-  | none => do
-    --dbg_trace "compileLevel go {(<- get).univCache.size} {(<- read).current}"
-    let lvl' <- go lvl
-    --let _ <- dematerializeLevel lvl'
-    modifyGet fun stt => (lvl', { stt with
-      univCache := stt.univCache.insert lvl lvl'
-    })
-  where
-    go : Lean.Level -> CompileM Ix.Level
-    | .zero => pure .zero
-    | .succ u => return .succ (← compileLevel u)
-    | .max a b  => return .max (← compileLevel a) (← compileLevel b)
-    | .imax a b => return .imax (← compileLevel a) (← compileLevel b)
-    | .param name => do
+    | .param n => do
       let lvls := (← read).univCtx
-      match lvls.idxOf? name with
-      | some n => pure $ .param name n
-      | none   => throw $ .levelNotFound name lvls s!"compileLevel"
+      match lvls.idxOf? n with
+      | some i => pure (.uvar i, .meta ⟨[.link (<- compileName n)]⟩)
+      | none   => throw $ .levelNotFound n lvls s!"compileLevel"
     | l@(.mvar ..) => throw $ .levelMetavariable l
 
-def dematerializeExpr (expr: Ix.Expr): CompileM MetaAddress := do
-  match (<- get).exprAddrs.find? expr with
-  | some x => pure x
-  | none => do
-    --dbg_trace "dematerializeExpr go {(<- get).exprAddrs.size} {(<- read).current}"
-    let (anon, meta) <- go expr
-    --dbg_trace "dematerializeExpr store {(<- get).exprAddrs.size} {(<- read).current}"
-    let anonAddr <- storeIxon anon
-    let metaAddr <- storeIxon meta
-    let maddr := ⟨anonAddr, metaAddr⟩
-    modifyGet fun stt => (maddr, { stt with
-      exprAddrs := stt.exprAddrs.insert expr maddr
-    })
-  where
-    go : Ix.Expr -> CompileM (Ixon × Ixon)
-    | .var md idx => do
-      --dbg_trace "dematExpr var {(<- get).exprAddrs.size} {(<- read).current}"
-      pure (.evar idx, .meta ⟨[.link md]⟩)
-    | .sort md univ => do
-      --dbg_trace "dematExpr sort {(<- get).exprAddrs.size} {(<- read).current}"
-      let ⟨udata, umeta⟩ <- dematerializeLevel univ
-      let data := .esort udata
-      let meta := .meta ⟨[.link md, .link umeta]⟩
-      pure (data, meta)
-    | .const md name ref univs => do
-      --dbg_trace "dematExpr const {(<- get).exprAddrs.size} {(<- read).current}"
-      let n <- dematerializeName name
-      let us <- univs.mapM dematerializeLevel
-      let data := .eref ref.data (us.map (·.data))
-      let meta := .meta ⟨[.link md, .name n, .link ref.meta] ++ us.map (.name ·.meta)⟩
-      pure (data, meta)
-    | .rec_ md name idx univs => do
-      --dbg_trace "dematExpr rec {(<- get).exprAddrs.size} {(<- read).current}"
-      let n <- dematerializeName name
-      let us <- univs.mapM dematerializeLevel
-      let data := .erec idx (us.map (·.data))
-      let meta := .meta ⟨[.link md, .name n] ++ us.map (.name ·.meta)⟩
-      pure (data, meta)
-    | .app md func argm => do
-      --dbg_trace "dematExpr app {(<- get).exprAddrs.size} {(<- read).current}"
-      let f' <- dematerializeExpr func
-      let a' <- dematerializeExpr argm
-      let data := .eapp f'.data a'.data
-      let meta := .meta ⟨[.link md, .link f'.meta, .link a'.meta]⟩
-      pure (data, meta)
-    | .lam md name info type body => do
-      --dbg_trace "dematExpr lam {(<- get).exprAddrs.size} {(<- read).current}"
-      let n <- dematerializeName name
-      let t' <- dematerializeExpr type
-      let b' <- dematerializeExpr body
-      let data := .elam t'.data b'.data
-      let meta := .meta ⟨[.link md, .name n, .info info, .link t'.meta, .link b'.meta]⟩
-      pure (data, meta)
-    | .pi md name info type body => do
-      --dbg_trace "dematExpr pi {(<- get).exprAddrs.size} {(<- read).current}"
-      let n <- dematerializeName name
-      let t' <- dematerializeExpr type
-      let b' <- dematerializeExpr body
-      let data := .eall t'.data b'.data
-      let meta := .meta ⟨[.link md, .name n, .info info, .link t'.meta, .link b'.meta]⟩
-      pure (data, meta)
-    | .letE md name type value body nD => do
-      --dbg_trace "dematExpr letE {(<- get).exprAddrs.size} {(<- read).current}"
-      let n <- dematerializeName name
-      let t' <- dematerializeExpr type
-      let v' <- dematerializeExpr value
-      let b' <- dematerializeExpr body
-      let data := .elet nD t'.data v'.data b'.data
-      let meta := .meta ⟨[.link md, .name n, .link t'.meta, .link v'.meta, .link b'.meta]⟩
-      pure (data, meta)
-    | .lit md (.natVal n) => do pure (.enat (<- storeNat n), .meta ⟨[.link md]⟩)
-    | .lit md (.strVal s) => do pure (.estr (<- storeString s), .meta ⟨[.link md]⟩)
-    | .proj md typeName type idx struct => do
-      --dbg_trace "dematExpr proj {(<- get).exprAddrs.size} {(<- read).current}"
-      let n <- dematerializeName typeName
-      let s' <- dematerializeExpr struct
-      let data := .eprj type.data idx s'.data
-      let meta := .meta ⟨[.link md, .name n, .link type.meta, .link s'.meta]⟩
-      pure (data, meta)
-
-def dematerializeConst (const: Ix.Const): CompileM MetaAddress := do
-  match (<- get).constAddrs.find? const with
-  | some x => pure x
-  | none => do
-    let (anon, meta) <- go const
-    let anonAddr <- storeIxon anon
-    let metaAddr <- storeIxon meta
-    let maddr := ⟨anonAddr, metaAddr⟩
-    dbg_trace "dematerializeConst exprAddrs {(<- get).exprAddrs.size} {(<- read).current}"
-    dbg_trace "dematerializeConst constAddrs {(<- get).constAddrs.size} {(<- read).current}"
-    modifyGet fun stt => (maddr, { stt with
-      constAddrs := stt.constAddrs.insert const maddr
-    })
-  where
-    goDef : Ix.Definition -> CompileM (Ixon.Definition × Ixon.Metadata)
-    | ⟨name, lvls, type, kind, value, hints, safety, all⟩ => do
-      let n <- dematerializeName name
-      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
-      let t <- dematerializeExpr type
-      let v <- dematerializeExpr value
-      let as <- storeMetadata ⟨<- all.mapM (.name <$> dematerializeName ·)⟩
-      let data := ⟨kind, safety, lvls.length, t.data, v.data⟩
-      let meta := ⟨[.name n, .link ls, .hints hints, .link t.meta, .link v.meta, .link as]⟩
-      pure (data, meta)
-    goCtor : Ix.Constructor -> CompileM (Ixon.Constructor × Ixon.Metadata)
-    | ⟨name, lvls, type, cidx, params, fields, usafe⟩ => do
-      let n <- dematerializeName name
-      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
-      let t <- dematerializeExpr type
-      let ctor := ⟨usafe, lvls.length, cidx, params, fields, t.data⟩
-      let meta := ⟨[.name n, .link ls, .link t.meta]⟩
-      pure (ctor, meta)
-    goRecrRule : Ix.RecursorRule -> CompileM (Ixon.RecursorRule × Ixon.Metadata)
-    | ⟨ctor, fields, rhs⟩ => do
-      let c <- dematerializeName ctor
-      let x <- dematerializeExpr rhs
-      let rule := ⟨fields, x.data⟩
-      let meta := ⟨[.name c, .link x.meta]⟩
-      pure (rule, meta)
-    goRecr : Ix.Recursor -> CompileM (Ixon.Recursor × Ixon.Metadata)
-    | ⟨name, lvls, type, params, indices, motives, minors, rules, k, usafe⟩ => do
-      let n <- dematerializeName name
-      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
-      let t <- dematerializeExpr type
-      let rules <- rules.mapM goRecrRule
-      let rulesData := rules.map (·.1)
-      let rulesMeta <- storeMetadata ⟨<- rules.mapM (.link <$> storeMetadata ·.2)⟩
-      let recr := ⟨k, usafe, lvls.length, params, indices, motives, minors, t.data, rulesData⟩
-      let meta := ⟨[.name n, .link ls, .link t.meta, .link rulesMeta]⟩
-      pure (recr, meta)
-    goInd : Ix.Inductive -> CompileM (Ixon.Inductive × Ixon.Metadata)
-    | ⟨name, lvls, type, params, indices, all, ctors, recrs, nested, recr, refl, usafe⟩ => do
-      let n <- dematerializeName name
-      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
-      let t <- dematerializeExpr type
-      let cs <- ctors.mapM goCtor
-      let ctorsData := cs.map (·.1)
-      let ctorsMeta <- storeMetadata ⟨<- cs.mapM (.link <$> storeMetadata ·.2)⟩
-      let rs <- recrs.mapM goRecr
-      let recrsData := rs.map (·.1)
-      let recrsMeta <- storeMetadata ⟨<- rs.mapM (.link <$> storeMetadata ·.2)⟩
-      let as <- storeMetadata ⟨<- all.mapM (.name <$> dematerializeName ·)⟩
-      let data := ⟨recr, refl, usafe, lvls.length, params, indices, nested, t.data, ctorsData, recrsData⟩
-      let meta := ⟨[.name n, .link ls, .link t.meta, .link as, .link ctorsMeta, .link recrsMeta]⟩
-      pure (data, meta)
-    go : Ix.Const -> CompileM (Ixon × Ixon)
-    | .axiom ⟨name, lvls, type, isUnsafe⟩ => do
-      let n <- dematerializeName name
-      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
-      let t <- dematerializeExpr type
-      let data := .axio ⟨isUnsafe, lvls.length, t.data⟩
-      let meta := .meta ⟨[.name n, .link ls]⟩
-      pure (data, meta)
-    | .quotient ⟨name, lvls, type, kind⟩ => do
-      let n <- dematerializeName name
-      let ls <- storeMetadata ⟨<- lvls.mapM (.name <$> dematerializeName ·)⟩
-      let t <- dematerializeExpr type
-      let data := .quot ⟨kind, lvls.length, t.data⟩
-      let meta := .meta ⟨[.name n, .link ls, .link t.meta]⟩
-      pure (data, meta)
-    | .definition d => (fun (d, m) => (.defn d, .meta m)) <$> goDef d
-    | .inductiveProj ⟨name, block, idx⟩ => do
-      let n <- dematerializeName name
-      let data := .iprj ⟨idx, block.data⟩
-      let meta := .meta ⟨[.name n, .link block.meta]⟩
-      pure (data, meta)
-    | .constructorProj ⟨name, block, idx, induct, cidx⟩ => do
-      let n <- dematerializeName name
-      let ind <- dematerializeName induct
-      let data := .cprj ⟨idx, cidx, block.data⟩
-      let meta := .meta ⟨[.name n, .link block.meta, .name ind]⟩
-      pure (data, meta)
-    | .recursorProj ⟨name, block, idx, induct, ridx⟩ => do
-      let n <- dematerializeName name
-      let ind <- dematerializeName induct
-      let data := .rprj ⟨idx, ridx, block.data⟩
-      let meta := .meta ⟨[.name n, .link block.meta, .name ind]⟩
-      pure (data, meta)
-    | .definitionProj ⟨name, block, idx⟩ => do
-      let n <- dematerializeName name
-      let data := .dprj ⟨idx, block.data⟩
-      let meta := .meta ⟨[.name n, .link block.meta]⟩
-      pure (data, meta)
-    | .mutual block => do
-      let mut data := #[]
-      let mut meta := #[]
-      -- iterate through each equivalence class
-      for defsClass in block.defs do
-        let mut classData := #[]
-        let mut classMeta := #[]
-        -- dematerialize each def in a class
-        for defn in defsClass do
-          let (defn', meta') <- goDef defn
-          classData := classData.push defn'
-          -- build up the class metadata as a list of links to the def metadata
-          classMeta := classMeta.push (.link (<- storeMetadata meta'))
-        -- make sure we have no empty classes and all defs in a class are equal
-        match classData.toList with
-          | [] => throw (.dematBadMutualBlock block)
-          | [x] => data := data.push x
-          | x::xs =>
-            if xs.foldr (fun y acc => (y == x) && acc) true
-            then data := data.push x
-            else throw (.dematBadMutualBlock block)
-        -- build up the block metadata as a list of links to the class metadata
-        meta := meta.push (.link (<- storeMetadata ⟨classMeta.toList⟩))
-      pure (.defs data.toList, .meta ⟨meta.toList⟩)
-    | .inductive block => do
-      let mut data := #[]
-      let mut meta := #[]
-      -- iterate through each equivalence class
-      for indsClass in block.inds do
-        let mut classData := #[]
-        let mut classMeta := #[]
-        -- dematerialize each inductive in a class
-        for indc in indsClass do
-          let (indc', meta') <- goInd indc
-          classData := classData.push indc'
-          -- build up the class metadata as a list of links to the indc metadata
-          classMeta := classMeta.push (.link (<- storeMetadata meta'))
-        -- make sure we have no empty classes and all defs in a class are equal
-        match classData.toList with
-          | [] => throw (.dematBadInductiveBlock block)
-          | [x] => data := data.push x
-          | x::xs =>
-            if xs.foldr (fun y acc => (y == x) && acc) true
-            then data := data.push x
-            else throw (.dematBadInductiveBlock block)
-        -- build up the block metadata as a list of links to the class metadata
-        meta := meta.push (.link (<- storeMetadata ⟨classMeta.toList⟩))
-      pure (.inds data.toList, .meta ⟨meta.toList⟩)
-
-def dematerializeSubstring : Substring -> CompileM Ixon.Substring
+def compileSubstring : Substring -> CompileM Ixon.Substring
 | ⟨str, startPos, stopPos⟩ => do
     pure ⟨<- storeString str, startPos.byteIdx, stopPos.byteIdx⟩
 
-def dematerializeSourceInfo : Lean.SourceInfo -> CompileM Ixon.SourceInfo
+def compileSourceInfo : Lean.SourceInfo -> CompileM Ixon.SourceInfo
 | .original l p t e => do
-  let l' <- dematerializeSubstring l
-  let t' <- dematerializeSubstring t
+  let l' <- compileSubstring l
+  let t' <- compileSubstring t
   pure <| .original l' p.byteIdx t' e.byteIdx
 | .synthetic p e c => pure (.synthetic p.byteIdx e.byteIdx c)
 | .none => pure .none
 
-def dematerializePreresolved : Lean.Syntax.Preresolved -> CompileM Ixon.Preresolved
-| .namespace ns => .namespace <$> dematerializeName ns
-| .decl n fs => .decl <$> dematerializeName n <*> fs.mapM storeString
+def compilePreresolved : Lean.Syntax.Preresolved -> CompileM Ixon.Preresolved
+| .namespace ns => .namespace <$> compileName ns
+| .decl n fs => .decl <$> compileName n <*> fs.mapM storeString
 
-partial def dematerializeSyntax (syn: Lean.Syntax) : CompileM Ixon.Syntax := do
-  dbg_trace "dematerializeSyntax {(<- read).current}"
+partial def compileSyntax (syn: Lean.Syntax) : CompileM Ixon.Syntax := do
+  dbg_trace "compileSyntax {(<- read).current}"
   match (<- get).synCache.find? syn with
   | some x => pure x
   | none => do
@@ -542,37 +291,37 @@ partial def dematerializeSyntax (syn: Lean.Syntax) : CompileM Ixon.Syntax := do
     go : Lean.Syntax -> CompileM Ixon.Syntax
     | .missing => pure .missing
     | .node info kind args => do
-      let info' <- dematerializeSourceInfo info
-      let kind' <- dematerializeName kind
-      let args' <- args.toList.mapM (dematerializeSyntax · >>= storeSerial)
+      let info' <- compileSourceInfo info
+      let kind' <- compileName kind
+      let args' <- args.toList.mapM (compileSyntax · >>= storeSerial)
       pure <| .node info' kind' args'
     | .atom info val => do
-      let info' <- dematerializeSourceInfo info 
+      let info' <- compileSourceInfo info 
       let val' <- storeString val
       pure <| .atom info' val'
     | .ident info rawVal val preresolved => do
-      let info' <- dematerializeSourceInfo info
-      let rawVal' <- dematerializeSubstring rawVal
-      let val' <- dematerializeName val
-      let ps' <- preresolved.mapM dematerializePreresolved
+      let info' <- compileSourceInfo info
+      let rawVal' <- compileSubstring rawVal
+      let val' <- compileName val
+      let ps' <- preresolved.mapM compilePreresolved
       pure <| .ident info' rawVal' val' ps'
 
-def dematerializeDataValue : Lean.DataValue -> CompileM Ixon.DataValue
+def compileDataValue : Lean.DataValue -> CompileM Ixon.DataValue
 | .ofString s => .ofString <$> storeString s
 | .ofBool b => pure (.ofBool b)
-| .ofName n => .ofName <$> dematerializeName n
+| .ofName n => .ofName <$> compileName n
 | .ofNat i => .ofName <$> storeNat i
 | .ofInt i => .ofInt <$> storeSerial i
-| .ofSyntax s => .ofSyntax <$> (dematerializeSyntax s >>= storeSerial)
+| .ofSyntax s => .ofSyntax <$> (compileSyntax s >>= storeSerial)
 
-def dematerializeKVMaps (maps: List Lean.KVMap): CompileM Address := do
+def compileKVMaps (maps: List Lean.KVMap): CompileM Address := do
   storeIxon (.meta ⟨<- maps.mapM go⟩)
   where
     go (map: Lean.KVMap): CompileM Metadatum := do
     let mut list := #[]
     for (name, dataValue) in map do
-      let n <- dematerializeName name
-      let d <- dematerializeDataValue dataValue
+      let n <- compileName name
+      let d <- compileDataValue dataValue
       list := list.push (n, d)
     pure <| .kvmap list.toList
 
@@ -590,157 +339,282 @@ def isInternalRec (expr : Lean.Expr) (name : Lean.Name) : Bool :=
   | .const n .. => n == name
   | _ => false
 
-
 mutual
 
-partial def compileExpr (kvs: List Lean.KVMap) (expr: Lean.Expr): CompileM Ix.Expr := do
-  match (<- get).exprCache.find? expr with
-  | some x => pure x
-  | none => do
-    --dbg_trace "compileExpr go {(<- get).exprCache.size} {(<- read).current}"
-    let expr' <- go expr
-    --let _ <- dematerializeExpr expr'
-    --dbg_trace "compileExpr exprCache {(<- get).exprCache.size} {(<- read).current}"
-    modifyGet fun stt => (expr', { stt with
-      exprCache := stt.exprCache.insert expr expr'
-    })
+partial def compileExpr: Lean.Expr -> CompileM MetaAddress 
+| expr => outer [] expr
   where
-    kv := dematerializeKVMaps kvs
-    go : Lean.Expr -> CompileM Ix.Expr
-    | (.mdata kv x) => do
-      --dbg_trace "compileExpr mdata {(<- read).current}"
-      compileExpr (kv::kvs) x
-    | .bvar idx => do 
-      --dbg_trace "compileExpr bvar {(<- read).current}"
-      match (← read).bindCtx[idx]? with
-      -- Bound variables must be in the bind context
-      | some _ => return .var (<- kv) idx
-      | none => throw $ .invalidBVarIndex idx
-    | .sort lvl => .sort <$> kv <*> compileLevel lvl
+    outer (kvs: List Lean.KVMap) (expr: Lean.Expr): CompileM MetaAddress := do
+      match (<- get).exprCache.find? expr with
+      | some x => pure x
+      | none => do
+        let (anon, meta) <- go kvs expr
+        let anonAddr <- storeIxon anon
+        let metaAddr <- storeIxon meta
+        let maddr := ⟨anonAddr, metaAddr⟩
+        modifyGet fun stt => (maddr, { stt with
+          exprCache := stt.exprCache.insert expr maddr
+        })
+    go (kvs: List Lean.KVMap): Lean.Expr -> CompileM (Ixon × Ixon)
+    | (.mdata kv x) => go (kv::kvs) x
+    | .bvar idx => do
+      let md <- compileKVMaps kvs
+      let data := .evar idx
+      let sort := .meta ⟨[.link md]⟩
+      pure (data, sort)
+    | .sort univ => do
+      let md <- compileKVMaps kvs
+      let ⟨udata, umeta⟩ <- compileLevel univ
+      let data := .esort udata
+      let meta := .meta ⟨[.link md, .link umeta]⟩
+      pure (data, meta)
     | .const name lvls => do
-      --dbg_trace "compileExpr const {name} {(<- read).current}"
-      let univs ← lvls.mapM compileLevel
+      let md <- compileKVMaps kvs
+      let n <- compileName name
+      let us <- lvls.mapM compileLevel
       match (← read).mutCtx.find? name with
-      | some i => return .rec_ (<- kv) name i univs
-      | none => match (<- get).comms.find? name with
-        | some addr => return .const (<- kv) name addr univs
-        | none => do
-          let addr <- findLeanConst name >>= compileConst >>= dematerializeConst
-          return .const (<- kv) name addr univs
-    | .app fnc arg => do
-      --dbg_trace "compileExpr app {(<- read).current}"
-      .app <$> kv <*> compileExpr [] fnc <*> compileExpr [] arg
-    | .lam name typ bod info => do
-      --dbg_trace "compileExpr lam {(<- read).current}"
-      let t <- compileExpr [] typ
-      let b <- withBinder name <| compileExpr [] bod
-      return .lam (<- kv) name info t b
-    | .forallE name dom img info => do
-      --dbg_trace "compileExpr all {(<- read).current}"
-      let d <- compileExpr [] dom
-      let i <- withBinder name <| compileExpr [] img
-      return .pi (<- kv) name info d i
-    | .letE name typ val bod nD => do
-      --dbg_trace "compileExpr let {(<- read).current}"
-      let t <- compileExpr [] typ
-      let v <- compileExpr [] val
-      let b <- withBinder name <| compileExpr [] bod
-      return .letE (<- kv) name t v b nD
-    | .lit lit => return .lit (<- kv) lit
-    | .proj name idx exp => do
-      --dbg_trace "compileExpr proj {(<- read).current}"
-      let addr <- findLeanConst name >>= compileConst >>= dematerializeConst
-      return .proj (<- kv) name addr idx (<- compileExpr [] exp)
+      | some idx => 
+        let data := .erec idx (us.map (·.data))
+        let meta := .meta ⟨[.link md, .link n, .links (us.map (·.meta))]⟩
+        pure (data, meta)
+      | none => do
+        let ref <- match (<- get).comms.find? name with
+          | some comm => pure comm
+          | none => findLeanConst name >>= compileConst
+        let data := .eref ref.data (us.map (·.data))
+        let meta := .meta ⟨[.link md, .link n, .link ref.meta, .links (us.map (·.meta))]⟩
+        pure (data, meta)
+    | .app func argm => do
+      let md <- compileKVMaps kvs
+      let f <- compileExpr func
+      let a <- compileExpr argm
+      let data := .eapp f.data a.data
+      let meta := .meta ⟨[.link md, .link f.meta, .link a.meta]⟩
+      pure (data, meta)
+    | .lam name type body info => do
+      let md <- compileKVMaps kvs
+      let n <- compileName name
+      let t <- compileExpr type
+      let b <- compileExpr body
+      let data := .elam t.data b.data
+      let meta := .meta ⟨[.link md, .link n, .info info, .link t.meta, .link b.meta]⟩
+      pure (data, meta)
+    | .forallE name type body info => do
+      let md <- compileKVMaps kvs
+      let n <- compileName name
+      let t <- compileExpr type
+      let b <- compileExpr body
+      let data := .eall t.data b.data
+      let meta := .meta ⟨[.link md, .link n, .info info, .link t.meta, .link b.meta]⟩
+      pure (data, meta)
+    | .letE name type value body nD => do
+      let md <- compileKVMaps kvs
+      let n <- compileName name
+      let t <- compileExpr type
+      let v <- compileExpr value
+      let b <- compileExpr body
+      let data := .elet nD t.data v.data b.data
+      let meta := .meta ⟨[.link md, .link n, .link t.meta, .link v.meta, .link b.meta]⟩
+      pure (data, meta)
+    | .lit (.natVal n) => do
+      let md <- compileKVMaps kvs
+      pure (.enat (<- storeNat n), .meta ⟨[.link md]⟩)
+    | .lit (.strVal s) => do
+      let md <- compileKVMaps kvs
+      pure (.estr (<- storeString s), .meta ⟨[.link md]⟩)
+    | .proj typeName idx struct => do
+      let md <- compileKVMaps kvs
+      let t <- match (<- get).comms.find? typeName with
+        | some comm => pure comm
+        | none => findLeanConst typeName >>= compileConst
+      let n <- compileName typeName
+      let s <- compileExpr struct
+      let data := .eprj t.data idx s.data
+      let meta := .meta ⟨[.link md, .link n, .link t.meta, .link s.meta]⟩
+      pure (data, meta)
     | expr@(.fvar ..)  => throw $ .exprFreeVariable expr
     | expr@(.mvar ..)  => throw $ .exprMetavariable expr
 
-partial def compileConst (const : Lean.ConstantInfo) : CompileM Ix.Const := do
-  match (<- get).constCache.find? const with
+partial def compileConst (const: Lean.ConstantInfo): CompileM MetaAddress := do
+  match (<- get).constCache.find? const.name with
   | some x => pure x
   | none => resetCtx const.name <| do
-    let const' <- go const
-    let addr <- dematerializeConst const'
+    let (anon, meta) <- go const
     let stt <- get
     dbg_trace "✓ compileConst {const.name}"
     dbg_trace "store {stt.store.size}"
-    dbg_trace "constNames {stt.constNames.size}"
     dbg_trace "constCache {stt.constCache.size}"
     dbg_trace "exprCache {stt.exprCache.size}"
     dbg_trace "nameCache {stt.nameCache.size}"
     dbg_trace "synCache {stt.synCache.size}"
     dbg_trace "strCache {stt.strCache.size}"
     dbg_trace "univCache {stt.univCache.size}"
-    modifyGet fun stt => (const', { stt with
-      constNames := stt.constNames.insert const.name addr
-      constCache := stt.constCache.insert const const'
+    let maddr := ⟨<- storeIxon anon, <- storeIxon meta⟩
+    modifyGet fun stt => (maddr, { stt with
+      constCache := stt.constCache.insert const.name maddr
     })
   where
-    go : Lean.ConstantInfo -> CompileM Ix.Const
-    | .defnInfo val => compileDefinition (mkPreDef val)
-    | .thmInfo val => compileDefinition (mkPreTheorem val)
-    | .opaqueInfo val => compileDefinition (mkPreOpaque val)
-    | .inductInfo val => compileInductive val
-    -- compile constructors through their parent inductive
+    go : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
+    | .defnInfo val => compilePreDef (mkPreDef val)
+    | .thmInfo val => compilePreDef (mkPreTheorem val)
+    | .opaqueInfo val => compilePreDef (mkPreOpaque val)
+    | .inductInfo val => mkPreInd val >>= compilePreInd
     | .ctorInfo val => do match <- findLeanConst val.induct with
       | .inductInfo ind => do
-        let _ <- compileInductive ind
-        compileConst (.ctorInfo val)
-      | c => throw $ .invalidConstantKind c.name "inductive" c.ctorName
+        let _ <- mkPreInd ind >>= compilePreInd
+        match (<- get).constCache.find? const.name with
+        | some ⟨data, meta⟩ => do pure (<- getIxon data, <- getIxon meta)
+        | none => throw <| .compileInductiveBlockMissingProjection const.name
+      | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
     -- compile recursors through their parent inductive
     | .recInfo val => do
       match ← findLeanConst val.getMajorInduct with
       | .inductInfo ind => do
-        let _ <- compileInductive ind
-        compileConst (.recInfo val)
+        let _ <- mkPreInd ind >>= compilePreInd
+        match (<- get).constCache.find? const.name with
+        | some ⟨data, meta⟩ => do pure (<- getIxon data, <- getIxon meta)
+        | none => throw <| .compileInductiveBlockMissingProjection const.name
       | c => throw $ .invalidConstantKind c.name "inductive" c.ctorName
     | .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => withLevels lvls do
-      return .axiom ⟨name, lvls, <- compileExpr [] type, isUnsafe⟩
+      let n <- compileName name
+      let ls <- lvls.mapM compileName
+      let t <- compileExpr type
+      let data := .axio ⟨isUnsafe, lvls.length, t.data⟩
+      let meta := .meta ⟨[.link n, .links ls, .link t.meta]⟩
+      pure (data, meta)
     | .quotInfo ⟨⟨name, lvls, type⟩, kind⟩ => withLevels lvls do
-      return .quotient ⟨name, lvls, <- compileExpr [] type, kind⟩
-
-partial def preDefToIR (d: PreDef) : CompileM Ix.Definition :=
-  withLevels d.levelParams do
-    let typ <- compileExpr [] d.type
-    let val <- compileExpr [] d.value
-    return ⟨d.name, d.levelParams, typ, d.kind, val, d.hints, d.safety, d.all⟩
-
-partial def compileDefinition: PreDef -> CompileM Ix.Const
-| defn => do
-  -- single definition outside a mutual block
-  if defn.all matches [_] then
-    return .definition (<- withMutCtx (.single defn.name 0) <| preDefToIR defn)
+      let n <- compileName name
+      let ls <- lvls.mapM compileName
+      let t <- compileExpr type
+      let data := .quot ⟨kind, lvls.length, t.data⟩
+      let meta := .meta ⟨[.link n, .links ls, .link t.meta]⟩
+      pure (data, meta)
+
+partial def compileDef: PreDef -> CompileM (Ixon.Definition × Ixon.Metadata)
+| d => withLevels d.levelParams do
+  let n <- compileName d.name
+  let ls <- d.levelParams.mapM compileName
+  let t <- compileExpr d.type
+  let v <- compileExpr d.value
+  let as <- d.all.mapM compileName
+  let data := ⟨d.kind, d.safety, ls.length, t.data, v.data⟩
+  let meta := ⟨[.link n, .links ls, .hints d.hints, .link t.meta, .link v.meta, .links as]⟩
+  return (data, meta)
+
+partial def compileMutDefs: List (List PreDef) -> CompileM (Ixon × Ixon)
+| defs => do
+  let mut data := #[]
+  let mut meta := #[]
+  -- iterate through each equivalence class
+  for defsClass in defs do
+    let mut classData := #[]
+    let mut classMeta := #[]
+    -- dematerialize each def in a class
+    for defn in defsClass do
+      let (defn', meta') <- compileDef defn
+      classData := classData.push defn'
+      -- build up the class metadata as a list of links to the def metadata
+      classMeta := classMeta.push (.link (<- storeMeta meta'))
+    -- make sure we have no empty classes and all defs in a class are equal
+    match classData.toList with
+      | [] => throw (.badMutualBlock defs)
+      | [x] => data := data.push x
+      | x::xs =>
+        if xs.foldr (fun y acc => (y == x) && acc) true
+        then data := data.push x
+        else throw (.badMutualBlock defs)
+    -- build up the block metadata as a list of links to the class metadata
+    meta := meta.push (.link (<- storeMeta ⟨classMeta.toList⟩))
+  pure (.defs data.toList, .meta ⟨meta.toList⟩)
+
+partial def compilePreDef: PreDef -> CompileM (Ixon × Ixon)
+| d => do
+  if d.all matches [_] then do
+    let (data, meta) <- withMutCtx {(d.name,0)} <| compileDef d
+    pure (.defn data, .meta meta)
   else do
-  -- collecting and sorting all definitions in the mutual block
-  let mut defs : Array PreDef := #[]
-  for name in defn.all do
-    match <- findLeanConst name with
-    | .defnInfo x => defs := defs.push (mkPreDef x)
-    | .opaqueInfo x => defs := defs.push (mkPreOpaque x)
-    | .thmInfo x => defs := defs.push (mkPreTheorem x)
-    | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
-  let mutDefs <- sortDefs defs.toList
-  let mutCtx := defMutCtx mutDefs
-  let definitions ← withMutCtx mutCtx <| mutDefs.mapM (·.mapM preDefToIR)
-  -- add top-level mutual block to our state
-  let block ← dematerializeConst <| .mutual ⟨definitions⟩
-  modify fun stt => { stt with blocks := stt.blocks.insert block }
-  -- then add all the projections, returning the def we started with
-  let mut ret? : Option Ix.Const := none
-  for name in defn.all do
-    let idx <- do match mutCtx.find? name with
-    | some idx => pure idx
-    | none => throw $ .cantFindMutDefIndex name
-    let const <- findLeanConst name
-    let const' := .definitionProj ⟨name, block, idx⟩
-    let addr <- dematerializeConst const'
-    modify fun stt => { stt with
-      constNames := stt.constNames.insert name addr
-      constCache := stt.constCache.insert const const'
-    }
-    if name == defn.name then ret? := some const'
-  match ret? with
-  | some ret => return ret
-  | none => throw $ .compileMutualBlockMissingProjection defn.name
+    let mut predefs : Array PreDef := #[]
+    for name in d.all do
+      match <- findLeanConst name with
+      | .defnInfo x => predefs := predefs.push (mkPreDef x)
+      | .opaqueInfo x => predefs := predefs.push (mkPreOpaque x)
+      | .thmInfo x => predefs := predefs.push (mkPreTheorem x)
+      | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
+    let mutDefs <- sortDefs predefs.toList
+    let mutCtx := defMutCtx mutDefs
+    let (data, meta) <- withMutCtx mutCtx <| compileMutDefs mutDefs
+    -- add top-level mutual block to our state
+    let block := ⟨<- storeIxon data, <- storeIxon meta⟩
+    modify fun stt => { stt with blocks := stt.blocks.insert block () }
+    -- then add all the projections, returning the def we started with
+    let mut ret? : Option (Ixon × Ixon) := none
+    for name in d.all do
+      let idx <- do match mutCtx.find? name with
+      | some idx => pure idx
+      | none => throw $ .cantFindMutDefIndex name
+      let data := .dprj ⟨idx, block.data⟩
+      let meta := .meta ⟨[.link block.meta]⟩
+      let addr := ⟨<- storeIxon data, <- storeIxon meta⟩
+      modify fun stt => { stt with
+        constCache := stt.constCache.insert name addr
+      }
+      if name == d.name then ret? := some (data, meta)
+    match ret? with
+    | some ret => return ret
+    | none => throw $ .compileMutualBlockMissingProjection d.name
+
+/--
+`sortDefs` recursively sorts a list of mutually referential definitions into
+ordered equivalence classes. For most cases equivalence can be determined by
+syntactic differences in the definitions, but when two definitions
+refer to one another in the same syntactical position the classification can
+be self-referential. Therefore we use a partition refinement algorithm that
+starts by assuming that all definitions in the mutual block are equal and
+recursively improves our classification by sorting based on syntax:
+
+```
+classes₀ := [startDefs]
+classes₁ := sortDefs classes₀
+classes₂ := sortDefs classes₁
+classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
+```
+Eventually we reach a fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no
+further refinement is possible (trivially when each def is in its own class). --/
+partial def sortDefs (classes : List PreDef) : CompileM (List (List PreDef)) :=
+  go [List.sortBy (compare ·.name ·.name) classes]
+  where
+    go (cs: List (List PreDef)): CompileM (List (List PreDef)) := do
+      dbg_trace "sortDefs blocks {(<- get).blocks.size} {(<- read).current}"
+      let ctx := defMutCtx cs
+      let cs' <- cs.mapM fun ds =>
+        match ds with
+        | []  => throw <| .badMutualBlock cs
+        | [d] => pure [[d]]
+        | ds  => ds.sortByM (compareDef ctx) >>= List.groupByM (eqDef ctx)
+      let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
+      if cs == cs' then return cs' else go cs'
+
+/-- AST comparison of two Lean definitions. --/
+partial def compareDef (ctx: MutCtx) (x y: PreDef)
+  : CompileM Ordering := do
+  dbg_trace "compareDefs constCmp {(<- get).constCmp.size} {(<- read).current}"
+  let key := match compare x.name y.name with
+    | .lt => (x.name, y.name)
+    | _ => (y.name, x.name)
+  match (<- get).constCmp.find? key with
+  | some o => return o
+  | none => do
+    let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
+    if sorder.strong then modify fun stt => { stt with
+        constCmp := stt.constCmp.insert key sorder.ord
+      }
+    return sorder.ord
+
+partial def eqDef (ctx: MutCtx) (x y: PreDef) : CompileM Bool :=
+  (fun o => o == .eq) <$> compareDef ctx x y
 
 /-- A name-irrelevant ordering of Lean expressions --/
 partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
@@ -800,168 +674,105 @@ partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
     SOrder.cmpM (pure ⟨true, compare nx ny⟩) 
       (compareExpr ctx xlvls ylvls tx ty)
 
-/-- AST comparison of two Lean definitions. --/
-partial def compareDef (ctx: MutCtx) (x y: PreDef)
-  : CompileM Ordering := do
-  dbg_trace "compareDefs constCmp {(<- get).constCmp.size} {(<- read).current}"
-  let key := match compare x.name y.name with
-    | .lt => (x.name, y.name)
-    | _ => (y.name, x.name)
-  match (<- get).constCmp.find? key with
-  | some o => return o
-  | none => do
-    let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
-        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
-    if sorder.strong then modify fun stt => { stt with
-        constCmp := stt.constCmp.insert key sorder.ord
-      }
-    return sorder.ord
-
-partial def eqDef (ctx: MutCtx) (x y: PreDef) : CompileM Bool :=
-  (fun o => o == .eq) <$> compareDef ctx x y
-
-/--
-`sortDefs` recursively sorts a list of mutual definitions into equivalence classes.
-At each stage, we take as input the current best known equivalence
-classes (held in the `mutCtx` of the CompileEnv). For most cases, equivalence
-can be determined by syntactic differences which are invariant to the current
-best known classification. For example:
-
-```
-mutual
-  def : Nat := 1
-  def bar : Nat := 2
-end
-```
-
-are both different due to the different values in the definition. We call this a
-"strong" ordering, and comparisons between defintions that produce strong
-orderings are cached across compilation.
-
-However, there are also weak orderings, where the order of definitions in a
-mutual block depends on itself.
-
-```
-mutual
-  def A : Nat → Nat
-  | 0 => 0
-  | n + 1 => B n + C n + 1
-
-  def B : Nat → Nat
-  | 0 => 0
-  | n + 1 => C n + 1
-
-  def C : Nat → Nat
-  | 0 => 0
-  | n + 1 => A n + 1
-end
-```
-
-Here since any reference to A, B, C has to be compiled into an index, the
-ordering chosen for A, B, C will effect itself, since we compile into
-something that looks, with order [A, B, C] like:
-
-```
-mutual
-  def #1 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #2 n + #3 n + 1
-
-  def #2 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #3 n + 1
-
-  def #3 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #1 n + 1
-end
-```
-
-This is all well and good, but if we chose order `[C, B, A]` then the block
-would compile as
-
-```
-mutual
-  def #1 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #3 n + 1
-
-  def #2 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #1 n + 1
-
-  def #3 : Nat → Nat
-  | 0 => 0
-  | n + 1 => #2 n + #1 n + 1
-end
-```
-
-with completely different hashes. So we need to figure out a canonical order for
-such mutual blocks.
-
-We start by assuming that all definitions in a mutual block are equal and then
-recursively refining this assumption through successive sorting passes, similar
-to partition refinement:
-```
-classes₀ := [startDefs]
-classes₁ := sortDefs classes₀
-classes₂ := sortDefs classes₁
-classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
-```
-Initially, `startDefs` is simply the list of definitions we receive from
-`DefinitionVal.all`, sorted by name. We assume that at we will reach some
-fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no further refinement is
-possible (we have not rigourously proven such a fixed point exists, but
-it seams reasonable given that after the first pass to find the strongly ordered
-definitions, the algorithm should only separate partitions into smaller ones)
--/
-partial def sortDefs (classes : List PreDef) : CompileM (List (List PreDef)) :=
-  go [List.sortBy (compare ·.name ·.name) classes]
-  where
-    go (cs: List (List PreDef)): CompileM (List (List PreDef)) := do
-      dbg_trace "sortDefs blocks {(<- get).blocks.size} {(<- read).current}"
-      let ctx := defMutCtx cs
-      let cs' <- cs.mapM fun ds =>
-        match ds with
-        | []  => throw <| .emptyDefsClass cs
-        | [d] => pure [[d]]
-        | ds  => ds.sortByM (compareDef ctx) >>= List.groupByM (eqDef ctx)
-      let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
-      if cs == cs' then return cs' else go cs'
-
-partial def makePreInd (ind: Lean.InductiveVal) : CompileM Ix.PreInd := do
-  let ctors <- ind.ctors.mapM getCtor
+partial def mkPreInd (i: Lean.InductiveVal) : CompileM Ix.PreInd := do
+  let ctors <- i.ctors.mapM getCtor
   let recrs := (<- get).env.constants.fold getRecrs []
-  return ⟨ind.name, ind.levelParams, ind.type, ind.numParams, ind.numIndices,
-    ind.all, ctors, recrs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
+  return ⟨i.name, i.levelParams, i.type, i.numParams, i.numIndices, i.all,
+    ctors, recrs, i.numNested, i.isRec, i.isReflexive, i.isUnsafe⟩
   where
     getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
       match (<- findLeanConst name) with
       | .ctorInfo c => pure c
       | _ => throw <| .invalidConstantKind name "constructor" ""
-    getRecrs (acc: List Lean.RecursorVal) : Lean.Name -> Lean.ConstantInfo -> List Lean.RecursorVal
+    getRecrs (acc: List Lean.RecursorVal)
+    : Lean.Name -> Lean.ConstantInfo -> List Lean.RecursorVal
     | .str n .., .recInfo r
-    | .num n .., .recInfo r => if n == ind.name then r::acc else acc
+    | .num n .., .recInfo r => if n == i.name then r::acc else acc
     | _, _ => acc
 
-/--
-Content-addresses an inductive and all inductives in the mutual block as a
-mutual block, even if the inductive itself is not in a mutual block.
-
-Content-addressing an inductive involves content-addressing its associated
-constructors and recursors, hence the complexity of this function.
--/
-partial def compileInductive: Lean.InductiveVal -> CompileM Ix.Const
+partial def compileRule: Lean.RecursorRule -> CompileM (Ixon.RecursorRule × (Address × Address))
+| r => do
+  let n <- compileName r.ctor
+  let rhs <- compileExpr r.rhs
+  pure (⟨r.nfields, rhs.data⟩, (n, rhs.meta))
+
+partial def compileRecursor: Lean.RecursorVal -> CompileM (Ixon.Recursor × Address)
+| r => withLevels r.levelParams <| do
+  let n <- compileName r.name
+  let ls <- r.levelParams.mapM compileName
+  let t <- compileExpr r.type
+  let rules <- r.rules.mapM compileRule
+  let data := ⟨r.k, r.isUnsafe, ls.length, r.numParams, r.numIndices,
+    r.numMotives, r.numMinors, t.data, rules.map (·.1)⟩
+  let meta <- storeMeta ⟨[.link n, .links ls, .rules (rules.map (·.2))]⟩
+  pure (data, meta)
+
+partial def compileConstructor: Lean.ConstructorVal -> CompileM (Ixon.Constructor × Address)
+| c => withLevels c.levelParams <| do
+  let n <- compileName c.name
+  let ls <- c.levelParams.mapM compileName
+  let t <- compileExpr c.type
+  let data := ⟨c.isUnsafe, ls.length, c.cidx, c.numParams, c.numFields, t.data⟩
+  let meta <- storeMeta ⟨[.link n, .links ls, .link t.meta]⟩
+  pure (data, meta)
+
+partial def compileInd: PreInd -> CompileM (Ixon.Inductive × Ixon.Metadata)
+| ⟨name, lvls, type, ps, is, all, ctors, recrs, nest, rcr, refl, usafe⟩ =>
+  withLevels lvls do 
+  let n <- compileName name
+  let ls <- lvls.mapM compileName
+  let t <- compileExpr type
+  let rs <- recrs.mapM compileRecursor
+  let cs <- ctors.mapM compileConstructor
+  let as <- all.mapM compileName
+  let data := ⟨rcr, refl, usafe, ls.length, ps, is, nest, t.data,
+    cs.map (·.1), rs.map (·.1)⟩
+  let meta := ⟨[.link n, .links ls, .link t.meta,
+    .links (cs.map (·.2)), .links (rs.map (·.2)), .links as]⟩
+  pure (data, meta)
+
+partial def compileMutInds : List (List PreInd) -> CompileM (Ixon × Ixon)
+| inds => do
+  let mut data := #[]
+  let mut meta := #[]
+  -- iterate through each equivalence class
+  for indsClass in inds do
+    let mut classData := #[]
+    let mut classMeta := #[]
+    -- dematerialize each inductive in a class
+    for indc in indsClass do
+      let (indc', meta') <- compileInd indc
+      classData := classData.push indc'
+      -- build up the class metadata as a list of links to the indc metadata
+      classMeta := classMeta.push (.link (<- storeMeta meta'))
+    -- make sure we have no empty classes and all defs in a class are equal
+    match classData.toList with
+      | [] => throw (.badInductiveBlock inds)
+      | [x] => data := data.push x
+      | x::xs =>
+        if xs.foldr (fun y acc => (y == x) && acc) true
+        then data := data.push x
+        else throw (.badInductiveBlock inds)
+    -- build up the block metadata as a list of links to the class metadata
+    meta := meta.push (.link (<- storeMeta ⟨classMeta.toList⟩))
+  pure (.inds data.toList, .meta ⟨meta.toList⟩)
+
+--/--
+--Content-addresses an inductive and all inductives in the mutual block as a
+--mutual block, even if the inductive itself is not in a mutual block.
+--
+--Content-addressing an inductive involves content-addressing its associated
+--constructors and recursors, hence the complexity of this function.
+---/
+partial def compilePreInd: PreInd -> CompileM (Ixon × Ixon)
 | ind => do
   let mut preInds := #[]
-  let mut ctorNames : RBMap Lean.Name (List Lean.Name × List Lean.Name) compare := {}
+  let mut ctorNames : Map Lean.Name (List Lean.Name × List Lean.Name) := {}
   -- collect all mutual inductives as Ix.PreInds
   for n in ind.all do
     match <- findLeanConst n with
     | .inductInfo ind =>
-      let preInd <- makePreInd ind
+      let preInd <- mkPreInd ind
       preInds := preInds.push preInd
       ctorNames := ctorNames.insert n (ind.ctors, preInd.recrs.map (·.name))
     | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
@@ -969,100 +780,43 @@ partial def compileInductive: Lean.InductiveVal -> CompileM Ix.Const
   let mutInds <- sortInds preInds.toList
   let mutCtx := indMutCtx mutInds
   -- compile each preinductive with the mutCtx
-  let inds ← withMutCtx mutCtx <| mutInds.mapM (·.mapM preInductiveToIR)
+  let (data, meta) <- withMutCtx mutCtx <| compileMutInds mutInds
   -- add top-level mutual block to our state
-  let block <- dematerializeConst <| .inductive ⟨inds⟩
-  modify fun stt => { stt with blocks := stt.blocks.insert block }
+  let block := ⟨<- storeIxon data, <- storeIxon meta⟩
+  modify fun stt => { stt with blocks := stt.blocks.insert block () }
   -- then add all projections, returning the inductive we started with
-  let mut ret? : Option Ix.Const := none
+  let mut ret? : Option (Ixon × Ixon) := none
   for (name, idx) in ind.all.zipIdx do
-    let const <- findLeanConst name
-    let const' := .inductiveProj ⟨name, block, idx⟩
-    let addr <- dematerializeConst const'
+    let n <- compileName name
+    let data := .iprj ⟨idx, block.data⟩
+    let meta := .meta ⟨[.link n, .link block.meta]⟩
+    let addr := ⟨<- storeIxon data, <- storeIxon meta⟩
     modify fun stt => { stt with
-      constNames := stt.constNames.insert name addr
-      constCache := stt.constCache.insert const const'
+      constCache := stt.constCache.insert name addr
     }
-    if name == ind.name then ret? := some const'
+    if name == ind.name then ret? := some (data, meta)
     let some (ctors, recrs) := ctorNames.find? ind.name
       | throw $ .cantFindMutDefIndex ind.name
     for (cname, cidx) in ctors.zipIdx do
-      -- Store and cache constructor projections
-      let cconst <- findLeanConst cname
-      let cconst' := .constructorProj ⟨cname, block, idx, name, cidx⟩
-      let caddr <- dematerializeConst cconst'
+      let cn <- compileName cname
+      let cdata := .cprj ⟨idx, cidx, block.data⟩
+      let cmeta := .meta ⟨[.link cn, .link block.meta]⟩
+      let caddr := ⟨<- storeIxon cdata, <- storeIxon cmeta⟩
       modify fun stt => { stt with
-        constNames := stt.constNames.insert cname caddr
-        constCache := stt.constCache.insert cconst cconst'
+        constCache := stt.constCache.insert cname caddr
       }
     for (rname, ridx) in recrs.zipIdx do
-      -- Store and cache recursor projections
-      let rconst <- findLeanConst rname
-      let rconst' := .recursorProj ⟨rname, block, idx, name, ridx⟩
-      let raddr <- dematerializeConst rconst'
+      let rn <- compileName rname
+      let rdata := .rprj ⟨idx, ridx, block.data⟩
+      let rmeta := .meta ⟨[.link rn, .link block.meta]⟩
+      let raddr := ⟨<- storeIxon rdata, <- storeIxon rmeta⟩
       modify fun stt => { stt with
-        constNames := stt.constNames.insert rname raddr
-        constCache := stt.constCache.insert rconst rconst'
+        constCache := stt.constCache.insert rname raddr
       }
   match ret? with
   | some ret => return ret
   | none => throw $ .compileInductiveBlockMissingProjection ind.name
 
-partial def preInductiveToIR (ind : Ix.PreInd) : CompileM Ix.Inductive 
-  := withLevels ind.levelParams $ do
-  let (recs, ctors) := <- ind.recrs.foldrM (init := ([], [])) collectRecsCtors
-  let type <- compileExpr [] ind.type
-    -- NOTE: for the purpose of extraction, the order of `ctors` and `recs` MUST
-    -- match the order used in `mutCtx`
-  return ⟨ind.name, ind.levelParams, type, ind.numParams, ind.numIndices,
-    ind.all, ctors, recs, ind.numNested, ind.isRec, ind.isReflexive, ind.isUnsafe⟩
-  where
-    collectRecsCtors : Lean.RecursorVal -> List Recursor × List Constructor
-    -> CompileM (List Recursor × List Constructor)
-    | r, (recs, ctors) =>
-      if isInternalRec r.type ind.name then do
-        let (thisRec, thisCtors) <- internalRecToIR (ind.ctors.map (·.name)) r
-        pure (thisRec :: recs, thisCtors)
-      else do
-        let thisRec ← externalRecToIR r
-        pure (thisRec :: recs, ctors)
-
-partial def internalRecToIR (ctors : List Lean.Name) (recr: Lean.RecursorVal)
-  : CompileM (Ix.Recursor × List Ix.Constructor) 
-  := withLevels recr.levelParams do
-    let typ ← compileExpr [] recr.type
-    let (retCtors, retRules) ← recr.rules.foldrM (init := ([], []))
-      fun r (retCtors, retRules) => do
-        if ctors.contains r.ctor then
-          let (ctor, rule) ← recRuleToIR r
-          pure $ (ctor :: retCtors, rule :: retRules)
-        else pure (retCtors, retRules) -- this is an external recursor rule
-    let recr := ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
-      recr.numMotives, recr.numMinors, retRules, recr.k, recr.isUnsafe⟩
-    return (recr, retCtors)
-
-partial def externalRecToIR: Lean.RecursorVal -> CompileM Recursor
-| recr => withLevels recr.levelParams do
-    let typ ← compileExpr [] recr.type
-    let rules ← recr.rules.mapM externalRecRuleToIR
-    return ⟨recr.name, recr.levelParams, typ, recr.numParams, recr.numIndices,
-      recr.numMotives, recr.numMinors, rules, recr.k, recr.isUnsafe⟩
-
-partial def recRuleToIR: Lean.RecursorRule -> CompileM (Ix.Constructor × Ix.RecursorRule)
-| rule => do
-  let rhs ← compileExpr [] rule.rhs
-  match ← findLeanConst rule.ctor with
-  | .ctorInfo ctor => withLevels ctor.levelParams do
-    let typ ← compileExpr [] ctor.type
-    let ctor := ⟨ctor.name, ctor.levelParams, typ, ctor.cidx,
-      ctor.numParams, ctor.numFields, ctor.isUnsafe⟩
-    pure (ctor, ⟨rule.ctor, rule.nfields, rhs⟩)
-  | const =>
-    throw $ .invalidConstantKind const.name "constructor" const.ctorName
-
-partial def externalRecRuleToIR: Lean.RecursorRule -> CompileM RecursorRule
-| rule => do return ⟨rule.ctor, rule.nfields, <- compileExpr [] rule.rhs⟩
-
 /-- AST comparison of two Lean inductives. --/
 partial def compareInd (ctx: MutCtx) (x y: PreInd) 
   : CompileM Ordering := do
@@ -1142,7 +896,7 @@ partial def sortInds (classes : List PreInd) : CompileM (List (List PreInd)) :=
       let ctx := indMutCtx cs
       let cs' <- cs.mapM fun ds =>
         match ds with
-        | []  => throw <| .emptyIndsClass cs
+        | []  => throw <| .badInductiveBlock cs
         | [d] => pure [[d]]
         | ds  => ds.sortByM (compareInd ctx) >>= List.groupByM (eqInd ctx)
       let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
@@ -1168,13 +922,13 @@ partial def tryAddLeanDef (defn: Lean.DefinitionVal) : CompileM Unit := do
     | .error e => throw $ .kernelException e
 
 partial def addDef (lvls: List Lean.Name) (typ val: Lean.Expr) : CompileM MetaAddress := do
-  let typ' <- compileExpr [] typ
-  let val' <- compileExpr [] val
-  let anon := .definition ⟨.anonymous, lvls, typ', .definition, val', .opaque, .safe, []⟩
-  let anonAddr <- dematerializeConst anon
+  --let typ' <- compileExpr typ
+  --let val' <- compileExpr val
+  let anon := .defnInfo ⟨⟨.anonymous, lvls, typ⟩, val, .opaque, .safe, []⟩
+  let anonAddr <- compileConst anon
   let name := anonAddr.data.toUniqueName
-  let const := .definition ⟨name, lvls, typ', .definition, val', .opaque, .safe, []⟩
-  let addr <- dematerializeConst const
+  let const := .defnInfo ⟨⟨name, lvls, typ⟩, val, .opaque, .safe, []⟩
+  let addr <- compileConst const
   if addr.data != anonAddr.data then
     throw <| .alphaInvarianceFailure anon anonAddr const addr
   else
@@ -1210,43 +964,43 @@ partial def storeLevel (lvls: Nat) (secret: Option Address): CompileM Address :=
     }
     return commAddr
   | none => return addr
-
---partial def checkClaim
---  (const: Lean.Name)
---  (type: Lean.Expr)
---  (sort: Lean.Expr)
---  (lvls: List Lean.Name)
---  (secret: Option Address)
---  : CompileM (Claim × Address × Address) := do
---  let leanConst <- findLeanConst const
---  let valAddr <- compileConst leanConst >>= comm
---  let typeAddr <- addDef lvls sort type >>= comm
---  let lvls <- packLevel lvls.length commit
---  return (Claim.checks (CheckClaim.mk lvls type value), typeMeta, valMeta)
---  where
---    commit (c: Ix.Const) : MetaAddress := do
---      match commit with
---      | none => dematerializeConst c
---      | some secret => 
 --
---    if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
-
+----partial def checkClaim
+----  (const: Lean.Name)
+----  (type: Lean.Expr)
+----  (sort: Lean.Expr)
+----  (lvls: List Lean.Name)
+----  (secret: Option Address)
+----  : CompileM (Claim × Address × Address) := do
+----  let leanConst <- findLeanConst const
+----  let valAddr <- compileConst leanConst >>= comm
+----  let typeAddr <- addDef lvls sort type >>= comm
+----  let lvls <- packLevel lvls.length commit
+----  return (Claim.checks (CheckClaim.mk lvls type value), typeMeta, valMeta)
+----  where
+----    commit (c: Ix.Const) : MetaAddress := do
+----      match commit with
+----      | none => dematerializeConst c
+----      | some secret => 
+----
+----    if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
 --
---partial def evalClaim
---  (lvls: List Lean.Name)
---  (input: Lean.Expr)
---  (output: Lean.Expr)
---  (type: Lean.Expr)
---  (sort: Lean.Expr)
---  (commit: Bool)
---  : CompileM (Claim × Address × Address × Address) := do
---  let (input, inputMeta) <- addDef lvls type input >>= comm
---  let (output, outputMeta) <- addDef lvls type output >>= comm
---  let (type, typeMeta) <- addDef lvls sort type >>= comm
---  let lvlsAddr <- packLevel lvls.length commit
---  return (Claim.evals (EvalClaim.mk lvlsAddr input output type), inputMeta, outputMeta, typeMeta)
---  where
---    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
+----
+----partial def evalClaim
+----  (lvls: List Lean.Name)
+----  (input: Lean.Expr)
+----  (output: Lean.Expr)
+----  (type: Lean.Expr)
+----  (sort: Lean.Expr)
+----  (commit: Bool)
+----  : CompileM (Claim × Address × Address × Address) := do
+----  let (input, inputMeta) <- addDef lvls type input >>= comm
+----  let (output, outputMeta) <- addDef lvls type output >>= comm
+----  let (type, typeMeta) <- addDef lvls sort type >>= comm
+----  let lvlsAddr <- packLevel lvls.length commit
+----  return (Claim.evals (EvalClaim.mk lvlsAddr input output type), inputMeta, outputMeta, typeMeta)
+----  where
+----    comm a := if commit then commitConst (Prod.fst a) (Prod.snd a) else pure a
 
 
 /--
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 756df5f0..8a789e1c 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -2,9 +2,6 @@ import Ix.Common
 import Ix.Address
 import Lean
 
-import Batteries.Data.RBMap
-open Batteries (RBMap)
-
 namespace Ix
 
 /-
@@ -89,7 +86,7 @@ inductive Level
   | max  : Level → Level → Level
   | imax : Level → Level → Level
   | param: Lean.Name → Nat → Level
-  deriving Inhabited, Ord, BEq, Repr
+  deriving Inhabited, Ord, BEq, Repr, Hashable
 
 /--
 Ix.Expr expressions are similar to Lean.Expr, except they exclude free variables
@@ -107,7 +104,7 @@ inductive Expr
   | letE  (mdata: Address) (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
   | lit   (mdata: Address) (lit: Lean.Literal)
   | proj  (mdata: Address) (typeName: Lean.Name) (type: MetaAddress) (idx: Nat) (struct: Expr)
-  deriving Inhabited, Ord, BEq, Repr
+  deriving Inhabited, Ord, BEq, Repr, Hashable
 
 /--
 Ix.Quotient quotients are analogous to Lean.QuotVal
@@ -117,7 +114,7 @@ structure Quotient where
   levelParams : List Lean.Name
   type : Expr
   kind : Lean.QuotKind
-  deriving Ord, BEq, Repr, Nonempty
+  deriving Ord, BEq, Repr, Nonempty, Hashable
 
 /--
 Ix.Axiom axioms are analogous to Lean.AxiomVal, differing only in not including
@@ -127,7 +124,7 @@ structure Axiom where
   levelParams : List Lean.Name
   type : Expr
   isUnsafe: Bool
-  deriving Ord, BEq, Repr, Nonempty
+  deriving Ord, BEq, Repr, Nonempty, Hashable
 
 structure PreDef where
   name: Lean.Name
@@ -138,7 +135,7 @@ structure PreDef where
   hints : Lean.ReducibilityHints
   safety : Lean.DefinitionSafety
   all : List Lean.Name
-  deriving BEq, Repr, Nonempty, Inhabited, Ord
+  deriving BEq, Repr, Nonempty, Inhabited, Ord, Hashable
 
 def mkPreDef (x: Lean.DefinitionVal) : PreDef := 
   ⟨x.name, x.levelParams, x.type, .definition, x.value, x.hints, x.safety, x.all⟩
@@ -150,7 +147,7 @@ def mkPreOpaque (x: Lean.OpaqueVal) : PreDef :=
   ⟨x.name, x.levelParams, x.type, .opaque, x.value, .opaque,
     if x.isUnsafe then .unsafe else .safe, x.all⟩
 
-def defMutCtx (defss: List (List PreDef)) : RBMap Lean.Name Nat compare
+def defMutCtx (defss: List (List PreDef)) : Map Lean.Name Nat
   := Id.run do
   let mut mutCtx := default
   let mut i := 0
@@ -181,7 +178,7 @@ structure Definition where
   hints : Lean.ReducibilityHints
   safety: Lean.DefinitionSafety
   all : List Lean.Name
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 def mkTheorem
   (name: Lean.Name)
@@ -219,7 +216,7 @@ structure Constructor where
   numParams : Nat
   numFields : Nat
   isUnsafe: Bool
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 /--
 Ix.RecursorRule is analogous to Lean.RecursorRule
@@ -228,7 +225,7 @@ structure RecursorRule where
   ctor : Lean.Name
   nfields : Nat
   rhs : Expr
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 /--
 Ix.Recursor represents inductive recursors and is analogous to Lean.RecursorVal.
@@ -248,7 +245,7 @@ structure Recursor where
   rules : List RecursorRule
   k : Bool
   isUnsafe: Bool
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 /--
 Ix.PreInd is used to capture a Lean.InductiveVal along with their
@@ -296,7 +293,7 @@ structure PreInd where
 -- and an inductive with 3 ctors and 2 recrs, then the whole class will reserve
 -- 8 indices (one for the inductive type itself plus 3 ctors and 4 recrs).
 
-def indMutCtx (indss: List (List PreInd)) : RBMap Lean.Name Nat compare 
+def indMutCtx (indss: List (List PreInd)) : Map Lean.Name Nat
   := Id.run do
   let mut mutCtx := default
   let mut idx := 0
@@ -333,7 +330,7 @@ structure Inductive where
   isRec : Bool
   isReflexive : Bool
   isUnsafe: Bool
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 
 structure InductiveProj where
@@ -343,7 +340,7 @@ structure InductiveProj where
   block: MetaAddress
   /-- index of the specific inductive datatype within the block --/
   idx   : Nat
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 structure ConstructorProj where
   /-- name of a specific constructor within an inductive --/
@@ -356,7 +353,7 @@ structure ConstructorProj where
   induct: Lean.Name
   /-- index of a specific constructor within the inductive --/
   cidx  : Nat
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 structure RecursorProj where
   /-- name of a specific recursor within the inductive --/
@@ -369,7 +366,7 @@ structure RecursorProj where
   induct: Lean.Name
   /-- index of a specific recursor within the inductive --/
   ridx : Nat
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 structure DefinitionProj where
   name: Lean.Name
@@ -377,12 +374,12 @@ structure DefinitionProj where
   block: MetaAddress
   /-- index of a specific definition within the block --/
   idx : Nat
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 structure MutualBlock where
   defs : List (List Definition)
   --all: List Lean.Name
-  deriving BEq, Ord, Repr, Nonempty
+  deriving BEq, Ord, Repr, Nonempty, Hashable
 
 def MutualBlock.ctx (x: MutualBlock) : List (List Lean.Name) :=
   x.defs.map fun xs => xs.map fun x => x.name
@@ -390,7 +387,7 @@ def MutualBlock.ctx (x: MutualBlock) : List (List Lean.Name) :=
 structure InductiveBlock where
   inds : List (List Inductive)
   --all: List Lean.Name
-  deriving BEq, Ord, Repr, Nonempty, Inhabited
+  deriving BEq, Ord, Repr, Nonempty, Inhabited, Hashable
 
 def InductiveBlock.ctx (x: InductiveBlock) : List (List Lean.Name) :=
   x.inds.map fun xs => xs.map fun x => x.name
@@ -407,7 +404,7 @@ inductive Const where
   -- constants to represent mutual blocks
   | «mutual» : MutualBlock → Const
   | «inductive» : InductiveBlock → Const
-  deriving BEq, Ord, Inhabited, Repr, Nonempty
+  deriving BEq, Ord, Inhabited, Repr, Nonempty, Hashable
 
 def Const.isMutBlock : Const → Bool
   | .mutual _ | .inductive _ => true
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 0bbf1bba..104e4e85 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -121,7 +121,7 @@ def getBytes (len: Nat) : GetM ByteArray := do
 structure Tag4 where
   flag: Fin 16
   size: UInt64
-  deriving Inhabited, Repr, BEq, Ord
+  deriving Inhabited, Repr, BEq, Ord, Hashable
 
 def Tag4.encodeHead (tag: Tag4): UInt8 :=
   let t := UInt8.shiftLeft (UInt8.ofNat tag.flag.val) 4
@@ -411,7 +411,7 @@ structure Quotient where
   kind : Lean.QuotKind
   lvls : Nat
   type : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Quotient where
   put := fun x => Serialize.put (x.kind, x.lvls, x.type)
@@ -421,7 +421,7 @@ structure Axiom where
   isUnsafe: Bool
   lvls : Nat
   type : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Axiom where
   put := fun x => Serialize.put (x.isUnsafe, x.lvls, x.type)
@@ -433,7 +433,7 @@ structure Definition where
   lvls : Nat
   type : Address
   value : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Definition where
   put x := Serialize.put (x.kind, x.safety, x.lvls, x.type, x.value)
@@ -446,7 +446,7 @@ structure Constructor where
   params : Nat
   fields : Nat
   type : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Constructor where
   put x := Serialize.put (x.isUnsafe, x.lvls, x.cidx, x.params, x.fields, x.type)
@@ -455,7 +455,7 @@ instance : Serialize Constructor where
 structure RecursorRule where
   fields : Nat
   rhs : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize RecursorRule where
   put x := Serialize.put (x.fields, x.rhs)
@@ -471,7 +471,7 @@ structure Recursor where
   minors : Nat
   type : Address
   rules : List RecursorRule
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Recursor where
   put x := Serialize.put ((x.k, x.isUnsafe), x.lvls, x.params, x.indices, x.motives, x.minors, x.type, x.rules)
@@ -488,7 +488,7 @@ structure Inductive where
   type : Address
   ctors : List Constructor
   recrs : List Recursor
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Inductive where
   put x := Serialize.put ((x.recr,x.refl,x.isUnsafe), x.lvls, x.params, x.indices, x.nested, x.type, x.ctors, x.recrs)
@@ -497,7 +497,7 @@ instance : Serialize Inductive where
 structure InductiveProj where
   idx : Nat
   block : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize InductiveProj where
   put := fun x => Serialize.put (x.idx, x.block)
@@ -507,7 +507,7 @@ structure ConstructorProj where
   idx : Nat
   cidx : Nat
   block : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize ConstructorProj where
   put := fun x => Serialize.put (x.idx, x.cidx, x.block)
@@ -517,7 +517,7 @@ structure RecursorProj where
   idx : Nat
   ridx : Nat
   block : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize RecursorProj where
   put := fun x => Serialize.put (x.idx, x.ridx, x.block)
@@ -526,7 +526,7 @@ instance : Serialize RecursorProj where
 structure DefinitionProj where
   idx : Nat
   block : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize DefinitionProj where
   put := fun x => Serialize.put (x.idx, x.block)
@@ -535,7 +535,7 @@ instance : Serialize DefinitionProj where
 structure Comm where
   secret : Address
   payload : Address
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Comm where
   put := fun x => Serialize.put (x.secret, x.payload)
@@ -543,7 +543,7 @@ instance : Serialize Comm where
 
 structure Env where
   env : List MetaAddress
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Env where
   put x := Serialize.put x.env
@@ -554,18 +554,18 @@ structure EvalClaim where
   input: Address
   output: Address
   type : Address
-deriving BEq, Repr, Inhabited, Ord
+deriving BEq, Repr, Inhabited, Ord, Hashable
 
 structure CheckClaim where
   lvls : Address
   type : Address
   value : Address
-deriving BEq, Repr, Inhabited, Ord
+deriving BEq, Repr, Inhabited, Ord, Hashable
 
 inductive Claim where
 | evals : EvalClaim -> Claim
 | checks : CheckClaim -> Claim
-deriving BEq, Repr, Inhabited, Ord
+deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : ToString CheckClaim where
   toString x := s!"#{x.value} : #{x.type} @ #{x.lvls}"
@@ -599,7 +599,7 @@ structure Proof where
   claim: Claim
   /-- Bytes of the Binius proof -/
   bin : ByteArray
-  deriving Inhabited, BEq, Ord
+  deriving Inhabited, BEq, Ord, Hashable
 
 instance : ToString Proof where
   toString p := s!"<{toString p.claim} := {hexOfBytes p.bin}>"
@@ -705,7 +705,7 @@ inductive DataValue where
 | ofNat (v: Address)
 | ofInt (v: Address)
 | ofSyntax (v: Address)
-deriving BEq, Repr, Ord, Inhabited, Ord
+deriving BEq, Repr, Ord, Inhabited, Ord, Hashable
 
 def putDataValue : DataValue → PutM Unit
 | .ofString v => putUInt8 0 *> put v
@@ -730,33 +730,33 @@ instance : Serialize DataValue where
   get := getDataValue
 
 inductive Metadatum where
-| name : Address -> Metadatum
-| info : Lean.BinderInfo -> Metadatum
 | link : Address -> Metadatum
+| info : Lean.BinderInfo -> Metadatum
 | hints : Lean.ReducibilityHints -> Metadatum
-| all : List Address -> Metadatum
+| links : List Address -> Metadatum
+| rules : List (Address × Address) -> Metadatum
 | kvmap : List (Address × DataValue) -> Metadatum
-deriving BEq, Repr, Ord, Inhabited, Ord
+deriving BEq, Repr, Ord, Inhabited, Ord, Hashable
 
 structure Metadata where
   nodes: List Metadatum
-  deriving BEq, Repr, Inhabited, Ord
+  deriving BEq, Repr, Inhabited, Ord, Hashable
 
 def putMetadatum : Metadatum → PutM Unit
-| .name n => putUInt8 0 *> put n
+| .link n => putUInt8 0 *> put n
 | .info i => putUInt8 1 *> putBinderInfo i
-| .link l => putUInt8 2 *> putBytes l.hash
-| .hints h => putUInt8 3 *> putReducibilityHints h
-| .all ns => putUInt8 4 *> put ns
+| .hints h => putUInt8 2 *> putReducibilityHints h
+| .links ns => putUInt8 3 *> put ns
+| .rules ns => putUInt8 4 *> put ns
 | .kvmap map => putUInt8 5 *> put map
 
 def getMetadatum : GetM Metadatum := do
   match (<- getUInt8) with
-  | 0 => .name <$> get
+  | 0 => .link <$> get
   | 1 => .info <$> get
-  | 2 => .link <$> (.mk <$> getBytes 32)
-  | 3 => .hints <$> get
-  | 4 => .all <$> get
+  | 2 => .hints <$> get
+  | 3 => .links <$> get
+  | 4 => .rules <$> get
   | 5 => .kvmap <$> get
   | e => throw s!"expected Metadatum encoding between 0 and 5, got {e}"
 
@@ -811,7 +811,7 @@ inductive Ixon where
 | comm : Comm -> Ixon                                   -- 0xE3, cryptographic commitment
 | envn : Env -> Ixon                                    -- 0xE4, Lean4 environment
 | meta : Metadata -> Ixon                               -- 0xFX, Lean4 metadata
-deriving BEq, Repr, Inhabited, Ord
+deriving BEq, Repr, Inhabited, Ord, Hashable
 
 
 partial def putIxon : Ixon -> PutM Unit
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index bba67563..8bd823d1 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -39,7 +39,7 @@ macro "get_env!" : term =>
   `(getFileEnv this_file!)
 
 def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO MetaAddress := do
-  let (addr, _) <- (Ix.compileConst const >>= Ix.dematerializeConst).runIO env
+  let (addr, _) <- (Ix.compileConst const).runIO env
   return addr
 
 def runCore (f : CoreM α) (env : Environment) : IO α :=
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 14152839..449773af 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -91,7 +91,7 @@ def testInductives : IO TestSeq := do
   --let consts := env.getConstMap.filter fun n _ => namesp.isPrefixOf n
   let all := (env.getDelta.find! `Test.Ix.Inductives.A).all
   let preinds <- all.mapM fun n => match env.getDelta.find! n with
-    | .inductInfo v => do match (<- (makePreInd v).run .init cstt) with
+    | .inductInfo v => do match (<- (mkPreInd v).run .init cstt) with
       | (.ok a, _) => pure a
       | (.error e, _) => do throw (IO.userError (<- e.pretty))
     | _ => throw (IO.userError "not an inductive")
@@ -117,7 +117,7 @@ def testDifficult : IO TestSeq := do
       | none => match env.getConstMap.get? name with
         | some c => pure c
         | none => throw (IO.userError s!"{name} not in env")
-    let (addr, stt) <- do match (<- (compileConst const >>= dematerializeConst).run .init cstt) with
+    let (addr, stt) <- do match (<- (compileConst const).run .init cstt) with
     | (.ok a, stt) => pure (a, stt)
     | (.error e, _) => IO.println s!"failed {const.name}" *> throw (IO.userError (<- e.pretty))
     IO.println s!"{const.name} -> {addr}"
@@ -166,7 +166,7 @@ def testRoundtripGetEnv : IO TestSeq := do
     | (.error e, _) => do
       IO.println s!"failed {c.name}"
       throw (IO.userError (<- e.pretty))
-    let addr <- match stt.constNames.find? c.name with
+    let addr <- match stt.constCache.find? c.name with
     | .some addr => pure addr
     | .none => throw (IO.userError "name {n} not in env")
     IO.println s!"✓ {c.name} -> {addr}"
@@ -178,7 +178,7 @@ def testRoundtripGetEnv : IO TestSeq := do
     | (.error e, _) => do
       IO.println s!"failed {c.name}"
       throw (IO.userError (<- e.pretty))
-    let addr <- match stt.constNames.find? c.name with
+    let addr <- match stt.constCache.find? c.name with
     | .some addr => pure addr
     | .none => throw (IO.userError "name {n} not in env")
     IO.println s!"✓ {c.name} -> {addr}"
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 61540019..22e01ec2 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -101,11 +101,11 @@ def genDataValue : Gen Ixon.DataValue :=
 
 def genMetadatum : Gen Ixon.Metadatum :=
   frequency [
-    (10, .name <$> genAddress),
     (10, .info <$> genBinderInfo),
     (10, .link <$> genAddress),
     (10, .hints <$> genReducibilityHints),
-    (10, .all <$> genList genAddress),
+    (10, .links <$> genList genAddress),
+    --(10, .rules <$> genList genAddress),
     (10, .kvmap <$> genList (Prod.mk <$> genAddress <*> genDataValue)),
   ]
 

From 2e54234edb1fcccbf98f327923e6315b76202fd8 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 9 Oct 2025 14:30:45 -0400
Subject: [PATCH 51/74] full compilation of Lean->Ixon, but slow

---
 Ix/CompileM.lean      | 28 +++++++++---------
 Ix/Ixon.lean          |  3 +-
 Ix/Meta.lean          |  3 +-
 Tests/Ix/Compile.lean | 68 +++++++++++++++++++++++++++++++++----------
 4 files changed, 70 insertions(+), 32 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 7f95c3bb..03c1cd9c 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -279,7 +279,7 @@ def compilePreresolved : Lean.Syntax.Preresolved -> CompileM Ixon.Preresolved
 | .decl n fs => .decl <$> compileName n <*> fs.mapM storeString
 
 partial def compileSyntax (syn: Lean.Syntax) : CompileM Ixon.Syntax := do
-  dbg_trace "compileSyntax {(<- read).current}"
+  --dbg_trace "compileSyntax {(<- read).current}"
   match (<- get).synCache.find? syn with
   | some x => pure x
   | none => do
@@ -440,15 +440,15 @@ partial def compileConst (const: Lean.ConstantInfo): CompileM MetaAddress := do
   | some x => pure x
   | none => resetCtx const.name <| do
     let (anon, meta) <- go const
-    let stt <- get
-    dbg_trace "✓ compileConst {const.name}"
-    dbg_trace "store {stt.store.size}"
-    dbg_trace "constCache {stt.constCache.size}"
-    dbg_trace "exprCache {stt.exprCache.size}"
-    dbg_trace "nameCache {stt.nameCache.size}"
-    dbg_trace "synCache {stt.synCache.size}"
-    dbg_trace "strCache {stt.strCache.size}"
-    dbg_trace "univCache {stt.univCache.size}"
+    --let stt <- get
+    --dbg_trace "✓ compileConst {const.name}"
+    --dbg_trace "store {stt.store.size}"
+    --dbg_trace "constCache {stt.constCache.size}"
+    --dbg_trace "exprCache {stt.exprCache.size}"
+    --dbg_trace "nameCache {stt.nameCache.size}"
+    --dbg_trace "synCache {stt.synCache.size}"
+    --dbg_trace "strCache {stt.strCache.size}"
+    --dbg_trace "univCache {stt.univCache.size}"
     let maddr := ⟨<- storeIxon anon, <- storeIxon meta⟩
     modifyGet fun stt => (maddr, { stt with
       constCache := stt.constCache.insert const.name maddr
@@ -584,7 +584,7 @@ partial def sortDefs (classes : List PreDef) : CompileM (List (List PreDef)) :=
   go [List.sortBy (compare ·.name ·.name) classes]
   where
     go (cs: List (List PreDef)): CompileM (List (List PreDef)) := do
-      dbg_trace "sortDefs blocks {(<- get).blocks.size} {(<- read).current}"
+      --dbg_trace "sortDefs blocks {(<- get).blocks.size} {(<- read).current}"
       let ctx := defMutCtx cs
       let cs' <- cs.mapM fun ds =>
         match ds with
@@ -597,7 +597,7 @@ partial def sortDefs (classes : List PreDef) : CompileM (List (List PreDef)) :=
 /-- AST comparison of two Lean definitions. --/
 partial def compareDef (ctx: MutCtx) (x y: PreDef)
   : CompileM Ordering := do
-  dbg_trace "compareDefs constCmp {(<- get).constCmp.size} {(<- read).current}"
+  --dbg_trace "compareDefs constCmp {(<- get).constCmp.size} {(<- read).current}"
   let key := match compare x.name y.name with
     | .lt => (x.name, y.name)
     | _ => (y.name, x.name)
@@ -820,7 +820,7 @@ partial def compilePreInd: PreInd -> CompileM (Ixon × Ixon)
 /-- AST comparison of two Lean inductives. --/
 partial def compareInd (ctx: MutCtx) (x y: PreInd) 
   : CompileM Ordering := do
-  dbg_trace "compareInd constCmp {(<- get).constCmp.size} {(<- read).current}"
+  --dbg_trace "compareInd constCmp {(<- get).constCmp.size} {(<- read).current}"
   let key := match compare x.name y.name with
     | .lt => (x.name, y.name)
     | _ => (y.name, x.name)
@@ -892,7 +892,7 @@ partial def sortInds (classes : List PreInd) : CompileM (List (List PreInd)) :=
   go [List.sortBy (compare ·.name ·.name) classes]
   where
     go (cs: List (List PreInd)): CompileM (List (List PreInd)) := do
-      dbg_trace "sortInds blocks {(<- get).blocks.size} {(<- read).current}"
+      --dbg_trace "sortInds blocks {(<- get).blocks.size} {(<- read).current}"
       let ctx := indMutCtx cs
       let cs' <- cs.mapM fun ds =>
         match ds with
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 104e4e85..b06b96d1 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -112,7 +112,6 @@ def getBytes (len: Nat) : GetM ByteArray := do
     return chunk
   else throw s!"EOF: need {len} bytes at index {st.idx}, but size is {st.bytes.size}"
 
-
 --  F := flag, L := large-bit, X := small-field, A := large_field
 -- 0xFFFF_LXXX {AAAA_AAAA, ...}
 -- "Tag" means the whole thing
@@ -139,7 +138,7 @@ def flag4_to_Fin16 (x: UInt8) : Fin 16 :=
 def Tag4.decodeHead (head: UInt8) : (Fin 16 × Bool × UInt8) :=
   let flag : Fin 16 := flag4_to_Fin16 head
   let largeBit := UInt8.land head 0b1000 != 0
-  let small := if flag == 0xC then head % 0b10000 else head % 0b1000
+  let small := head % 0b1000
   (flag, largeBit, small)
 
 def getTagSize (large: Bool) (small: UInt8) : GetM UInt64 := do
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index 8bd823d1..2d688081 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -38,7 +38,8 @@ elab "this_file!" : term => do
 macro "get_env!" : term =>
   `(getFileEnv this_file!)
 
-def computeIxAddress (env: Lean.Environment) (const : ConstantInfo) : IO MetaAddress := do
+def computeIxAddress (env: Lean.Environment) (const: ConstantInfo): IO MetaAddress 
+  := do
   let (addr, _) <- (Ix.compileConst const).runIO env
   return addr
 
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 449773af..2d5dd2d5 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -4,6 +4,7 @@ import Ix.Ixon
 import Ix.Address
 import Ix.Common
 import Ix.CompileM
+import Ix.Cronos
 --import Ix.DecompileM
 import Ix.Meta
 import Ix.IR
@@ -104,6 +105,29 @@ def testInductives : IO TestSeq := do
   let nss := dss.map fun ds => ds.map (·.name)
   return test "test inductives" (res == nss)
 
+def testEasy : IO TestSeq := do
+  let env <- get_env!
+  let difficult := [
+    `Nat.add_comm
+  ]
+  let mut res := true
+  for name in difficult do
+    IO.println s!"⚙️ Compiling {name}"
+    let mut cstt : CompileState := .init env 0
+    let start <- IO.monoNanosNow
+    let const <- do match env.getDelta.find? name with
+      | some c => pure c
+      | none => match env.getConstMap.get? name with
+        | some c => pure c
+        | none => throw (IO.userError s!"{name} not in env")
+    let (addr, stt) <- do match (<- (compileConst const).run .init cstt) with
+    | (.ok a, stt) => pure (a, stt)
+    | (.error e, _) => IO.println s!"failed {const.name}" *> throw (IO.userError (<- e.pretty))
+    let done <- IO.monoNanosNow
+    IO.println s!"✅ {addr}"
+    IO.println s!"Elapsed {Cronos.nanoToSec (done - start)}"
+  return test "easy compile roundtrip" (res == true)
+
 def testDifficult : IO TestSeq := do
   let env <- get_env!
   let difficult := [
@@ -156,22 +180,31 @@ def testDifficult : IO TestSeq := do
   return test "difficult compile roundtrip" (res == true)
 
 def testRoundtripGetEnv : IO TestSeq := do
+  IO.println s!"Getting env"
   let env <- get_env!
   let mut cstt : CompileState := .init env 0
-  --IO.println s!"compiling env"
+  IO.println s!"Compiling env"
+  let mut inDelta := 0
+  let mut inConst := 0
+  let numDelta := env.getDelta.stats.numNodes
+  let numConst := env.getConstMap.size
+  let allStart <- IO.monoNanosNow
   for (_, c) in env.getDelta do
-    let (_, stt) <- do match (<- (compileConst c).run .init cstt) with
-    | (.ok a, stt) => do
-      pure (a, stt)
+    let start <- IO.monoNanosNow
+    IO.println s!"⚙️ Compiling {inDelta}/{numDelta}: {c.name}"
+    let (addr, stt) <- do match (<- (compileConst c).run .init cstt) with
+    | (.ok a, stt) => pure (a, stt)
     | (.error e, _) => do
       IO.println s!"failed {c.name}"
       throw (IO.userError (<- e.pretty))
-    let addr <- match stt.constCache.find? c.name with
-    | .some addr => pure addr
-    | .none => throw (IO.userError "name {n} not in env")
-    IO.println s!"✓ {c.name} -> {addr}"
+    let done <- IO.monoNanosNow
+    IO.println s!"✅ {addr}"
+    IO.println s!"Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec (done - allStart)}"
+    inDelta := inDelta + 1
     cstt := stt
   for (_, c) in env.getConstMap do
+    let start <- IO.monoNanosNow
+    IO.println s!"⚙️ Compiling {inConst}/{numConst}: {c.name} "
     let (_, stt) <- do match (<- (compileConst c).run .init cstt) with
     | (.ok a, stt) => do
       pure (a, stt)
@@ -181,9 +214,13 @@ def testRoundtripGetEnv : IO TestSeq := do
     let addr <- match stt.constCache.find? c.name with
     | .some addr => pure addr
     | .none => throw (IO.userError "name {n} not in env")
-    IO.println s!"✓ {c.name} -> {addr}"
+    let done <- IO.monoNanosNow
+    IO.println s!"✅ {addr}"
+    IO.println s!"Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec (done - allStart)}"
+    inConst := inConst + 1
     cstt := stt
-  IO.println s!"compiled env"
+  let allDone <- IO.monoNanosNow
+  IO.println s!"Compiled env in {Cronos.nanoToSec (allDone - allStart)}"
  -- IO.println s!"decompiling env"
  -- let mut store : Ixon.Store := {}
  -- for (_,(a, b)) in cstt.names do
@@ -223,9 +260,10 @@ def testRoundtripGetEnv : IO TestSeq := do
   return test "env compile roundtrip" true --(res == true)
 
 def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
-   testMutual,
-   testInductives,
-   testDifficult,
---   testUnits,
-   --testRoundtripGetEnv
+  --testMutual,
+  --testInductives,
+  --testDifficult,
+  --testUnits,
+  testEasy
+  --testRoundtripGetEnv
 ]

From b9ed33b8446dcdbf99a1fd3deb6972b45d559d4c Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 13 Oct 2025 15:28:01 -0400
Subject: [PATCH 52/74] Tarjan's SCC algorithm for mutuals, so we can compile
 Recursors

---
 Ix.lean               |   1 +
 Ix/Common.lean        |   1 +
 Ix/CompileM.lean      | 315 +++++++++++++++++++++++++++---------------
 Ix/CondenseM.lean     | 134 ++++++++++++++++++
 Ix/IR.lean            |  27 +++-
 Ix/Ixon.lean          | 236 +++++++++++++++----------------
 Ix/Meta.lean          |   1 -
 Tests/Ix/Compile.lean |   9 +-
 Tests/Ix/Ixon.lean    |   9 +-
 9 files changed, 488 insertions(+), 245 deletions(-)
 create mode 100644 Ix/CondenseM.lean

diff --git a/Ix.lean b/Ix.lean
index 740fe99c..0aa1279a 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -4,4 +4,5 @@ import Ix.Ixon
 import Ix.IR
 import Ix.Meta
 import Ix.CompileM
+import Ix.CondenseM
 --import Ix.DecompileM
diff --git a/Ix/Common.lean b/Ix/Common.lean
index 64a3962f..bc24fd50 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -265,6 +265,7 @@ def Std.HashMap.find? {A B} [BEq A] [Hashable A] (map: Std.HashMap A B) (a: A)
   := Std.HashMap.get? map a
 
 abbrev Ix.Map := Std.HashMap
+abbrev Ix.Set := Std.HashSet
 
 abbrev MutCtx := Ix.Map Lean.Name Nat
 
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 03c1cd9c..ab351204 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -3,6 +3,7 @@ import Ix.Ixon
 import Ix.Address
 import Ix.IR
 import Ix.Common
+import Ix.CondenseM
 --import Ix.Store
 import Ix.SOrder
 import Ix.Cronos
@@ -35,15 +36,27 @@ structure CompileState where
   comms: Map Lean.Name MetaAddress
   constCmp: Map (Lean.Name × Lean.Name) Ordering
   --exprCmp: Map (CompileEnv × Lean.Expr × Lean.Expr) Ordering
+  alls: Map Lean.Name (Set Lean.Name)
   axioms: Map Lean.Name MetaAddress
   blocks: Map MetaAddress Unit
   cronos: Cronos
 
+def collectRecursors (env: Lean.Environment) : Map Lean.Name (Set Lean.Name) := Id.run do
+ let mut map := {}
+ for (n, c) in env.constants do
+  match c with
+  | .recInfo val => do
+    map := map.alter val.getMajorInduct <| fun x => match x with
+      | .none => .some {n}
+      | .some s => .some (s.insert n)
+  | _ => continue
+ return map
+
 def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize := 200000)
   : CompileState :=
   ⟨maxHeartBeats, env, mkStdGen seed, default, default, default, default,
-  default, default, default, default, default, default, default, default,
-  default, default⟩
+  default, default, default, default, default, default, CondenseM.run env,
+  default, default, default⟩
 
 inductive CompileError where
 | unknownConstant : Lean.Name -> CompileError
@@ -65,8 +78,10 @@ inductive CompileError where
 --| dematBadInductiveBlock: InductiveBlock -> CompileError
 | badMutualBlock: List (List PreDef) -> CompileError
 | badInductiveBlock: List (List PreInd) -> CompileError
+| badRecursorBlock: List (List Lean.RecursorVal) -> CompileError
 | badIxonDeserialization : Address -> String -> CompileError
 | unknownStoreAddress : Address -> CompileError
+| condensationError : Lean.Name -> CompileError
 --| emptyIndsEquivalenceClass: List (List PreInd) -> CompileError
 
 def CompileError.pretty : CompileError -> IO String
@@ -85,8 +100,10 @@ def CompileError.pretty : CompileError -> IO String
   pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
 | .badMutualBlock block => pure s!"bad mutual block {repr block}"
 | .badInductiveBlock block => pure s!"bad mutual block {repr block}"
+| .badRecursorBlock block => pure s!"bad mutual block {repr block}"
 | .badIxonDeserialization a s => pure s!"bad deserialization of ixon at {a}, error: {s}"
 | .unknownStoreAddress a => pure s!"unknown store address {a}"
+| .condensationError n => pure s!"condensation error {n}"
 
 abbrev CompileM :=
   ReaderT CompileEnv <| ExceptT CompileError <| StateT CompileState IO
@@ -149,6 +166,11 @@ def getIxon (addr: Address) : CompileM Ixon := do
     | .error e => throw <| .badIxonDeserialization addr e
   | none => throw <| .unknownStoreAddress addr
 
+def getAll (name: Lean.Name) : CompileM (Set Lean.Name) := do
+  match (<- get).alls.get? name with
+  | some set => pure set
+  | none => throw <| .condensationError name
+
 def storeString (str: String): CompileM Address := do
   match (<- get).strCache.find? str with
   | some addr => pure addr
@@ -455,26 +477,19 @@ partial def compileConst (const: Lean.ConstantInfo): CompileM MetaAddress := do
     })
   where
     go : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
-    | .defnInfo val => compilePreDef (mkPreDef val)
-    | .thmInfo val => compilePreDef (mkPreTheorem val)
-    | .opaqueInfo val => compilePreDef (mkPreOpaque val)
-    | .inductInfo val => mkPreInd val >>= compilePreInd
+    | .defnInfo val => compileDefs (mkPreDef val)
+    | .thmInfo val => compileDefs (mkPreTheorem val)
+    | .opaqueInfo val => compileDefs (mkPreOpaque val)
+    | .inductInfo val => mkPreInd val >>= compileInds
     | .ctorInfo val => do match <- findLeanConst val.induct with
       | .inductInfo ind => do
-        let _ <- mkPreInd ind >>= compilePreInd
+        let _ <- mkPreInd ind >>= compileInds
         match (<- get).constCache.find? const.name with
         | some ⟨data, meta⟩ => do pure (<- getIxon data, <- getIxon meta)
         | none => throw <| .compileInductiveBlockMissingProjection const.name
       | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
     -- compile recursors through their parent inductive
-    | .recInfo val => do
-      match ← findLeanConst val.getMajorInduct with
-      | .inductInfo ind => do
-        let _ <- mkPreInd ind >>= compilePreInd
-        match (<- get).constCache.find? const.name with
-        | some ⟨data, meta⟩ => do pure (<- getIxon data, <- getIxon meta)
-        | none => throw <| .compileInductiveBlockMissingProjection const.name
-      | c => throw $ .invalidConstantKind c.name "inductive" c.ctorName
+    | .recInfo val => compileRecs val
     | .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => withLevels lvls do
       let n <- compileName name
       let ls <- lvls.mapM compileName
@@ -509,7 +524,7 @@ partial def compileMutDefs: List (List PreDef) -> CompileM (Ixon × Ixon)
   for defsClass in defs do
     let mut classData := #[]
     let mut classMeta := #[]
-    -- dematerialize each def in a class
+    -- compile each def in a class
     for defn in defsClass do
       let (defn', meta') <- compileDef defn
       classData := classData.push defn'
@@ -527,20 +542,21 @@ partial def compileMutDefs: List (List PreDef) -> CompileM (Ixon × Ixon)
     meta := meta.push (.link (<- storeMeta ⟨classMeta.toList⟩))
   pure (.defs data.toList, .meta ⟨meta.toList⟩)
 
-partial def compilePreDef: PreDef -> CompileM (Ixon × Ixon)
+partial def compileDefs: PreDef -> CompileM (Ixon × Ixon)
 | d => do
-  if d.all matches [_] then do
+  let all: Set Lean.Name <- getAll d.name
+  if all == {d.name} then do
     let (data, meta) <- withMutCtx {(d.name,0)} <| compileDef d
     pure (.defn data, .meta meta)
   else do
-    let mut predefs : Array PreDef := #[]
-    for name in d.all do
+    let mut defs : Array PreDef := #[]
+    for name in all do
       match <- findLeanConst name with
-      | .defnInfo x => predefs := predefs.push (mkPreDef x)
-      | .opaqueInfo x => predefs := predefs.push (mkPreOpaque x)
-      | .thmInfo x => predefs := predefs.push (mkPreTheorem x)
+      | .defnInfo x => defs := defs.push (mkPreDef x)
+      | .opaqueInfo x => defs := defs.push (mkPreOpaque x)
+      | .thmInfo x => defs := defs.push (mkPreTheorem x)
       | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
-    let mutDefs <- sortDefs predefs.toList
+    let mutDefs <- sortDefs defs.toList
     let mutCtx := defMutCtx mutDefs
     let (data, meta) <- withMutCtx mutCtx <| compileMutDefs mutDefs
     -- add top-level mutual block to our state
@@ -548,7 +564,7 @@ partial def compilePreDef: PreDef -> CompileM (Ixon × Ixon)
     modify fun stt => { stt with blocks := stt.blocks.insert block () }
     -- then add all the projections, returning the def we started with
     let mut ret? : Option (Ixon × Ixon) := none
-    for name in d.all do
+    for name in all do
       let idx <- do match mutCtx.find? name with
       | some idx => pure idx
       | none => throw $ .cantFindMutDefIndex name
@@ -580,7 +596,7 @@ classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
 ```
 Eventually we reach a fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no
 further refinement is possible (trivially when each def is in its own class). --/
-partial def sortDefs (classes : List PreDef) : CompileM (List (List PreDef)) :=
+partial def sortDefs (classes: List PreDef) : CompileM (List (List PreDef)) :=
   go [List.sortBy (compare ·.name ·.name) classes]
   where
     go (cs: List (List PreDef)): CompileM (List (List PreDef)) := do
@@ -676,36 +692,14 @@ partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
 
 partial def mkPreInd (i: Lean.InductiveVal) : CompileM Ix.PreInd := do
   let ctors <- i.ctors.mapM getCtor
-  let recrs := (<- get).env.constants.fold getRecrs []
+  --let recrs := (<- get).env.constants.fold getRecrs []
   return ⟨i.name, i.levelParams, i.type, i.numParams, i.numIndices, i.all,
-    ctors, recrs, i.numNested, i.isRec, i.isReflexive, i.isUnsafe⟩
+    ctors, i.numNested, i.isRec, i.isReflexive, i.isUnsafe⟩
   where
     getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
       match (<- findLeanConst name) with
       | .ctorInfo c => pure c
       | _ => throw <| .invalidConstantKind name "constructor" ""
-    getRecrs (acc: List Lean.RecursorVal)
-    : Lean.Name -> Lean.ConstantInfo -> List Lean.RecursorVal
-    | .str n .., .recInfo r
-    | .num n .., .recInfo r => if n == i.name then r::acc else acc
-    | _, _ => acc
-
-partial def compileRule: Lean.RecursorRule -> CompileM (Ixon.RecursorRule × (Address × Address))
-| r => do
-  let n <- compileName r.ctor
-  let rhs <- compileExpr r.rhs
-  pure (⟨r.nfields, rhs.data⟩, (n, rhs.meta))
-
-partial def compileRecursor: Lean.RecursorVal -> CompileM (Ixon.Recursor × Address)
-| r => withLevels r.levelParams <| do
-  let n <- compileName r.name
-  let ls <- r.levelParams.mapM compileName
-  let t <- compileExpr r.type
-  let rules <- r.rules.mapM compileRule
-  let data := ⟨r.k, r.isUnsafe, ls.length, r.numParams, r.numIndices,
-    r.numMotives, r.numMinors, t.data, rules.map (·.1)⟩
-  let meta <- storeMeta ⟨[.link n, .links ls, .rules (rules.map (·.2))]⟩
-  pure (data, meta)
 
 partial def compileConstructor: Lean.ConstructorVal -> CompileM (Ixon.Constructor × Address)
 | c => withLevels c.levelParams <| do
@@ -717,18 +711,18 @@ partial def compileConstructor: Lean.ConstructorVal -> CompileM (Ixon.Constructo
   pure (data, meta)
 
 partial def compileInd: PreInd -> CompileM (Ixon.Inductive × Ixon.Metadata)
-| ⟨name, lvls, type, ps, is, all, ctors, recrs, nest, rcr, refl, usafe⟩ =>
+| ⟨name, lvls, type, ps, is, all, ctors, nest, rcr, refl, usafe⟩ =>
   withLevels lvls do 
   let n <- compileName name
   let ls <- lvls.mapM compileName
   let t <- compileExpr type
-  let rs <- recrs.mapM compileRecursor
+  --let rs <- recrs.mapM compileRecursor
   let cs <- ctors.mapM compileConstructor
   let as <- all.mapM compileName
   let data := ⟨rcr, refl, usafe, ls.length, ps, is, nest, t.data,
-    cs.map (·.1), rs.map (·.1)⟩
+    cs.map (·.1)⟩
   let meta := ⟨[.link n, .links ls, .link t.meta,
-    .links (cs.map (·.2)), .links (rs.map (·.2)), .links as]⟩
+    .links (cs.map (·.2)), .links as]⟩
   pure (data, meta)
 
 partial def compileMutInds : List (List PreInd) -> CompileM (Ixon × Ixon)
@@ -757,27 +751,28 @@ partial def compileMutInds : List (List PreInd) -> CompileM (Ixon × Ixon)
     meta := meta.push (.link (<- storeMeta ⟨classMeta.toList⟩))
   pure (.inds data.toList, .meta ⟨meta.toList⟩)
 
---/--
---Content-addresses an inductive and all inductives in the mutual block as a
---mutual block, even if the inductive itself is not in a mutual block.
---
---Content-addressing an inductive involves content-addressing its associated
---constructors and recursors, hence the complexity of this function.
----/
-partial def compilePreInd: PreInd -> CompileM (Ixon × Ixon)
+/--
+Content-addresses an inductive and all inductives in the mutual block as a
+mutual block, even if the inductive itself is not in a mutual block.
+
+Content-addressing an inductive involves content-addressing its associated
+constructors and recursors, hence the complexity of this function.
+-/
+partial def compileInds: PreInd -> CompileM (Ixon × Ixon)
 | ind => do
-  let mut preInds := #[]
-  let mut ctorNames : Map Lean.Name (List Lean.Name × List Lean.Name) := {}
+  let all: Set Lean.Name <- getAll ind.name
+  let mut inds := #[]
+  let mut ctorNames : Map Lean.Name (List Lean.Name) := {}
   -- collect all mutual inductives as Ix.PreInds
-  for n in ind.all do
+  for n in all do
     match <- findLeanConst n with
-    | .inductInfo ind =>
-      let preInd <- mkPreInd ind
-      preInds := preInds.push preInd
-      ctorNames := ctorNames.insert n (ind.ctors, preInd.recrs.map (·.name))
-    | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
+    | .inductInfo val =>
+      let ind <- mkPreInd val
+      inds := inds.push ind
+      ctorNames := ctorNames.insert n val.ctors
+    | _ => continue
   -- sort PreInds into equivalence classes
-  let mutInds <- sortInds preInds.toList
+  let mutInds <- sortInds inds.toList
   let mutCtx := indMutCtx mutInds
   -- compile each preinductive with the mutCtx
   let (data, meta) <- withMutCtx mutCtx <| compileMutInds mutInds
@@ -786,16 +781,16 @@ partial def compilePreInd: PreInd -> CompileM (Ixon × Ixon)
   modify fun stt => { stt with blocks := stt.blocks.insert block () }
   -- then add all projections, returning the inductive we started with
   let mut ret? : Option (Ixon × Ixon) := none
-  for (name, idx) in ind.all.zipIdx do
-    let n <- compileName name
+  for (ind', idx) in inds.zipIdx do
+    let n <- compileName ind'.name
     let data := .iprj ⟨idx, block.data⟩
     let meta := .meta ⟨[.link n, .link block.meta]⟩
     let addr := ⟨<- storeIxon data, <- storeIxon meta⟩
     modify fun stt => { stt with
-      constCache := stt.constCache.insert name addr
+      constCache := stt.constCache.insert ind'.name addr
     }
-    if name == ind.name then ret? := some (data, meta)
-    let some (ctors, recrs) := ctorNames.find? ind.name
+    if ind'.name == ind.name then ret? := some (data, meta)
+    let some ctors := ctorNames.find? ind.name
       | throw $ .cantFindMutDefIndex ind.name
     for (cname, cidx) in ctors.zipIdx do
       let cn <- compileName cname
@@ -805,14 +800,14 @@ partial def compilePreInd: PreInd -> CompileM (Ixon × Ixon)
       modify fun stt => { stt with
         constCache := stt.constCache.insert cname caddr
       }
-    for (rname, ridx) in recrs.zipIdx do
-      let rn <- compileName rname
-      let rdata := .rprj ⟨idx, ridx, block.data⟩
-      let rmeta := .meta ⟨[.link rn, .link block.meta]⟩
-      let raddr := ⟨<- storeIxon rdata, <- storeIxon rmeta⟩
-      modify fun stt => { stt with
-        constCache := stt.constCache.insert rname raddr
-      }
+    --for (rname, ridx) in recrs.zipIdx do
+    --  let rn <- compileName rname
+    --  let rdata := .rprj ⟨idx, ridx, block.data⟩
+    --  let rmeta := .meta ⟨[.link rn, .link block.meta]⟩
+    --  let raddr := ⟨<- storeIxon rdata, <- storeIxon rmeta⟩
+    --  modify fun stt => { stt with
+    --    constCache := stt.constCache.insert rname raddr
+    --  }
   match ret? with
   | some ret => return ret
   | none => throw $ .compileInductiveBlockMissingProjection ind.name
@@ -832,10 +827,11 @@ partial def compareInd (ctx: MutCtx) (x y: PreInd)
       SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
       SOrder.cmpM (pure ⟨true, compare x.numIndices y.numIndices⟩) <|
       SOrder.cmpM (pure ⟨true, compare x.ctors.length y.ctors.length⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.recrs.length y.recrs.length⟩) <|
+      --SOrder.cmpM (pure ⟨true, compare x.recrs.length y.recrs.length⟩) <|
       SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
-      SOrder.cmpM (SOrder.zipM compareCtor x.ctors y.ctors)
-        (SOrder.zipM compareRecr x.recrs y.recrs)
+      (SOrder.zipM compareCtor x.ctors y.ctors)
+      --SOrder.cmpM (SOrder.zipM compareCtor x.ctors y.ctors)
+      --  (SOrder.zipM compareRecr x.recrs y.recrs)
     if sorder.strong then modify fun stt => { stt with
         constCmp := stt.constCmp.insert key sorder.ord
     }
@@ -858,30 +854,6 @@ partial def compareInd (ctx: MutCtx) (x y: PreInd)
           constCmp := stt.constCmp.insert key sorder.ord
         }
       return sorder
-    compareRecr (x y: Lean.RecursorVal) : CompileM SOrder := do
-      let key := match compare x.name y.name with
-        | .lt => (x.name, y.name)
-        | _ => (y.name, x.name)
-      match (<- get).constCmp.find? key with
-      | some o => return ⟨true, o⟩
-      | none => do
-      let sorder <- do
-        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-        SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
-        SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
-        SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
-        SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
-          (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
-      if sorder.strong then modify fun stt => { stt with
-          constCmp := stt.constCmp.insert key sorder.ord
-        }
-      return sorder
-    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
-      : CompileM SOrder := do
-        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
-          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
 
 partial def eqInd (ctx: MutCtx) (x y: PreInd) : CompileM Bool :=
   (fun o => o == .eq) <$> compareInd ctx x y
@@ -901,6 +873,127 @@ partial def sortInds (classes : List PreInd) : CompileM (List (List PreInd)) :=
         | ds  => ds.sortByM (compareInd ctx) >>= List.groupByM (eqInd ctx)
       let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
       if cs == cs' then return cs' else go cs'
+
+/-- AST comparison of two Lean inductives. --/
+partial def compareRec (ctx: MutCtx) (x y: Lean.RecursorVal) 
+  : CompileM Ordering := do
+  let key := match compare x.name y.name with
+    | .lt => (x.name, y.name)
+    | _ => (y.name, x.name)
+  match (<- get).constCmp.find? key with
+  | some o => return o
+  | none => do
+    let sorder <- do
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
+      SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
+      SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+        (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
+    if sorder.strong then modify fun stt => { stt with
+        constCmp := stt.constCmp.insert key sorder.ord
+      }
+    return sorder.ord
+  where
+    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
+      : CompileM SOrder := do
+        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
+          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
+
+partial def eqRec (ctx: MutCtx) (x y: Lean.RecursorVal) : CompileM Bool :=
+  (fun o => o == .eq) <$> compareRec ctx x y
+
+/-- `sortRecs` recursively sorts a list of inductive recursors into equivalence
+classes, analogous to `sortDefs` --/
+partial def sortRecs (classes : List Lean.RecursorVal)
+  : CompileM (List (List Lean.RecursorVal)) :=
+  go [List.sortBy (compare ·.name ·.name) classes]
+  where
+    go (cs: List (List Lean.RecursorVal)): CompileM (List (List Lean.RecursorVal)) := do
+      --dbg_trace "sortInds blocks {(<- get).blocks.size} {(<- read).current}"
+      let ctx := recMutCtx cs
+      let cs' <- cs.mapM fun ds =>
+        match ds with
+        | []  => throw <| .badRecursorBlock cs
+        | [d] => pure [[d]]
+        | ds  => ds.sortByM (compareRec ctx) >>= List.groupByM (eqRec ctx)
+      let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
+      if cs == cs' then return cs' else go cs'
+
+partial def compileRule: Lean.RecursorRule -> CompileM (Ixon.RecursorRule × (Address × Address))
+| r => do
+  let n <- compileName r.ctor
+  let rhs <- compileExpr r.rhs
+  pure (⟨r.nfields, rhs.data⟩, (n, rhs.meta))
+
+partial def compileRec: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata)
+| r => withLevels r.levelParams <| do
+  let n <- compileName r.name
+  let ls <- r.levelParams.mapM compileName
+  let t <- compileExpr r.type
+  let rules <- r.rules.mapM compileRule
+  let data := ⟨r.k, r.isUnsafe, ls.length, r.numParams, r.numIndices,
+    r.numMotives, r.numMinors, t.data, rules.map (·.1)⟩
+  let meta := ⟨[.link n, .links ls, .rules (rules.map (·.2))]⟩
+  pure (data, meta)
+
+partial def compileMutRecs: List (List Lean.RecursorVal) -> CompileM (Ixon × Ixon)
+| recs => do
+  let mut data := #[]
+  let mut meta := #[]
+  -- iterate through each equivalence class
+  for recsClass in recs do
+    let mut classData := #[]
+    let mut classMeta := #[]
+    -- compile each def in a class
+    for recr in recsClass do
+      let (recr', meta') <- compileRec recr
+      classData := classData.push recr'
+      -- build up the class metadata as a list of links to the def metadata
+      classMeta := classMeta.push (.link (<- storeMeta meta'))
+    -- make sure we have no empty classes and all defs in a class are equal
+    match classData.toList with
+      | [] => throw (.badRecursorBlock recs)
+      | [x] => data := data.push x
+      | x::xs =>
+        if xs.foldr (fun y acc => (y == x) && acc) true
+        then data := data.push x
+        else throw (.badRecursorBlock recs)
+    -- build up the block metadata as a list of links to the class metadata
+    meta := meta.push (.link (<- storeMeta ⟨classMeta.toList⟩))
+  pure (.recs data.toList, .meta ⟨meta.toList⟩)
+
+partial def compileRecs : Lean.RecursorVal -> CompileM (Ixon × Ixon)
+| r => do
+  let all: Set Lean.Name <- getAll r.name
+  let mut recs : Array Lean.RecursorVal := #[]
+  for name in all do
+    match <- findLeanConst name with
+    | .recInfo val => recs := recs.push val
+    | x => throw $ .invalidConstantKind x.name "recursor" x.ctorName
+  let mutRecs <- sortRecs recs.toList
+  let mutCtx := recMutCtx mutRecs
+  let (data, meta) <- withMutCtx mutCtx <| compileMutRecs mutRecs
+  let block := ⟨<- storeIxon data, <- storeIxon meta⟩
+  modify fun stt => { stt with blocks := stt.blocks.insert block () }
+  let mut ret? : Option (Ixon × Ixon) := none
+  for recr in recs do
+    let idx <- do match mutCtx.find? recr.name with
+    | some idx => pure idx
+    | none => throw $ .cantFindMutDefIndex recr.name
+    let data := .rprj ⟨idx, block.data⟩
+    let meta := .meta ⟨[.link block.meta]⟩
+    let addr := ⟨<- storeIxon data, <- storeIxon meta⟩
+    modify fun stt => { stt with
+      constCache := stt.constCache.insert recr.name addr
+    }
+    if recr.name == r.name then ret? := some (data, meta)
+  match ret? with
+  | some ret => return ret
+  | none => throw $ .compileMutualBlockMissingProjection r.name
+
 end
 
 partial def makeLeanDef
diff --git a/Ix/CondenseM.lean b/Ix/CondenseM.lean
new file mode 100644
index 00000000..04c98416
--- /dev/null
+++ b/Ix/CondenseM.lean
@@ -0,0 +1,134 @@
+import Lean
+import Ix.Common
+
+namespace Ix
+
+structure CondenseState where
+  exprRefs: Map Lean.Expr (Set Lean.Name)
+  refs: Map Lean.Name (Set Lean.Name)
+  names: Map Lean.Name UInt64
+  ids: Map UInt64 Lean.Name
+  lowLink: Map UInt64 UInt64
+  stack: Array UInt64
+  onStack: Set UInt64
+  id : UInt64
+
+def CondenseState.init : CondenseState := ⟨{}, {}, {}, {}, {}, #[], {}, 0⟩
+
+abbrev CondenseM := ReaderT Lean.Environment <| StateT CondenseState Id
+
+def refsExpr : Lean.Expr -> CondenseM (Set Lean.Name)
+| expr => do match (<- get).exprRefs.find? expr with
+  | some x => pure x
+  | none => do
+    let refs <- go expr
+    modifyGet fun stt => (refs, { stt with
+      exprRefs := stt.exprRefs.insert expr refs
+    })
+  where
+    go : Lean.Expr -> CondenseM (Set Lean.Name)
+    | .const name _ => pure {name}
+    | .app f a => .union <$> refsExpr f <*> refsExpr a
+    | .lam _ t b _ => .union <$> refsExpr t <*> refsExpr b
+    | .forallE _ t b _ => .union <$> refsExpr t <*> refsExpr b
+    | .letE _ t v b _ => do
+      let t' <- refsExpr t
+      let v' <- refsExpr v
+      let b' <- refsExpr b
+      return t'.union (v'.union b')
+    | .proj n _ s => do return (<- refsExpr s).insert n
+    | .mdata _ x => refsExpr x
+    | _ => return {}
+
+partial def refsConst : Lean.ConstantInfo -> CondenseM (Set Lean.Name)
+| const => do match (<- get).refs.find? const.name with
+  | some x => pure x
+  | none => do
+    let constRefs <- go const
+    modifyGet fun stt => (constRefs, { stt with
+      refs := stt.refs.insert const.name constRefs
+    })
+  where
+    go : Lean.ConstantInfo -> CondenseM (Set Lean.Name)
+    | .axiomInfo val => refsExpr val.type
+    | .defnInfo val => .union <$> refsExpr val.type <*> refsExpr val.value
+    | .thmInfo val => .union <$> refsExpr val.type <*> refsExpr val.value
+    | .opaqueInfo val => .union <$> refsExpr val.type <*> refsExpr val.value
+    | .quotInfo val => refsExpr val.type
+    | .inductInfo val => do
+      let env := (<- read).constants
+      let ctorTypes: Set Lean.Name <- val.ctors.foldrM (fun n acc => do
+        acc.union <$> refsConst (env.find! n)) {}
+      let type <- refsExpr val.type
+      return .union (.ofList val.ctors) (.union ctorTypes type)
+    | .ctorInfo val => refsExpr val.type
+    | .recInfo val => do
+      let t <- refsExpr val.type
+      let rs <- val.rules.foldrM (fun r s => .union s <$> refsExpr r.rhs) {}
+      return .union t rs
+
+partial def visit : Lean.Name -> CondenseM Unit
+| name => do match (<- read).constants.find? name with
+  | .none => return ()
+  | .some c => do
+    let refs <- refsConst c
+    let id := (<- get).id
+    modify fun stt => { stt with
+      names := stt.names.insert name id
+      ids := stt.ids.insert id name
+      stack := stt.stack.push id
+      onStack := stt.onStack.insert id
+      lowLink := stt.lowLink.insert id id
+      id := id + 1
+    }
+    for ref in refs do
+      match (<- read).constants.find? ref with
+      | none => continue
+      | some _ => do match (<- get).names.get? ref with
+        | .none => do
+          visit ref
+          modify fun stt =>
+            let ll := stt.lowLink.get! id
+            let rll := stt.lowLink.get! (stt.names.get! ref)
+            { stt with lowLink := stt.lowLink.insert id (min ll rll) }
+        | .some id' => if (<- get).onStack.contains id' then
+          modify fun stt =>
+            let ll := stt.lowLink.get! id
+            { stt with lowLink := stt.lowLink.insert id (min ll id') }
+    if id == (<- get).lowLink.get! id then
+      let mut stack := (<- get).stack
+      if !stack.isEmpty then
+        while true do
+          let top := stack.back!
+          stack := stack.pop
+          modify fun stt => { stt with
+            lowLink := stt.lowLink.insert top id
+            onStack := stt.onStack.erase top
+          }
+          if top == id then break
+      modify fun stt => { stt with stack := stack }
+
+def condense: CondenseM (Map Lean.Name (Set Lean.Name)) := do
+  let mut idx := 0
+  for (name,_) in (<- read).constants do
+    dbg_trace "condensing {name} {idx}"
+    idx := idx + 1
+    match (<- get).names.get? name with
+    | .some _ => continue
+    | .none => visit name
+  let mut blocks : Map Lean.Name (Set Lean.Name) := {}
+  for (i, low) in (<- get).lowLink do
+    let name := (<- get).ids.get! i
+    let lowName := (<- get).ids.get! low
+    blocks := blocks.alter lowName fun x => match x with
+      | .some s => .some (s.insert name)
+      | .none => .some {name}
+  for (_, set) in blocks do
+    for n in set do
+      blocks := blocks.insert n set
+  return blocks
+
+def CondenseM.run (env: Lean.Environment): Map Lean.Name (Set Lean.Name) :=
+ Id.run (StateT.run (ReaderT.run condense env) CondenseState.init).1
+
+end Ix
diff --git a/Ix/IR.lean b/Ix/IR.lean
index 8a789e1c..c0c2744c 100644
--- a/Ix/IR.lean
+++ b/Ix/IR.lean
@@ -159,6 +159,18 @@ def defMutCtx (defss: List (List PreDef)) : Map Lean.Name Nat
     i := i + 1
   return mutCtx
 
+def recMutCtx (recss: List (List Lean.RecursorVal)) : Map Lean.Name Nat
+  := Id.run do
+  let mut mutCtx := default
+  let mut i := 0
+  for recs in recss do
+    let mut x := #[]
+    for r in recs do
+      x := x.push r.name
+      mutCtx := mutCtx.insert r.name i
+    i := i + 1
+  return mutCtx
+
 /--
 Ix.Definition definitions combine Lean.DefinitionVal, Lean.OpaqueVal and
 Lean.TheoremVal into a single structure in order to enable content-addressing of
@@ -259,7 +271,7 @@ structure PreInd where
   numIndices : Nat
   all : List Lean.Name
   ctors : List Lean.ConstructorVal
-  recrs : List Lean.RecursorVal
+  --recrs : List Lean.RecursorVal
   numNested: Nat
   isRec : Bool
   isReflexive : Bool
@@ -299,17 +311,18 @@ def indMutCtx (indss: List (List PreInd)) : Map Lean.Name Nat
   let mut idx := 0
   for inds in indss do
     let mut maxCtors := 0
-    let mut maxRecrs := 0
+    --let mut maxRecrs := 0
     for ind in inds do
       maxCtors := max maxCtors ind.ctors.length
-      maxRecrs := max maxRecrs ind.recrs.length
+      --maxRecrs := max maxRecrs ind.recrs.length
     for ind in inds do
       mutCtx := mutCtx.insert ind.name idx
       for (c, cidx) in List.zipIdx ind.ctors do
         mutCtx := mutCtx.insert c.name (idx + 1 + cidx)
-      for (r, ridx) in List.zipIdx ind.recrs do
-        mutCtx := mutCtx.insert r.name (idx + 1 + maxCtors + ridx)
-    idx := idx + 1 + maxCtors + maxRecrs
+      --for (r, ridx) in List.zipIdx ind.recrs do
+      --  mutCtx := mutCtx.insert r.name (idx + 1 + maxCtors + ridx)
+    --idx := idx + 1 + maxCtors + maxRecrs
+    idx := idx + 1 + maxCtors
   return mutCtx
 
 /--
@@ -325,7 +338,7 @@ structure Inductive where
   numIndices : Nat
   all : List Lean.Name
   ctors : List Constructor
-  recrs : List Recursor
+  --recrs : List Recursor
   numNested: Nat
   isRec : Bool
   isReflexive : Bool
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index b06b96d1..ab12266c 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -160,23 +160,17 @@ instance : Serialize Tag4 where
   put := putTag4
   get := getTag4
 
-def putList [Serialize A] (xs : List A) : PutM Unit := do
-  Serialize.put (Tag4.mk 0xA (UInt64.ofNat xs.length))
-  List.forM xs Serialize.put
+def putBytesTagged (xs : ByteArray) : PutM Unit := do
+  Serialize.put (Tag4.mk 0x9 (UInt64.ofNat xs.size))
+  xs.data.forM Serialize.put
 
-def getList [Serialize A] : GetM (List A) := do
+def getBytesTagged : GetM ByteArray := do
   let tag : Tag4 <- Serialize.get
   match tag with
-  | ⟨0xA, size⟩ => do
-    List.mapM (λ _ => Serialize.get) (List.range size.toNat)
-  | e => throw s!"expected List with tag 0xA, got {repr e}"
-
-instance [Serialize A] : Serialize (List A) where
-  put := putList
-  get := getList
-
-def putBytesTagged (x: ByteArray) : PutM Unit := Serialize.put x.toList
-def getBytesTagged : GetM ByteArray := (.mk ∘ .mk) <$> Serialize.get
+  | ⟨0x9, size⟩ => do
+    let bs <- Array.mapM (λ _ => Serialize.get) (Array.range size.toNat)
+    return ⟨bs⟩
+  | e => throw s!"expected Bytes with tag 0xA, got {repr e}"
 
 instance : Serialize ByteArray where
   put := putBytesTagged
@@ -292,6 +286,14 @@ instance (priority := default + 105)
     | [a, b, c, d, e, f, g, h] => pure (a, b, c, d, e, f, g, h)
     | e => throw s!"expected packed (Bool × Bool × Bool × Bool × Bool × Bool × Bool × Bool), got {e}"
 
+instance [Serialize A] : Serialize (List A) where
+  put xs := do
+    Serialize.put xs.length
+    puts xs
+  get := do
+    let len : Nat <- Serialize.get
+    gets len
+
 def putQuotKind : Lean.QuotKind → PutM Unit
 | .type => putUInt8 0
 | .ctor => putUInt8 1
@@ -380,20 +382,6 @@ instance [Serialize A] [Serialize B] : Serialize (A × B) where
   put := fun (a, b) => Serialize.put a *> Serialize.put b
   get := (·,·) <$> Serialize.get <*> Serialize.get
 
-def putOption [Serialize A]: Option A → PutM Unit
-| .none => Serialize.put ([] : List A)
-| .some x => Serialize.put [x]
-
-def getOption [Serialize A] : GetM (Option A) := do
-  match ← Serialize.get with
-  | [] => return .none
-  | [x] => return .some x
-  | _ => throw s!"Expected Option"
-
-instance [Serialize A] : Serialize (Option A) where
-  put := putOption
-  get := getOption
-
 instance: Serialize Unit where
   put _ := pure ()
   get := pure ()
@@ -460,6 +448,22 @@ instance : Serialize RecursorRule where
   put x := Serialize.put (x.fields, x.rhs)
   get := (fun (a,b) => .mk a b) <$> Serialize.get
 
+--structure Recursor where
+--  k : Bool
+--  isUnsafe: Bool
+--  lvls : Nat
+--  params : Nat
+--  indices : Nat
+--  motives : Nat
+--  minors : Nat
+--  type : Address
+--  rules : List RecursorRule
+--  deriving BEq, Repr, Inhabited, Ord, Hashable
+--
+--instance : Serialize Recursor where
+--  put x := Serialize.put ((x.k, x.isUnsafe), x.lvls, x.params, x.indices, x.motives, x.minors, x.type, x.rules)
+--  get := (fun ((a,b),c,d,e,f,g,h,i) => .mk a b c d e f g h i) <$> Serialize.get
+
 structure Recursor where
   k : Bool
   isUnsafe: Bool
@@ -486,12 +490,13 @@ structure Inductive where
   nested : Nat
   type : Address
   ctors : List Constructor
-  recrs : List Recursor
+  --recrs : List Recursor
   deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Inductive where
-  put x := Serialize.put ((x.recr,x.refl,x.isUnsafe), x.lvls, x.params, x.indices, x.nested, x.type, x.ctors, x.recrs)
-  get := (fun ((a,b,c),d,e,f,g,h,i,j) => .mk a b c d e f g h i j) <$> Serialize.get
+  put x := Serialize.put ((x.recr,x.refl,x.isUnsafe), x.lvls, x.params,
+  x.indices, x.nested, x.type, x.ctors) --, x.recrs)
+  get := (fun ((a,b,c),d,e,f,g,h,i) => .mk a b c d e f g h i) <$> Serialize.get
 
 structure InductiveProj where
   idx : Nat
@@ -514,13 +519,12 @@ instance : Serialize ConstructorProj where
 
 structure RecursorProj where
   idx : Nat
-  ridx : Nat
   block : Address
   deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize RecursorProj where
-  put := fun x => Serialize.put (x.idx, x.ridx, x.block)
-  get := (fun (x,y,z) => .mk x y z) <$> Serialize.get
+  put := fun x => Serialize.put (x.idx, x.block)
+  get := (fun (x,y) => .mk x y) <$> Serialize.get
 
 structure DefinitionProj where
   idx : Nat
@@ -782,27 +786,28 @@ inductive Ixon where
 | usucc : Address -> Ixon                               -- 0x04 univ succ
 | umax  : Address -> Address -> Ixon                    -- 0x05 univ max
 | uimax : Address -> Address -> Ixon                    -- 0x06 univ imax
-| uvar  : Nat -> Ixon                                   -- 0x1X
+| uvar  : Nat -> Ixon                                   -- 0x1X univ var
 | evar  : Nat -> Ixon                                   -- 0x2X, variables
 | eref  : Address -> List Address -> Ixon               -- 0x3X, global reference
 | erec  : Nat -> List Address -> Ixon                   -- 0x4X, local recursion
 | eprj  : Address -> Nat -> Address -> Ixon             -- 0x5X, structure projection
-| esort : Address -> Ixon                               -- 0x90, universes
-| estr  : Address -> Ixon                               -- 0x91, utf8 string
-| enat  : Address -> Ixon                               -- 0x92, natural number
-| eapp  : Address -> Address -> Ixon                    -- 0x93, application
-| elam  : Address -> Address -> Ixon                    -- 0x94, lambda
-| eall  : Address -> Address -> Ixon                    -- 0x95, forall
-| elet  : Bool -> Address -> Address -> Address -> Ixon -- 0x96, 0x97, let
-| list : List Ixon -> Ixon                              -- 0xAX, list
-| defn : Definition -> Ixon                             -- 0xB0, definition
-| axio : Axiom -> Ixon                                  -- 0xB1, axiom
-| quot : Quotient -> Ixon                               -- 0xB2, quotient
-| cprj : ConstructorProj -> Ixon                        -- 0xB3, ctor projection
-| rprj : RecursorProj -> Ixon                           -- 0xB4, recr projection
-| iprj : InductiveProj -> Ixon                          -- 0xB5, indc projection
-| dprj : DefinitionProj -> Ixon                         -- 0xB6, defn projection
-| inds : List Inductive -> Ixon                         -- 0xCX, mutual inductive types
+| esort : Address -> Ixon                               -- 0x80, universes
+| estr  : Address -> Ixon                               -- 0x81, utf8 string
+| enat  : Address -> Ixon                               -- 0x82, natural number
+| eapp  : Address -> Address -> Ixon                    -- 0x83, application
+| elam  : Address -> Address -> Ixon                    -- 0x84, lambda
+| eall  : Address -> Address -> Ixon                    -- 0x85, forall
+| elet  : Bool -> Address -> Address -> Address -> Ixon -- 0x86, 0x87, let
+| blob : ByteArray -> Ixon                              -- 0x9X, bytes
+| defn : Definition -> Ixon                             -- 0xA0, definition
+| axio : Axiom -> Ixon                                  -- 0xA1, axiom
+| quot : Quotient -> Ixon                               -- 0xA2, quotient
+| cprj : ConstructorProj -> Ixon                        -- 0xA3, ctor projection
+| rprj : RecursorProj -> Ixon                           -- 0xA4, recr projection
+| iprj : InductiveProj -> Ixon                          -- 0xA5, indc projection
+| dprj : DefinitionProj -> Ixon                         -- 0xA6, defn projection
+| inds : List Inductive -> Ixon                         -- 0xBX, mutual inductive types
+| recs : List Recursor -> Ixon                          -- 0xCX, mutual recursors
 | defs : List Definition -> Ixon                        -- 0xDX, mutual definitions
 | prof : Proof -> Ixon                                  -- 0xE0, zero-knowledge proof
 | eval : EvalClaim -> Ixon                              -- 0xE1, cryptographic claim
@@ -812,8 +817,7 @@ inductive Ixon where
 | meta : Metadata -> Ixon                               -- 0xFX, Lean4 metadata
 deriving BEq, Repr, Inhabited, Ord, Hashable
 
-
-partial def putIxon : Ixon -> PutM Unit
+def putIxon : Ixon -> PutM Unit
 | .nanon => put (Tag4.mk 0x0 0)
 | .nstr n s => put (Tag4.mk 0x0 1) *> put n *> put s
 | .nnum n i => put (Tag4.mk 0x0 2) *> put n *> put i
@@ -830,28 +834,29 @@ partial def putIxon : Ixon -> PutM Unit
 | .eref a ls => put (Tag4.mk 0x3 ls.length.toUInt64) *> put a *> puts ls
 | .erec i ls =>
   let bytes := i.toBytesLE
-  put (Tag4.mk 0x4 bytes.size.toUInt64) *> putBytes ⟨bytes⟩ *> putList ls
+  put (Tag4.mk 0x4 bytes.size.toUInt64) *> putBytes ⟨bytes⟩ *> puts ls
 | .eprj t n x =>
   let bytes := n.toBytesLE
   put (Tag4.mk 0x5 bytes.size.toUInt64) *> put t *> putBytes ⟨bytes⟩ *> put x
-| .esort u => put (Tag4.mk 0x9 0x0) *> put u
-| .estr s => put (Tag4.mk 0x9 0x1) *> put s
-| .enat n => put (Tag4.mk 0x9 0x2) *> put n
-| .eapp f a => put (Tag4.mk 0x9 0x3) *> put f *> put a
-| .elam t b => put (Tag4.mk 0x9 0x4) *> put t *> put b
-| .eall t b => put (Tag4.mk 0x9 0x5) *> put t *> put b
+| .esort u => put (Tag4.mk 0x8 0x0) *> put u
+| .estr s => put (Tag4.mk 0x8 0x1) *> put s
+| .enat n => put (Tag4.mk 0x8 0x2) *> put n
+| .eapp f a => put (Tag4.mk 0x8 0x3) *> put f *> put a
+| .elam t b => put (Tag4.mk 0x8 0x4) *> put t *> put b
+| .eall t b => put (Tag4.mk 0x8 0x5) *> put t *> put b
 | .elet nD t d b => if nD
-  then put (Tag4.mk 0x9 0x6) *> put t *> put d *> put b
-  else put (Tag4.mk 0x9 0x7) *> put t *> put d *> put b
-| .list xs => put (Tag4.mk 0xA xs.length.toUInt64) *> (List.forM xs putIxon)
-| .defn x => put (Tag4.mk 0xB 0x0) *> put x
-| .axio x => put (Tag4.mk 0xB 0x1) *> put x
-| .quot x => put (Tag4.mk 0xB 0x2) *> put x
-| .cprj x => put (Tag4.mk 0xB 0x3) *> put x
-| .rprj x => put (Tag4.mk 0xB 0x4) *> put x
-| .iprj x => put (Tag4.mk 0xB 0x5) *> put x
-| .dprj x => put (Tag4.mk 0xB 0x6) *> put x
-| .inds xs => put (Tag4.mk 0xC xs.length.toUInt64) *> puts xs
+  then put (Tag4.mk 0x8 0x6) *> put t *> put d *> put b
+  else put (Tag4.mk 0x8 0x7) *> put t *> put d *> put b
+| .blob xs => put (Tag4.mk 0x9 xs.size.toUInt64) *> xs.data.forM put
+| .defn x => put (Tag4.mk 0xA 0x0) *> put x
+| .axio x => put (Tag4.mk 0xA 0x1) *> put x
+| .quot x => put (Tag4.mk 0xA 0x2) *> put x
+| .cprj x => put (Tag4.mk 0xA 0x3) *> put x
+| .rprj x => put (Tag4.mk 0xA 0x4) *> put x
+| .iprj x => put (Tag4.mk 0xA 0x5) *> put x
+| .dprj x => put (Tag4.mk 0xA 0x6) *> put x
+| .inds xs => put (Tag4.mk 0xB xs.length.toUInt64) *> puts xs
+| .recs xs => put (Tag4.mk 0xC xs.length.toUInt64) *> puts xs
 | .defs xs => put (Tag4.mk 0xD xs.length.toUInt64) *> puts xs
 | .prof x => put (Tag4.mk 0xE 0x0) *> put x
 | .eval x => put (Tag4.mk 0xE 0x1) *> put x
@@ -861,53 +866,48 @@ partial def putIxon : Ixon -> PutM Unit
 | .meta m => put m
 
 def getIxon : GetM Ixon := do
-  let st ← MonadState.get
-  go (st.bytes.size - st.idx)
-  where
-    go : Nat → GetM Ixon
-    | 0 => throw "Out of fuel"
-    | Nat.succ f => do
-      let tag <- getTag4
-      match tag with
-      | ⟨0x0, 0⟩ => pure <| .nanon
-      | ⟨0x0, 1⟩ => .nstr <$> get <*> get
-      | ⟨0x0, 2⟩ => .nnum <$> get <*> get
-      | ⟨0x0, 3⟩ => pure <| .uzero
-      | ⟨0x0, 4⟩ => .usucc <$> get
-      | ⟨0x0, 5⟩ => .umax <$> get <*> get
-      | ⟨0x0, 6⟩ => .uimax <$> get <*> get
-      | ⟨0x1, x⟩ => .uvar <$> getNat (getBytes x.toNat)
-      | ⟨0x2, x⟩ => .evar <$> getNat (getBytes x.toNat)
-      | ⟨0x3, x⟩ => .eref <$> get <*> gets x.toNat
-      | ⟨0x4, x⟩ => .erec <$> getNat (getBytes x.toNat) <*> get
-      | ⟨0x5, x⟩ => .eprj <$> get <*> getNat (getBytes x.toNat) <*> get
-      | ⟨0x9, 0⟩ => .esort <$> get
-      | ⟨0x9, 1⟩ => .estr <$> get
-      | ⟨0x9, 2⟩ => .enat <$> get
-      | ⟨0x9, 3⟩ => .eapp <$> get <*> get
-      | ⟨0x9, 4⟩ => .elam <$> get <*> get
-      | ⟨0x9, 5⟩ => .eall <$> get <*> get
-      | ⟨0x9, 6⟩ => .elet true <$> get <*> get <*> get
-      | ⟨0x9, 7⟩ => .elet false <$> get <*> get <*> get
-      | ⟨0xA, x⟩ => .list <$> getMany x.toNat (go f)
-      | ⟨0xB, 0x0⟩ => .defn <$> get
-      | ⟨0xB, 0x1⟩ => .axio <$> get
-      | ⟨0xB, 0x2⟩ => .quot <$> get
-      | ⟨0xB, 0x3⟩ => .cprj <$> get
-      | ⟨0xB, 0x4⟩ => .rprj <$> get
-      | ⟨0xB, 0x5⟩ => .iprj <$> get
-      | ⟨0xB, 0x6⟩ => .dprj <$> get
-      | ⟨0xC, x⟩ => .inds <$> getMany x.toNat get
-      | ⟨0xD, x⟩ => .defs <$> getMany x.toNat get
-      | ⟨0xE, 0x0⟩ => .prof <$> get
-      | ⟨0xE, 0x1⟩ => .eval <$> get
-      | ⟨0xE, 0x2⟩ => .chck <$> get
-      | ⟨0xE, 0x3⟩ => .comm <$> get
-      | ⟨0xE, 0x4⟩ => .envn <$> get
-      | ⟨0xF, x⟩ => do
-        let nodes <- getMany x.toNat Serialize.get
-        return .meta ⟨nodes⟩
-      | x => throw s!"Unknown Ixon tag {repr x}"
+  let tag <- getTag4
+  match tag with
+  | ⟨0x0, 0⟩ => pure <| .nanon
+  | ⟨0x0, 1⟩ => .nstr <$> get <*> get
+  | ⟨0x0, 2⟩ => .nnum <$> get <*> get
+  | ⟨0x0, 3⟩ => pure <| .uzero
+  | ⟨0x0, 4⟩ => .usucc <$> get
+  | ⟨0x0, 5⟩ => .umax <$> get <*> get
+  | ⟨0x0, 6⟩ => .uimax <$> get <*> get
+  | ⟨0x1, x⟩ => .uvar <$> getNat (getBytes x.toNat)
+  | ⟨0x2, x⟩ => .evar <$> getNat (getBytes x.toNat)
+  | ⟨0x3, x⟩ => .eref <$> get <*> gets x.toNat
+  | ⟨0x4, x⟩ => .erec <$> getNat (getBytes x.toNat) <*> get
+  | ⟨0x5, x⟩ => .eprj <$> get <*> getNat (getBytes x.toNat) <*> get
+  | ⟨0x8, 0⟩ => .esort <$> get
+  | ⟨0x8, 1⟩ => .estr <$> get
+  | ⟨0x8, 2⟩ => .enat <$> get
+  | ⟨0x8, 3⟩ => .eapp <$> get <*> get
+  | ⟨0x8, 4⟩ => .elam <$> get <*> get
+  | ⟨0x8, 5⟩ => .eall <$> get <*> get
+  | ⟨0x8, 6⟩ => .elet true <$> get <*> get <*> get
+  | ⟨0x8, 7⟩ => .elet false <$> get <*> get <*> get
+  | ⟨0x9, x⟩ => (.blob ∘ .mk ∘ .mk) <$> getMany x.toNat getUInt8
+  | ⟨0xA, 0x0⟩ => .defn <$> get
+  | ⟨0xA, 0x1⟩ => .axio <$> get
+  | ⟨0xA, 0x2⟩ => .quot <$> get
+  | ⟨0xA, 0x3⟩ => .cprj <$> get
+  | ⟨0xA, 0x4⟩ => .rprj <$> get
+  | ⟨0xA, 0x5⟩ => .iprj <$> get
+  | ⟨0xA, 0x6⟩ => .dprj <$> get
+  | ⟨0xC, x⟩ => .inds <$> getMany x.toNat get
+  | ⟨0xB, x⟩ => .recs <$> getMany x.toNat get
+  | ⟨0xD, x⟩ => .defs <$> getMany x.toNat get
+  | ⟨0xE, 0x0⟩ => .prof <$> get
+  | ⟨0xE, 0x1⟩ => .eval <$> get
+  | ⟨0xE, 0x2⟩ => .chck <$> get
+  | ⟨0xE, 0x3⟩ => .comm <$> get
+  | ⟨0xE, 0x4⟩ => .envn <$> get
+  | ⟨0xF, x⟩ => do
+    let nodes <- getMany x.toNat Serialize.get
+    return .meta ⟨nodes⟩
+  | x => throw s!"Unknown Ixon tag {repr x}"
 
 instance : Serialize Ixon where
   put := putIxon
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index 2d688081..bc9626c8 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -68,4 +68,3 @@ def metaMakeEvalClaim (func: Lean.Name) (args : List Lean.Expr)
   let lvls := (Lean.collectLevelParams default input).params.toList
   return (lvls, input, output, type, sort)
 
-
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 2d5dd2d5..65cf4883 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -182,12 +182,13 @@ def testDifficult : IO TestSeq := do
 def testRoundtripGetEnv : IO TestSeq := do
   IO.println s!"Getting env"
   let env <- get_env!
+  IO.println s!"Building condensation graph of env"
+  let numDelta := env.getDelta.stats.numNodes
+  let numConst := env.getConstMap.size
   let mut cstt : CompileState := .init env 0
   IO.println s!"Compiling env"
   let mut inDelta := 0
   let mut inConst := 0
-  let numDelta := env.getDelta.stats.numNodes
-  let numConst := env.getConstMap.size
   let allStart <- IO.monoNanosNow
   for (_, c) in env.getDelta do
     let start <- IO.monoNanosNow
@@ -264,6 +265,6 @@ def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
   --testInductives,
   --testDifficult,
   --testUnits,
-  testEasy
-  --testRoundtripGetEnv
+  --testEasy,
+  testRoundtripGetEnv
 ]
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 22e01ec2..c7a25cc4 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -36,7 +36,7 @@ def genConstructorProj : Gen Ixon.ConstructorProj :=
   .mk <$> genNat <*> genNat <*> genAddress
 
 def genRecursorProj : Gen Ixon.RecursorProj :=
-  .mk <$> genNat <*> genNat <*> genAddress
+  .mk <$> genNat <*> genAddress
 
 def genInductiveProj : Gen Ixon.InductiveProj :=
   .mk <$> genNat <*> genAddress
@@ -56,7 +56,8 @@ def genConstructor : Gen Ixon.Constructor :=
 
 def genInductive : Gen Ixon.Inductive :=
   .mk <$> genBool <*> genBool <*> genBool <*> genNat <*> genNat <*> genNat <*> genNat
-    <*> genAddress <*> genList genConstructor <*> genList genRecursor
+    <*> genAddress <*> genList genConstructor
+    --<*> genList genRecursor
 
 def genEvalClaim : Gen Ixon.EvalClaim :=
   .mk <$> genAddress <*> genAddress <*> genAddress <*> genAddress
@@ -133,16 +134,16 @@ partial def genIxon : Gen Ixon.Ixon :=
     (10, .elam <$> genAddress <*> genAddress),
     (10, .eall <$> genAddress <*> genAddress),
     (10, .elet <$> genBool <*> genAddress <*> genAddress <*> genAddress),
-    (10, .list <$> genList genIxon),
+    (10, (.blob ∘ .mk ∘ .mk) <$> genList genUInt8),
     (10, .defn <$> genDefinition),
     (10, .axio <$> genAxiom),
     (10, .quot <$> genQuotient),
     (10, .cprj <$> genConstructorProj),
-    (10, .rprj <$> genRecursorProj),
     (10, .iprj <$> genInductiveProj),
     (10, .dprj <$> genDefinitionProj),
     (10, .inds <$> genList genInductive),
     (10, .defs <$> genList genDefinition),
+    (10, .recs <$> genList genRecursor),
     (10, .prof <$> genProof),
     (10, .eval <$> genEvalClaim),
     (10, .chck <$> genCheckClaim),

From bd52874073ffd5ccb8ab199b102098fdb89ceeb9 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 15 Oct 2025 17:45:46 -0400
Subject: [PATCH 53/74] simplify mutual compilation, remove IR

---
 Ix.lean               |   1 -
 Ix/CompileM.lean      | 643 ++++++++++++++----------------------------
 Ix/IR.lean            | 603 ---------------------------------------
 Ix/Ixon.lean          |  93 +++---
 Ix/Mutual.lean        |  99 +++++++
 Tests/Ix/Compile.lean |  17 +-
 Tests/Ix/IR.lean      | 122 --------
 Tests/Ix/Ixon.lean    |   6 +-
 8 files changed, 376 insertions(+), 1208 deletions(-)
 delete mode 100644 Ix/IR.lean
 create mode 100644 Ix/Mutual.lean

diff --git a/Ix.lean b/Ix.lean
index 0aa1279a..cf563426 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -1,7 +1,6 @@
 -- This module serves as the root of the `Ix` library.
 -- Import modules here that should be built as part of the library.
 import Ix.Ixon
-import Ix.IR
 import Ix.Meta
 import Ix.CompileM
 import Ix.CondenseM
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index ab351204..d65ab5ac 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -1,14 +1,13 @@
 import Std.Data.HashMap
 import Ix.Ixon
 import Ix.Address
-import Ix.IR
+import Ix.Mutual
 import Ix.Common
 import Ix.CondenseM
 --import Ix.Store
 import Ix.SOrder
 import Ix.Cronos
 
-
 namespace Ix
 open Ixon hiding Substring
 
@@ -41,17 +40,6 @@ structure CompileState where
   blocks: Map MetaAddress Unit
   cronos: Cronos
 
-def collectRecursors (env: Lean.Environment) : Map Lean.Name (Set Lean.Name) := Id.run do
- let mut map := {}
- for (n, c) in env.constants do
-  match c with
-  | .recInfo val => do
-    map := map.alter val.getMajorInduct <| fun x => match x with
-      | .none => .some {n}
-      | .some s => .some (s.insert n)
-  | _ => continue
- return map
-
 def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize := 200000)
   : CompileState :=
   ⟨maxHeartBeats, env, mkStdGen seed, default, default, default, default,
@@ -66,19 +54,17 @@ inductive CompileError where
 | invalidBVarIndex : Nat -> CompileError
 | levelNotFound : Lean.Name -> List Lean.Name -> String -> CompileError
 | invalidConstantKind : Lean.Name -> String -> String -> CompileError
-| compileMutualBlockMissingProjection : Lean.Name -> CompileError
-| compileInductiveBlockMissingProjection : Lean.Name -> CompileError
+| mutualBlockMissingProjection : Lean.Name -> CompileError
 --| nonRecursorExtractedFromChildren : Lean.Name → CompileError
-| cantFindMutDefIndex : Lean.Name -> CompileError
+| cantFindMutIndex : Lean.Name -> MutCtx -> CompileError
+| cantFindMutMeta : Lean.Name -> Map Lean.Name Metadata -> CompileError
 | kernelException : Lean.Kernel.Exception → CompileError
 --| cantPackLevel : Nat → CompileError
 --| nonCongruentInductives : PreInd -> PreInd -> CompileError
 | alphaInvarianceFailure : Lean.ConstantInfo -> MetaAddress -> Lean.ConstantInfo -> MetaAddress -> CompileError
 --| dematBadMutualBlock: MutualBlock -> CompileError
 --| dematBadInductiveBlock: InductiveBlock -> CompileError
-| badMutualBlock: List (List PreDef) -> CompileError
-| badInductiveBlock: List (List PreInd) -> CompileError
-| badRecursorBlock: List (List Lean.RecursorVal) -> CompileError
+| badMutualBlock: List (List MutConst) -> CompileError
 | badIxonDeserialization : Address -> String -> CompileError
 | unknownStoreAddress : Address -> CompileError
 | condensationError : Lean.Name -> CompileError
@@ -92,15 +78,14 @@ def CompileError.pretty : CompileError -> IO String
 | .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
 | .levelNotFound n ns msg => pure s!"'Level {n}' not found in '{ns}', {msg}"
 | .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
-| .compileMutualBlockMissingProjection n => pure s!"Constant '{n}' wasn't content-addressed in mutual block"
-| .compileInductiveBlockMissingProjection n => pure s!"Constant '{n}' wasn't content-addressed in inductive block"
-| .cantFindMutDefIndex n => pure s!"Can't find index for mutual definition '{n}'"
+| .mutualBlockMissingProjection n => pure s!"Constant '{n}' wasn't content-addressed in mutual block"
+| .cantFindMutIndex n mc => pure s!"Can't find index for mutual definition '{n}' in {repr mc}"
+| .cantFindMutMeta n ms => pure s!"Can't find metadata for mutual definition
+'{n}' in {repr ms}"
 | .kernelException e => (·.pretty 80) <$> (e.toMessageData .empty).format
 | .alphaInvarianceFailure x xa y ya => 
   pure s!"alpha invariance failure {repr x} hashes to {xa}, but {repr y} hashes to {ya}"
 | .badMutualBlock block => pure s!"bad mutual block {repr block}"
-| .badInductiveBlock block => pure s!"bad mutual block {repr block}"
-| .badRecursorBlock block => pure s!"bad mutual block {repr block}"
 | .badIxonDeserialization a s => pure s!"bad deserialization of ixon at {a}, error: {s}"
 | .unknownStoreAddress a => pure s!"unknown store address {a}"
 | .condensationError n => pure s!"condensation error {n}"
@@ -352,14 +337,15 @@ def findLeanConst (name : Lean.Name) : CompileM Lean.ConstantInfo := do
   | some const => pure const
   | none => throw $ .unknownConstant name
 
-def isInternalRec (expr : Lean.Expr) (name : Lean.Name) : Bool :=
-  match expr with
-  | .forallE _ t e _  => match e with
-    | .forallE ..  => isInternalRec e name
-    | _ => isInternalRec t name -- t is the major premise
-  | .app e .. => isInternalRec e name
-  | .const n .. => n == name
-  | _ => false
+def MutConst.mkIndc (i: Lean.InductiveVal) : CompileM MutConst := do
+  let ctors <- i.ctors.mapM getCtor
+  return .indc ⟨i.name, i.levelParams, i.type, i.numParams, i.numIndices, i.all,
+    ctors, i.numNested, i.isRec, i.isReflexive, i.isUnsafe⟩
+  where
+    getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
+      match (<- findLeanConst name) with
+      | .ctorInfo c => pure c
+      | _ => throw <| .invalidConstantKind name "constructor" ""
 
 mutual
 
@@ -477,19 +463,18 @@ partial def compileConst (const: Lean.ConstantInfo): CompileM MetaAddress := do
     })
   where
     go : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
-    | .defnInfo val => compileDefs (mkPreDef val)
-    | .thmInfo val => compileDefs (mkPreTheorem val)
-    | .opaqueInfo val => compileDefs (mkPreOpaque val)
-    | .inductInfo val => mkPreInd val >>= compileInds
+    | .defnInfo val => compileMutual (MutConst.mkDefn val)
+    | .thmInfo val => compileMutual (MutConst.mkTheo val)
+    | .opaqueInfo val => compileMutual (MutConst.mkOpaq val)
+    | .inductInfo val => MutConst.mkIndc val >>= compileMutual
     | .ctorInfo val => do match <- findLeanConst val.induct with
       | .inductInfo ind => do
-        let _ <- mkPreInd ind >>= compileInds
+        let _ <- MutConst.mkIndc ind >>= compileMutual
         match (<- get).constCache.find? const.name with
         | some ⟨data, meta⟩ => do pure (<- getIxon data, <- getIxon meta)
-        | none => throw <| .compileInductiveBlockMissingProjection const.name
+        | none => throw <| .mutualBlockMissingProjection const.name
       | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
-    -- compile recursors through their parent inductive
-    | .recInfo val => compileRecs val
+    | .recInfo val => compileMutual (MutConst.recr val)
     | .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => withLevels lvls do
       let n <- compileName name
       let ls <- lvls.mapM compileName
@@ -505,7 +490,7 @@ partial def compileConst (const: Lean.ConstantInfo): CompileM MetaAddress := do
       let meta := .meta ⟨[.link n, .links ls, .link t.meta]⟩
       pure (data, meta)
 
-partial def compileDef: PreDef -> CompileM (Ixon.Definition × Ixon.Metadata)
+partial def compileDefn: Ix.Def -> CompileM (Ixon.Definition × Ixon.Metadata)
 | d => withLevels d.levelParams do
   let n <- compileName d.name
   let ls <- d.levelParams.mapM compileName
@@ -516,121 +501,230 @@ partial def compileDef: PreDef -> CompileM (Ixon.Definition × Ixon.Metadata)
   let meta := ⟨[.link n, .links ls, .hints d.hints, .link t.meta, .link v.meta, .links as]⟩
   return (data, meta)
 
-partial def compileMutDefs: List (List PreDef) -> CompileM (Ixon × Ixon)
-| defs => do
-  let mut data := #[]
-  let mut meta := #[]
-  -- iterate through each equivalence class
-  for defsClass in defs do
-    let mut classData := #[]
-    let mut classMeta := #[]
-    -- compile each def in a class
-    for defn in defsClass do
-      let (defn', meta') <- compileDef defn
-      classData := classData.push defn'
-      -- build up the class metadata as a list of links to the def metadata
-      classMeta := classMeta.push (.link (<- storeMeta meta'))
-    -- make sure we have no empty classes and all defs in a class are equal
-    match classData.toList with
-      | [] => throw (.badMutualBlock defs)
-      | [x] => data := data.push x
-      | x::xs =>
-        if xs.foldr (fun y acc => (y == x) && acc) true
-        then data := data.push x
-        else throw (.badMutualBlock defs)
-    -- build up the block metadata as a list of links to the class metadata
-    meta := meta.push (.link (<- storeMeta ⟨classMeta.toList⟩))
-  pure (.defs data.toList, .meta ⟨meta.toList⟩)
+partial def compileRule: Lean.RecursorRule -> CompileM (Ixon.RecursorRule × (Address × Address))
+| r => do
+  let n <- compileName r.ctor
+  let rhs <- compileExpr r.rhs
+  pure (⟨r.nfields, rhs.data⟩, (n, rhs.meta))
+
+partial def compileRecr: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata)
+| r => withLevels r.levelParams <| do
+  let n <- compileName r.name
+  let ls <- r.levelParams.mapM compileName
+  let t <- compileExpr r.type
+  let rules <- r.rules.mapM compileRule
+  let data := ⟨r.k, r.isUnsafe, ls.length, r.numParams, r.numIndices,
+    r.numMotives, r.numMinors, t.data, rules.map (·.1)⟩
+  let meta := ⟨[.link n, .links ls, .rules (rules.map (·.2))]⟩
+  pure (data, meta)
 
-partial def compileDefs: PreDef -> CompileM (Ixon × Ixon)
-| d => do
-  let all: Set Lean.Name <- getAll d.name
-  if all == {d.name} then do
-    let (data, meta) <- withMutCtx {(d.name,0)} <| compileDef d
-    pure (.defn data, .meta meta)
-  else do
-    let mut defs : Array PreDef := #[]
+partial def compileConstructor: Lean.ConstructorVal -> CompileM (Ixon.Constructor × Address)
+| c => withLevels c.levelParams <| do
+  let n <- compileName c.name
+  let ls <- c.levelParams.mapM compileName
+  let t <- compileExpr c.type
+  let data := ⟨c.isUnsafe, ls.length, c.cidx, c.numParams, c.numFields, t.data⟩
+  let meta <- storeMeta ⟨[.link n, .links ls, .link t.meta]⟩
+  pure (data, meta)
+
+partial def compileIndc: Ix.Ind -> CompileM (Ixon.Inductive × Ixon.Metadata)
+| ⟨name, lvls, type, ps, is, all, ctors, nest, rcr, refl, usafe⟩ =>
+  withLevels lvls do 
+  let n <- compileName name
+  let ls <- lvls.mapM compileName
+  let t <- compileExpr type
+  let cs <- ctors.mapM compileConstructor
+  let as <- all.mapM compileName
+  let data := ⟨rcr, refl, usafe, ls.length, ps, is, nest, t.data,
+    cs.map (·.1)⟩
+  let meta := ⟨[.link n, .links ls, .link t.meta,
+    .links (cs.map (·.2)), .links as]⟩
+  pure (data, meta)
+
+partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
+| const => do
+  let all: Set Lean.Name <- getAll const.name
+  if all == {const.name} && const matches .defn _ then do
+    match const with
+    | .defn d => do
+      let (data, meta) <- withMutCtx {(d.name,0)} <| compileDefn d
+      pure (.defn data, .meta meta)
+    | .recr r => do
+      let (data, meta) <- withMutCtx {(r.name,0)} <| compileRecr r
+      pure (.recr data, .meta meta)
+    | _ => unreachable!
+  else
+    let mut consts := #[]
     for name in all do
       match <- findLeanConst name with
-      | .defnInfo x => defs := defs.push (mkPreDef x)
-      | .opaqueInfo x => defs := defs.push (mkPreOpaque x)
-      | .thmInfo x => defs := defs.push (mkPreTheorem x)
-      | x => throw $ .invalidConstantKind x.name "mutdef" x.ctorName
-    let mutDefs <- sortDefs defs.toList
-    let mutCtx := defMutCtx mutDefs
-    let (data, meta) <- withMutCtx mutCtx <| compileMutDefs mutDefs
+      | .inductInfo val => do consts := consts.push (<- MutConst.mkIndc val)
+      | .defnInfo val => consts := consts.push (MutConst.mkDefn val)
+      | .opaqueInfo val => consts := consts.push (MutConst.mkOpaq val)
+      | .thmInfo val => consts := consts.push (MutConst.mkTheo val)
+      | .recInfo val => consts := consts.push (MutConst.recr val)
+      | _ => continue
+    -- sort MutConsts into equivalence classes
+    let mutConsts <- sortConsts consts.toList
+    let mutCtx := MutConst.ctx mutConsts
+    -- compile each constant with the mutCtx
+    let (data, metas) <- withMutCtx mutCtx (compileMutConsts mutConsts)
     -- add top-level mutual block to our state
-    let block := ⟨<- storeIxon data, <- storeIxon meta⟩
+    let allAddrs <- all.toList.mapM compileName
+    let block := ⟨<- storeIxon data, <- storeMeta ⟨[.links allAddrs]⟩⟩
     modify fun stt => { stt with blocks := stt.blocks.insert block () }
-    -- then add all the projections, returning the def we started with
+    -- then add all projections, returning the inductive we started with
     let mut ret? : Option (Ixon × Ixon) := none
-    for name in all do
-      let idx <- do match mutCtx.find? name with
+    for const' in consts do
+      let idx <- do match mutCtx.find? const'.name with
       | some idx => pure idx
-      | none => throw $ .cantFindMutDefIndex name
-      let data := .dprj ⟨idx, block.data⟩
-      let meta := .meta ⟨[.link block.meta]⟩
-      let addr := ⟨<- storeIxon data, <- storeIxon meta⟩
+      | none => throw $ .cantFindMutIndex const'.name mutCtx
+      let meta <- do match metas.find? const'.name with
+      | some meta => pure ⟨(.link block.meta)::meta.nodes⟩
+      | none => throw $ .cantFindMutMeta const'.name metas
+      let data := match const with
+      | .defn _ => .dprj ⟨idx, block.data⟩
+      | .indc _ => .iprj ⟨idx, block.data⟩
+      | .recr _ => .rprj ⟨idx, block.data⟩
+      let addr := ⟨<- storeIxon data, <- storeMeta meta⟩
       modify fun stt => { stt with
-        constCache := stt.constCache.insert name addr
+        constCache := stt.constCache.insert const'.name addr
       }
-      if name == d.name then ret? := some (data, meta)
+      if const'.name == const.name then ret? := some (data, .meta meta)
+      for ctor in const'.ctors do
+        let cdata := .cprj ⟨idx, ctor.cidx, block.data⟩
+        let cmeta <- do match metas.find? const'.name with
+        | some meta => pure ⟨(.link block.meta)::meta.nodes⟩
+        | none => throw $ .cantFindMutMeta const'.name metas
+        let caddr := ⟨<- storeIxon cdata, <- storeMeta cmeta⟩
+        modify fun stt => { stt with
+          constCache := stt.constCache.insert ctor.name caddr
+        }
     match ret? with
     | some ret => return ret
-    | none => throw $ .compileMutualBlockMissingProjection d.name
+    | none => throw $ .mutualBlockMissingProjection const.name
 
-/--
-`sortDefs` recursively sorts a list of mutually referential definitions into
-ordered equivalence classes. For most cases equivalence can be determined by
-syntactic differences in the definitions, but when two definitions
-refer to one another in the same syntactical position the classification can
-be self-referential. Therefore we use a partition refinement algorithm that
-starts by assuming that all definitions in the mutual block are equal and
-recursively improves our classification by sorting based on syntax:
-
-```
-classes₀ := [startDefs]
-classes₁ := sortDefs classes₀
-classes₂ := sortDefs classes₁
-classes₍ᵢ₊₁₎ := sortDefs classesᵢ ...
-```
-Eventually we reach a fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no
-further refinement is possible (trivially when each def is in its own class). --/
-partial def sortDefs (classes: List PreDef) : CompileM (List (List PreDef)) :=
-  go [List.sortBy (compare ·.name ·.name) classes]
+/-- Compile a mutual block --/
+partial def compileMutConsts: List (List MutConst) -> CompileM (Ixon × Map Lean.Name Metadata)
+| classes => do
+  let mut data := #[]
+  let mut meta := {}
+  -- iterate through each equivalence class
+  for constClass in classes do
+    let mut classData := #[]
+    -- compile each def in a class
+    for const in constClass do
+      let (data', meta') <- match const with
+      | .indc x => (fun (x, y) => (Ixon.MutConst.indc x, y)) <$> compileIndc x
+      | .defn x => (fun (x, y) => (Ixon.MutConst.defn x, y)) <$> compileDefn x
+      | .recr x => (fun (x, y) => (Ixon.MutConst.recr x, y)) <$> compileRecr x
+      classData := classData.push data'
+      meta := meta.insert const.name meta'
+    -- make sure we have no empty classes and all defs in a class are equal
+    match classData.toList with
+      | [] => throw (.badMutualBlock classes)
+      | [x] => data := data.push x
+      | x::xs =>
+        if xs.foldr (fun y acc => (y == x) && acc) true
+        then data := data.push x
+        else throw (.badMutualBlock classes)
+  pure (.muts data.toList, meta)
+
+--/--
+--`sortConsts` recursively sorts a list of mutually referential constants into
+--ordered equivalence classes. For most cases equivalence can be determined by
+--syntactic differences in the definitions, but when two definitions
+--refer to one another in the same syntactical position the classification can
+--be self-referential. Therefore we use a partition refinement algorithm that
+--starts by assuming that all definitions in the mutual block are equal and
+--recursively improves our classification by sorting based on syntax:
+--```
+--classes₀ := [startConsts]
+--classes₁ := sortConsts classes₀
+--classes₂ := sortConsts classes₁
+--classes₍ᵢ₊₁₎ := sortConsts classesᵢ ...
+--```
+--Eventually we reach a fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no
+--further refinement is possible (trivially when each const is in its own class). --/
+partial def sortConsts (classes: List MutConst) : CompileM (List (List MutConst))
+  := go [List.sortBy (compare ·.name ·.name) classes]
   where
-    go (cs: List (List PreDef)): CompileM (List (List PreDef)) := do
+    go (cs: List (List MutConst)): CompileM (List (List MutConst)) := do
       --dbg_trace "sortDefs blocks {(<- get).blocks.size} {(<- read).current}"
-      let ctx := defMutCtx cs
+      let ctx := MutConst.ctx cs
       let cs' <- cs.mapM fun ds =>
         match ds with
         | []  => throw <| .badMutualBlock cs
         | [d] => pure [[d]]
-        | ds  => ds.sortByM (compareDef ctx) >>= List.groupByM (eqDef ctx)
+        | ds  => ds.sortByM (compareConst ctx) >>= List.groupByM (eqConst ctx)
       let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
       if cs == cs' then return cs' else go cs'
 
 /-- AST comparison of two Lean definitions. --/
-partial def compareDef (ctx: MutCtx) (x y: PreDef)
+partial def compareConst (ctx: MutCtx) (x y: MutConst)
   : CompileM Ordering := do
-  --dbg_trace "compareDefs constCmp {(<- get).constCmp.size} {(<- read).current}"
   let key := match compare x.name y.name with
     | .lt => (x.name, y.name)
     | _ => (y.name, x.name)
   match (<- get).constCmp.find? key with
   | some o => return o
   | none => do
-    let sorder <- SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
-        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
+    let sorder: SOrder <- match x,y with
+    | .defn x, .defn y => compareDef x y
+    | .defn _, _ => pure ⟨true, Ordering.lt⟩
+    | .indc x, .indc y => compareInd x y
+    | .indc _, _ => pure ⟨true, Ordering.lt⟩
+    | .recr x, .recr y => compareRecr x y
+    | .recr _, _ => pure ⟨true, Ordering.lt⟩
     if sorder.strong then modify fun stt => { stt with
         constCmp := stt.constCmp.insert key sorder.ord
       }
     return sorder.ord
+  where
+    compareDef (x y: Def) : CompileM SOrder := do
+      SOrder.cmpM (pure ⟨true, compare x.kind y.kind⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+        (compareExpr ctx x.levelParams y.levelParams x.value y.value)
+    compareInd (x y: Ind) : CompileM SOrder := do
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.numIndices y.numIndices⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.ctors.length y.ctors.length⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+      (SOrder.zipM compareCtor x.ctors y.ctors)
+    compareCtor (x y: Lean.ConstructorVal) : CompileM SOrder := do
+      let key := match compare x.name y.name with
+        | .lt => (x.name, y.name)
+        | _ => (y.name, x.name)
+      match (<- get).constCmp.find? key with
+      | some o => return ⟨true, o⟩
+      | none => do
+      let sorder <- do
+        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.cidx y.cidx⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
+        SOrder.cmpM (pure ⟨true, compare x.numFields y.numFields⟩) <|
+          (compareExpr ctx x.levelParams y.levelParams x.type y.type)
+      if sorder.strong then modify fun stt => { stt with
+          constCmp := stt.constCmp.insert key sorder.ord
+        }
+      return sorder
+    compareRecr (x y: Lean.RecursorVal) : CompileM SOrder := do
+      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
+      SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
+      SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
+      SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
+      SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
+      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
+        (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
+    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
+      : CompileM SOrder := do
+        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
+          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
 
-partial def eqDef (ctx: MutCtx) (x y: PreDef) : CompileM Bool :=
-  (fun o => o == .eq) <$> compareDef ctx x y
+partial def eqConst (ctx: MutCtx) (x y: MutConst) : CompileM Bool :=
+  (fun o => o == .eq) <$> compareConst ctx x y
 
 /-- A name-irrelevant ordering of Lean expressions --/
 partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
@@ -689,311 +783,6 @@ partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
   | .proj _ nx tx, .proj _ ny ty => 
     SOrder.cmpM (pure ⟨true, compare nx ny⟩) 
       (compareExpr ctx xlvls ylvls tx ty)
-
-partial def mkPreInd (i: Lean.InductiveVal) : CompileM Ix.PreInd := do
-  let ctors <- i.ctors.mapM getCtor
-  --let recrs := (<- get).env.constants.fold getRecrs []
-  return ⟨i.name, i.levelParams, i.type, i.numParams, i.numIndices, i.all,
-    ctors, i.numNested, i.isRec, i.isReflexive, i.isUnsafe⟩
-  where
-    getCtor (name: Lean.Name) : CompileM (Lean.ConstructorVal) := do
-      match (<- findLeanConst name) with
-      | .ctorInfo c => pure c
-      | _ => throw <| .invalidConstantKind name "constructor" ""
-
-partial def compileConstructor: Lean.ConstructorVal -> CompileM (Ixon.Constructor × Address)
-| c => withLevels c.levelParams <| do
-  let n <- compileName c.name
-  let ls <- c.levelParams.mapM compileName
-  let t <- compileExpr c.type
-  let data := ⟨c.isUnsafe, ls.length, c.cidx, c.numParams, c.numFields, t.data⟩
-  let meta <- storeMeta ⟨[.link n, .links ls, .link t.meta]⟩
-  pure (data, meta)
-
-partial def compileInd: PreInd -> CompileM (Ixon.Inductive × Ixon.Metadata)
-| ⟨name, lvls, type, ps, is, all, ctors, nest, rcr, refl, usafe⟩ =>
-  withLevels lvls do 
-  let n <- compileName name
-  let ls <- lvls.mapM compileName
-  let t <- compileExpr type
-  --let rs <- recrs.mapM compileRecursor
-  let cs <- ctors.mapM compileConstructor
-  let as <- all.mapM compileName
-  let data := ⟨rcr, refl, usafe, ls.length, ps, is, nest, t.data,
-    cs.map (·.1)⟩
-  let meta := ⟨[.link n, .links ls, .link t.meta,
-    .links (cs.map (·.2)), .links as]⟩
-  pure (data, meta)
-
-partial def compileMutInds : List (List PreInd) -> CompileM (Ixon × Ixon)
-| inds => do
-  let mut data := #[]
-  let mut meta := #[]
-  -- iterate through each equivalence class
-  for indsClass in inds do
-    let mut classData := #[]
-    let mut classMeta := #[]
-    -- dematerialize each inductive in a class
-    for indc in indsClass do
-      let (indc', meta') <- compileInd indc
-      classData := classData.push indc'
-      -- build up the class metadata as a list of links to the indc metadata
-      classMeta := classMeta.push (.link (<- storeMeta meta'))
-    -- make sure we have no empty classes and all defs in a class are equal
-    match classData.toList with
-      | [] => throw (.badInductiveBlock inds)
-      | [x] => data := data.push x
-      | x::xs =>
-        if xs.foldr (fun y acc => (y == x) && acc) true
-        then data := data.push x
-        else throw (.badInductiveBlock inds)
-    -- build up the block metadata as a list of links to the class metadata
-    meta := meta.push (.link (<- storeMeta ⟨classMeta.toList⟩))
-  pure (.inds data.toList, .meta ⟨meta.toList⟩)
-
-/--
-Content-addresses an inductive and all inductives in the mutual block as a
-mutual block, even if the inductive itself is not in a mutual block.
-
-Content-addressing an inductive involves content-addressing its associated
-constructors and recursors, hence the complexity of this function.
--/
-partial def compileInds: PreInd -> CompileM (Ixon × Ixon)
-| ind => do
-  let all: Set Lean.Name <- getAll ind.name
-  let mut inds := #[]
-  let mut ctorNames : Map Lean.Name (List Lean.Name) := {}
-  -- collect all mutual inductives as Ix.PreInds
-  for n in all do
-    match <- findLeanConst n with
-    | .inductInfo val =>
-      let ind <- mkPreInd val
-      inds := inds.push ind
-      ctorNames := ctorNames.insert n val.ctors
-    | _ => continue
-  -- sort PreInds into equivalence classes
-  let mutInds <- sortInds inds.toList
-  let mutCtx := indMutCtx mutInds
-  -- compile each preinductive with the mutCtx
-  let (data, meta) <- withMutCtx mutCtx <| compileMutInds mutInds
-  -- add top-level mutual block to our state
-  let block := ⟨<- storeIxon data, <- storeIxon meta⟩
-  modify fun stt => { stt with blocks := stt.blocks.insert block () }
-  -- then add all projections, returning the inductive we started with
-  let mut ret? : Option (Ixon × Ixon) := none
-  for (ind', idx) in inds.zipIdx do
-    let n <- compileName ind'.name
-    let data := .iprj ⟨idx, block.data⟩
-    let meta := .meta ⟨[.link n, .link block.meta]⟩
-    let addr := ⟨<- storeIxon data, <- storeIxon meta⟩
-    modify fun stt => { stt with
-      constCache := stt.constCache.insert ind'.name addr
-    }
-    if ind'.name == ind.name then ret? := some (data, meta)
-    let some ctors := ctorNames.find? ind.name
-      | throw $ .cantFindMutDefIndex ind.name
-    for (cname, cidx) in ctors.zipIdx do
-      let cn <- compileName cname
-      let cdata := .cprj ⟨idx, cidx, block.data⟩
-      let cmeta := .meta ⟨[.link cn, .link block.meta]⟩
-      let caddr := ⟨<- storeIxon cdata, <- storeIxon cmeta⟩
-      modify fun stt => { stt with
-        constCache := stt.constCache.insert cname caddr
-      }
-    --for (rname, ridx) in recrs.zipIdx do
-    --  let rn <- compileName rname
-    --  let rdata := .rprj ⟨idx, ridx, block.data⟩
-    --  let rmeta := .meta ⟨[.link rn, .link block.meta]⟩
-    --  let raddr := ⟨<- storeIxon rdata, <- storeIxon rmeta⟩
-    --  modify fun stt => { stt with
-    --    constCache := stt.constCache.insert rname raddr
-    --  }
-  match ret? with
-  | some ret => return ret
-  | none => throw $ .compileInductiveBlockMissingProjection ind.name
-
-/-- AST comparison of two Lean inductives. --/
-partial def compareInd (ctx: MutCtx) (x y: PreInd) 
-  : CompileM Ordering := do
-  --dbg_trace "compareInd constCmp {(<- get).constCmp.size} {(<- read).current}"
-  let key := match compare x.name y.name with
-    | .lt => (x.name, y.name)
-    | _ => (y.name, x.name)
-  match (<- get).constCmp.find? key with
-  | some o => return o
-  | none => do
-    let sorder <- do
-      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.numIndices y.numIndices⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.ctors.length y.ctors.length⟩) <|
-      --SOrder.cmpM (pure ⟨true, compare x.recrs.length y.recrs.length⟩) <|
-      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
-      (SOrder.zipM compareCtor x.ctors y.ctors)
-      --SOrder.cmpM (SOrder.zipM compareCtor x.ctors y.ctors)
-      --  (SOrder.zipM compareRecr x.recrs y.recrs)
-    if sorder.strong then modify fun stt => { stt with
-        constCmp := stt.constCmp.insert key sorder.ord
-    }
-    return sorder.ord
-  where
-    compareCtor (x y: Lean.ConstructorVal) : CompileM SOrder := do
-      let key := match compare x.name y.name with
-        | .lt => (x.name, y.name)
-        | _ => (y.name, x.name)
-      match (<- get).constCmp.find? key with
-      | some o => return ⟨true, o⟩
-      | none => do
-      let sorder <- do
-        SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.cidx y.cidx⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.numParams y.numParams⟩) <|
-        SOrder.cmpM (pure ⟨true, compare x.numFields y.numFields⟩) <|
-          (compareExpr ctx x.levelParams y.levelParams x.type y.type)
-      if sorder.strong then modify fun stt => { stt with
-          constCmp := stt.constCmp.insert key sorder.ord
-        }
-      return sorder
-
-partial def eqInd (ctx: MutCtx) (x y: PreInd) : CompileM Bool :=
-  (fun o => o == .eq) <$> compareInd ctx x y
-
-/-- `sortInds` recursively sorts a list of inductive datatypes into equivalence
-classes, analogous to `sortDefs` --/
-partial def sortInds (classes : List PreInd) : CompileM (List (List PreInd)) :=
-  go [List.sortBy (compare ·.name ·.name) classes]
-  where
-    go (cs: List (List PreInd)): CompileM (List (List PreInd)) := do
-      --dbg_trace "sortInds blocks {(<- get).blocks.size} {(<- read).current}"
-      let ctx := indMutCtx cs
-      let cs' <- cs.mapM fun ds =>
-        match ds with
-        | []  => throw <| .badInductiveBlock cs
-        | [d] => pure [[d]]
-        | ds  => ds.sortByM (compareInd ctx) >>= List.groupByM (eqInd ctx)
-      let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
-      if cs == cs' then return cs' else go cs'
-
-/-- AST comparison of two Lean inductives. --/
-partial def compareRec (ctx: MutCtx) (x y: Lean.RecursorVal) 
-  : CompileM Ordering := do
-  let key := match compare x.name y.name with
-    | .lt => (x.name, y.name)
-    | _ => (y.name, x.name)
-  match (<- get).constCmp.find? key with
-  | some o => return o
-  | none => do
-    let sorder <- do
-      SOrder.cmpM (pure ⟨true, compare x.levelParams.length y.levelParams.length⟩) <|
-      SOrder.cmpM (pure ⟨true,compare x.numParams y.numParams⟩) <|
-      SOrder.cmpM (pure ⟨true,compare x.numIndices y.numIndices⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.numMotives y.numMotives⟩) <|
-      SOrder.cmpM (pure ⟨true,compare x.numMinors y.numMinors⟩) <|
-      SOrder.cmpM (pure ⟨true, compare x.k y.k⟩) <|
-      SOrder.cmpM (compareExpr ctx x.levelParams y.levelParams x.type y.type) <|
-        (SOrder.zipM (compareRule x.levelParams y.levelParams) x.rules y.rules)
-    if sorder.strong then modify fun stt => { stt with
-        constCmp := stt.constCmp.insert key sorder.ord
-      }
-    return sorder.ord
-  where
-    compareRule (xlvls ylvls: List Lean.Name) (x y: Lean.RecursorRule)
-      : CompileM SOrder := do
-        SOrder.cmpM (pure ⟨true, compare x.nfields y.nfields⟩)
-          (compareExpr ctx xlvls ylvls x.rhs y.rhs)
-
-partial def eqRec (ctx: MutCtx) (x y: Lean.RecursorVal) : CompileM Bool :=
-  (fun o => o == .eq) <$> compareRec ctx x y
-
-/-- `sortRecs` recursively sorts a list of inductive recursors into equivalence
-classes, analogous to `sortDefs` --/
-partial def sortRecs (classes : List Lean.RecursorVal)
-  : CompileM (List (List Lean.RecursorVal)) :=
-  go [List.sortBy (compare ·.name ·.name) classes]
-  where
-    go (cs: List (List Lean.RecursorVal)): CompileM (List (List Lean.RecursorVal)) := do
-      --dbg_trace "sortInds blocks {(<- get).blocks.size} {(<- read).current}"
-      let ctx := recMutCtx cs
-      let cs' <- cs.mapM fun ds =>
-        match ds with
-        | []  => throw <| .badRecursorBlock cs
-        | [d] => pure [[d]]
-        | ds  => ds.sortByM (compareRec ctx) >>= List.groupByM (eqRec ctx)
-      let cs' := cs'.flatten.map (List.sortBy (compare ·.name ·.name))
-      if cs == cs' then return cs' else go cs'
-
-partial def compileRule: Lean.RecursorRule -> CompileM (Ixon.RecursorRule × (Address × Address))
-| r => do
-  let n <- compileName r.ctor
-  let rhs <- compileExpr r.rhs
-  pure (⟨r.nfields, rhs.data⟩, (n, rhs.meta))
-
-partial def compileRec: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata)
-| r => withLevels r.levelParams <| do
-  let n <- compileName r.name
-  let ls <- r.levelParams.mapM compileName
-  let t <- compileExpr r.type
-  let rules <- r.rules.mapM compileRule
-  let data := ⟨r.k, r.isUnsafe, ls.length, r.numParams, r.numIndices,
-    r.numMotives, r.numMinors, t.data, rules.map (·.1)⟩
-  let meta := ⟨[.link n, .links ls, .rules (rules.map (·.2))]⟩
-  pure (data, meta)
-
-partial def compileMutRecs: List (List Lean.RecursorVal) -> CompileM (Ixon × Ixon)
-| recs => do
-  let mut data := #[]
-  let mut meta := #[]
-  -- iterate through each equivalence class
-  for recsClass in recs do
-    let mut classData := #[]
-    let mut classMeta := #[]
-    -- compile each def in a class
-    for recr in recsClass do
-      let (recr', meta') <- compileRec recr
-      classData := classData.push recr'
-      -- build up the class metadata as a list of links to the def metadata
-      classMeta := classMeta.push (.link (<- storeMeta meta'))
-    -- make sure we have no empty classes and all defs in a class are equal
-    match classData.toList with
-      | [] => throw (.badRecursorBlock recs)
-      | [x] => data := data.push x
-      | x::xs =>
-        if xs.foldr (fun y acc => (y == x) && acc) true
-        then data := data.push x
-        else throw (.badRecursorBlock recs)
-    -- build up the block metadata as a list of links to the class metadata
-    meta := meta.push (.link (<- storeMeta ⟨classMeta.toList⟩))
-  pure (.recs data.toList, .meta ⟨meta.toList⟩)
-
-partial def compileRecs : Lean.RecursorVal -> CompileM (Ixon × Ixon)
-| r => do
-  let all: Set Lean.Name <- getAll r.name
-  let mut recs : Array Lean.RecursorVal := #[]
-  for name in all do
-    match <- findLeanConst name with
-    | .recInfo val => recs := recs.push val
-    | x => throw $ .invalidConstantKind x.name "recursor" x.ctorName
-  let mutRecs <- sortRecs recs.toList
-  let mutCtx := recMutCtx mutRecs
-  let (data, meta) <- withMutCtx mutCtx <| compileMutRecs mutRecs
-  let block := ⟨<- storeIxon data, <- storeIxon meta⟩
-  modify fun stt => { stt with blocks := stt.blocks.insert block () }
-  let mut ret? : Option (Ixon × Ixon) := none
-  for recr in recs do
-    let idx <- do match mutCtx.find? recr.name with
-    | some idx => pure idx
-    | none => throw $ .cantFindMutDefIndex recr.name
-    let data := .rprj ⟨idx, block.data⟩
-    let meta := .meta ⟨[.link block.meta]⟩
-    let addr := ⟨<- storeIxon data, <- storeIxon meta⟩
-    modify fun stt => { stt with
-      constCache := stt.constCache.insert recr.name addr
-    }
-    if recr.name == r.name then ret? := some (data, meta)
-  match ret? with
-  | some ret => return ret
-  | none => throw $ .compileMutualBlockMissingProjection r.name
-
 end
 
 partial def makeLeanDef
diff --git a/Ix/IR.lean b/Ix/IR.lean
deleted file mode 100644
index c0c2744c..00000000
--- a/Ix/IR.lean
+++ /dev/null
@@ -1,603 +0,0 @@
-import Ix.Common
-import Ix.Address
-import Lean
-
-namespace Ix
-
-/-
-Ix.IR is an internal representation of the Lean kernel values defined in
-[Lean.Declaration](https://leanprover-community.github.io/mathlib4_docs/Lean/Declaration.html)
-The purpose of Ix.IR is to separate-in-place alpha-invariant or nameless
-computational information from non-computational symbolic or ergonomic metadata.
-
-Ix.IR is generated as an intermediate output from the Ix compiler in Ix.CompileM,
-in the course of generating the anonymously content-addressed Ixon bytecode.
-Ix.IR is consumed by the Ix transporter in Ix.TransportM, which completes
-separation or "dematerialization" of the Lean kernel into Ixon bytecode and Ixon
-metadata. The transporter can also reconstitute, or "rematerialize" Ix IR from
-the Ixon wire-format.
-
-Finally, Ix.IR can be converted back into Lean kernel values via Ix.DecompileM
-
-The Ix IR differs from the Lean kernel in the following ways:
-
-1. It excludes all `unsafe` constants, as these are not guaranteed to be
-   well-defined in the pure setting of a zero-knowledge prover
-2. It excludes free variables and metavariables in expressions, all Ix IR terms
-are closed.
-3. It guarantees disambiguation of all names with de-bruijn index (int the case
-   of universe variables) and hash Addresses in the case of global constant
-   references. These Addresses are generated by hashing the anonymous Ixon
-   bytecode of the referenced constant, following dematerialization. The
-   separated metadata is also hashed and stored in-place in the Expr.const
-   reference.
-4. Since inductive datatypes are content-addressed namelessly, only the type of
-   an inductive and the type and order of its constructors are relevant for
-   defining an Ix inductive. Consequently, the datatypes
-
-   ```lean
-   inductive Boolean where
-   | false : Bool
-   | true : Bool
-
-   inductive Loobean where
-   | true : Bool
-   | false : Bool
-   ```
-
-   compile to identical Ixon inductives, with the same Ix address (differing
-   only in their metadata)
-
-   As a consequence, Ix will accept as valid the following Lean code:
-
-   ```lean
-   def Boolean.and (x y: Boolean) : Boolean
-   | .true, .true => true
-   | _, _ => false
-
-   def coerceLoobeanAsBoolean : Bool := Boolean.and Loobean.false Loobean.false
-   ```
-
-   We conjecture that this does not cause soundness issues in the Ix
-   typechecker, as one can treat this case as the Ix compiler inferring an
-   implicit coercion between isomorphic datatypes like so:
-
-   ```
-   def Loobean.toBoolean : Loobean -> Boolean
-   | .true => Boolean.false
-   | .false => Boolean.true
-
-   def coerceLoobeanAsBoolean : Bool :=
-    Boolean.and Loobean.false.toBoolean Loobean.false.toBoolean
-   ```
-
-   However, we have not rigorously demonstrated this yet, and therefore best
-   practice is to only pass environments to Ix which have passed Lean
-   typechecking to sanitize this case.
--/
-
-/--
-Ix.Level universe levels are almost identical to Lean.Level, except that they
-add de-bruijn indices for variable parameters and exclude metavariables.
---/
-inductive Level
-  | zero
-  | succ : Level → Level
-  | max  : Level → Level → Level
-  | imax : Level → Level → Level
-  | param: Lean.Name → Nat → Level
-  deriving Inhabited, Ord, BEq, Repr, Hashable
-
-/--
-Ix.Expr expressions are similar to Lean.Expr, except they exclude free variables
-and metavariables, and annotate global constant references with Ix.Address
-content-addresses
---/
-inductive Expr
-  | var   (mdata: Address) (idx: Nat)
-  | sort  (mdata: Address) (univ: Level)
-  | const (mdata: Address) (name: Lean.Name) (ref: MetaAddress) (univs: List Level)
-  | rec_  (mdata: Address) (name: Lean.Name) (idx: Nat) (univs: List Level)
-  | app   (mdata: Address) (func: Expr) (argm: Expr)
-  | lam   (mdata: Address) (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
-  | pi    (mdata: Address) (name: Lean.Name) (info: Lean.BinderInfo) (type: Expr) (body: Expr)
-  | letE  (mdata: Address) (name: Lean.Name) (type: Expr) (value: Expr) (body: Expr) (nonDep: Bool)
-  | lit   (mdata: Address) (lit: Lean.Literal)
-  | proj  (mdata: Address) (typeName: Lean.Name) (type: MetaAddress) (idx: Nat) (struct: Expr)
-  deriving Inhabited, Ord, BEq, Repr, Hashable
-
-/--
-Ix.Quotient quotients are analogous to Lean.QuotVal
---/
-structure Quotient where
-  name: Lean.Name
-  levelParams : List Lean.Name
-  type : Expr
-  kind : Lean.QuotKind
-  deriving Ord, BEq, Repr, Nonempty, Hashable
-
-/--
-Ix.Axiom axioms are analogous to Lean.AxiomVal, differing only in not including
---/
-structure Axiom where
-  name: Lean.Name
-  levelParams : List Lean.Name
-  type : Expr
-  isUnsafe: Bool
-  deriving Ord, BEq, Repr, Nonempty, Hashable
-
-structure PreDef where
-  name: Lean.Name
-  levelParams : List Lean.Name
-  type : Lean.Expr
-  kind : DefKind
-  value : Lean.Expr
-  hints : Lean.ReducibilityHints
-  safety : Lean.DefinitionSafety
-  all : List Lean.Name
-  deriving BEq, Repr, Nonempty, Inhabited, Ord, Hashable
-
-def mkPreDef (x: Lean.DefinitionVal) : PreDef := 
-  ⟨x.name, x.levelParams, x.type, .definition, x.value, x.hints, x.safety, x.all⟩
-
-def mkPreTheorem (x: Lean.TheoremVal) : PreDef := 
-  ⟨x.name, x.levelParams, x.type, .theorem, x.value, .opaque, .safe, x.all⟩
-
-def mkPreOpaque (x: Lean.OpaqueVal) : PreDef := 
-  ⟨x.name, x.levelParams, x.type, .opaque, x.value, .opaque,
-    if x.isUnsafe then .unsafe else .safe, x.all⟩
-
-def defMutCtx (defss: List (List PreDef)) : Map Lean.Name Nat
-  := Id.run do
-  let mut mutCtx := default
-  let mut i := 0
-  for defs in defss do
-    let mut x := #[]
-    for d in defs do
-      x := x.push d.name
-      mutCtx := mutCtx.insert d.name i
-    i := i + 1
-  return mutCtx
-
-def recMutCtx (recss: List (List Lean.RecursorVal)) : Map Lean.Name Nat
-  := Id.run do
-  let mut mutCtx := default
-  let mut i := 0
-  for recs in recss do
-    let mut x := #[]
-    for r in recs do
-      x := x.push r.name
-      mutCtx := mutCtx.insert r.name i
-    i := i + 1
-  return mutCtx
-
-/--
-Ix.Definition definitions combine Lean.DefinitionVal, Lean.OpaqueVal and
-Lean.TheoremVal into a single structure in order to enable content-addressing of
-mutually recursive blocks. These cases are disambiguated via the Ix.DefKind
-inductive. ReducibilityHints are preserved only as metadata, and are set to
-`ReducibilityHints.opaque` and ignored if the DefKind is either .opaque or
-.theorem. The `safety : Lean.DefinitionSafety` parameter from DefinitionVal is
-replaced with a boolean for partial definitions, as Ix definitions are
-restricted to exclude unsafe constants.
---/
-structure Definition where
-  name: Lean.Name
-  levelParams : List Lean.Name
-  type : Expr
-  kind: DefKind
-  value : Expr
-  hints : Lean.ReducibilityHints
-  safety: Lean.DefinitionSafety
-  all : List Lean.Name
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-def mkTheorem
-  (name: Lean.Name)
-  (levelParams: List Lean.Name)
-  (type: Expr)
-  (value: Expr)
-  (all: List Lean.Name)
-  : Definition
-  := ⟨name, levelParams, type, .theorem, value, .opaque, .safe, all⟩
-
-def mkOpaque
-  (name: Lean.Name)
-  (levelParams: List Lean.Name)
-  (type: Expr)
-  (value: Expr)
-  (all: List Lean.Name)
-  (isUnsafe: Bool)
-  : Definition
-  := ⟨name, levelParams, type, .opaque, value, .opaque, if isUnsafe then .unsafe else .safe, all⟩
-
-/--
-Ix.Constructor inductive datatype constructors are analogous to
-Lean.ConstructorVal. The primary difference is that Ix.Constructor only appears
-within an Ix.Inductive, and is not directly present in the top level
-environment. This is done to enable content-addressing of inductive datatypes.
-Instead, Ix.ConstructorProj is used to project or access an inductive
-constructor at the top level. Unlike other Ix constants, the `name` parameter is
-represented here, but only as metadata to aid in decompilation.
---/
-structure Constructor where
-  name : Lean.Name
-  levelParams : List Lean.Name
-  type : Expr
-  cidx : Nat
-  numParams : Nat
-  numFields : Nat
-  isUnsafe: Bool
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-/--
-Ix.RecursorRule is analogous to Lean.RecursorRule
---/
-structure RecursorRule where
-  ctor : Lean.Name
-  nfields : Nat
-  rhs : Expr
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-/--
-Ix.Recursor represents inductive recursors and is analogous to Lean.RecursorVal.
-However, like Ix.Constructor, recursors do not appear directly in the top-level
-environment but are instead held directly within their corresponding Inductive.
-Recursors are accessed in an environment using the `Ix.RecursorProj` projection
-constant
---/
-structure Recursor where
-  name: Lean.Name
-  levelParams : List Lean.Name
-  type : Expr
-  numParams : Nat
-  numIndices : Nat
-  numMotives : Nat
-  numMinors  : Nat
-  rules : List RecursorRule
-  k : Bool
-  isUnsafe: Bool
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-/--
-Ix.PreInd is used to capture a Lean.InductiveVal along with their
-constructors and recursors, in order to perform structural sorting
---/
-structure PreInd where
-  name: Lean.Name
-  levelParams : List Lean.Name
-  type : Lean.Expr
-  numParams : Nat
-  numIndices : Nat
-  all : List Lean.Name
-  ctors : List Lean.ConstructorVal
-  --recrs : List Lean.RecursorVal
-  numNested: Nat
-  isRec : Bool
-  isReflexive : Bool
-  isUnsafe: Bool
-  deriving BEq, Repr, Nonempty, Inhabited
-
-
--- We have a list of classes of inductive datatypes, each class representing a
--- possible equivalence class. We would like to construct a unique numerical
--- index for each inductive, constructor and recursor within this list of
--- classes.
-
--- Consider the classes: `[e_0, e_1, ..., e_a]`, where `a` is the maximum index
--- of our input. Each class `e_x` contains inductives `[i_x_0, i_j_1, ...,
--- i_j_b]`, where `b` is the maximum index of `e_x`. Each `i_x_y` contains
--- `i_x_y_c` constructors and `i_x_y_r` recursors. If the classes are true
--- equivalence classes then the all inductives in `e_x` will have the same
--- number of constructors and recursors and 
--- `∀ y1 y2: i_x_y1_c == i_x_y2_c && i_x_y1_r == i_x_y2_r` 
---
--- Unfortunately, since we use this function within the sorting function that
--- produces the equivalence classes, our indexing has to be robust to the
--- possiblity that inductives in a class do *not* have the same number of
--- constructors and recursors.
---
--- We do this by first finding the inductives in the class with the maximum
--- number of constructors and the maximum number of recursors. Then we
--- "reserves" index space for the entire class based on those two maxima.
--- Inductives with smaller numbers of constructors or recursors will not create
--- conflicts. For example, if a class has an inductive with 2 ctors and 4 recrs
--- and an inductive with 3 ctors and 2 recrs, then the whole class will reserve
--- 8 indices (one for the inductive type itself plus 3 ctors and 4 recrs).
-
-def indMutCtx (indss: List (List PreInd)) : Map Lean.Name Nat
-  := Id.run do
-  let mut mutCtx := default
-  let mut idx := 0
-  for inds in indss do
-    let mut maxCtors := 0
-    --let mut maxRecrs := 0
-    for ind in inds do
-      maxCtors := max maxCtors ind.ctors.length
-      --maxRecrs := max maxRecrs ind.recrs.length
-    for ind in inds do
-      mutCtx := mutCtx.insert ind.name idx
-      for (c, cidx) in List.zipIdx ind.ctors do
-        mutCtx := mutCtx.insert c.name (idx + 1 + cidx)
-      --for (r, ridx) in List.zipIdx ind.recrs do
-      --  mutCtx := mutCtx.insert r.name (idx + 1 + maxCtors + ridx)
-    --idx := idx + 1 + maxCtors + maxRecrs
-    idx := idx + 1 + maxCtors
-  return mutCtx
-
-/--
-Ix.Inductive represents inductive datatypes and is analogous to
-Lean.InductiveVal. However, unlike in Lean, Ix.Inductive directly contains its
-corresponding Constructors and Recursors in order to enable content-addressing.
---/
-structure Inductive where
-  name: Lean.Name
-  levelParams : List Lean.Name
-  type : Expr
-  numParams : Nat
-  numIndices : Nat
-  all : List Lean.Name
-  ctors : List Constructor
-  --recrs : List Recursor
-  numNested: Nat
-  isRec : Bool
-  isReflexive : Bool
-  isUnsafe: Bool
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-
-structure InductiveProj where
-  /-- name of an inductive within a mutual inductive block --/
-  name: Lean.Name
-  /-- content-address of a mutual inductive block --/
-  block: MetaAddress
-  /-- index of the specific inductive datatype within the block --/
-  idx   : Nat
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-structure ConstructorProj where
-  /-- name of a specific constructor within an inductive --/
-  name: Lean.Name
-  /-- content-address of a mutual inductive block --/
-  block: MetaAddress
-  /-- index of a specific inductive datatype within the block --/
-  idx   : Nat
-  /-- name of a specific inductive datatype within the block --/
-  induct: Lean.Name
-  /-- index of a specific constructor within the inductive --/
-  cidx  : Nat
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-structure RecursorProj where
-  /-- name of a specific recursor within the inductive --/
-  name: Lean.Name
-  /-- content-address of a mutual inductive block --/
-  block: MetaAddress
-  /-- index of a specific inductive datatype within the block --/
-  idx : Nat
-  /-- name of a specific inductive datatype within the block --/
-  induct: Lean.Name
-  /-- index of a specific recursor within the inductive --/
-  ridx : Nat
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-structure DefinitionProj where
-  name: Lean.Name
-  /-- content-address of a mutual definition block --/
-  block: MetaAddress
-  /-- index of a specific definition within the block --/
-  idx : Nat
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-structure MutualBlock where
-  defs : List (List Definition)
-  --all: List Lean.Name
-  deriving BEq, Ord, Repr, Nonempty, Hashable
-
-def MutualBlock.ctx (x: MutualBlock) : List (List Lean.Name) :=
-  x.defs.map fun xs => xs.map fun x => x.name
-
-structure InductiveBlock where
-  inds : List (List Inductive)
-  --all: List Lean.Name
-  deriving BEq, Ord, Repr, Nonempty, Inhabited, Hashable
-
-def InductiveBlock.ctx (x: InductiveBlock) : List (List Lean.Name) :=
-  x.inds.map fun xs => xs.map fun x => x.name
-
-inductive Const where
-  | «axiom» : Axiom → Const
-  | quotient : Quotient → Const
-  | «definition»: Definition → Const
-  -- projections of mutual blocks
-  | inductiveProj : InductiveProj → Const
-  | constructorProj : ConstructorProj → Const
-  | recursorProj : RecursorProj → Const
-  | definitionProj : DefinitionProj → Const
-  -- constants to represent mutual blocks
-  | «mutual» : MutualBlock → Const
-  | «inductive» : InductiveBlock → Const
-  deriving BEq, Ord, Inhabited, Repr, Nonempty, Hashable
-
-def Const.isMutBlock : Const → Bool
-  | .mutual _ | .inductive _ => true
-  | _ => false
-
-def Const.name : Const → List (Lean.Name)
-  | .axiom x => [x.name]
-  | .quotient x => [x.name]
-  | .definition x => [x.name]
-  | .inductiveProj x => [x.name]
-  | .constructorProj x => [x.name]
-  | .recursorProj x => [x.name]
-  | .definitionProj x => [x.name]
-  | .mutual x => x.ctx.flatten
-  | .inductive x => x.ctx.flatten
-
-namespace Level
-
-/--
-Reduces as a `max` applied to two values: `max a 0 = max 0 a = a` and
-`max (succ a) (succ b) = succ (max a b)`.
-It is assumed that `a` and `b` are already reduced
--/
-def reduceMax (a b : Level) : Level :=
-  match a, b with
-  | .zero, _ => b
-  | _, .zero => a
-  | .succ a, .succ b => .succ (reduceMax a b)
-  | .param _ idx, .param _ idx' => if idx == idx' then a else .max a b
-  | _, _ => .max a b
-
-/--
-Reduces as an `imax` applied to two values.
-It is assumed that `a` and `b` are already reduced
--/
-def reduceIMax (a b : Level) : Level :=
-  match b with
-  -- IMax(a, b) will reduce to 0 if b == 0
-  | .zero => .zero
-  -- IMax(a, b) will reduce as Max(a, b) if b == Succ(..) (impossible case)
-  | .succ _ => reduceMax a b
-  | .param _ idx => match a with
-    | .param _ idx' => if idx == idx' then a else .imax a b
-    | _ => .imax a b
-  -- Otherwise, IMax(a, b) is stuck, with a and b reduced
-  | _ => .imax a b
-
-/--
-Reduce, or simplify, the universe levels to a normal form. Notice that universe
-levels with no free paramiables always reduce to a number, i.e., a sequence of
-`succ`s followed by a `zero`
--/
-def reduce : Level → Level
-  | .succ u' => .succ (reduce u')
-  | .max a b => reduceMax (reduce a) (reduce b)
-  | .imax a b =>
-    let b' := reduce b
-    match b' with
-    | .zero => .zero
-    | .succ _ => reduceMax (reduce a) b'
-    | _ => .imax (reduce a) b'
-  | u => u
-
-/--
-Instantiate a paramiable and reduce at the same time. Assumes an already reduced
-`subst`. This function is only used in the comparison algorithm, and it doesn't
-shift paramiables, because we want to instantiate a paramiable `param idx` with
-`succ (param idx)`, so by shifting the paramiables we would transform `param (idx+1)`
-into `param idx` which is not what we want
--/
-def instReduce (u : Level) (idx : Nat) (subst : Level) : Level :=
-  match u with
-  | .succ u => .succ (instReduce u idx subst)
-  | .max a b => reduceMax (instReduce a idx subst) (instReduce b idx subst)
-  | .imax a b =>
-    let a' := instReduce a idx subst
-    let b' := instReduce b idx subst
-    match b' with
-    | .zero => .zero
-    | .succ _ => reduceMax a' b'
-    | _ => .imax a' b'
-  | .param _ idx' => if idx' == idx then subst else u
-  | .zero => u
-
-/--
-Instantiate multiple paramiables at the same time and reduce. Assumes already
-reduced `substs`
--/
-def instBulkReduce (substs : List Level) : Level → Level
-  | z@(.zero ..) => z
-  | .succ u => .succ (instBulkReduce substs u)
-  | .max a b => reduceMax (instBulkReduce substs a) (instBulkReduce substs b)
-  | .imax a b =>
-    let b' := instBulkReduce substs b
-    match b' with
-    | .zero => .zero
-    | .succ _ => reduceMax (instBulkReduce substs a) b'
-    | _ => .imax (instBulkReduce substs a) b'
-  | .param n idx => match substs[idx]? with
-    | some u => u
-    -- This case should never happen if we're correctly enclosing every
-    -- expression with a big enough universe environment
-    | none => .param n (idx - substs.length)
-
-/--
-We say that two universe levels `a` and `b` are (semantically) equal, if they
-are equal as numbers for all possible substitution of free paramiables to numbers.
-Although writing an algorithm that follows this exact scheme is impossible, it
-is possible to write one that is equivalent to such semantical equality.
-Comparison algorithm `a <= b + diff`. Assumes `a` and `b` are already reduced
--/
-partial def leq (a b : Level) (diff : Int) : Bool :=
-  if diff >= 0 && a == .zero then true
-  else match a, b with
-  | .zero, .zero => diff >= 0
-  --! Succ cases
-  | .succ a, _ => leq a b (diff - 1)
-  | _, .succ b => leq a b (diff + 1)
-  | .param .., .zero => false
-  | .zero, .param .. => diff >= 0
-  | .param _ x, .param _ y => x == y && diff >= 0
-  --! IMax cases
-  -- The case `a = imax c d` has only three possibilities:
-  -- 1) d = param ..
-  -- 2) d = max ..
-  -- 3) d = imax ..
-  -- It can't be any otherway since we are assuming `a` is reduced, and thus `d` is reduced as well
-  | .imax _ (.param n idx), _ =>
-    -- In the case for `param idx`, we need to compare two substitutions:
-    -- 1) idx <- zero
-    -- 2) idx <- succ (param idx)
-    -- In the first substitution, we know `a` becomes `zero`
-    leq .zero (instReduce b idx .zero) diff &&
-    let succ := .succ (.param n idx)
-    leq (instReduce a idx succ) (instReduce b idx succ) diff
-
-  | .imax c (.max e f), _ =>
-    -- Here we use the relationship
-    -- imax c (max e f) = max (imax c e) (imax c f)
-    let new_max := reduceMax (reduceIMax c e) (reduceIMax c f)
-    leq new_max b diff
-  | .imax c (.imax e f), _ =>
-    -- Here we use the relationship
-    -- imax c (imax e f) = max (imax c e) (imax e f)
-    let new_max := reduceMax (reduceIMax c e) (.imax e f)
-    leq new_max b diff
-  -- Analogous to previous case
-  | _, .imax _ (.param n idx) =>
-    leq (instReduce a idx .zero) .zero diff &&
-    let succ := .succ (.param n idx)
-    leq (instReduce a idx succ) (instReduce b idx succ) diff
-  | _, .imax c (.max e f) =>
-    let new_max := reduceMax (reduceIMax c e) (reduceIMax c f)
-    leq a new_max diff
-  | _, .imax c (.imax e f) =>
-    let new_max := reduceMax (reduceIMax c e) (.imax e f)
-    leq a new_max diff
-  --! Max cases
-  | .max c d, _ => leq c b diff && leq d b diff
-  | _, .max c d => leq a c diff || leq a d diff
-  | _, _ => false -- Impossible cases
-
-/-- The equality algorithm. Assumes `a` and `b` are already reduced -/
-def equalLevel (a b : Level) : Bool :=
-  leq a b 0 && leq b a 0
-
-/--
-Two lists of universes are considered equal iff they have the same length and
-`Ix.equalLevel` returns `true` for all of their zip pairs
--/
-def equalLevels : List Level → List Level → Bool
-  | [], [] => true
-  | u::us, u'::us' => equalLevel u u' && equalLevels us us'
-  | _, _ => false
-
-/-- Faster equality for zero, assumes that the input is already reduced -/
-def isZero : Level → Bool
-  | .zero => true
-  -- all other cases are false since they are either `succ` or a reduced
-  -- expression with free paramiables, which are never semantically equal to zero
-  | _ => false
-
-end Ix.Level
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index ab12266c..3cd94003 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -448,22 +448,6 @@ instance : Serialize RecursorRule where
   put x := Serialize.put (x.fields, x.rhs)
   get := (fun (a,b) => .mk a b) <$> Serialize.get
 
---structure Recursor where
---  k : Bool
---  isUnsafe: Bool
---  lvls : Nat
---  params : Nat
---  indices : Nat
---  motives : Nat
---  minors : Nat
---  type : Address
---  rules : List RecursorRule
---  deriving BEq, Repr, Inhabited, Ord, Hashable
---
---instance : Serialize Recursor where
---  put x := Serialize.put ((x.k, x.isUnsafe), x.lvls, x.params, x.indices, x.motives, x.minors, x.type, x.rules)
---  get := (fun ((a,b),c,d,e,f,g,h,i) => .mk a b c d e f g h i) <$> Serialize.get
-
 structure Recursor where
   k : Bool
   isUnsafe: Bool
@@ -701,6 +685,32 @@ instance : Serialize Int where
   put := putInt
   get := getInt
 
+inductive MutConst where
+| defn : Definition -> MutConst
+| indc : Inductive -> MutConst
+| recr : Recursor -> MutConst
+deriving BEq, Repr, Ord, Inhabited, Ord, Hashable
+
+def putMutConst : MutConst → PutM Unit
+| .defn v => putUInt8 0 *> put v
+| .indc v => putUInt8 1 *> put v
+| .recr v => putUInt8 2 *> put v
+
+def getMutConst : GetM MutConst := do
+  match (← getUInt8) with
+  | 0 => .defn <$> get
+  | 1 => .indc <$> get
+  | 2 => .recr <$> get
+  | e => throw s!"expected MutConst encoding between 0 and 2, got {e}"
+
+instance : Serialize MutConst where
+  put := putMutConst
+  get := getMutConst
+
+instance : Serialize Int where
+  put := putInt
+  get := getInt
+
 inductive DataValue where
 | ofString (v: Address)
 | ofBool (v: Bool)
@@ -800,15 +810,14 @@ inductive Ixon where
 | elet  : Bool -> Address -> Address -> Address -> Ixon -- 0x86, 0x87, let
 | blob : ByteArray -> Ixon                              -- 0x9X, bytes
 | defn : Definition -> Ixon                             -- 0xA0, definition
-| axio : Axiom -> Ixon                                  -- 0xA1, axiom
-| quot : Quotient -> Ixon                               -- 0xA2, quotient
-| cprj : ConstructorProj -> Ixon                        -- 0xA3, ctor projection
-| rprj : RecursorProj -> Ixon                           -- 0xA4, recr projection
-| iprj : InductiveProj -> Ixon                          -- 0xA5, indc projection
-| dprj : DefinitionProj -> Ixon                         -- 0xA6, defn projection
-| inds : List Inductive -> Ixon                         -- 0xBX, mutual inductive types
-| recs : List Recursor -> Ixon                          -- 0xCX, mutual recursors
-| defs : List Definition -> Ixon                        -- 0xDX, mutual definitions
+| recr : Recursor -> Ixon                               -- 0xA1, recursor
+| axio : Axiom -> Ixon                                  -- 0xA2, axiom
+| quot : Quotient -> Ixon                               -- 0xA3, quotient
+| cprj : ConstructorProj -> Ixon                        -- 0xA4, ctor projection
+| rprj : RecursorProj -> Ixon                           -- 0xA5, recr projection
+| iprj : InductiveProj -> Ixon                          -- 0xA6, indc projection
+| dprj : DefinitionProj -> Ixon                         -- 0xA7, defn projection
+| muts : List MutConst -> Ixon                          -- 0xBX, mutual inductive types
 | prof : Proof -> Ixon                                  -- 0xE0, zero-knowledge proof
 | eval : EvalClaim -> Ixon                              -- 0xE1, cryptographic claim
 | chck : CheckClaim -> Ixon                             -- 0xE2, cryptographic claim
@@ -849,15 +858,14 @@ def putIxon : Ixon -> PutM Unit
   else put (Tag4.mk 0x8 0x7) *> put t *> put d *> put b
 | .blob xs => put (Tag4.mk 0x9 xs.size.toUInt64) *> xs.data.forM put
 | .defn x => put (Tag4.mk 0xA 0x0) *> put x
-| .axio x => put (Tag4.mk 0xA 0x1) *> put x
-| .quot x => put (Tag4.mk 0xA 0x2) *> put x
-| .cprj x => put (Tag4.mk 0xA 0x3) *> put x
-| .rprj x => put (Tag4.mk 0xA 0x4) *> put x
-| .iprj x => put (Tag4.mk 0xA 0x5) *> put x
-| .dprj x => put (Tag4.mk 0xA 0x6) *> put x
-| .inds xs => put (Tag4.mk 0xB xs.length.toUInt64) *> puts xs
-| .recs xs => put (Tag4.mk 0xC xs.length.toUInt64) *> puts xs
-| .defs xs => put (Tag4.mk 0xD xs.length.toUInt64) *> puts xs
+| .recr x => put (Tag4.mk 0xA 0x1) *> put x
+| .axio x => put (Tag4.mk 0xA 0x2) *> put x
+| .quot x => put (Tag4.mk 0xA 0x3) *> put x
+| .cprj x => put (Tag4.mk 0xA 0x4) *> put x
+| .rprj x => put (Tag4.mk 0xA 0x5) *> put x
+| .iprj x => put (Tag4.mk 0xA 0x6) *> put x
+| .dprj x => put (Tag4.mk 0xA 0x7) *> put x
+| .muts xs => put (Tag4.mk 0xB xs.length.toUInt64) *> puts xs
 | .prof x => put (Tag4.mk 0xE 0x0) *> put x
 | .eval x => put (Tag4.mk 0xE 0x1) *> put x
 | .chck x => put (Tag4.mk 0xE 0x2) *> put x
@@ -890,15 +898,14 @@ def getIxon : GetM Ixon := do
   | ⟨0x8, 7⟩ => .elet false <$> get <*> get <*> get
   | ⟨0x9, x⟩ => (.blob ∘ .mk ∘ .mk) <$> getMany x.toNat getUInt8
   | ⟨0xA, 0x0⟩ => .defn <$> get
-  | ⟨0xA, 0x1⟩ => .axio <$> get
-  | ⟨0xA, 0x2⟩ => .quot <$> get
-  | ⟨0xA, 0x3⟩ => .cprj <$> get
-  | ⟨0xA, 0x4⟩ => .rprj <$> get
-  | ⟨0xA, 0x5⟩ => .iprj <$> get
-  | ⟨0xA, 0x6⟩ => .dprj <$> get
-  | ⟨0xC, x⟩ => .inds <$> getMany x.toNat get
-  | ⟨0xB, x⟩ => .recs <$> getMany x.toNat get
-  | ⟨0xD, x⟩ => .defs <$> getMany x.toNat get
+  | ⟨0xA, 0x1⟩ => .recr <$> get
+  | ⟨0xA, 0x2⟩ => .axio <$> get
+  | ⟨0xA, 0x3⟩ => .quot <$> get
+  | ⟨0xA, 0x4⟩ => .cprj <$> get
+  | ⟨0xA, 0x5⟩ => .rprj <$> get
+  | ⟨0xA, 0x6⟩ => .iprj <$> get
+  | ⟨0xA, 0x7⟩ => .dprj <$> get
+  | ⟨0xB, x⟩ => .muts <$> getMany x.toNat get
   | ⟨0xE, 0x0⟩ => .prof <$> get
   | ⟨0xE, 0x1⟩ => .eval <$> get
   | ⟨0xE, 0x2⟩ => .chck <$> get
diff --git a/Ix/Mutual.lean b/Ix/Mutual.lean
new file mode 100644
index 00000000..9f14d3ca
--- /dev/null
+++ b/Ix/Mutual.lean
@@ -0,0 +1,99 @@
+import Ix.Common
+import Ix.Address
+import Lean
+
+namespace Ix
+
+structure Def where
+  name: Lean.Name
+  levelParams : List Lean.Name
+  type : Lean.Expr
+  kind : DefKind
+  value : Lean.Expr
+  hints : Lean.ReducibilityHints
+  safety : Lean.DefinitionSafety
+  all : List Lean.Name
+  deriving BEq, Repr, Nonempty, Inhabited, Ord, Hashable
+
+structure Ind where
+  name: Lean.Name
+  levelParams : List Lean.Name
+  type : Lean.Expr
+  numParams : Nat
+  numIndices : Nat
+  all : List Lean.Name
+  ctors : List Lean.ConstructorVal
+  numNested: Nat
+  isRec : Bool
+  isReflexive : Bool
+  isUnsafe: Bool
+  deriving BEq, Repr, Nonempty, Inhabited
+
+abbrev Rec := Lean.RecursorVal
+
+inductive MutConst where
+| defn : Def -> MutConst
+| indc : Ind -> MutConst
+| recr : Rec -> MutConst
+deriving BEq, Repr, Nonempty, Inhabited
+
+def MutConst.mkDefn : Lean.DefinitionVal -> MutConst
+| x => .defn ⟨x.name, x.levelParams, x.type, .definition, x.value, x.hints, x.safety, x.all⟩
+
+def MutConst.mkOpaq : Lean.OpaqueVal -> MutConst
+| x => .defn ⟨x.name, x.levelParams, x.type, .opaque, x.value, .opaque,
+    if x.isUnsafe then .unsafe else .safe, x.all⟩
+
+def MutConst.mkTheo : Lean.TheoremVal -> MutConst
+| x => .defn ⟨x.name, x.levelParams, x.type, .theorem, x.value, .opaque, .safe, x.all⟩
+
+def MutConst.name : MutConst -> Lean.Name
+| .defn x => x.name
+| .indc x => x.name
+| .recr x => x.name
+
+def MutConst.ctors : MutConst -> List (Lean.ConstructorVal)
+| .indc x => x.ctors
+| .defn _ => []
+| .recr _ => []
+
+-- We have a list of classes of mutual constants, each class representing a
+-- possible equivalence class. We would like to construct a unique numerical
+-- index for each constant (which could be a definition, inductive+constructors
+-- or recursor) within this list of classes. If the classes are true equivalence
+-- classes then all constants in a class will be the same kind of constant,
+-- and, if inductives, have the same number of constructors.
+--
+-- Unfortunately, since we use this function within the sorting function that
+-- produces the equivalence classes, our indexing has to be robust to the
+-- possiblity that constants are *not* the same, and that the inductives in a
+-- class do *not* have the same number of constructors.
+--
+-- We do this by first finding the inductives in the possible class with the
+-- largest number of constructors. Then we "reserve" index space for the entire
+-- class based on this maximum. Inductives with a smaller number of constructors,
+-- (or definitions and recursors, which can be treated the same as inductives
+-- with no constructors) will be able to create unique indices without conflict,
+-- since we index them as if they could have the maximum number of constructors.
+-- For example, if a class has an inductive with 2 ctors
+-- and an inductive with 3 ctors, then the whole class will reserve
+-- 4 indices (one for each inductive type itself plus 3 ctors) for each constant.
+--
+-- In practice, Lean should never give us a mutual block that mixes inductives
+-- definitions and recursors, but we combine them for robustness and code
+-- deduplication.
+def MutConst.ctx (constss: List (List MutConst)) : Map Lean.Name Nat
+  := Id.run do
+  let mut mutCtx := default
+  let mut idx := 0
+  for consts in constss do
+    let mut maxCtors := 0
+    for const in consts do
+      maxCtors := max maxCtors const.ctors.length
+      mutCtx := mutCtx.insert const.name idx
+      for (c, cidx) in List.zipIdx const.ctors do
+        mutCtx := mutCtx.insert c.name (idx + 1 + cidx)
+    idx := idx + 1 + maxCtors
+  return mutCtx
+
+end Ix
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 65cf4883..d3cb2b50 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -7,7 +7,6 @@ import Ix.CompileM
 import Ix.Cronos
 --import Ix.DecompileM
 import Ix.Meta
-import Ix.IR
 import Ix.Store
 import Lean
 import Tests.Ix.Fixtures
@@ -71,12 +70,12 @@ def testMutual : IO TestSeq := do
   let env <- get_env!
   let mut cstt : CompileState := .init env 0
   let all := (env.getDelta.find! `Test.Ix.Mutual.A).all
-  let predefs <- all.mapM fun n => match env.getDelta.find! n with
-    | .defnInfo d => pure <| Ix.mkPreDef d
-    | .opaqueInfo d => pure <| Ix.mkPreOpaque d
-    | .thmInfo d => pure <| Ix.mkPreTheorem d
+  let consts <- all.mapM fun n => match env.getDelta.find! n with
+    | .defnInfo d => pure <| Ix.MutConst.mkDefn d
+    | .opaqueInfo d => pure <| Ix.MutConst.mkOpaq d
+    | .thmInfo d => pure <| Ix.MutConst.mkTheo d
     | _ => throw (IO.userError "not a def")
-  let (dss, _) <- match (<- (sortDefs predefs).run .init cstt) with
+  let (dss, _) <- match (<- (sortConsts consts).run .init cstt) with
     | (.ok a, stt) => do
       pure (a, stt)
     | (.error e, _) => do
@@ -91,12 +90,12 @@ def testInductives : IO TestSeq := do
   --let delta := env.getDelta.filter fun n _ => namesp.isPrefixOf n
   --let consts := env.getConstMap.filter fun n _ => namesp.isPrefixOf n
   let all := (env.getDelta.find! `Test.Ix.Inductives.A).all
-  let preinds <- all.mapM fun n => match env.getDelta.find! n with
-    | .inductInfo v => do match (<- (mkPreInd v).run .init cstt) with
+  let consts <- all.mapM fun n => match env.getDelta.find! n with
+    | .inductInfo v => do match (<- (Ix.MutConst.mkIndc v).run .init cstt) with
       | (.ok a, _) => pure a
       | (.error e, _) => do throw (IO.userError (<- e.pretty))
     | _ => throw (IO.userError "not an inductive")
-  let (dss, _) <- do match (<- (sortInds preinds).run .init cstt) with
+  let (dss, _) <- do match (<- (sortConsts consts).run .init cstt) with
     | (.ok a, stt) => do
       pure (a, stt)
     | (.error e, _) => do
diff --git a/Tests/Ix/IR.lean b/Tests/Ix/IR.lean
index 5fc244a0..e69de29b 100644
--- a/Tests/Ix/IR.lean
+++ b/Tests/Ix/IR.lean
@@ -1,122 +0,0 @@
-import Ix.Common
-import Ix.IR
-
-import LSpec.SlimCheck.Gen
-import LSpec
-
-import Tests.Common
-import Tests.Ix.Common
-
-open LSpec
-open SlimCheck
-open SlimCheck.Gen
-
-namespace Ix
-
---def genLevel : Gen Ix.Level := getSize >>= go
---  where
---    go : Nat -> Gen Ix.Level
---    | 0 => return .zero
---    | Nat.succ f =>
---      frequency [
---        (100, return .zero),
---        (100, .param <$> genName <*> genNat),
---        (50, .succ <$> go f),
---        (25, .max <$> go f <*> go f),
---        (25, .imax <$> go f <*> go f)
---      ]
---
---instance : Shrinkable Ix.Level where
---  shrink _ := []
---
---instance : SampleableExt Ix.Level := SampleableExt.mkSelfContained genLevel
---
---def genExpr : Gen Ix.Expr := getSize >>= go
---  where
---    go : Nat -> Gen Ix.Expr
---    | 0 => return .lit (.natVal 0)
---    | Nat.succ f =>
---      frequency [
---        (100, .var <$> genNat),
---        (100, .sort <$> genLevel),
---        (50, .const <$> genName <*> genAddress <*> genAddress <*> genList genLevel),
---        (50, .rec_ <$> genName <*> genNat <*> genList genLevel),
---        (50, .app <$> go f <*> go f),
---        (50, .lam <$> genName <*> genBinderInfo <*> go f <*> go f),
---        (50, .pi <$> genName <*> genBinderInfo <*> go f <*> go f),
---        (25, .letE <$> genName <*> go f <*> go f <*> go f <*> pure .true),
---        (25, .letE <$> genName <*> go f <*> go f <*> go f <*> pure .false),
---        (100, .lit <$> .strVal <$> genString),
---        (100, .lit <$> .natVal <$> chooseAny Nat),
---        (25, .proj <$> genName <*> genAddress <*> genAddress <*> genNat <*> go f),
---      ]
---
---instance : Shrinkable Ix.Expr where
---  shrink _ := []
---
---instance : SampleableExt Ix.Expr := SampleableExt.mkSelfContained genExpr
---
---def genConst : Gen Ix.Const := getSize >>= go
---  where
---    genNames : Gen (List Lean.Name) := genList genName
---    genDef : Gen Ix.Definition := do
---      let n <- genName
---      let lvls <- genNames
---      let type <- genExpr
---      let mode <- genDefKind
---      let value <- genExpr
---      let hints <- genReducibilityHints
---      let safety <- oneOf #[pure .safe, pure .partial, pure .unsafe]
---      let all <- genNames
---      return ⟨n, lvls, type, mode, value, hints, safety, all⟩
---    genCtor : Gen Ix.Constructor := 
---      .mk <$> genName <*> genNames <*> genExpr <*> genNat <*> genNat <*> genNat <*> genBool
---    genRecr : Gen Ix.Recursor := 
---      .mk <$> genName <*> genNames <*> genExpr <*> genNat <*> genNat <*> genNat <*> genNat
---        <*> genList (.mk <$> genName <*> genNat <*> genExpr)
---        <*> genBool <*> genBool
---    genInd : Gen Ix.Inductive := do
---      let n <- genName
---      let lvls <- genNames
---      let type <- genExpr
---      let params <- genNat
---      let indices <- genNat
---      let all <- genNames
---      let ctors <- genList genCtor
---      let recrs <- genList genRecr
---      let nested <- genNat
---      let (isRec, isRefl, isUnsafe) <- (·,·,·) <$> genBool <*> genBool <*> genBool
---      return ⟨n, lvls, type, params, indices, all, ctors, recrs, nested, isRec, isRefl, isUnsafe⟩
---    genMutDef : Gen Ix.MutualBlock := do
---      let nns <- genList (genListSize genName 1 5)
---      let ds <- nns.mapM fun ns => do
---        let x <- genDef
---        ns.mapM (fun _ => pure x)
---      return .mk ds
---    genMutInd : Gen Ix.InductiveBlock := do
---      let nns <- genList (genListSize genName 1 5)
---      let ds <- nns.mapM fun ns => do
---        let x <- genInd
---        ns.mapM (fun _ => pure x)
---      return .mk ds
---    go : Nat -> Gen Ix.Const
---    | 0 => return .«axiom» (.mk .anonymous [] (Ix.Expr.sort (Ix.Level.zero)) false)
---    | Nat.succ _ =>
---      frequency [
---        (100, .«axiom» <$> (.mk <$> genName <*> genNames <*> genExpr <*> genBool)),
---        (100, .«definition» <$> genDef),
---        (100, .quotient <$> (.mk <$> genName <*> genNames <*> genExpr <*> genQuotKind)),
---        (100, .inductiveProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat)),
---        (100, .constructorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat <*> genName <*> genNat)),
---        (100, .recursorProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat <*> genName <*> genNat)),
---        (100, .definitionProj <$> (.mk <$> genName <*> genAddress <*> genAddress <*> genNat)),
---        (100, .mutual <$> genMutDef),
---        (100, .inductive <$> genMutInd),
---      ]
---
---instance : Shrinkable Ix.Const where
---  shrink _ := []
---
---instance : SampleableExt Ix.Const := SampleableExt.mkSelfContained genConst
---
---end Ix
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index c7a25cc4..43c2bb73 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -141,9 +141,9 @@ partial def genIxon : Gen Ixon.Ixon :=
     (10, .cprj <$> genConstructorProj),
     (10, .iprj <$> genInductiveProj),
     (10, .dprj <$> genDefinitionProj),
-    (10, .inds <$> genList genInductive),
-    (10, .defs <$> genList genDefinition),
-    (10, .recs <$> genList genRecursor),
+    (10, .muts <$> genList (.indc <$> genInductive)),
+    (10, .muts <$> genList (.defn <$> genDefinition)),
+    (10, .muts <$> genList (.recr <$> genRecursor)),
     (10, .prof <$> genProof),
     (10, .eval <$> genEvalClaim),
     (10, .chck <$> genCheckClaim),

From c38a0e70ca8fdf36a68e8a9f9413b60edb03ba8b Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 15 Oct 2025 20:09:33 -0400
Subject: [PATCH 54/74] compile unsafe Lean?

---
 Ix/CompileM.lean      | 102 +++++++++++++++++++++++-------------------
 Ix/CondenseM.lean     |   1 -
 Ix/Ixon.lean          |  25 +++++++++++
 Ix/Meta.lean          |   4 +-
 Tests/Ix/Compile.lean |  92 +++++++++++++++++++------------------
 5 files changed, 132 insertions(+), 92 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index d65ab5ac..2d9a116a 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -333,9 +333,13 @@ def compileKVMaps (maps: List Lean.KVMap): CompileM Address := do
     pure <| .kvmap list.toList
 
 def findLeanConst (name : Lean.Name) : CompileM Lean.ConstantInfo := do
-  match (← get).env.constants.find? name with
+  match (<- get).env.constants.find? name with
   | some const => pure const
-  | none => throw $ .unknownConstant name
+  | none => do
+    let cstage2 := Lean.Name.mkSimple "_cstage2"
+    match (<- get).env.constants.find? (name.append cstage2) with
+     | some const => pure const
+     | none => throw $ .unknownConstant name
 
 def MutConst.mkIndc (i: Lean.InductiveVal) : CompileM MutConst := do
   let ctors <- i.ctors.mapM getCtor
@@ -388,7 +392,7 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
       | none => do
         let ref <- match (<- get).comms.find? name with
           | some comm => pure comm
-          | none => findLeanConst name >>= compileConst
+          | none => compileConstName name
         let data := .eref ref.data (us.map (·.data))
         let meta := .meta ⟨[.link md, .link n, .link ref.meta, .links (us.map (·.meta))]⟩
         pure (data, meta)
@@ -434,7 +438,7 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
       let md <- compileKVMaps kvs
       let t <- match (<- get).comms.find? typeName with
         | some comm => pure comm
-        | none => findLeanConst typeName >>= compileConst
+        | none => compileConstName typeName
       let n <- compileName typeName
       let s <- compileExpr struct
       let data := .eprj t.data idx s.data
@@ -443,11 +447,15 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
     | expr@(.fvar ..)  => throw $ .exprFreeVariable expr
     | expr@(.mvar ..)  => throw $ .exprMetavariable expr
 
-partial def compileConst (const: Lean.ConstantInfo): CompileM MetaAddress := do
-  match (<- get).constCache.find? const.name with
+partial def compileConstName (name: Lean.Name): CompileM MetaAddress := do
+  match (<- get).constCache.find? name with
   | some x => pure x
-  | none => resetCtx const.name <| do
-    let (anon, meta) <- go const
+  | none => resetCtx name <| do
+    let (anon, meta) <- do
+      if name == Lean.Name.mkSimple "_obj" then pure (.prim .obj, .meta ⟨[]⟩)
+      else if name == Lean.Name.mkSimple "_neutral" then pure (.prim .neutral, .meta ⟨[]⟩)
+      else if name == Lean.Name.mkSimple "_unreachable" then pure (.prim .unreachable, .meta ⟨[]⟩)
+      else do findLeanConst name >>= compileConstant
     --let stt <- get
     --dbg_trace "✓ compileConst {const.name}"
     --dbg_trace "store {stt.store.size}"
@@ -459,36 +467,36 @@ partial def compileConst (const: Lean.ConstantInfo): CompileM MetaAddress := do
     --dbg_trace "univCache {stt.univCache.size}"
     let maddr := ⟨<- storeIxon anon, <- storeIxon meta⟩
     modifyGet fun stt => (maddr, { stt with
-      constCache := stt.constCache.insert const.name maddr
+      constCache := stt.constCache.insert name maddr
     })
-  where
-    go : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
-    | .defnInfo val => compileMutual (MutConst.mkDefn val)
-    | .thmInfo val => compileMutual (MutConst.mkTheo val)
-    | .opaqueInfo val => compileMutual (MutConst.mkOpaq val)
-    | .inductInfo val => MutConst.mkIndc val >>= compileMutual
-    | .ctorInfo val => do match <- findLeanConst val.induct with
-      | .inductInfo ind => do
-        let _ <- MutConst.mkIndc ind >>= compileMutual
-        match (<- get).constCache.find? const.name with
-        | some ⟨data, meta⟩ => do pure (<- getIxon data, <- getIxon meta)
-        | none => throw <| .mutualBlockMissingProjection const.name
-      | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
-    | .recInfo val => compileMutual (MutConst.recr val)
-    | .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => withLevels lvls do
-      let n <- compileName name
-      let ls <- lvls.mapM compileName
-      let t <- compileExpr type
-      let data := .axio ⟨isUnsafe, lvls.length, t.data⟩
-      let meta := .meta ⟨[.link n, .links ls, .link t.meta]⟩
-      pure (data, meta)
-    | .quotInfo ⟨⟨name, lvls, type⟩, kind⟩ => withLevels lvls do
-      let n <- compileName name
-      let ls <- lvls.mapM compileName
-      let t <- compileExpr type
-      let data := .quot ⟨kind, lvls.length, t.data⟩
-      let meta := .meta ⟨[.link n, .links ls, .link t.meta]⟩
-      pure (data, meta)
+
+partial def compileConstant : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
+| .defnInfo val => compileMutual (MutConst.mkDefn val)
+| .thmInfo val => compileMutual (MutConst.mkTheo val)
+| .opaqueInfo val => compileMutual (MutConst.mkOpaq val)
+| .inductInfo val => MutConst.mkIndc val >>= compileMutual
+| .ctorInfo val => do match <- findLeanConst val.induct with
+  | .inductInfo ind => do
+    let _ <- MutConst.mkIndc ind >>= compileMutual
+    match (<- get).constCache.find? val.name with
+    | some ⟨data, meta⟩ => do pure (<- getIxon data, <- getIxon meta)
+    | none => throw <| .mutualBlockMissingProjection val.name
+  | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
+| .recInfo val => compileMutual (MutConst.recr val)
+| .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => withLevels lvls do
+  let n <- compileName name
+  let ls <- lvls.mapM compileName
+  let t <- compileExpr type
+  let data := .axio ⟨isUnsafe, lvls.length, t.data⟩
+  let meta := .meta ⟨[.link n, .links ls, .link t.meta]⟩
+  pure (data, meta)
+| .quotInfo ⟨⟨name, lvls, type⟩, kind⟩ => withLevels lvls do
+  let n <- compileName name
+  let ls <- lvls.mapM compileName
+  let t <- compileExpr type
+  let data := .quot ⟨kind, lvls.length, t.data⟩
+  let meta := .meta ⟨[.link n, .links ls, .link t.meta]⟩
+  pure (data, meta)
 
 partial def compileDefn: Ix.Def -> CompileM (Ixon.Definition × Ixon.Metadata)
 | d => withLevels d.levelParams do
@@ -752,8 +760,8 @@ partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
     | none, none =>
       if x == y then return ⟨true, .eq⟩
       else do
-        let x' <- compileConst $ ← findLeanConst x
-        let y' <- compileConst $ ← findLeanConst y
+        let x' <- compileConstName x
+        let y' <- compileConstName y
         return ⟨true, compare x' y'⟩
   | .const .., _ => return ⟨true, .lt⟩
   | _, .const .. => return ⟨true, .gt⟩
@@ -807,10 +815,12 @@ partial def addDef (lvls: List Lean.Name) (typ val: Lean.Expr) : CompileM MetaAd
   --let typ' <- compileExpr typ
   --let val' <- compileExpr val
   let anon := .defnInfo ⟨⟨.anonymous, lvls, typ⟩, val, .opaque, .safe, []⟩
-  let anonAddr <- compileConst anon
+  let (data, meta) <- compileConstant anon
+  let anonAddr := ⟨<- storeIxon data, <- storeIxon meta⟩
   let name := anonAddr.data.toUniqueName
   let const := .defnInfo ⟨⟨name, lvls, typ⟩, val, .opaque, .safe, []⟩
-  let addr <- compileConst const
+  let (data, meta) <- compileConstant const
+  let addr := ⟨<- storeIxon data, <- storeIxon meta⟩
   if addr.data != anonAddr.data then
     throw <| .alphaInvarianceFailure anon anonAddr const addr
   else
@@ -894,12 +904,12 @@ Open references are variables that point to names which aren't present in the
 `Lean.ConstMap`.
 -/
 def compileDelta (delta : Lean.PersistentHashMap Lean.Name Lean.ConstantInfo)
-  : CompileM Unit := delta.forM fun _ c => discard $ compileConst c
+  : CompileM Unit := delta.forM fun n _ => discard $ compileConstName n
 
-def compileEnv (env: Lean.Environment)
-  : CompileM Unit := do
-  compileDelta env.getDelta
-  env.getConstMap.forM fun _ c => if !c.isUnsafe then discard $ compileConst c else pure ()
+--def compileEnv (env: Lean.Environment)
+--  : CompileM Unit := do
+--  compileDelta env.getDelta
+--  env.getConstMap.forM fun n _ => if !c.isUnsafe then discard $ compileConstName n else pure ()
 
 def CompileM.runIO (c : CompileM α) 
   (env: Lean.Environment)
diff --git a/Ix/CondenseM.lean b/Ix/CondenseM.lean
index 04c98416..34136060 100644
--- a/Ix/CondenseM.lean
+++ b/Ix/CondenseM.lean
@@ -111,7 +111,6 @@ partial def visit : Lean.Name -> CondenseM Unit
 def condense: CondenseM (Map Lean.Name (Set Lean.Name)) := do
   let mut idx := 0
   for (name,_) in (<- read).constants do
-    dbg_trace "condensing {name} {idx}"
     idx := idx + 1
     match (<- get).names.get? name with
     | .some _ => continue
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 3cd94003..3922e75d 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -711,6 +711,28 @@ instance : Serialize Int where
   put := putInt
   get := getInt
 
+inductive BuiltIn where
+| obj : BuiltIn
+| neutral : BuiltIn
+| unreachable : BuiltIn
+deriving BEq, Repr, Ord, Inhabited, Ord, Hashable
+
+def putBuiltIn : BuiltIn → PutM Unit
+| .obj => putUInt8 0
+| .neutral => putUInt8 1
+| .unreachable => putUInt8 2
+
+def getBuiltIn : GetM BuiltIn := do
+  match (← getUInt8) with
+  | 0 => pure .obj
+  | 1 => pure .neutral
+  | 2 => pure .unreachable
+  | e => throw s!"expected BuiltIn encoding between 0 and 5, got {e}"
+
+instance : Serialize BuiltIn where
+  put := putBuiltIn
+  get := getBuiltIn
+
 inductive DataValue where
 | ofString (v: Address)
 | ofBool (v: Bool)
@@ -823,6 +845,7 @@ inductive Ixon where
 | chck : CheckClaim -> Ixon                             -- 0xE2, cryptographic claim
 | comm : Comm -> Ixon                                   -- 0xE3, cryptographic commitment
 | envn : Env -> Ixon                                    -- 0xE4, Lean4 environment
+| prim : BuiltIn -> Ixon                                -- 0xE5, compiler builtins
 | meta : Metadata -> Ixon                               -- 0xFX, Lean4 metadata
 deriving BEq, Repr, Inhabited, Ord, Hashable
 
@@ -871,6 +894,7 @@ def putIxon : Ixon -> PutM Unit
 | .chck x => put (Tag4.mk 0xE 0x2) *> put x
 | .comm x => put (Tag4.mk 0xE 0x3) *> put x
 | .envn x => put (Tag4.mk 0xE 0x4) *> put x
+| .prim x => put (Tag4.mk 0xE 0x5) *> put x
 | .meta m => put m
 
 def getIxon : GetM Ixon := do
@@ -911,6 +935,7 @@ def getIxon : GetM Ixon := do
   | ⟨0xE, 0x2⟩ => .chck <$> get
   | ⟨0xE, 0x3⟩ => .comm <$> get
   | ⟨0xE, 0x4⟩ => .envn <$> get
+  | ⟨0xE, 0x5⟩ => .prim <$> get
   | ⟨0xF, x⟩ => do
     let nodes <- getMany x.toNat Serialize.get
     return .meta ⟨nodes⟩
diff --git a/Ix/Meta.lean b/Ix/Meta.lean
index bc9626c8..605df2b4 100644
--- a/Ix/Meta.lean
+++ b/Ix/Meta.lean
@@ -38,9 +38,9 @@ elab "this_file!" : term => do
 macro "get_env!" : term =>
   `(getFileEnv this_file!)
 
-def computeIxAddress (env: Lean.Environment) (const: ConstantInfo): IO MetaAddress 
+def computeIxAddress (env: Lean.Environment) (const: Lean.Name): IO MetaAddress 
   := do
-  let (addr, _) <- (Ix.compileConst const).runIO env
+  let (addr, _) <- (Ix.compileConstName const).runIO env
   return addr
 
 def runCore (f : CoreM α) (env : Environment) : IO α :=
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index d3cb2b50..1f44fc09 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -106,22 +106,17 @@ def testInductives : IO TestSeq := do
 
 def testEasy : IO TestSeq := do
   let env <- get_env!
-  let difficult := [
+  let easy := [
     `Nat.add_comm
   ]
   let mut res := true
-  for name in difficult do
+  for name in easy do
     IO.println s!"⚙️ Compiling {name}"
     let mut cstt : CompileState := .init env 0
     let start <- IO.monoNanosNow
-    let const <- do match env.getDelta.find? name with
-      | some c => pure c
-      | none => match env.getConstMap.get? name with
-        | some c => pure c
-        | none => throw (IO.userError s!"{name} not in env")
-    let (addr, stt) <- do match (<- (compileConst const).run .init cstt) with
+    let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
     | (.ok a, stt) => pure (a, stt)
-    | (.error e, _) => IO.println s!"failed {const.name}" *> throw (IO.userError (<- e.pretty))
+    | (.error e, _) => IO.println s!"failed {name}" *> throw (IO.userError (<- e.pretty))
     let done <- IO.monoNanosNow
     IO.println s!"✅ {addr}"
     IO.println s!"Elapsed {Cronos.nanoToSec (done - start)}"
@@ -135,15 +130,10 @@ def testDifficult : IO TestSeq := do
   let mut res := true
   for name in difficult do
     let mut cstt : CompileState := .init env 0
-    let const <- do match env.getDelta.find? name with
-      | some c => pure c
-      | none => match env.getConstMap.get? name with
-        | some c => pure c
-        | none => throw (IO.userError s!"{name} not in env")
-    let (addr, stt) <- do match (<- (compileConst const).run .init cstt) with
+    let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
     | (.ok a, stt) => pure (a, stt)
-    | (.error e, _) => IO.println s!"failed {const.name}" *> throw (IO.userError (<- e.pretty))
-    IO.println s!"{const.name} -> {addr}"
+    | (.error e, _) => IO.println s!"failed {name}" *> throw (IO.userError (<- e.pretty))
+    IO.println s!"{name} -> {addr}"
     --cstt := stt
     --let mut store : Ixon.Store := {}
     --for (_,(a, b)) in cstt.names do
@@ -181,42 +171,24 @@ def testDifficult : IO TestSeq := do
 def testRoundtripGetEnv : IO TestSeq := do
   IO.println s!"Getting env"
   let env <- get_env!
+  let sccStart <- IO.monoNanosNow
   IO.println s!"Building condensation graph of env"
-  let numDelta := env.getDelta.stats.numNodes
-  let numConst := env.getConstMap.size
+  let numConst := env.constants.map₁.size + env.constants.map₂.stats.numNodes
   let mut cstt : CompileState := .init env 0
+  let sccEnd <- IO.monoNanosNow
+  IO.println s!"Condensation graph in {Cronos.nanoToSec (sccEnd - sccStart)}"
   IO.println s!"Compiling env"
-  let mut inDelta := 0
   let mut inConst := 0
   let allStart <- IO.monoNanosNow
-  for (_, c) in env.getDelta do
+  for (name, _) in env.constants do
     let start <- IO.monoNanosNow
-    IO.println s!"⚙️ Compiling {inDelta}/{numDelta}: {c.name}"
-    let (addr, stt) <- do match (<- (compileConst c).run .init cstt) with
+    let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
     | (.ok a, stt) => pure (a, stt)
     | (.error e, _) => do
-      IO.println s!"failed {c.name}"
+      IO.println s!"failed {name}"
       throw (IO.userError (<- e.pretty))
     let done <- IO.monoNanosNow
-    IO.println s!"✅ {addr}"
-    IO.println s!"Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec (done - allStart)}"
-    inDelta := inDelta + 1
-    cstt := stt
-  for (_, c) in env.getConstMap do
-    let start <- IO.monoNanosNow
-    IO.println s!"⚙️ Compiling {inConst}/{numConst}: {c.name} "
-    let (_, stt) <- do match (<- (compileConst c).run .init cstt) with
-    | (.ok a, stt) => do
-      pure (a, stt)
-    | (.error e, _) => do
-      IO.println s!"failed {c.name}"
-      throw (IO.userError (<- e.pretty))
-    let addr <- match stt.constCache.find? c.name with
-    | .some addr => pure addr
-    | .none => throw (IO.userError "name {n} not in env")
-    let done <- IO.monoNanosNow
-    IO.println s!"✅ {addr}"
-    IO.println s!"Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec (done - allStart)}"
+    IO.println s!"✓ Compiled {inConst}/{numConst} Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec (done - allStart)} {name} @ {addr}"
     inConst := inConst + 1
     cstt := stt
   let allDone <- IO.monoNanosNow
@@ -259,6 +231,40 @@ def testRoundtripGetEnv : IO TestSeq := do
  -- IO.println s!"output env: {dstt.constants.toList.length}"
   return test "env compile roundtrip" true --(res == true)
 
+--#eval (`_cstage2).isSuffixOf (`f.a._cstage2)
+--open Lean Meta
+--
+--set_option pp.all true
+--set_option pp.privateNames true
+--set_option pp.fullNames true
+
+--#eval show MetaM _ from do
+--  getConstInfo `Lean.Language.instInhabitedDynamicSnapshot._closed_2._cstage2
+--
+--#eval show MetaM _ from do
+--  getConstInfo `Lean.Language.instInhabitedDynamicSnapshot._closed_2._cstage2 
+--
+--def printPrivate (pre : Name) : CoreM (Array Name) := do
+--  let env ← getEnv
+--  let mut hits := #[]
+--  for (n, _) in env.const2ModIdx do
+--    if pre.isPrefixOf n then
+--      hits := hits.push n
+--  pure hits
+--
+--#eval do
+--  let hits ← printPrivate `_private.Lean.Language.Basic
+--  IO.println s!"found:"
+--  for n in hits do
+--    IO.println s!"{n}"
+--
+--#eval 
+--  IO.println s!"{(mkPrivateNameCore `Lean.Language.Basic `Lean.Language.DynamicSnapShot)}"
+--
+--#eval show MetaM _ from do
+--  let env ← getEnv
+--  return env.const2ModIdx.size
+
 def Tests.Ix.Compile.suiteIO: List (IO TestSeq) := [
   --testMutual,
   --testInductives,

From a999ecba962fc061c8c0aebb368747bb75c262c7 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 21 Oct 2025 23:54:23 -0400
Subject: [PATCH 55/74] decompilation wip

---
 Ix/Address.lean       |   1 -
 Ix/CompileM.lean      | 138 +++---
 Ix/DecompileM.lean    | 998 +++++++++++++++++++++++++++---------------
 Ix/Ixon.lean          |  16 +-
 Ix/Mutual.lean        |  49 ++-
 Tests/Ix/Compile.lean |  40 +-
 Tests/Ix/Ixon.lean    |   1 +
 7 files changed, 809 insertions(+), 434 deletions(-)

diff --git a/Ix/Address.lean b/Ix/Address.lean
index 7200f84a..98e427ea 100644
--- a/Ix/Address.lean
+++ b/Ix/Address.lean
@@ -12,7 +12,6 @@ structure Address where
 
 def Address.blake3 (x: ByteArray) : Address := ⟨(Blake3.hash x).val⟩
 
-
 def hexOfNat : Nat -> Option Char
 | 0 => .some '0'
 | 1 => .some '1'
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 2d9a116a..99928a3b 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -34,6 +34,7 @@ structure CompileState where
   strCache: Map String Address
   comms: Map Lean.Name MetaAddress
   constCmp: Map (Lean.Name × Lean.Name) Ordering
+  cstagePatch : Map Lean.Name Lean.Name
   --exprCmp: Map (CompileEnv × Lean.Expr × Lean.Expr) Ordering
   alls: Map Lean.Name (Set Lean.Name)
   axioms: Map Lean.Name MetaAddress
@@ -43,8 +44,8 @@ structure CompileState where
 def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize := 200000)
   : CompileState :=
   ⟨maxHeartBeats, env, mkStdGen seed, default, default, default, default,
-  default, default, default, default, default, default, CondenseM.run env,
-  default, default, default⟩
+  default, default, default, default, default, default, default,
+  CondenseM.run env, default, default, default⟩
 
 inductive CompileError where
 | unknownConstant : Lean.Name -> CompileError
@@ -57,7 +58,7 @@ inductive CompileError where
 | mutualBlockMissingProjection : Lean.Name -> CompileError
 --| nonRecursorExtractedFromChildren : Lean.Name → CompileError
 | cantFindMutIndex : Lean.Name -> MutCtx -> CompileError
-| cantFindMutMeta : Lean.Name -> Map Lean.Name Metadata -> CompileError
+| cantFindMutMeta : Lean.Name -> Map Address Address -> CompileError
 | kernelException : Lean.Kernel.Exception → CompileError
 --| cantPackLevel : Nat → CompileError
 --| nonCongruentInductives : PreInd -> PreInd -> CompileError
@@ -198,7 +199,7 @@ def compileName (name: Lean.Name): CompileM Address := do
     })
   where
     go : Lean.Name -> CompileM Address
-    | .anonymous => pure <| Address.blake3 ⟨#[]⟩
+    | .anonymous => storeIxon .nanon
     | .str n s => do
       let n' <- compileName n
       let s' <- storeString s
@@ -317,7 +318,7 @@ def compileDataValue : Lean.DataValue -> CompileM Ixon.DataValue
 | .ofString s => .ofString <$> storeString s
 | .ofBool b => pure (.ofBool b)
 | .ofName n => .ofName <$> compileName n
-| .ofNat i => .ofName <$> storeNat i
+| .ofNat i => .ofNat <$> storeNat i
 | .ofInt i => .ofInt <$> storeSerial i
 | .ofSyntax s => .ofSyntax <$> (compileSyntax s >>= storeSerial)
 
@@ -336,9 +337,13 @@ def findLeanConst (name : Lean.Name) : CompileM Lean.ConstantInfo := do
   match (<- get).env.constants.find? name with
   | some const => pure const
   | none => do
-    let cstage2 := Lean.Name.mkSimple "_cstage2"
-    match (<- get).env.constants.find? (name.append cstage2) with
-     | some const => pure const
+    let name2 := name.append (Lean.Name.mkSimple "_cstage2")
+    match (<- get).env.constants.find? name2 with
+     | some const => do
+      let _ <- compileName name2
+      modifyGet fun stt => (const, { stt with
+        cstagePatch := stt.cstagePatch.insert name name2
+      })
      | none => throw $ .unknownConstant name
 
 def MutConst.mkIndc (i: Lean.InductiveVal) : CompileM MutConst := do
@@ -351,6 +356,15 @@ def MutConst.mkIndc (i: Lean.InductiveVal) : CompileM MutConst := do
       | .ctorInfo c => pure c
       | _ => throw <| .invalidConstantKind name "constructor" ""
 
+--def mkProjCtx (mss: List (List MutConst)) : Map Lean.Name Nat := Id.run do
+--  let mut ctx := {}
+--  let mut i := 0
+--  for ms in mss do
+--    for m in ms do
+--      ctx := ctx.insert m.name i
+--    i := i + 1
+--  return ctx
+
 mutual
 
 partial def compileExpr: Lean.Expr -> CompileM MetaAddress 
@@ -367,13 +381,14 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
         modifyGet fun stt => (maddr, { stt with
           exprCache := stt.exprCache.insert expr maddr
         })
+
     go (kvs: List Lean.KVMap): Lean.Expr -> CompileM (Ixon × Ixon)
     | (.mdata kv x) => go (kv::kvs) x
     | .bvar idx => do
       let md <- compileKVMaps kvs
       let data := .evar idx
-      let sort := .meta ⟨[.link md]⟩
-      pure (data, sort)
+      let meta := .meta ⟨[.link md]⟩
+      pure (data, meta)
     | .sort univ => do
       let md <- compileKVMaps kvs
       let ⟨udata, umeta⟩ <- compileLevel univ
@@ -521,33 +536,44 @@ partial def compileRecr: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata
   let ls <- r.levelParams.mapM compileName
   let t <- compileExpr r.type
   let rules <- r.rules.mapM compileRule
+  let as <- r.all.mapM compileName
   let data := ⟨r.k, r.isUnsafe, ls.length, r.numParams, r.numIndices,
     r.numMotives, r.numMinors, t.data, rules.map (·.1)⟩
-  let meta := ⟨[.link n, .links ls, .rules (rules.map (·.2))]⟩
+  let meta := ⟨[.link n, .links ls, .link t.meta, .map (rules.map (·.2)), .links as]⟩
   pure (data, meta)
 
-partial def compileConstructor: Lean.ConstructorVal -> CompileM (Ixon.Constructor × Address)
+partial def compileConstructor (induct: Address)
+: Lean.ConstructorVal -> CompileM (Ixon.Constructor × Metadata)
 | c => withLevels c.levelParams <| do
   let n <- compileName c.name
   let ls <- c.levelParams.mapM compileName
   let t <- compileExpr c.type
   let data := ⟨c.isUnsafe, ls.length, c.cidx, c.numParams, c.numFields, t.data⟩
-  let meta <- storeMeta ⟨[.link n, .links ls, .link t.meta]⟩
+  let meta := ⟨[.link n, .links ls, .link t.meta, .link induct]⟩
   pure (data, meta)
 
-partial def compileIndc: Ix.Ind -> CompileM (Ixon.Inductive × Ixon.Metadata)
+partial def compileIndc: Ix.Ind -> CompileM (Ixon.Inductive × Map Address Address)
 | ⟨name, lvls, type, ps, is, all, ctors, nest, rcr, refl, usafe⟩ =>
   withLevels lvls do 
   let n <- compileName name
   let ls <- lvls.mapM compileName
   let t <- compileExpr type
-  let cs <- ctors.mapM compileConstructor
+  let mut cds := #[]
+  let mut cms := #[]
+  let mut metaMap := {}
+  for ctor in ctors do
+    let (cd, cm) <- compileConstructor n ctor
+    let cn <- compileName ctor.name
+    cds := cds.push cd
+    let cm' <- storeMeta cm
+    cms := cms.push cm'
+    metaMap := metaMap.insert cn cm'
   let as <- all.mapM compileName
-  let data := ⟨rcr, refl, usafe, ls.length, ps, is, nest, t.data,
-    cs.map (·.1)⟩
-  let meta := ⟨[.link n, .links ls, .link t.meta,
-    .links (cs.map (·.2)), .links as]⟩
-  pure (data, meta)
+  let data := ⟨rcr, refl, usafe, ls.length, ps, is, nest, t.data, cds.toList⟩
+  let meta := ⟨[.link n, .links ls, .link t.meta, .links cms.toList, .links as]⟩
+  let m <- storeMeta meta
+  metaMap := metaMap.insert n m
+  pure (data, metaMap)
 
 partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
 | const => do
@@ -574,20 +600,24 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
     -- sort MutConsts into equivalence classes
     let mutConsts <- sortConsts consts.toList
     let mutCtx := MutConst.ctx mutConsts
+    let mutMeta <- mutConsts.mapM fun m => m.mapM <| fun c => compileName c.name
     -- compile each constant with the mutCtx
     let (data, metas) <- withMutCtx mutCtx (compileMutConsts mutConsts)
     -- add top-level mutual block to our state
-    let allAddrs <- all.toList.mapM compileName
-    let block := ⟨<- storeIxon data, <- storeMeta ⟨[.links allAddrs]⟩⟩
+    let ctx <- mutCtx.toList.mapM fun (n, i) => do
+      pure (<- compileName n, <- storeNat i)
+    let block := ⟨<- storeIxon data, <- storeMeta ⟨[.muts mutMeta, .map ctx, .map metas.toList]⟩⟩
     modify fun stt => { stt with blocks := stt.blocks.insert block () }
     -- then add all projections, returning the inductive we started with
     let mut ret? : Option (Ixon × Ixon) := none
+    --let mut projCtx := mkProjCtx mutConsts
     for const' in consts do
       let idx <- do match mutCtx.find? const'.name with
       | some idx => pure idx
       | none => throw $ .cantFindMutIndex const'.name mutCtx
-      let meta <- do match metas.find? const'.name with
-      | some meta => pure ⟨(.link block.meta)::meta.nodes⟩
+      let n <- compileName const'.name
+      let meta <- do match metas.find? n with
+      | some meta => pure ⟨[.link block.meta, .link meta]⟩
       | none => throw $ .cantFindMutMeta const'.name metas
       let data := match const with
       | .defn _ => .dprj ⟨idx, block.data⟩
@@ -600,8 +630,9 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
       if const'.name == const.name then ret? := some (data, .meta meta)
       for ctor in const'.ctors do
         let cdata := .cprj ⟨idx, ctor.cidx, block.data⟩
-        let cmeta <- do match metas.find? const'.name with
-        | some meta => pure ⟨(.link block.meta)::meta.nodes⟩
+        let cn <- compileName ctor.name
+        let cmeta <- do match metas.find? cn with
+        | some meta => pure ⟨[.link block.meta, .link meta]⟩
         | none => throw $ .cantFindMutMeta const'.name metas
         let caddr := ⟨<- storeIxon cdata, <- storeMeta cmeta⟩
         modify fun stt => { stt with
@@ -612,21 +643,29 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
     | none => throw $ .mutualBlockMissingProjection const.name
 
 /-- Compile a mutual block --/
-partial def compileMutConsts: List (List MutConst) -> CompileM (Ixon × Map Lean.Name Metadata)
+partial def compileMutConsts: List (List MutConst)
+  -> CompileM (Ixon × Map Address Address)
 | classes => do
   let mut data := #[]
   let mut meta := {}
   -- iterate through each equivalence class
   for constClass in classes do
     let mut classData := #[]
-    -- compile each def in a class
+    -- compile each constant in a class
     for const in constClass do
-      let (data', meta') <- match const with
-      | .indc x => (fun (x, y) => (Ixon.MutConst.indc x, y)) <$> compileIndc x
-      | .defn x => (fun (x, y) => (Ixon.MutConst.defn x, y)) <$> compileDefn x
-      | .recr x => (fun (x, y) => (Ixon.MutConst.recr x, y)) <$> compileRecr x
-      classData := classData.push data'
-      meta := meta.insert const.name meta'
+      match const with
+      | .indc x => do
+        let (i, m) <- compileIndc x
+        classData := classData.push (.indc i)
+        meta := meta.union m
+      | .defn x => do
+        let (d, m) <- compileDefn x
+        classData := classData.push (.defn d)
+        meta := meta.insert (<- compileName x.name) (<- storeMeta m)
+      | .recr x => do
+        let (r, m) <- compileRecr x
+        classData := classData.push (.recr r)
+        meta := meta.insert (<- compileName x.name) (<- storeMeta m)
     -- make sure we have no empty classes and all defs in a class are equal
     match classData.toList with
       | [] => throw (.badMutualBlock classes)
@@ -637,22 +676,21 @@ partial def compileMutConsts: List (List MutConst) -> CompileM (Ixon × Map Lean
         else throw (.badMutualBlock classes)
   pure (.muts data.toList, meta)
 
---/--
---`sortConsts` recursively sorts a list of mutually referential constants into
---ordered equivalence classes. For most cases equivalence can be determined by
---syntactic differences in the definitions, but when two definitions
---refer to one another in the same syntactical position the classification can
---be self-referential. Therefore we use a partition refinement algorithm that
---starts by assuming that all definitions in the mutual block are equal and
---recursively improves our classification by sorting based on syntax:
---```
---classes₀ := [startConsts]
---classes₁ := sortConsts classes₀
---classes₂ := sortConsts classes₁
---classes₍ᵢ₊₁₎ := sortConsts classesᵢ ...
---```
---Eventually we reach a fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no
---further refinement is possible (trivially when each const is in its own class). --/
+/-- `sortConsts` recursively sorts a list of mutually referential constants into
+ordered equivalence classes. For most cases equivalence can be determined by
+syntactic differences in the definitions, but when two definitions
+refer to one another in the same syntactical position the classification can
+be self-referential. Therefore we use a partition refinement algorithm that
+starts by assuming that all definitions in the mutual block are equal and
+recursively improves our classification by sorting based on syntax:
+```
+classes₀ := [startConsts]
+classes₁ := sortConsts classes₀
+classes₂ := sortConsts classes₁
+classes₍ᵢ₊₁₎ := sortConsts classesᵢ ...
+```
+Eventually we reach a fixed-point where `classes₍ᵢ₊₁₎ := classesᵢ` and no
+further refinement is possible (trivially when each const is in its own class). --/
 partial def sortConsts (classes: List MutConst) : CompileM (List (List MutConst))
   := go [List.sortBy (compare ·.name ·.name) classes]
   where
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index a55de637..c2b0391c 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -3,114 +3,122 @@ import Ix.Ixon
 import Ix.Common
 import Ix.Store
 import Ix.CompileM
+import Init.Data.List.Control
 
-open Ix.Compile
-open Ixon
-
---namespace Ix.Decompile
---
---/- the current Ix constant being decompiled -/
---structure Named where
---  name: Lean.Name
---  cont: Address
---  meta: Address
---deriving Inhabited, Repr
---
---instance : ToString Named where
---  toString n := s!"{n.cont}:{n.meta}-{n.name}"
---
---/- The local environment for the Ix -> Lean4 decompiler -/
---structure DecompileEnv where
---  names : Std.HashMap Lean.Name (Address × Address) 
---  store : Std.HashMap Address Ixon
---  univCtx : List Lean.Name
---  bindCtx : List Lean.Name
---  mutCtx  : Std.HashMap Lean.Name Nat
---  current: Named
---  deriving Repr, Inhabited
---
---/- initialize from an Ixon store and a name-index to the store -/
---def DecompileEnv.init
---  (names : Std.HashMap Lean.Name (Address × Address))
---  (store : Std.HashMap Address Ixon)
---  : DecompileEnv
---  := ⟨names, store, default, default, default, default⟩
---
---/- a collection of an inductive datatype with its constructors and recursors -/
---structure InductiveBlock where
---  val: Lean.ConstantInfo
---  ctors: List Lean.ConstantInfo
---  recrs: List Lean.ConstantInfo
---deriving Repr
---
---def InductiveBlock.contains (i: InductiveBlock) (name: Lean.Name) : Bool := 
---  i.val.name == name ||
---  i.ctors.any (fun c => c.name == name) ||
---  i.recrs.any (fun r => r.name == name)
---
---/- A Block is one of the possible sets of Lean constants we could generate
--- from a pair of content and metadata Ix addresses -/
---inductive Block where
---| single : Lean.ConstantInfo -> Block
---| mutual : List Lean.ConstantInfo -> Block
---| inductive: List InductiveBlock -> Block
---deriving Repr
---
---def Block.contains (name: Lean.Name) : Block -> Bool
---| .single const => const.name == name
---| .mutual consts => consts.any (fun c => c.name == name)
---| .inductive is => is.any (fun i => i.contains name)
---
---/- The name of an inductive datatype with the names of its constructors and
---recursors. Used to create a BlockNames struct.
----/
---structure InductiveBlockNames where
---  val: Lean.Name
---  ctors: List Lean.Name
---  recrs: List Lean.Name
---deriving Repr
---
---def InductiveBlockNames.contains (i: InductiveBlockNames) (name: Lean.Name) : Bool := 
---  i.val == name ||
---  i.ctors.any (fun c => c == name) ||
---  i.recrs.any (fun r => r == name)
---
---/- A BlockNames struct is the names of a Block. Naively, the decompiler
---operates by mapping content-address pairs to blocks, but since each block might
---be mapped onto by many address pairs, we only record address pair to BlockNames
---mapping, and separately keep a single level map of Lean.Name to
---Lean.ConstantInfo
----/
---inductive BlockNames where
---| single : Lean.Name -> BlockNames
---| mutual : List Lean.Name -> BlockNames
---| inductive : List InductiveBlockNames -> BlockNames
---deriving Repr, Inhabited, Nonempty
---
---def BlockNames.contains (name: Lean.Name) : BlockNames -> Bool
---| .single const => const == name
---| .mutual consts => consts.any (fun c => c == name)
---| .inductive is => is.any (fun i => i.contains name)
---
---structure DecompileState where
---  constants: Std.HashMap Lean.Name Lean.ConstantInfo
---  blocks : Std.HashMap (Address × Address) BlockNames
---  deriving Inhabited
---
---inductive DecompileError
---| freeLevel (curr: Named) (ctx: List Lean.Name) (lvl: Lean.Name) (idx: Nat)
---| mismatchedLevelName
---  (curr: Named) (ctx: List Lean.Name) (got: Lean.Name)
---  (exp: Lean.Name) (idx: Nat)
---| invalidBVarIndex (curr: Named) (ctx: List Lean.Name) (idx: Nat)
---| mismatchedMutIdx
---  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) 
---  (idx: Nat) (got: Nat)
---| unknownMutual 
---  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) (idx: Nat)
+open Ix.CompileM
+open Ixon hiding Substring
+
+namespace Ix
+
+/- the current Ix constant being decompiled -/
+structure Named where
+  name: Lean.Name
+  addr: MetaAddress
+deriving Inhabited, Repr
+
+instance : ToString Named where
+  toString n := s!"{n.addr}.{n.name}"
+
+/- The local environment for the Ix -> Lean4 decompiler -/
+structure DecompileEnv where
+  names : Map Lean.Name MetaAddress
+  store : Map Address ByteArray
+  univCtx : List Lean.Name
+  bindCtx : List Lean.Name
+  mutCtx  : Std.HashMap Lean.Name Nat
+  current : Named
+  deriving Repr, Inhabited
+
+/- initialize from an Ixon store and a name-index to the store -/
+def DecompileEnv.init
+  (names : Map Lean.Name MetaAddress)
+  (store : Map Address ByteArray)
+  : DecompileEnv
+  := ⟨names, store, default, default, default, default⟩
+
+/- A Block is one of the possible sets of Lean constants we could generate
+ from a pair of content and metadata Ix addresses -/
+inductive Block where
+| prim : Block
+| defn : Def -> Block
+| recr : Lean.RecursorVal -> Block
+| axio : Lean.AxiomVal -> Block
+| quot : Lean.QuotVal -> Block
+| muts : List MutConst -> Block
+deriving Repr, Inhabited, Nonempty
+
+def Block.contains (name: Lean.Name) : Block -> Bool
+| .prim => name == .mkSimple "_obj" || name == .mkSimple "_neutral" || name == .mkSimple "_unreachable"
+| .defn val => val.name == name
+| .recr val => val.name == name
+| .axio val => val.name == name
+| .quot val => val.name == name
+| .muts consts => consts.any (·.contains name)
+
+def Block.consts : Block -> Set Lean.ConstantInfo
+| .prim => {}
+| .defn val => {defn val}
+| .recr val => {.recInfo val}
+| .axio val => {.axiomInfo val}
+| .quot val => {.quotInfo val}
+| .muts consts => consts.foldr (fun m set => set.union (mutConst m)) {}
+where
+  defn: Def -> Lean.ConstantInfo
+  | ⟨name, lvls, type, kind, value, hints, safety, all⟩ => match kind with
+  | .«definition» => .defnInfo ⟨⟨name, lvls, type⟩, value, hints, safety, all⟩
+  | .«opaque» => .opaqueInfo ⟨⟨name, lvls, type⟩, value, safety == .unsafe, all⟩
+  | .«theorem» => .thmInfo ⟨⟨name, lvls, type⟩, value, all⟩
+  mutConst: MutConst -> Set Lean.ConstantInfo
+  | .defn d => {defn d}
+  | .recr r => {.recInfo r}
+  | .indc i => (Std.HashSet.ofList (.ctorInfo <$> i.ctors)).insert <|
+    .inductInfo (⟨⟨i.name, i.levelParams, i.type⟩, i.numParams,
+      i.numIndices, i.all, (·.name) <$> i.ctors, i.numNested, i.isRec,
+      i.isReflexive, i.isUnsafe⟩)
+
+structure DecompileState where
+  constants: Map Lean.Name Lean.ConstantInfo
+  constCache: Map MetaAddress (Lean.Name × Set Lean.Name)
+  exprCache: Map MetaAddress Lean.Expr
+  univCache: Map MetaAddress Lean.Level
+  synCache: Map Address Lean.Syntax
+  nameCache: Map Address Lean.Name
+  deriving Inhabited
+
+inductive DecompileError
+| freeLevel (curr: Named) (ctx: List Lean.Name) (lvl: Lean.Name) (idx: Nat)
+| mismatchedLevelName
+  (curr: Named) (ctx: List Lean.Name) (got: Lean.Name)
+  (exp: Lean.Name) (idx: Nat)
+| mismatchedName (curr: Named) (n m: Lean.Name)
+| invalidBVarIndex (curr: Named) (ctx: List Lean.Name) (idx: Nat)
+| mismatchedUnivArgs (curr: Named) (d m : List Address)
+| mismatchedLevels (curr: Named) (n: Nat) (ls: List Address)
+| mismatchedRules (curr: Named) (rs: List RecursorRule) (ms: List (Address × Address))
+| mismatchedCtors (curr: Named) (cs: List Constructor) (ms: List Address)
+| mismatchedMutIdx
+  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) 
+  (idx: Nat) (got: Nat)
+| unknownMutual 
+  (curr: Named) (ctx: Std.HashMap Lean.Name Nat) (exp: Lean.Name) (idx: Nat)
 --| transport (curr: Named) (err: TransportError) (cont meta: Address)
 --| unknownName (curr: Named) (name: Lean.Name)
---| unknownStoreAddress (curr: Named) (exp: Address)
+| badDeserialization (addr: Address) (exp: String) (str: String)
+| unknownStoreAddress (curr: Named) (addr: Address)
+| badName (curr: Named) (ixon: Ixon)
+| badLevel (curr: Named) (data meta: Ixon)
+| badKVMap (curr: Named) (ixon: Ixon)
+| badKVMapMetadatum (curr: Named) (meta: Metadatum)
+| badExpr (curr: Named) (data meta: Ixon)
+| badDef (curr: Named) (d: Ixon.Definition) (meta: Metadata)
+| badRecr (curr: Named) (d: Ixon.Recursor) (meta: Metadata)
+| badCtor (curr: Named) (ctor: Ixon.Constructor) (meta: Ixon)
+| badIndc (curr: Named) (ctor: Ixon.Inductive) (meta: Metadata)
+| badMuts (curr: Named) (data meta: Ixon)
+| badConst (curr: Named) (data meta: Ixon)
+| badProj (curr: Named) (block: Block) (msg: String)
+| badProjMeta (curr: Named) (meta: Ixon) (msg: String)
+| badCache (name: Lean.Name) (set: Set Lean.Name)
 --| expectedIxonMetadata (curr: Named) (exp: Address) (got: Ixon)
 --| badProjection
 --  (curr: Named) (name: Lean.Name) (cont meta: Address) (msg: String)
@@ -129,23 +137,43 @@ open Ixon
 --| expectedMutIndConst (curr: Named) (got: Ix.Const) (cont meta: Address)
 --| expectedMutDefConst (curr: Named) (got: Ix.Const) (cont meta: Address)
 --| overloadedConstants (curr: Named) (x y: Lean.ConstantInfo)
---| todo
---deriving Repr
---
---
---def DecompileError.pretty : DecompileError -> String
---| .freeLevel c lvls n i => s!"Free level {n} at {i} with ctx {repr lvls} @ {c}"
---| .mismatchedLevelName c ctx n' n i => 
---  s!"Expected level name {n} at index {i} but got {n'} with context {repr ctx} @ {c}"
---| .invalidBVarIndex c ctx i => 
---  s!"Bound variable {i} escapes context {ctx} @ {c}"
---| .mismatchedMutIdx c ctx n i i' => 
---  s!"expected mutual recusion index {i} at name {n} but got {i'} with context {repr ctx} @ {c}"
---| .unknownMutual c ctx n i => 
---  s!"unknown mutual name {n} with expected index {i} with context {repr ctx} @ {c}"
+| todo
+deriving Repr
+
+def DecompileError.pretty : DecompileError -> String
+| .freeLevel c lvls n i => s!"Free level {n} at {i} with ctx {repr lvls} @ {c}"
+| .mismatchedLevelName c ctx n' n i => 
+  s!"Expected level name {n} at index {i} but got {n'} with context {repr ctx} @ {c}"
+| .mismatchedName c n m => 
+  s!"Expected name {n} got {m} @ {c}"
+| .invalidBVarIndex c ctx i => 
+  s!"Bound variable {i} escapes context {ctx} @ {c}"
+| .mismatchedUnivArgs c d m => s!"mismatched univ args in {repr d} {repr m} @ {c}"
+| .mismatchedLevels c n ls => s!"mismatched levels {n} {ls} @ {c}"
+| .mismatchedRules c ras rms => s!"mismatched rules {repr ras} {rms} @ {c}"
+| .mismatchedCtors c cs ms => s!"mismatched rules {repr cs} {ms} @ {c}"
+| .mismatchedMutIdx c ctx n i i' => 
+  s!"expected mutual recusion index {i} at name {n} but got {i'} with context {repr ctx} @ {c}"
+| .unknownMutual c ctx n i => 
+  s!"DecompileError: unknown mutual name {n} with expected index {i} with context {repr ctx} @ {c}"
 --| .transport curr e c m => s!"decompiler transport error {e} at {c} {m} @ {curr}"
 --| .unknownName c n => s!"unknown name {n} @ {c}"
---| .unknownStoreAddress c x => s!"unknown store address {x} @ {c}"
+| .badDeserialization a e s => s!"DecompileError: bad deserialization at {a}, expected {e}, error: {s}"
+| .unknownStoreAddress c x => s!"DecompileError: unknown store address {x} @ {c}"
+| .badName c i => s!"expected Name, got {repr i} @ {c}"
+| .badLevel c d m => s!"expected Level, got {repr d} {repr m} @ {c}"
+| .badKVMap c m => s!"expected KVMap, got {repr m} @ {c}"
+| .badKVMapMetadatum c m => s!"expected KVMapMetadatum, got {repr m} @ {c}"
+| .badExpr c d m => s!"expected Expr, got {repr d} {repr m} @ {c}"
+| .badDef c d m => s!"expected Def, got {repr d} {repr m} @ {c}"
+| .badRecr c d m => s!"expected Recr, got {repr d} {repr m} @ {c}"
+| .badCtor c d m => s!"expected Ctor, got {repr d} {repr m} @ {c}"
+| .badIndc c d m => s!"expected Indc, got {repr d} {repr m} @ {c}"
+| .badMuts c d m => s!"expected Muts, got {repr d} {repr m} @ {c}"
+| .badConst c d m => s!"expected const, got {repr d} {repr m} @ {c}"
+| .badProj c b n => s!"bad Block projection of {repr b}, with {n} @ {c}"
+| .badProjMeta c m n => s!"bad Block projection metadata {repr m} with {n} @ {c}"
+| .badCache n s => s!"bad cache entry, expected {n} in {repr s}"
 --| .expectedIxonMetadata c x ixon => s!"expected metadata at address {x}, got {repr ixon} @ {c}"
 --| .badProjection curr n c m s => s!"bad projection {n} at address {c}:{m}, {s} @ {curr}"
 --| .nonCongruentInductives c x y  => s!"noncongruent inductives {repr x} {repr y} @ {c}"
@@ -167,246 +195,496 @@ open Ixon
 --  s!"expected mutual definition constant, got {repr g} at address {c} {m} @ {curr}"
 --| .overloadedConstants curr x y => 
 --  s!"overloaded constants, tried to overwrite {repr y} with {repr x} @ {curr}"
---| .todo => s!"todo"
---
---abbrev DecompileM := ReaderT DecompileEnv <| EStateM DecompileError DecompileState
---
---def DecompileM.run (env: DecompileEnv) (stt: DecompileState) (c : DecompileM α)
---  : EStateM.Result DecompileError DecompileState α
---  := EStateM.run (ReaderT.run c env) stt
---
----- add binding name to local context
---def withBinder (name: Lean.Name) : DecompileM α -> DecompileM α :=
---  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
---
----- add levels to local context
---def withLevels (lvls : List Lean.Name) : DecompileM α -> DecompileM α :=
---  withReader $ fun c => { c with univCtx := lvls }
---
----- add mutual recursion info to local context
---def withMutCtx (mutCtx : Std.HashMap Lean.Name Nat)
---  : DecompileM α -> DecompileM α :=
---  withReader $ fun c => { c with mutCtx := mutCtx }
---
---def withNamed (name: Lean.Name) (cont meta: Address)
---  : DecompileM α -> DecompileM α :=
---  withReader $ fun c => { c with current := ⟨name, cont, meta⟩ }
---
----- reset local context
---def resetCtx : DecompileM α -> DecompileM α :=
---  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {} }
---
---def resetCtxWithLevels (lvls: List Lean.Name) : DecompileM α -> DecompileM α :=
---  withReader $ fun c => { c with univCtx := lvls, bindCtx := [], mutCtx := {} }
---
---def decompileLevel: Ix.Level → DecompileM Lean.Level
---| .zero => pure .zero
---| .succ u => .succ <$> decompileLevel u
---| .max a b => Lean.Level.max  <$> decompileLevel a <*> decompileLevel b
---| .imax a b => Lean.Level.imax <$> decompileLevel a <*> decompileLevel b
---| .param n i => do
---  let env <- read
---  match env.univCtx[i]? with
---  | some n' =>
---    if n == n' then pure (Lean.Level.param n)
---    else throw (.mismatchedLevelName env.current env.univCtx n' n i)
---  | none => throw <| .freeLevel env.current env.univCtx n i
---
---partial def insertConst
---  (const: Lean.ConstantInfo)
---  : DecompileM Lean.Name := do
---  match (<- get).constants.get? const.name with
---  | .some const' =>
---      if const == const' then return const.name
---      else throw <| .overloadedConstants (<- read).current const const'
---  | .none => modify fun stt => 
---    { stt with constants := stt.constants.insert const.name const }
---    return const.name
---
---partial def insertBlock (c m: Address) (b: Block) : DecompileM BlockNames := do
---  let bn <- match b with
---    | .single const => .single <$> insertConst const
---    | .mutual cs => .mutual <$> cs.mapM insertConst
---    | .inductive is => .inductive <$> is.mapM insertInductive
---  modifyGet fun stt =>
---    (bn, { stt with blocks := stt.blocks.insert (c, m) bn })
---  where
---    insertInductive (i: InductiveBlock) : DecompileM InductiveBlockNames := do
---      let val <- insertConst i.val
---      let ctors <- i.ctors.mapM insertConst
---      let recrs <- i.recrs.mapM insertConst
---      return ⟨val, ctors, recrs⟩
---
---partial def decompileMutualCtx (ctx: List (List Lean.Name))
---  : DecompileM (Std.HashMap Lean.Name Nat) := do
---  let mut mutCtx : Std.HashMap Lean.Name Nat := {}
---  for (ns, i) in List.zipIdx ctx do
---    for n in ns do
---      mutCtx := mutCtx.insert n i
---  return mutCtx
---
---partial def checkCtorRecrLengths : List Ix.Inductive -> DecompileM (Nat × Nat)
---| [] => return (0, 0)
---| x::xs => go x xs
---  where
---    go : Ix.Inductive -> List Ix.Inductive -> DecompileM (Nat × Nat)
---    | x, [] => return (x.ctors.length, x.recrs.length)
---    | x, a::as => do
---      if x.ctors.length == a.ctors.length && x.recrs.length == a.recrs.length
---      then go x as else throw <| .nonCongruentInductives (<- read).current x a
---
---partial def decompileMutIndCtx (block: Ix.InductiveBlock)
---  : DecompileM (Std.HashMap Lean.Name Nat) := do
---  let mut mutCtx : Std.HashMap Lean.Name Nat := {}
---  let mut i := 0
---  for inds in block.inds do
---    let (numCtors, numRecrs) <- checkCtorRecrLengths inds
---    for ind in inds do
---      mutCtx := mutCtx.insert ind.name i
---      for (c, cidx) in List.zipIdx ind.ctors do
---        mutCtx := mutCtx.insert c.name (i + cidx)
---      for (r, ridx) in List.zipIdx ind.recrs do
---        mutCtx := mutCtx.insert r.name (i + numCtors + ridx)
---    i := i + 1 + numCtors + numRecrs
---  return mutCtx
---
---mutual
---
---partial def decompileExpr: Ix.Expr → DecompileM Lean.Expr
---| .var i      => do match (← read).bindCtx[i]? with
---  | some _ => return .bvar i
---  | none => throw <| .invalidBVarIndex (<-read).current (<-read).bindCtx i
---| .sort u     => Lean.Expr.sort <$> decompileLevel u
---| .lit l      => pure (.lit l)
---| .app f a    => Lean.mkApp <$> decompileExpr f <*> decompileExpr a
---| .lam n bi t b =>
---    Lean.mkLambda n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
---| .pi n bi t b =>
---    Lean.mkForall n bi <$> decompileExpr t <*> withBinder n (decompileExpr b)
---| .letE n t v b nd =>
---    (@Lean.mkLet n)
---      <$> decompileExpr t
---      <*> decompileExpr v
---      <*> withBinder n (decompileExpr b)
---      <*> pure nd
---| .proj n cont meta i e => do
---    let _ <- ensureBlock n cont meta
---    Lean.mkProj n i <$> decompileExpr e
---| .const n cont meta us => do
---    let _ <- ensureBlock n cont meta
---    return Lean.mkConst n (<- us.mapM decompileLevel)
---| .rec_ n i us => do match (<- read).mutCtx.get? n with
---  | some i' =>
---    if i == i' then return Lean.mkConst n (<- us.mapM decompileLevel)
---    else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx n i i'
---  | none => throw <| .unknownMutual (<- read).current (<- read).mutCtx n i
---
---partial def ensureBlock (name: Lean.Name) (c m: Address) : DecompileM BlockNames := do
---  match (<- get).blocks.get? (c, m) with
---  | .some b =>
---    if b.contains name then pure b
---    else throw <| .nameNotInBlockNames (<- read).current b name c m
---  | .none =>
---    let cont : Ixon.Const <- match (<- read).store.get? c with
---      | .some ixon => pure ixon
---      | .none => throw <| .unknownStoreAddress (<- read).current c
---    let meta : Ixon.Const <- match (<- read).store.get? m with
---      | .some ixon => pure ixon
---      | .none => throw <| .unknownStoreAddress (<- read).current m
---    match rematerialize cont meta with
---    | .ok const  => do
---      let blockNames <- withNamed name c m <| decompileConst const
---      if !blockNames.contains name then
---         throw <| .nameNotInBlockNames (<- read).current blockNames name c m
---      return blockNames
---    | .error e => throw (.transport (<- read).current e c m)
---
---partial def decompileDefn (x: Ix.Definition)
---  : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
---    let type <- decompileExpr x.type
---    let val <- decompileExpr x.value
---    match x.kind with
---    | .definition => return .defnInfo <|
---      Lean.mkDefinitionValEx x.name x.levelParams type val x.hints x.safety x.all
---    | .opaque => return .opaqueInfo <|
---      Lean.mkOpaqueValEx x.name x.levelParams type val (x.safety == .unsafe) x.all
---    | .theorem => return .thmInfo <|
---      Lean.mkTheoremValEx x.name x.levelParams type val x.all
---
---partial def decompileIndc (x: Ix.Inductive)
---  : DecompileM
---    (Lean.ConstantInfo × List Lean.ConstantInfo × List Lean.ConstantInfo)
---    := withLevels x.levelParams do
---      let type <- decompileExpr x.type
---      let indc :=
---        Lean.mkInductiveValEx x.name x.levelParams type x.numParams x.numIndices
---          x.all (x.ctors.map (·.name)) x.numNested x.isRec x.isUnsafe x.isReflexive
---      let ctors <- x.ctors.mapM (decompileCtor x.name)
---      let recrs <- x.recrs.mapM (decompileRecr x.all)
---      return (.inductInfo indc, ctors, recrs)
---  where
---    decompileCtor (indcName: Lean.Name) (x: Ix.Constructor)
---      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
---      let type <- decompileExpr x.type
---      return .ctorInfo <|
---        Lean.mkConstructorValEx x.name x.levelParams type indcName
---          x.cidx x.numParams x.numFields x.isUnsafe
---    decompileRecrRule (x: Ix.RecursorRule) : DecompileM Lean.RecursorRule := do
---      let rhs <- decompileExpr x.rhs
---      return ⟨x.ctor, x.nfields, rhs⟩
---    decompileRecr (indcAll: List Lean.Name) (x: Ix.Recursor)
---      : DecompileM Lean.ConstantInfo := withLevels x.levelParams do
---      let type <- decompileExpr x.type
---      let rules <- x.rules.mapM decompileRecrRule
---      return .recInfo <|
---        Lean.mkRecursorValEx x.name x.levelParams type indcAll
---          x.numParams x.numIndices x.numMotives x.numMinors rules x.k x.isUnsafe
---
----- TODO: name integrity
---partial def decompileConst : Ix.Const -> DecompileM BlockNames
---| .axiom x => withLevels x.levelParams do
---  let ⟨_, c, m⟩ := (<- read).current
---  let type <- decompileExpr x.type
---  let const := (.axiomInfo <| Lean.mkAxiomValEx x.name x.levelParams type x.isUnsafe)
---  insertBlock c m (.single const)
---| .definition x => do
---  let ⟨_, c, m⟩ := (<- read).current
---  let const <- decompileDefn x
---  insertBlock c m (.single const)
---| .quotient x => withLevels x.levelParams do
---  let ⟨_, c, m⟩ := (<- read).current
---  let type <- decompileExpr x.type
---  let const := (.quotInfo <| Lean.mkQuotValEx x.name x.levelParams type x.kind)
---  insertBlock c m (.single const)
---| .inductiveProj x => ensureBlock x.name x.blockCont x.blockMeta
---| .constructorProj x => ensureBlock x.induct x.blockCont x.blockMeta
---| .recursorProj x => ensureBlock x.induct x.blockCont x.blockMeta
---| .definitionProj x => ensureBlock x.name x.blockCont x.blockMeta
---| .mutual x => do
---  let ⟨_, c, m⟩ := (<- read).current
---  let mutCtx <- decompileMutualCtx x.ctx
---  withMutCtx mutCtx do
---    let mut block := #[]
---    for defns in x.defs do
---      for defn in defns do
---        let const <- decompileDefn defn
---        block := block.push const
---    insertBlock c m (.mutual block.toList)
---| .inductive x => do
---  let ⟨_, c, m⟩ := (<- read).current
---  let mutCtx <- decompileMutIndCtx x
---  withMutCtx mutCtx do
---    let mut block := #[]
---    for inds in x.inds do
---      for ind in inds do
---        let (i, cs, rs) <- decompileIndc ind
---        block := block.push ⟨i, cs, rs⟩
---    insertBlock c m (Block.inductive block.toList)
---
---end
---
+| .todo => s!"todo"
+
+abbrev DecompileM := ReaderT DecompileEnv <| EStateM DecompileError DecompileState
+
+def DecompileM.run (env: DecompileEnv) (stt: DecompileState) (c : DecompileM α)
+  : EStateM.Result DecompileError DecompileState α
+  := EStateM.run (ReaderT.run c env) stt
+
+-- add binding name to local context
+def withBinder' (name: Lean.Name) : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
+
+-- add levels to local context
+def withLevels' (lvls : List Lean.Name) : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with univCtx := lvls }
+
+-- add mutual recursion info to local context
+def withMutCtx' (mutCtx : Std.HashMap Lean.Name Nat)
+  : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with mutCtx := mutCtx }
+
+def withNamed (name: Lean.Name) (meta: MetaAddress)
+  : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with current := ⟨name, meta⟩ }
+
+-- reset local context
+def resetCtx' : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {} }
+
+def readStore [Serialize A] (addr: Address) (exp: String): DecompileM A := do
+  --dbg_trace "readStore {addr}"
+  match (<- read).store.find? addr with
+  | some bytes => match Ixon.de bytes with
+    | .ok ixon => pure ixon
+    | .error e => throw <| .badDeserialization addr exp e
+  | none => throw <| .unknownStoreAddress (<- read).current addr
+
+def readNat (addr: Address) : DecompileM Nat := do
+  --dbg_trace "readNat {addr}"
+  match (<- read).store.find? addr with
+  | some bytes => return Nat.fromBytesLE bytes.data
+  | none => throw <| .unknownStoreAddress (<- read).current addr
+
+def readString (addr: Address): DecompileM String := do
+  --dbg_trace "readString {addr}"
+  match (<- read).store.find? addr with
+  | some bytes => match String.fromUTF8? bytes with
+    | .some s => pure s
+    | .none => throw <| .badDeserialization addr "UTF8" ""
+  | none => throw <| .unknownStoreAddress (<- read).current addr
+
+def readIxon (addr: Address) : DecompileM Ixon := do
+  --dbg_trace "readIxon {addr}"
+  match (<- read).store.find? addr with
+  | some bytes => match Ixon.de bytes with
+    | .ok ixon => pure ixon
+    | .error e => throw <| .badDeserialization addr "Ixon" e
+  | none => throw <| .unknownStoreAddress (<- read).current addr
+
+partial def decompileName (addr: Address) : DecompileM Lean.Name := do
+  --dbg_trace "decompileName {addr}"
+  match (<- get).nameCache.find? addr with
+  | some name => pure name
+  | none => do
+    let name <- go (<- readIxon addr)
+    modifyGet fun stt => (name, { stt with
+      nameCache := stt.nameCache.insert addr name
+    })
+  where
+    go : Ixon -> DecompileM Lean.Name
+    | .nanon => return Lean.Name.anonymous
+    | .nstr n s => do
+       let n' <- decompileName n
+       let s' <- readString s
+       return Lean.Name.str n' s'
+    | .nnum n i => do
+       let n' <- decompileName n
+       let i' <- readNat i
+       return Lean.Name.num n' i'
+    | ixon => do throw <| .badName (<- read).current ixon
+
+partial def decompileLevel (addr: MetaAddress): DecompileM Lean.Level := do
+  --dbg_trace s!"decompileLevel"
+  match (<- get).univCache.find? addr with
+  | some x => pure x
+  | none => do
+    let level <- go (<- readIxon addr.data) (<- readIxon addr.meta)
+    modifyGet fun stt => (level, { stt with
+      univCache := stt.univCache.insert addr level
+    })
+  where
+    go : Ixon -> Ixon -> DecompileM Lean.Level
+    | .uzero, .meta ⟨[]⟩ => return .zero
+    | .usucc a, .meta ⟨[.link m]⟩ => do
+      let x <- decompileLevel ⟨a, m⟩
+      return .succ x
+    | .umax xa ya, .meta ⟨[.link xm, .link ym]⟩ => do
+      let x <- decompileLevel ⟨xa, xm⟩
+      let y <- decompileLevel ⟨ya, ym⟩
+      return .max x y
+    | .uimax xa ya, .meta ⟨[.link xm, .link ym]⟩ => do
+      let x <- decompileLevel ⟨xa, xm⟩
+      let y <- decompileLevel ⟨ya, ym⟩
+      return .imax x y
+    | .uvar i, .meta ⟨[.link n]⟩ => do
+      let name <- decompileName n
+      match (<- read).univCtx[i]? with
+      | some name' => do
+        if name' == name then pure (.param name)
+        else throw <| .mismatchedLevelName (<- read).current (<- read).univCtx name name' i
+      | none => do throw <| .freeLevel (<- read).current (<- read).univCtx name i
+    | d , m => do throw <| .badLevel (<- read).current d m
+
+def decompileSubstring : Ixon.Substring -> DecompileM Substring
+| ⟨s, startPos, stopPos⟩ => do pure ⟨<- readString s, ⟨startPos⟩, ⟨stopPos⟩⟩
+
+def decompileSourceInfo : Ixon.SourceInfo -> DecompileM Lean.SourceInfo
+| .original l p t e => do
+  let l' <- decompileSubstring l
+  let t' <- decompileSubstring t
+  pure <| .original l' ⟨p⟩ t' ⟨e⟩
+| .synthetic p e c => pure <| .synthetic ⟨p⟩ ⟨e⟩ c
+| .none => pure .none
+
+def decompilePreresolved : Ixon.Preresolved -> DecompileM Lean.Syntax.Preresolved
+| .namespace ns => .namespace <$> decompileName ns
+| .decl n fs => .decl <$> decompileName n <*> (fs.mapM readString)
+
+partial def decompileSyntax (addr: Address): DecompileM Lean.Syntax := do
+  match (<- get).synCache.find? addr with
+  | some x => pure x
+  | none => do
+    let syn' <- go (<- readStore addr "Syntax")
+    modifyGet fun stt => (syn', { stt with
+      synCache := stt.synCache.insert addr syn'
+    })
+  where
+    go : Ixon.Syntax -> DecompileM Lean.Syntax
+    | .missing => pure .missing
+    | .node info kind args => do
+      let info' <- decompileSourceInfo info
+      let kind' <- decompileName kind
+      let args' <- args.mapM decompileSyntax
+      pure <| .node info' kind' ⟨args'⟩
+    | .atom info val => do
+      let info' <- decompileSourceInfo info
+      let val' <- readString val
+      pure <| .atom info' val'
+    | .ident info rawVal val preresolved => do
+      let info' <- decompileSourceInfo info
+      let rawVal' <- decompileSubstring rawVal
+      let val' <- decompileName val
+      let ps' <- preresolved.mapM decompilePreresolved
+      pure <| .ident info' rawVal' val' ps'
+
+partial def decompileDataValue: Ixon.DataValue -> DecompileM Lean.DataValue
+| .ofString s => .ofString <$> readString s
+| .ofBool b => pure (.ofBool b)
+| .ofName n => .ofName <$> decompileName n
+| .ofNat i => .ofNat <$> readNat i
+| .ofInt i => .ofInt <$> readStore i "Int"
+| .ofSyntax s => .ofSyntax <$> (decompileSyntax s)
+
+partial def decompileKVMaps (addr: Address) : DecompileM (List Lean.KVMap) := do
+  match (<- readIxon addr) with
+  | .meta ⟨ms⟩ => ms.mapM go
+  | x => throw <| .badKVMap (<- read).current x
+  where
+    go : Metadatum -> DecompileM Lean.KVMap
+    | .kvmap xs => do
+      let mut kv := {}
+      for (n, d) in xs do
+        let n <- decompileName n
+        let d <- decompileDataValue d
+        kv := kv.insert n d
+      return kv
+    | x => do throw <| .badKVMapMetadatum (<- read).current x
+
+partial def insertBlock (block: Block): DecompileM (Set Lean.Name) := do
+  let mut set := {}
+  for c in block.consts do
+    modify fun stt => { stt with constants := stt.constants.insert c.name c }
+    set := set.insert c.name
+  return set
+
+partial def matchNames (x y: Lean.Name) : DecompileM α -> DecompileM α
+| a => do
+  let cs2 := Lean.Name.mkSimple "_cstage2"
+  if x == y || x == y.append cs2  || x.append cs2 == y then a
+  else throw <| .mismatchedName (<- read).current x y
+
+mutual
+
+partial def decompileExpr (addr: MetaAddress): DecompileM Lean.Expr := do
+  --dbg_trace s!"decompileExpr {addr}"
+  match (<- get).exprCache.find? addr with
+  | some x => pure x
+  | none => do
+    let level <- go (<- readIxon addr.data) (<- readIxon addr.meta)
+    modifyGet fun stt => (level, { stt with
+      exprCache := stt.exprCache.insert addr level
+    })
+  where
+    mdata : List Lean.KVMap -> Lean.Expr -> Lean.Expr
+    | [], x => x
+    | kv::kvs, x => .mdata kv (mdata kvs x)
+    univs (as ms: List Address): DecompileM (List Lean.Level) := do
+      if as.length != ms.length
+      then throw <| .mismatchedUnivArgs (<- read).current as ms
+      else (as.zip ms).mapM fun (ua, um) => decompileLevel ⟨ua, um⟩
+    go : Ixon -> Ixon -> DecompileM Lean.Expr
+    | .evar i, .meta ⟨[.link md]⟩ => do
+      --dbg_trace s!"decompileExpr evar"
+      let kvs <- decompileKVMaps md
+      match (<- read).bindCtx[i]? with
+      | some _ => return mdata kvs (.bvar i)
+      | none => throw <| .invalidBVarIndex (<-read).current (<-read).bindCtx i
+    | .esort ua, .meta ⟨[.link md, .link um]⟩ => do
+      --dbg_trace s!"decompileExpr esort"
+      let kvs <- decompileKVMaps md
+      let u <- decompileLevel ⟨ua, um⟩
+      return mdata kvs (.sort u)
+    | .erec idx uas, .meta ⟨[.link md, .link n, .links ums]⟩ => do
+      --dbg_trace s!"decompileExpr erec"
+      let kvs <- decompileKVMaps md
+      let us <- univs uas ums
+      let name <- decompileName n
+      match (<- read).mutCtx.get? name with
+      | some idx' => do
+        if idx' == idx then return mdata kvs (.const name us)
+        else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx name idx idx'
+      | none => do throw <| .unknownMutual (<- read).current (<- read).mutCtx name idx
+    | .eref rd uas, .meta ⟨[.link md, .link n, .link rm, .links ums]⟩ => do
+      --dbg_trace s!"decompileExpr eref"
+      let name <- decompileName n
+      let kvs <- decompileKVMaps md
+      let us <- univs uas ums
+      let (name', _) <- decompileNamedConst name ⟨rd, rm⟩
+      return mdata kvs (.const name' us)
+    | .eapp fa aa, .meta ⟨[.link md, .link fm, .link am]⟩ => do
+      --dbg_trace s!"decompileExpr eapp"
+      let kvs <- decompileKVMaps md
+      let f <- decompileExpr ⟨fa, fm⟩
+      let a <- decompileExpr ⟨aa, am⟩
+      return mdata kvs (.app f a)
+    | .elam ta ba, .meta ⟨[.link md, .link n, .info i, .link tm, .link bm]⟩ => do
+      --dbg_trace s!"decompileExpr elam"
+      let name <- decompileName n
+      let kvs <- decompileKVMaps md
+      let t <- decompileExpr ⟨ta, tm⟩
+      let b <- withBinder' name (decompileExpr ⟨ba, bm⟩)
+      return mdata kvs (.lam name t b i)
+    | .eall ta ba, .meta ⟨[.link md, .link n, .info i, .link tm, .link bm]⟩ => do
+      --dbg_trace s!"decompileExpr eall"
+      let name <- decompileName n
+      let kvs <- decompileKVMaps md
+      let t <- decompileExpr ⟨ta, tm⟩
+      let b <- withBinder' name (decompileExpr ⟨ba, bm⟩)
+      return mdata kvs (.forallE name t b i)
+    | .elet nD ta va ba, .meta ⟨[.link md, .link n, .link tm, .link vm, .link bm]⟩ => do
+      --dbg_trace s!"decompileExpr elet"
+      let name <- decompileName n
+      let kvs <- decompileKVMaps md
+      let t <- decompileExpr ⟨ta, tm⟩
+      let v <- decompileExpr ⟨va, vm⟩
+      let b <- withBinder' name (decompileExpr ⟨ba, bm⟩)
+      return mdata kvs (.letE name t v b nD)
+    | .enat n, .meta ⟨[.link md]⟩ => do
+      --dbg_trace s!"decompileExpr enat"
+      let kvs <- decompileKVMaps md
+      let n <- readNat n
+      return mdata kvs (.lit (.natVal n))
+    | .estr n, .meta ⟨[.link md]⟩ => do
+      --dbg_trace s!"decompileExpr estr"
+      let kvs <- decompileKVMaps md
+      let n <- readString n
+      return mdata kvs (.lit (.strVal n))
+    | .eprj ta idx sa, .meta ⟨[.link md, .link n, .link tm, .link sm]⟩ => do
+      --dbg_trace s!"decompileExpr eprj"
+      let kvs <- decompileKVMaps md
+      let name <- decompileName n
+      let (name', _) <- decompileNamedConst name ⟨ta, tm⟩
+      let s <- decompileExpr ⟨sa, sm⟩
+      return mdata kvs (.proj name' idx s)
+    | d , m => do throw <| .badExpr (<- read).current d m
+
+partial def decompileLevels (n: Nat) (ls: List Address)
+  : DecompileM (List Lean.Name) := do
+  --dbg_trace "decompileLevels"
+  if ls.length != n then throw <| .mismatchedLevels (<- read).current n ls
+  else ls.mapM decompileName
+
+partial def decompileDef: Ixon.Definition -> Metadata -> DecompileM Def
+| d, ⟨[.link n, .links ls, .hints h, .link tm, .link vm, .links as]⟩ => do
+  --dbg_trace "decompileDef"
+  let name <- decompileName n
+  let lvls <- decompileLevels d.lvls ls
+  withLevels' lvls <| do
+    let t <- decompileExpr ⟨d.type, tm⟩
+    let v <- decompileExpr ⟨d.value, vm⟩
+    let all <- as.mapM decompileName
+    return ⟨name, lvls, t, d.kind, v, h, d.safety, all⟩
+| d, m => do throw <| .badDef (<- read).current d m
+
+partial def decompileRules (rs: List RecursorRule) (ms: List (Address × Address))
+  : DecompileM (List Lean.RecursorRule) := do
+  if rs.length != ms.length
+  then throw <| .mismatchedRules (<- read).current rs ms
+  else (List.zip rs ms).mapM <| fun (r, n, rm) => do
+    let n <- decompileName n
+    let rhs <- decompileExpr ⟨r.rhs, rm⟩
+    return ⟨n, r.fields, rhs⟩
+
+partial def decompileRecr: Ixon.Recursor -> Metadata -> DecompileM Rec
+| r, ⟨[.link n, .links ls, .link tm, .map rs, .links as]⟩ => do
+  let name <- decompileName n
+  let lvls <- decompileLevels r.lvls ls
+  withLevels' lvls <| do
+    let t <- decompileExpr ⟨r.type, tm⟩
+    let all <- as.mapM decompileName
+    let rs <- decompileRules r.rules rs
+    return ⟨⟨name, lvls, t⟩, all, r.params, r.indices, r.motives,
+      r.minors, rs, r.k, r.isUnsafe⟩
+| r, m => do throw <| .badRecr (<- read).current r m
+
+partial def decompileCtors (cs: List Ixon.Constructor) (ms: List Address)
+  : DecompileM (List Lean.ConstructorVal) := do
+  if cs.length != ms.length
+  then throw <| .mismatchedCtors (<- read).current cs ms
+  else (List.zip cs ms).mapM <| fun (c, m) => do go c (<- readIxon m)
+  where
+    go : Ixon.Constructor -> Ixon -> DecompileM Lean.ConstructorVal
+    | c, .meta ⟨[.link n, .links ls, .link tm, .link i]⟩ => do
+      let name <- decompileName n
+      let induct <- decompileName i
+      let lvls <- decompileLevels c.lvls ls
+      let type <- decompileExpr ⟨c.type, tm⟩
+      return ⟨⟨name, lvls, type⟩, induct, c.cidx, c.params, c.fields, c.isUnsafe⟩
+    | c, m => do throw <| .badCtor (<- read).current c m
+
+partial def decompileIndc: Ixon.Inductive -> Metadata -> DecompileM Ind
+| i, ⟨[.link n, .links ls, .link tm, .links cs, .links as]⟩ => do
+  let name <- decompileName n
+  let lvls <- decompileLevels i.lvls ls
+  withLevels' lvls <| do
+    let t <- decompileExpr ⟨i.type, tm⟩
+    let all <- as.mapM decompileName
+    let ctors <- decompileCtors i.ctors cs
+    return ⟨name, lvls, t, i.params, i.indices, all, ctors,
+      i.nested, i.recr, i.refl, i.isUnsafe⟩
+| i, m => do throw <| .badIndc (<- read).current i m
+
+partial def decompileConst (addr: MetaAddress)
+  : DecompileM (Lean.Name × Set Lean.Name) := do
+  --dbg_trace s!"decompileConst {addr}"
+  match (<- get).constCache.find? addr with
+  | some x => pure x
+  | none => resetCtx' do
+    let (name, block) <- go (<- readIxon addr.data) (<- readIxon addr.meta)
+    let blockNames <- insertBlock block
+    modifyGet fun stt => ((name, blockNames), { stt with
+      constCache := stt.constCache.insert addr (name, blockNames)
+    })
+  where
+    go : Ixon -> Ixon -> DecompileM (Lean.Name × Block)
+    | .defn d, .meta m@⟨(.link n)::_⟩ => do
+      --dbg_trace s!"decompileConst defn"
+      let name <- decompileName n
+      let d <- withMutCtx' {(name, 0)} <| decompileDef d m
+      return (d.name, .defn d)
+    | .axio a, .meta ⟨[.link n, .links ls, .link tm]⟩ => do
+      --dbg_trace s!"decompileConst axio"
+      let name <- decompileName n
+      let lvls <- decompileLevels a.lvls ls
+      let t <- decompileExpr ⟨a.type, tm⟩
+      return (name, .axio ⟨⟨name, lvls, t⟩, a.isUnsafe⟩)
+    | .quot q, .meta ⟨[.link n, .links ls, .link tm]⟩ => do
+      --dbg_trace s!"decompileConst quot"
+      let name <- decompileName n
+      let lvls <- decompileLevels q.lvls ls
+      let t <- decompileExpr ⟨q.type, tm⟩
+      return (name, .quot ⟨⟨name, lvls, t⟩, q.kind⟩)
+    | .recr r, .meta m@⟨(.link n)::_⟩ => do 
+      --dbg_trace s!"decompileConst recr"
+      let name <- decompileName n
+      let r <- withMutCtx' {(name, 0)} <| decompileRecr r m
+      return (r.name, .recr r)
+    | .dprj ⟨idx, bd⟩, .meta ⟨[.link bm, .link m]⟩ => do
+      match (<- readIxon m) with
+      | .meta ⟨[.link n, .links _, .hints _, .link _, .link _, .links _]⟩ => do
+        let name <- decompileName n
+        let block <- decompileMuts (<- readIxon bd) (<- readIxon bm)
+        match block with
+        | .muts ms => match ms[idx]? with
+          | .some (.defn d) => matchNames name d.name (pure (name, block))
+          | _ => do throw <| .badProj (<- read).current block s!"malformed dprj index {idx}"
+        | _ => do throw <| .badProj (<- read).current block "dprj into non-mutual block"
+      | m => do throw <| .badProjMeta (<- read).current m "dprj"
+    | .rprj ⟨idx, bd⟩, .meta ⟨[.link bm, .link m]⟩ => do
+      match (<- readIxon m) with
+      | .meta ⟨[.link n, .links _, .link _, .map _, .links _]⟩ => do
+        let name <- decompileName n
+        let block <- decompileMuts (<- readIxon bd) (<- readIxon bm)
+        match block with
+        | .muts ms => match ms[idx]? with
+          | .some (.recr r) => matchNames name r.name (pure (name, block))
+          | _ => do throw <| .badProj (<- read).current block s!"malformed rprj index {idx}"
+        | _ => do throw <| .badProj (<- read).current block "rprj inton non-mutual block"
+      | m => do throw <| .badProjMeta (<- read).current m "rprj"
+    | .iprj ⟨idx, bd⟩, .meta ⟨[.link bm, .link m]⟩ => do
+      match (<- readIxon m) with
+      | .meta ⟨[.link n, .links _, .link _, .links _, .links _]⟩ => do
+        let name <- decompileName n
+        let block <- decompileMuts (<- readIxon bd) (<- readIxon bm)
+        match block with
+        | .muts ms => match ms[idx]? with
+          | .some (.indc i) => matchNames name i.name (pure (name, block))
+          | _ => do 
+            let bmeta <- match (<- readStore bm "metadata") with
+            | Ixon.meta ⟨[.muts _, .map cs, .map _]⟩ => do
+              let mut map : Map Lean.Name Nat := {}
+              for (n, i) in cs do
+                map := map.insert (<- decompileName n) (<- readNat i)
+              pure map
+            | _ => unreachable!
+            throw <| .badProj (<- read).current block s!"malformed iprj index {idx} & {repr bmeta}"
+        | _ => do throw <| .badProj (<- read).current block "iprj into non-mutual block"
+      | m => do throw <| .badProjMeta (<- read).current m "iprj"
+    | .cprj ⟨idx, cidx, bd⟩, .meta ⟨[.link bm, .link m]⟩ => do
+      match (<- readIxon m) with
+      | .meta ⟨[.link n, .links _, .link _, .link i]⟩ => do
+        let name <- decompileName n
+        let induct <- decompileName i
+        let block <- decompileMuts (<- readIxon bd) (<- readIxon bm)
+        match block with
+        | .muts ms => match ms[idx]? with
+          | .some (.indc i) => matchNames induct i.name <|
+            match i.ctors[cidx]? with
+            | .some c => matchNames name c.name (pure (name, block))
+            | .none => do throw <| .badProj (<- read).current block s!"malformed cprj ctor index {cidx}"
+          | _ => do throw <| .badProj (<- read).current block s!"malformed cprj index {idx}"
+        | _ => do throw <| .badProj (<- read).current block "cprj into non-mutual block"
+      | m => do throw <| .badProjMeta (<- read).current m "cprj"
+    | .prim .obj, .meta ⟨[]⟩ => do
+      --dbg_trace s!"decompileConst prim _obj"
+      return (.mkSimple "_obj", .prim)
+    | .prim .neutral, .meta ⟨[]⟩ => do
+      --dbg_trace s!"decompileConst prim _neutral"
+      return (.mkSimple "_neutral", .prim)
+    | .prim .unreachable, .meta ⟨[]⟩ => do
+      --dbg_trace s!"decompileConst prim _unreachable"
+      return (.mkSimple "_unreachable", .prim)
+    | d, m => do throw <| .badConst (<- read).current d m
+
+partial def decompileNamedConst (name: Lean.Name) (addr: MetaAddress)
+  : DecompileM (Lean.Name × Set Lean.Name) := do
+  --dbg_trace s!"decompileNamedConst {name} {addr}"
+  let (n, set) <- withNamed name addr <| decompileConst addr
+  matchNames n name (pure (n, set))
+
+partial def decompileMutConst : Ixon.MutConst -> Metadata -> DecompileM MutConst
+| .defn d, m => .defn <$> decompileDef d m
+| .recr r, m => .recr <$> decompileRecr r m
+| .indc i, m => .indc <$> decompileIndc i m
+
+partial def decompileMuts: Ixon -> Ixon -> DecompileM Block
+| ms@(.muts cs), m@(.meta ⟨[.muts names, .map ctx, .map metaMap]⟩) => do
+    if cs.length != names.length then throw <| .badMuts (<- read).current ms m
+    else
+      let mut map : Map Lean.Name Metadata := {}
+      for (name, meta) in metaMap do
+        map := map.insert (<- decompileName name) (<- readStore meta "Metadata")
+      let mut muts := #[]
+      let mut mutCtx := {}
+      for (n, i) in ctx do
+        mutCtx := mutCtx.insert (<- decompileName n) (<- readNat i)
+      for (const, names) in cs.zip names do
+        for n in names do
+          let name <- decompileName n
+          let const' <- match map.get? name with
+            | .some meta => withMutCtx' mutCtx <| decompileMutConst const meta
+            | .none => do throw <| .badMuts (<- read).current ms m
+          muts := muts.push const'
+      return .muts muts.toList
+| ms, m => do throw <| .badMuts (<- read).current ms m
+
+end
+
+end Ix
+
 --def decompileEnv : DecompileM Unit := do
 --  for (n, (anon, meta)) in (<- read).names do
 --    let _ <- ensureBlock n anon meta
---
---end Decompile
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 3922e75d..37acf483 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -170,7 +170,7 @@ def getBytesTagged : GetM ByteArray := do
   | ⟨0x9, size⟩ => do
     let bs <- Array.mapM (λ _ => Serialize.get) (Array.range size.toNat)
     return ⟨bs⟩
-  | e => throw s!"expected Bytes with tag 0xA, got {repr e}"
+  | e => throw s!"expected Bytes with tag 0x9, got {repr e}"
 
 instance : Serialize ByteArray where
   put := putBytesTagged
@@ -769,8 +769,9 @@ inductive Metadatum where
 | info : Lean.BinderInfo -> Metadatum
 | hints : Lean.ReducibilityHints -> Metadatum
 | links : List Address -> Metadatum
-| rules : List (Address × Address) -> Metadatum
+| map : List (Address × Address) -> Metadatum
 | kvmap : List (Address × DataValue) -> Metadatum
+| muts : List (List Address) -> Metadatum
 deriving BEq, Repr, Ord, Inhabited, Ord, Hashable
 
 structure Metadata where
@@ -782,8 +783,9 @@ def putMetadatum : Metadatum → PutM Unit
 | .info i => putUInt8 1 *> putBinderInfo i
 | .hints h => putUInt8 2 *> putReducibilityHints h
 | .links ns => putUInt8 3 *> put ns
-| .rules ns => putUInt8 4 *> put ns
+| .map ns => putUInt8 4 *> put ns
 | .kvmap map => putUInt8 5 *> put map
+| .muts map => putUInt8 6 *> put map
 
 def getMetadatum : GetM Metadatum := do
   match (<- getUInt8) with
@@ -791,8 +793,9 @@ def getMetadatum : GetM Metadatum := do
   | 1 => .info <$> get
   | 2 => .hints <$> get
   | 3 => .links <$> get
-  | 4 => .rules <$> get
+  | 4 => .map <$> get
   | 5 => .kvmap <$> get
+  | 6 => .muts <$> get
   | e => throw s!"expected Metadatum encoding between 0 and 5, got {e}"
 
 instance : Serialize Metadatum where
@@ -865,8 +868,7 @@ def putIxon : Ixon -> PutM Unit
   put (Tag4.mk 0x2 bytes.size.toUInt64) *> putBytes ⟨bytes⟩
 | .eref a ls => put (Tag4.mk 0x3 ls.length.toUInt64) *> put a *> puts ls
 | .erec i ls =>
-  let bytes := i.toBytesLE
-  put (Tag4.mk 0x4 bytes.size.toUInt64) *> putBytes ⟨bytes⟩ *> puts ls
+  put (Tag4.mk 0x4 ls.length.toUInt64) *> put i *> puts ls
 | .eprj t n x =>
   let bytes := n.toBytesLE
   put (Tag4.mk 0x5 bytes.size.toUInt64) *> put t *> putBytes ⟨bytes⟩ *> put x
@@ -910,7 +912,7 @@ def getIxon : GetM Ixon := do
   | ⟨0x1, x⟩ => .uvar <$> getNat (getBytes x.toNat)
   | ⟨0x2, x⟩ => .evar <$> getNat (getBytes x.toNat)
   | ⟨0x3, x⟩ => .eref <$> get <*> gets x.toNat
-  | ⟨0x4, x⟩ => .erec <$> getNat (getBytes x.toNat) <*> get
+  | ⟨0x4, x⟩ => .erec <$> get <*> gets x.toNat
   | ⟨0x5, x⟩ => .eprj <$> get <*> getNat (getBytes x.toNat) <*> get
   | ⟨0x8, 0⟩ => .esort <$> get
   | ⟨0x8, 1⟩ => .estr <$> get
diff --git a/Ix/Mutual.lean b/Ix/Mutual.lean
index 9f14d3ca..4865cb32 100644
--- a/Ix/Mutual.lean
+++ b/Ix/Mutual.lean
@@ -57,14 +57,20 @@ def MutConst.ctors : MutConst -> List (Lean.ConstructorVal)
 | .defn _ => []
 | .recr _ => []
 
+def MutConst.contains (name: Lean.Name) : MutConst -> Bool
+| .defn val => val.name == name
+| .recr val => val.name == name
+| .indc val => val.name == name || val.ctors.any (fun c => c.name == name)
+
 -- We have a list of classes of mutual constants, each class representing a
--- possible equivalence class. We would like to construct a unique numerical
+-- possible equivalence class. We would like to construct a numerical
 -- index for each constant (which could be a definition, inductive+constructors
--- or recursor) within this list of classes. If the classes are true equivalence
--- classes then all constants in a class will be the same kind of constant,
--- and, if inductives, have the same number of constructors.
+-- or recursor) within this list of classes, such that each constant in the
+-- same equivalence class has the same index. If the classes are true
+-- equivalence classes then all constants in a class will be the same kind of
+-- constant, and, if inductives, have the same number of constructors.
 --
--- Unfortunately, since we use this function within the sorting function that
+-- However, since we use this function within the sorting function that
 -- produces the equivalence classes, our indexing has to be robust to the
 -- possiblity that constants are *not* the same, and that the inductives in a
 -- class do *not* have the same number of constructors.
@@ -77,23 +83,42 @@ def MutConst.ctors : MutConst -> List (Lean.ConstructorVal)
 -- since we index them as if they could have the maximum number of constructors.
 -- For example, if a class has an inductive with 2 ctors
 -- and an inductive with 3 ctors, then the whole class will reserve
--- 4 indices (one for each inductive type itself plus 3 ctors) for each constant.
+-- 4 indices (one for each inductive type itself plus 3 ctors).
 --
 -- In practice, Lean should never give us a mutual block that mixes inductives
 -- definitions and recursors, but we combine them for robustness and code
 -- deduplication.
-def MutConst.ctx (constss: List (List MutConst)) : Map Lean.Name Nat
+-- layout: [i0, i1, ..., iN, i0c0, ... i0cM, ... inc0, iNcM]
+def MutConst.ctx (classes: List (List MutConst)) : Map Lean.Name Nat
   := Id.run do
   let mut mutCtx := default
-  let mut idx := 0
-  for consts in constss do
+  let mut i := classes.length
+  for (consts, j) in classes.zipIdx do
     let mut maxCtors := 0
     for const in consts do
+      mutCtx := mutCtx.insert const.name j
       maxCtors := max maxCtors const.ctors.length
-      mutCtx := mutCtx.insert const.name idx
       for (c, cidx) in List.zipIdx const.ctors do
-        mutCtx := mutCtx.insert c.name (idx + 1 + cidx)
-    idx := idx + 1 + maxCtors
+        mutCtx := mutCtx.insert c.name (i + cidx)
+    i := i + maxCtors
   return mutCtx
 
+
+--def a0 : Lean.ConstructorVal := ⟨⟨`a0, [], .bvar 0⟩, `a, 0, 0, 0, false⟩
+--def a1 : Lean.ConstructorVal := ⟨⟨`a1, [], .bvar 0⟩, `a, 1, 0, 0, false⟩
+--def a2 : Lean.ConstructorVal := ⟨⟨`a2, [], .bvar 0⟩, `a, 2, 0, 0, false⟩
+--def a : Ind := ⟨`a, [], .bvar 0, 0, 0, [], [a0, a1, a2], 0, false, false, false⟩
+--
+--def b0 : Lean.ConstructorVal := ⟨⟨`b0, [], .bvar 0⟩, `b, 0, 0, 0, false⟩
+--def b1 : Lean.ConstructorVal := ⟨⟨`b1, [], .bvar 0⟩, `b, 1, 0, 0, false⟩
+--def b2 : Lean.ConstructorVal := ⟨⟨`b2, [], .bvar 0⟩, `b, 2, 0, 0, false⟩
+--def b : Ind := ⟨`b, [], .bvar 0, 0, 0, [], [b0, b1], 0, false, false, false⟩
+--
+--def c0 : Lean.ConstructorVal := ⟨⟨`c0, [], .bvar 0⟩, `c, 0, 0, 0, false⟩
+--def c1 : Lean.ConstructorVal := ⟨⟨`c1, [], .bvar 0⟩, `c, 1, 0, 0, false⟩
+--def c2 : Lean.ConstructorVal := ⟨⟨`c2, [], .bvar 0⟩, `c, 2, 0, 0, false⟩
+--def c : Ind := ⟨`c, [], .bvar 0, 0, 0, [], [c0, c1, c2], 0, false, false, false⟩
+--
+--#eval MutConst.ctx [[.indc a, .indc b], [.indc c]]
+
 end Ix
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 1f44fc09..b7679c14 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -4,8 +4,8 @@ import Ix.Ixon
 import Ix.Address
 import Ix.Common
 import Ix.CompileM
+import Ix.DecompileM
 import Ix.Cronos
---import Ix.DecompileM
 import Ix.Meta
 import Ix.Store
 import Lean
@@ -175,10 +175,11 @@ def testRoundtripGetEnv : IO TestSeq := do
   IO.println s!"Building condensation graph of env"
   let numConst := env.constants.map₁.size + env.constants.map₂.stats.numNodes
   let mut cstt : CompileState := .init env 0
+  let mut dstt : DecompileState := default
   let sccEnd <- IO.monoNanosNow
   IO.println s!"Condensation graph in {Cronos.nanoToSec (sccEnd - sccStart)}"
   IO.println s!"Compiling env"
-  let mut inConst := 0
+  let mut inConst := 1
   let allStart <- IO.monoNanosNow
   for (name, _) in env.constants do
     let start <- IO.monoNanosNow
@@ -188,9 +189,40 @@ def testRoundtripGetEnv : IO TestSeq := do
       IO.println s!"failed {name}"
       throw (IO.userError (<- e.pretty))
     let done <- IO.monoNanosNow
-    IO.println s!"✓ Compiled {inConst}/{numConst} Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec (done - allStart)} {name} @ {addr}"
-    inConst := inConst + 1
+    let pct := ((Float.ofNat inConst) / Float.ofNat numConst)
+    let total := done - allStart
+    IO.println s!"-> Compiled {pct * 100}%, {inConst}/{numConst},
+    Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec total},
+    Remaining {((Cronos.nanoToSec total) / pct) / 60} min
+    {name}
+    {addr}"
     cstt := stt
+    let denv := DecompileEnv.init cstt.constCache cstt.store
+    let (name', stt) <- match DecompileM.run denv dstt (decompileNamedConst name addr) with
+    | .ok (n,_) stt => pure (n, stt)
+    | .error e _ => do
+      IO.println s!"failed {name}"
+      --IO.println s!"denv: {repr denv}"
+      --let c := env.constants.find? name
+      --IO.println s!"{repr c}"
+      throw (IO.userError e.pretty)
+    match env.constants.find? name, stt.constants.find? name' with
+    | .some c, .some c' => if c == c then pure () else do
+        IO.println s!"failed {name} {repr c} {repr c'}"
+        throw (IO.userError "decompiled constant not equal")
+    | .some _, .none => do
+      throw (IO.userError s!"{name'} not found in dstt")
+    | .none, _ => do
+      throw (IO.userError "{name} not found in env")
+    let done2 <- IO.monoNanosNow
+    let total2 := done2 - allStart
+    IO.println s!"<- Decompiled {pct * 100}%, {inConst}/{numConst},
+    Elapsed {Cronos.nanoToSec (done2 - done)}/{Cronos.nanoToSec total},
+    Remaining {((Cronos.nanoToSec total2) / pct) / 60} min
+    {name}
+    {addr}"
+    inConst := inConst + 1
+    dstt := stt
   let allDone <- IO.monoNanosNow
   IO.println s!"Compiled env in {Cronos.nanoToSec (allDone - allStart)}"
  -- IO.println s!"decompiling env"
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 43c2bb73..762e4ced 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -113,6 +113,7 @@ def genMetadatum : Gen Ixon.Metadatum :=
 def genMetadata : Gen Ixon.Metadata :=
   .mk <$> genList genMetadatum
 
+
 partial def genIxon : Gen Ixon.Ixon :=
   frequency [
     (10, pure .nanon),

From cf72c4b43deeec50cee754b9acc25db084cbe8b6 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 22 Oct 2025 17:04:33 -0400
Subject: [PATCH 56/74] decompilation progress, but failing on _cstage2

---
 Ix/Common.lean         |  14 ++---
 Ix/CompileM.lean       |  87 ++++++++++++++++++++++--------
 Ix/DecompileM.lean     | 118 ++++++++++++++++++++++-------------------
 Ix/Mutual.lean         |   2 +-
 Tests/Ix/Compile.lean  |  11 +++-
 Tests/Ix/Fixtures.lean |   2 -
 6 files changed, 146 insertions(+), 88 deletions(-)

diff --git a/Ix/Common.lean b/Ix/Common.lean
index bc24fd50..e7104942 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -267,15 +267,15 @@ def Std.HashMap.find? {A B} [BEq A] [Hashable A] (map: Std.HashMap A B) (a: A)
 abbrev Ix.Map := Std.HashMap
 abbrev Ix.Set := Std.HashSet
 
-abbrev MutCtx := Ix.Map Lean.Name Nat
+abbrev MutCtx := Batteries.RBMap Lean.Name Nat compare
 
-instance : BEq MutCtx where
-  beq a b := a.size == b.size && a.fold
-    (fun acc k v => acc && match b.find? k with
-      | some v' => v == v'
-      | none => false) true
+--instance : BEq MutCtx where
+--  beq a b := a.size == b.size && a.fold
+--    (fun acc k v => acc && match b.find? k with
+--      | some v' => v == v'
+--      | none => false) true
 
--- TODO: incremental comparison with ForIn zip
+---- TODO: incremental comparison with ForIn zip
 instance : Ord MutCtx where
   compare a b := compare a.toList b.toList
 
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 99928a3b..cb7d4530 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -18,6 +18,15 @@ structure CompileEnv where
   current : Lean.Name
 deriving BEq, Ord
 
+structure ExprCtx where
+  univCtx : List Lean.Name
+  bindCtx : List Lean.Name
+  mutCtx : List (Lean.Name × Nat)
+deriving BEq, Hashable
+
+def ExprCtx.fromEnv : CompileEnv -> ExprCtx
+| ⟨u, b, m, _⟩ => ⟨u, b, m.toList⟩
+
 def CompileEnv.init: CompileEnv := ⟨default, default, default, default⟩
 
 structure CompileState where
@@ -26,9 +35,9 @@ structure CompileState where
   prng: StdGen
   store: Map Address ByteArray
   ixonCache: Map Ixon Address
-  univCache: Map Lean.Level MetaAddress
+  univCache: Map ((List Lean.Name) ×  Lean.Level) MetaAddress
   constCache: Map Lean.Name MetaAddress
-  exprCache: Map Lean.Expr MetaAddress
+  exprCache: Map (ExprCtx × Lean.Expr) MetaAddress
   synCache: Map Lean.Syntax Ixon.Syntax
   nameCache: Map Lean.Name Address
   strCache: Map String Address
@@ -53,7 +62,7 @@ inductive CompileError where
 | exprMetavariable : Lean.Expr -> CompileError
 | exprFreeVariable : Lean.Expr -> CompileError
 | invalidBVarIndex : Nat -> CompileError
-| levelNotFound : Lean.Name -> List Lean.Name -> String -> CompileError
+| levelNotFound : Lean.Name -> Lean.Name -> List Lean.Name -> String -> CompileError
 | invalidConstantKind : Lean.Name -> String -> String -> CompileError
 | mutualBlockMissingProjection : Lean.Name -> CompileError
 --| nonRecursorExtractedFromChildren : Lean.Name → CompileError
@@ -77,7 +86,7 @@ def CompileError.pretty : CompileError -> IO String
 | .exprMetavariable e => pure s!"Unfilled level metavariable on expression '{e}'"
 | .exprFreeVariable e => pure s!"Free variable in expression '{e}'"
 | .invalidBVarIndex idx => pure s!"Invalid index {idx} for bound variable context"
-| .levelNotFound n ns msg => pure s!"'Level {n}' not found in '{ns}', {msg}"
+| .levelNotFound c n ns msg => pure s!"'Level {n}' not found in '{ns}', {msg} @ {c}"
 | .invalidConstantKind n ex gt => pure s!"Invalid constant kind for '{n}'. Expected '{ex}' but got '{gt}'"
 | .mutualBlockMissingProjection n => pure s!"Constant '{n}' wasn't content-addressed in mutual block"
 | .cantFindMutIndex n mc => pure s!"Can't find index for mutual definition '{n}' in {repr mc}"
@@ -191,9 +200,12 @@ def storeMeta (meta: Metadata): CompileM Address := do
 
 def compileName (name: Lean.Name): CompileM Address := do
   match (<- get).nameCache.find? name with
-  | some addr => pure addr
+  | some addr =>
+  --dbg_trace "compileName cached {(<- read).current} {addr} {name}"
+    pure addr
   | none => do
     let addr <- go name
+  --dbg_trace "compileName {(<- read).current} {addr} {name}"
     modifyGet fun stt => (addr, { stt with
       nameCache := stt.nameCache.insert name addr
     })
@@ -232,13 +244,14 @@ def compareLevel (xctx yctx: List Lean.Name)
     match (xctx.idxOf? x), (yctx.idxOf? y) with
     | some xi, some yi => return ⟨true, compare xi yi⟩
     | none,    _       => 
-      throw $ .levelNotFound x xctx s!"compareLevel"
+      throw $ .levelNotFound (<- read).current x xctx s!"compareLevel"
     | _,       none    => 
-      throw $ .levelNotFound y yctx s!"compareLevel"
+      throw $ .levelNotFound (<- read).current y yctx s!"compareLevel"
 
 /-- Canonicalizes a Lean universe level --/
 def compileLevel (lvl: Lean.Level): CompileM MetaAddress := do
-  match (<- get).univCache.find? lvl with
+  let ctx := (<- read).univCtx
+  match (<- get).univCache.find? (ctx, lvl) with
   | some l => pure l
   | none => do
     --dbg_trace "compileLevel go {(<- get).univAddrs.size} {(<- read).current}"
@@ -247,7 +260,7 @@ def compileLevel (lvl: Lean.Level): CompileM MetaAddress := do
     let metaAddr <- storeIxon meta
     let maddr := ⟨anonAddr, metaAddr⟩
     modifyGet fun stt => (maddr, { stt with
-      univCache := stt.univCache.insert lvl maddr
+      univCache := stt.univCache.insert (ctx, lvl) maddr
     })
   where
     go : Lean.Level -> CompileM (Ixon × Ixon)
@@ -267,7 +280,7 @@ def compileLevel (lvl: Lean.Level): CompileM MetaAddress := do
       let lvls := (← read).univCtx
       match lvls.idxOf? n with
       | some i => pure (.uvar i, .meta ⟨[.link (<- compileName n)]⟩)
-      | none   => throw $ .levelNotFound n lvls s!"compileLevel"
+      | none   => do throw <| .levelNotFound (<- read).current n lvls s!"compileLevel"
     | l@(.mvar ..) => throw $ .levelMetavariable l
 
 def compileSubstring : Substring -> CompileM Ixon.Substring
@@ -371,7 +384,8 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
 | expr => outer [] expr
   where
     outer (kvs: List Lean.KVMap) (expr: Lean.Expr): CompileM MetaAddress := do
-      match (<- get).exprCache.find? expr with
+      let ctx := ExprCtx.fromEnv (<- read)
+      match (<- get).exprCache.find? (ctx, expr) with
       | some x => pure x
       | none => do
         let (anon, meta) <- go kvs expr
@@ -379,9 +393,8 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
         let metaAddr <- storeIxon meta
         let maddr := ⟨anonAddr, metaAddr⟩
         modifyGet fun stt => (maddr, { stt with
-          exprCache := stt.exprCache.insert expr maddr
+          exprCache := stt.exprCache.insert (ctx, expr) maddr
         })
-
     go (kvs: List Lean.KVMap): Lean.Expr -> CompileM (Ixon × Ixon)
     | (.mdata kv x) => go (kv::kvs) x
     | .bvar idx => do
@@ -401,6 +414,7 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
       let us <- lvls.mapM compileLevel
       match (← read).mutCtx.find? name with
       | some idx => 
+      --dbg_trace s!"compileExpr {(<- read).current}, const rec {name} {idx}, mutCtx: {repr (<- read).mutCtx}, md {md}, us: {repr us}, n: {n}"
         let data := .erec idx (us.map (·.data))
         let meta := .meta ⟨[.link md, .link n, .links (us.map (·.meta))]⟩
         pure (data, meta)
@@ -408,6 +422,7 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
         let ref <- match (<- get).comms.find? name with
           | some comm => pure comm
           | none => compileConstName name
+      --dbg_trace s!"compileExpr {(<- read).current}, const ref {name}, mutCtx: {repr (<- read).mutCtx}, md {md}, repr {us}, ref {ref}"
         let data := .eref ref.data (us.map (·.data))
         let meta := .meta ⟨[.link md, .link n, .link ref.meta, .links (us.map (·.meta))]⟩
         pure (data, meta)
@@ -465,7 +480,7 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
 partial def compileConstName (name: Lean.Name): CompileM MetaAddress := do
   match (<- get).constCache.find? name with
   | some x => pure x
-  | none => resetCtx name <| do
+  | none => do
     let (anon, meta) <- do
       if name == Lean.Name.mkSimple "_obj" then pure (.prim .obj, .meta ⟨[]⟩)
       else if name == Lean.Name.mkSimple "_neutral" then pure (.prim .neutral, .meta ⟨[]⟩)
@@ -484,8 +499,12 @@ partial def compileConstName (name: Lean.Name): CompileM MetaAddress := do
     modifyGet fun stt => (maddr, { stt with
       constCache := stt.constCache.insert name maddr
     })
-
 partial def compileConstant : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
+| c => do
+--dbg_trace "compileConstant {c.name}"
+  resetCtx c.name <| compileConstant' c
+
+partial def compileConstant' : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
 | .defnInfo val => compileMutual (MutConst.mkDefn val)
 | .thmInfo val => compileMutual (MutConst.mkTheo val)
 | .opaqueInfo val => compileMutual (MutConst.mkOpaq val)
@@ -497,7 +516,9 @@ partial def compileConstant : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
     | some ⟨data, meta⟩ => do pure (<- getIxon data, <- getIxon meta)
     | none => throw <| .mutualBlockMissingProjection val.name
   | c => throw <| .invalidConstantKind c.name "inductive" c.ctorName
-| .recInfo val => compileMutual (MutConst.recr val)
+| .recInfo val => do
+--dbg_trace "compileConstant recInfo {val.name} mutCtx {repr <| (<- read).mutCtx}"
+  compileMutual (MutConst.recr val)
 | .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => withLevels lvls do
   let n <- compileName name
   let ls <- lvls.mapM compileName
@@ -532,6 +553,7 @@ partial def compileRule: Lean.RecursorRule -> CompileM (Ixon.RecursorRule × (Ad
 
 partial def compileRecr: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata)
 | r => withLevels r.levelParams <| do
+--dbg_trace s!"compileRecr {(<- read).current} {repr <| r.name} mutCtx: {repr (<- read).mutCtx}"
   let n <- compileName r.name
   let ls <- r.levelParams.mapM compileName
   let t <- compileExpr r.type
@@ -577,14 +599,17 @@ partial def compileIndc: Ix.Ind -> CompileM (Ixon.Inductive × Map Address Addre
 
 partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
 | const => do
+--dbg_trace s!"compileMutual {const.name}"
   let all: Set Lean.Name <- getAll const.name
-  if all == {const.name} && const matches .defn _ then do
+--dbg_trace s!"compileMutual {const.name} all: {repr all}"
+  if all == {const.name} &&
+    (const matches .defn _ || const matches .recr _) then do
     match const with
     | .defn d => do
-      let (data, meta) <- withMutCtx {(d.name,0)} <| compileDefn d
+      let (data, meta) <- withMutCtx (.single d.name 0) <| compileDefn d
       pure (.defn data, .meta meta)
     | .recr r => do
-      let (data, meta) <- withMutCtx {(r.name,0)} <| compileRecr r
+      let (data, meta) <- withMutCtx (.single r.name 0) <| compileRecr r
       pure (.recr data, .meta meta)
     | _ => unreachable!
   else
@@ -597,9 +622,12 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
       | .thmInfo val => consts := consts.push (MutConst.mkTheo val)
       | .recInfo val => consts := consts.push (MutConst.recr val)
       | _ => continue
+  --dbg_trace s!"compileMutual {const.name} consts: {repr <| consts.map (·.name)}"
     -- sort MutConsts into equivalence classes
     let mutConsts <- sortConsts consts.toList
+  --dbg_trace s!"compileMutual {const.name} mutConsts: {repr <| mutConsts.map (·.map (·.name))}"
     let mutCtx := MutConst.ctx mutConsts
+  --dbg_trace s!"compileMutual {const.name} mutCtx: {repr mutCtx}"
     let mutMeta <- mutConsts.mapM fun m => m.mapM <| fun c => compileName c.name
     -- compile each constant with the mutCtx
     let (data, metas) <- withMutCtx mutCtx (compileMutConsts mutConsts)
@@ -646,6 +674,7 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
 partial def compileMutConsts: List (List MutConst)
   -> CompileM (Ixon × Map Address Address)
 | classes => do
+--dbg_trace s!"compileMutConsts {(<- read).current} {repr <| classes.map (·.map (·.name))} mutCtx: {repr (<- read).mutCtx}"
   let mut data := #[]
   let mut meta := {}
   -- iterate through each equivalence class
@@ -695,7 +724,7 @@ partial def sortConsts (classes: List MutConst) : CompileM (List (List MutConst)
   := go [List.sortBy (compare ·.name ·.name) classes]
   where
     go (cs: List (List MutConst)): CompileM (List (List MutConst)) := do
-      --dbg_trace "sortDefs blocks {(<- get).blocks.size} {(<- read).current}"
+    --dbg_trace "sortConsts {(<- read).current} {cs.map (·.map (·.name))}"
       let ctx := MutConst.ctx cs
       let cs' <- cs.mapM fun ds =>
         match ds with
@@ -798,6 +827,7 @@ partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
     | none, none =>
       if x == y then return ⟨true, .eq⟩
       else do
+      --dbg_trace s!"compareExpr const {(<- read).current} consts {x} {y}"
         let x' <- compileConstName x
         let y' <- compileConstName y
         return ⟨true, compare x' y'⟩
@@ -826,9 +856,20 @@ partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
   | .lit x, .lit y => return ⟨true, compare x y⟩
   | .lit .., _ => return ⟨true, .lt⟩
   | _, .lit .. => return ⟨true, .gt⟩
-  | .proj _ nx tx, .proj _ ny ty => 
-    SOrder.cmpM (pure ⟨true, compare nx ny⟩) 
-      (compareExpr ctx xlvls ylvls tx ty)
+  | .proj tnx ix tx, .proj tny iy ty => 
+    SOrder.cmpM (pure ⟨true, compare ix iy⟩) <|
+    SOrder.cmpM (compareExpr ctx xlvls ylvls tx ty) <|
+    match ctx.find? tnx, ctx.find? tny with
+    | some nx, some ny => return ⟨false, compare nx ny⟩
+    | none, some _ => return ⟨true, .gt⟩
+    | some _, none => return ⟨true, .lt⟩
+    | none, none =>
+      if tnx == tny then return ⟨true, .eq⟩
+      else do
+      --dbg_trace s!"compareExpr proj {(<- read).current} consts {tnx} {tny}"
+        let x' <- compileConstName tnx
+        let y' <- compileConstName tny
+        return ⟨true, compare x' y'⟩
 end
 
 partial def makeLeanDef
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index c2b0391c..29d54968 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -44,7 +44,7 @@ inductive Block where
 | recr : Lean.RecursorVal -> Block
 | axio : Lean.AxiomVal -> Block
 | quot : Lean.QuotVal -> Block
-| muts : List MutConst -> Block
+| muts : List (List MutConst) -> Block
 deriving Repr, Inhabited, Nonempty
 
 def Block.contains (name: Lean.Name) : Block -> Bool
@@ -53,7 +53,7 @@ def Block.contains (name: Lean.Name) : Block -> Bool
 | .recr val => val.name == name
 | .axio val => val.name == name
 | .quot val => val.name == name
-| .muts consts => consts.any (·.contains name)
+| .muts consts => consts.any (·.any (·.contains name))
 
 def Block.consts : Block -> Set Lean.ConstantInfo
 | .prim => {}
@@ -61,7 +61,8 @@ def Block.consts : Block -> Set Lean.ConstantInfo
 | .recr val => {.recInfo val}
 | .axio val => {.axiomInfo val}
 | .quot val => {.quotInfo val}
-| .muts consts => consts.foldr (fun m set => set.union (mutConst m)) {}
+| .muts consts => consts.foldr (fun m set => set.union (m.foldr 
+    (fun m' set' => set'.union (mutConst m')) {})) {}
 where
   defn: Def -> Lean.ConstantInfo
   | ⟨name, lvls, type, kind, value, hints, safety, all⟩ => match kind with
@@ -91,6 +92,7 @@ inductive DecompileError
   (curr: Named) (ctx: List Lean.Name) (got: Lean.Name)
   (exp: Lean.Name) (idx: Nat)
 | mismatchedName (curr: Named) (n m: Lean.Name)
+| mismatchedNameSet (curr: Named) (n: Lean.Name) (ms: List Lean.Name)
 | invalidBVarIndex (curr: Named) (ctx: List Lean.Name) (idx: Nat)
 | mismatchedUnivArgs (curr: Named) (d m : List Address)
 | mismatchedLevels (curr: Named) (n: Nat) (ls: List Address)
@@ -146,6 +148,8 @@ def DecompileError.pretty : DecompileError -> String
   s!"Expected level name {n} at index {i} but got {n'} with context {repr ctx} @ {c}"
 | .mismatchedName c n m => 
   s!"Expected name {n} got {m} @ {c}"
+| .mismatchedNameSet c n ms => 
+  s!"Expected name {n} in {ms} @ {c}"
 | .invalidBVarIndex c ctx i => 
   s!"Bound variable {i} escapes context {ctx} @ {c}"
 | .mismatchedUnivArgs c d m => s!"mismatched univ args in {repr d} {repr m} @ {c}"
@@ -216,13 +220,12 @@ def withMutCtx' (mutCtx : Std.HashMap Lean.Name Nat)
   : DecompileM α -> DecompileM α :=
   withReader $ fun c => { c with mutCtx := mutCtx }
 
-def withNamed (name: Lean.Name) (meta: MetaAddress)
-  : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with current := ⟨name, meta⟩ }
-
 -- reset local context
-def resetCtx' : DecompileM α -> DecompileM α :=
-  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {} }
+def resetCtx' (name: Lean.Name) (meta: MetaAddress) 
+  : DecompileM α -> DecompileM α :=
+  withReader $ fun c => { c with 
+    univCtx := [], bindCtx := [], mutCtx := {}, current := ⟨name, meta⟩
+  }
 
 def readStore [Serialize A] (addr: Address) (exp: String): DecompileM A := do
   --dbg_trace "readStore {addr}"
@@ -255,11 +258,13 @@ def readIxon (addr: Address) : DecompileM Ixon := do
   | none => throw <| .unknownStoreAddress (<- read).current addr
 
 partial def decompileName (addr: Address) : DecompileM Lean.Name := do
-  --dbg_trace "decompileName {addr}"
   match (<- get).nameCache.find? addr with
-  | some name => pure name
+  | some name => 
+  --dbg_trace "decompileName {(<- read).current.name} {addr} {name}"
+    pure name
   | none => do
     let name <- go (<- readIxon addr)
+  --dbg_trace "decompileName {(<- read).current.name} {addr} {name}"
     modifyGet fun stt => (name, { stt with
       nameCache := stt.nameCache.insert addr name
     })
@@ -380,12 +385,26 @@ partial def insertBlock (block: Block): DecompileM (Set Lean.Name) := do
     set := set.insert c.name
   return set
 
-partial def matchNames (x y: Lean.Name) : DecompileM α -> DecompileM α
-| a => do
+def namesEqPatch (x y: Lean.Name) : Bool :=
   let cs2 := Lean.Name.mkSimple "_cstage2"
-  if x == y || x == y.append cs2  || x.append cs2 == y then a
+  x == y || x == y.append cs2  || x.append cs2 == y
+
+def matchNames (x y: Lean.Name) : DecompileM α -> DecompileM α
+| a => do
+  if namesEqPatch x y then a
   else throw <| .mismatchedName (<- read).current x y
 
+partial def matchBlock (n: Lean.Name) (idx: Nat) (block: Block)
+  : DecompileM MutConst := go block
+  where
+    go : Block -> DecompileM MutConst
+    | .muts mss => match mss[idx]? with
+      | .some ms => match ms.find? (fun m => namesEqPatch n m.name) with
+        | .some m => return m
+        | .none => do throw <| .todo
+      | .none => do throw <| .todo
+    | _ => do throw <| .todo
+
 mutual
 
 partial def decompileExpr (addr: MetaAddress): DecompileM Lean.Expr := do
@@ -418,18 +437,18 @@ partial def decompileExpr (addr: MetaAddress): DecompileM Lean.Expr := do
       let u <- decompileLevel ⟨ua, um⟩
       return mdata kvs (.sort u)
     | .erec idx uas, .meta ⟨[.link md, .link n, .links ums]⟩ => do
-      --dbg_trace s!"decompileExpr erec"
       let kvs <- decompileKVMaps md
       let us <- univs uas ums
       let name <- decompileName n
+    --dbg_trace s!"decompileExpr {(<- read).current} erec {idx} {name}, md: {md}, us: {repr us}, n: {n}"
       match (<- read).mutCtx.get? name with
       | some idx' => do
         if idx' == idx then return mdata kvs (.const name us)
         else throw <| .mismatchedMutIdx (<- read).current (<- read).mutCtx name idx idx'
       | none => do throw <| .unknownMutual (<- read).current (<- read).mutCtx name idx
     | .eref rd uas, .meta ⟨[.link md, .link n, .link rm, .links ums]⟩ => do
-      --dbg_trace s!"decompileExpr eref"
       let name <- decompileName n
+    --dbg_trace s!"decompileExpr {(<- read).current} eref {name}"
       let kvs <- decompileKVMaps md
       let us <- univs uas ums
       let (name', _) <- decompileNamedConst name ⟨rd, rm⟩
@@ -489,8 +508,8 @@ partial def decompileLevels (n: Nat) (ls: List Address)
 
 partial def decompileDef: Ixon.Definition -> Metadata -> DecompileM Def
 | d, ⟨[.link n, .links ls, .hints h, .link tm, .link vm, .links as]⟩ => do
-  --dbg_trace "decompileDef"
   let name <- decompileName n
+--dbg_trace s!"decompileDef {(<- read).current} {name} {repr (<- read).mutCtx}"
   let lvls <- decompileLevels d.lvls ls
   withLevels' lvls <| do
     let t <- decompileExpr ⟨d.type, tm⟩
@@ -511,6 +530,7 @@ partial def decompileRules (rs: List RecursorRule) (ms: List (Address × Address
 partial def decompileRecr: Ixon.Recursor -> Metadata -> DecompileM Rec
 | r, ⟨[.link n, .links ls, .link tm, .map rs, .links as]⟩ => do
   let name <- decompileName n
+--dbg_trace s!"decompileRecr {(<- read).current} {name} {repr (<- read).mutCtx}"
   let lvls <- decompileLevels r.lvls ls
   withLevels' lvls <| do
     let t <- decompileExpr ⟨r.type, tm⟩
@@ -538,6 +558,7 @@ partial def decompileCtors (cs: List Ixon.Constructor) (ms: List Address)
 partial def decompileIndc: Ixon.Inductive -> Metadata -> DecompileM Ind
 | i, ⟨[.link n, .links ls, .link tm, .links cs, .links as]⟩ => do
   let name <- decompileName n
+--dbg_trace s!"decompileIndc {(<- read).current} {name} {repr (<- read).mutCtx}"
   let lvls <- decompileLevels i.lvls ls
   withLevels' lvls <| do
     let t <- decompileExpr ⟨i.type, tm⟩
@@ -549,10 +570,10 @@ partial def decompileIndc: Ixon.Inductive -> Metadata -> DecompileM Ind
 
 partial def decompileConst (addr: MetaAddress)
   : DecompileM (Lean.Name × Set Lean.Name) := do
-  --dbg_trace s!"decompileConst {addr}"
+--dbg_trace s!"decompileConst {(<- read).current} {addr} {repr (<- read).mutCtx}"
   match (<- get).constCache.find? addr with
   | some x => pure x
-  | none => resetCtx' do
+  | none => do
     let (name, block) <- go (<- readIxon addr.data) (<- readIxon addr.meta)
     let blockNames <- insertBlock block
     modifyGet fun stt => ((name, blockNames), { stt with
@@ -587,41 +608,27 @@ partial def decompileConst (addr: MetaAddress)
       | .meta ⟨[.link n, .links _, .hints _, .link _, .link _, .links _]⟩ => do
         let name <- decompileName n
         let block <- decompileMuts (<- readIxon bd) (<- readIxon bm)
-        match block with
-        | .muts ms => match ms[idx]? with
-          | .some (.defn d) => matchNames name d.name (pure (name, block))
-          | _ => do throw <| .badProj (<- read).current block s!"malformed dprj index {idx}"
-        | _ => do throw <| .badProj (<- read).current block "dprj into non-mutual block"
+        match (<- matchBlock name idx block) with
+        | .defn _ => pure (name, block)
+        | e => throw <| .badProj (<- read).current block s!"malformed dprj at {idx} of {repr e}"
       | m => do throw <| .badProjMeta (<- read).current m "dprj"
     | .rprj ⟨idx, bd⟩, .meta ⟨[.link bm, .link m]⟩ => do
       match (<- readIxon m) with
       | .meta ⟨[.link n, .links _, .link _, .map _, .links _]⟩ => do
         let name <- decompileName n
         let block <- decompileMuts (<- readIxon bd) (<- readIxon bm)
-        match block with
-        | .muts ms => match ms[idx]? with
-          | .some (.recr r) => matchNames name r.name (pure (name, block))
-          | _ => do throw <| .badProj (<- read).current block s!"malformed rprj index {idx}"
-        | _ => do throw <| .badProj (<- read).current block "rprj inton non-mutual block"
+        match (<- matchBlock name idx block) with
+        | .recr _ => (pure (name, block))
+        | e => throw <| .badProj (<- read).current block s!"malformed rprj at {idx} of {repr e}"
       | m => do throw <| .badProjMeta (<- read).current m "rprj"
     | .iprj ⟨idx, bd⟩, .meta ⟨[.link bm, .link m]⟩ => do
       match (<- readIxon m) with
       | .meta ⟨[.link n, .links _, .link _, .links _, .links _]⟩ => do
         let name <- decompileName n
         let block <- decompileMuts (<- readIxon bd) (<- readIxon bm)
-        match block with
-        | .muts ms => match ms[idx]? with
-          | .some (.indc i) => matchNames name i.name (pure (name, block))
-          | _ => do 
-            let bmeta <- match (<- readStore bm "metadata") with
-            | Ixon.meta ⟨[.muts _, .map cs, .map _]⟩ => do
-              let mut map : Map Lean.Name Nat := {}
-              for (n, i) in cs do
-                map := map.insert (<- decompileName n) (<- readNat i)
-              pure map
-            | _ => unreachable!
-            throw <| .badProj (<- read).current block s!"malformed iprj index {idx} & {repr bmeta}"
-        | _ => do throw <| .badProj (<- read).current block "iprj into non-mutual block"
+        match (<- matchBlock name idx block) with
+        | .indc _ => (pure (name, block))
+        | e => throw <| .badProj (<- read).current block s!"malformed iprj at {idx} of {repr e}"
       | m => do throw <| .badProjMeta (<- read).current m "iprj"
     | .cprj ⟨idx, cidx, bd⟩, .meta ⟨[.link bm, .link m]⟩ => do
       match (<- readIxon m) with
@@ -629,14 +636,11 @@ partial def decompileConst (addr: MetaAddress)
         let name <- decompileName n
         let induct <- decompileName i
         let block <- decompileMuts (<- readIxon bd) (<- readIxon bm)
-        match block with
-        | .muts ms => match ms[idx]? with
-          | .some (.indc i) => matchNames induct i.name <|
-            match i.ctors[cidx]? with
-            | .some c => matchNames name c.name (pure (name, block))
-            | .none => do throw <| .badProj (<- read).current block s!"malformed cprj ctor index {cidx}"
-          | _ => do throw <| .badProj (<- read).current block s!"malformed cprj index {idx}"
-        | _ => do throw <| .badProj (<- read).current block "cprj into non-mutual block"
+        match (<- matchBlock induct idx block) with
+        | .indc i => match i.ctors[cidx]? with
+          | .some c => matchNames name c.name (pure (name, block))
+          | .none => do throw <| .badProj (<- read).current block s!"malformed cprj ctor index {cidx}"
+        | e => throw <| .badProj (<- read).current block s!"malformed cprj at {idx} of {repr e}"
       | m => do throw <| .badProjMeta (<- read).current m "cprj"
     | .prim .obj, .meta ⟨[]⟩ => do
       --dbg_trace s!"decompileConst prim _obj"
@@ -652,7 +656,8 @@ partial def decompileConst (addr: MetaAddress)
 partial def decompileNamedConst (name: Lean.Name) (addr: MetaAddress)
   : DecompileM (Lean.Name × Set Lean.Name) := do
   --dbg_trace s!"decompileNamedConst {name} {addr}"
-  let (n, set) <- withNamed name addr <| decompileConst addr
+--dbg_trace s!"decompileNamedConst {name} {addr} {repr (<- read).mutCtx}"
+  let (n, set) <- resetCtx' name addr <| decompileConst addr
   matchNames n name (pure (n, set))
 
 partial def decompileMutConst : Ixon.MutConst -> Metadata -> DecompileM MutConst
@@ -662,23 +667,28 @@ partial def decompileMutConst : Ixon.MutConst -> Metadata -> DecompileM MutConst
 
 partial def decompileMuts: Ixon -> Ixon -> DecompileM Block
 | ms@(.muts cs), m@(.meta ⟨[.muts names, .map ctx, .map metaMap]⟩) => do
+  --dbg_trace s!"decompileMuts {(<- read).current} {repr (<- read).mutCtx}"
     if cs.length != names.length then throw <| .badMuts (<- read).current ms m
     else
       let mut map : Map Lean.Name Metadata := {}
       for (name, meta) in metaMap do
         map := map.insert (<- decompileName name) (<- readStore meta "Metadata")
-      let mut muts := #[]
+      let mut mutClasses := #[]
       let mut mutCtx := {}
       for (n, i) in ctx do
         mutCtx := mutCtx.insert (<- decompileName n) (<- readNat i)
+    --dbg_trace s!"decompileMuts {(<- read).current} inner mutCtx {repr mutCtx}"
       for (const, names) in cs.zip names do
+        let mut mutClass := #[]
         for n in names do
           let name <- decompileName n
+        --dbg_trace s!"decompileMuts {(<- read).current} inner loop {name} {repr mutCtx}"
           let const' <- match map.get? name with
             | .some meta => withMutCtx' mutCtx <| decompileMutConst const meta
             | .none => do throw <| .badMuts (<- read).current ms m
-          muts := muts.push const'
-      return .muts muts.toList
+          mutClass := mutClass.push const'
+        mutClasses := mutClasses.push mutClass
+      return .muts (Array.toList <$> mutClasses).toList
 | ms, m => do throw <| .badMuts (<- read).current ms m
 
 end
diff --git a/Ix/Mutual.lean b/Ix/Mutual.lean
index 4865cb32..ba6088a2 100644
--- a/Ix/Mutual.lean
+++ b/Ix/Mutual.lean
@@ -89,7 +89,7 @@ def MutConst.contains (name: Lean.Name) : MutConst -> Bool
 -- definitions and recursors, but we combine them for robustness and code
 -- deduplication.
 -- layout: [i0, i1, ..., iN, i0c0, ... i0cM, ... inc0, iNcM]
-def MutConst.ctx (classes: List (List MutConst)) : Map Lean.Name Nat
+def MutConst.ctx (classes: List (List MutConst)) : MutCtx
   := Id.run do
   let mut mutCtx := default
   let mut i := classes.length
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index b7679c14..8eaf0e92 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -84,6 +84,15 @@ def testMutual : IO TestSeq := do
   let nss := dss.map fun ds => ds.map (·.name)
   return test "test mutual" (res == nss)
 
+--#eval show Lean.MetaM _ from do
+--  let env ← Lean.getEnv
+--  return env.find? `Std.DHashMap.Const.toList._rarg._cstage2
+
+--#eval show Lean.MetaM _ from do
+--  let env ← Lean.getEnv
+--  return env.find? `Array.foldrMUnsafe.fold._at.Std.DHashMap.Const.toList._spec_2
+
+
 def testInductives : IO TestSeq := do
   let env <- get_env!
   let mut cstt : CompileState := .init env 0
@@ -202,7 +211,7 @@ def testRoundtripGetEnv : IO TestSeq := do
     | .ok (n,_) stt => pure (n, stt)
     | .error e _ => do
       IO.println s!"failed {name}"
-      --IO.println s!"denv: {repr denv}"
+      IO.println s!"cstt all: {repr <| cstt.alls.get? name}"
       --let c := env.constants.find? name
       --IO.println s!"{repr c}"
       throw (IO.userError e.pretty)
diff --git a/Tests/Ix/Fixtures.lean b/Tests/Ix/Fixtures.lean
index 1189aba6..bbb12bcf 100644
--- a/Tests/Ix/Fixtures.lean
+++ b/Tests/Ix/Fixtures.lean
@@ -138,7 +138,6 @@ inductive BLA'
   | nil
 
 mutual
-  -- BLE and BLI should be distinct because we don't group by weak equality
   inductive BLE | bli : BLI → BLE
   inductive BLI | ble : BLE → BLI
   inductive BLO | blea : BLE → BLI → BLO
@@ -151,7 +150,6 @@ mutual
 end
 
 mutual
-  -- BLE and BLI should be distinct because we don't group by weak equality
   inductive BLE'' | bli : BLI'' → BLE''
   inductive BLO'' | blea : BLE'' → BLA' → BLO''
   inductive BLI'' | ble : BLE'' → BLI''

From f5ac204b8ad6445029b6ca39795b44b182a955f9 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 23 Oct 2025 17:42:05 -0400
Subject: [PATCH 57/74] preprocessing GroundM step, but CondenseM breaking

---
 Ix/CompileM.lean      |  69 +++++++------
 Ix/CondenseM.lean     |  75 +++-----------
 Ix/DecompileM.lean    |  28 +++---
 Ix/GroundM.lean       | 194 ++++++++++++++++++++++++++++++++++++
 Tests/Ix/Compile.lean | 222 ++++++++++++++++++++++--------------------
 5 files changed, 372 insertions(+), 216 deletions(-)
 create mode 100644 Ix/GroundM.lean

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index cb7d4530..f4de6585 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -4,6 +4,7 @@ import Ix.Address
 import Ix.Mutual
 import Ix.Common
 import Ix.CondenseM
+import Ix.GroundM
 --import Ix.Store
 import Ix.SOrder
 import Ix.Cronos
@@ -13,21 +14,19 @@ open Ixon hiding Substring
 
 structure CompileEnv where
   univCtx : List Lean.Name
-  bindCtx : List Lean.Name
   mutCtx  : MutCtx
   current : Lean.Name
 deriving BEq, Ord
 
 structure ExprCtx where
   univCtx : List Lean.Name
-  bindCtx : List Lean.Name
   mutCtx : List (Lean.Name × Nat)
 deriving BEq, Hashable
 
 def ExprCtx.fromEnv : CompileEnv -> ExprCtx
-| ⟨u, b, m, _⟩ => ⟨u, b, m.toList⟩
+| ⟨u, m, _⟩ => ⟨u, m.toList⟩
 
-def CompileEnv.init: CompileEnv := ⟨default, default, default, default⟩
+def CompileEnv.init: CompileEnv := ⟨default, default, default⟩
 
 structure CompileState where
   maxHeartBeats: USize
@@ -50,11 +49,13 @@ structure CompileState where
   blocks: Map MetaAddress Unit
   cronos: Cronos
 
-def CompileState.init (env: Lean.Environment) (seed: Nat) (maxHeartBeats: USize := 200000)
+def CompileState.init (env: Lean.Environment)
+  (alls: Map Lean.Name (Set Lean.Name))
+  (seed: Nat) (maxHeartBeats: USize := 200000)
   : CompileState :=
   ⟨maxHeartBeats, env, mkStdGen seed, default, default, default, default,
   default, default, default, default, default, default, default,
-  CondenseM.run env, default, default, default⟩
+  alls, default, default, default⟩
 
 inductive CompileError where
 | unknownConstant : Lean.Name -> CompileError
@@ -123,24 +124,20 @@ def freshSecret : CompileM Address := do
 --  liftM (Store.writeConst const).toIO
 
 -- add binding name to local context
-def withCurrent (name: Lean.Name) : CompileM α -> CompileM α :=
+def CompileM.withCurrent (name: Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with current := name }
 
--- add binding name to local context
-def withBinder (name: Lean.Name) : CompileM α -> CompileM α :=
-  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
-
 -- add levels to local context
-def withLevels (lvls : List Lean.Name) : CompileM α -> CompileM α :=
+def CompileM.withLevels (lvls : List Lean.Name) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with univCtx := lvls }
 
 -- add mutual recursion info to local context
-def withMutCtx (mutCtx : MutCtx) : CompileM α -> CompileM α :=
+def CompileM.withMutCtx (mutCtx : MutCtx) : CompileM α -> CompileM α :=
   withReader $ fun c => { c with mutCtx := mutCtx }
 
 -- reset local context
-def resetCtx (current: Lean.Name) : CompileM α -> CompileM α :=
-  withReader $ fun c => { c with univCtx := [], bindCtx := [], mutCtx := {}, current }
+def CompileM.resetCtx (current: Lean.Name) : CompileM α -> CompileM α :=
+  withReader $ fun c => { c with univCtx := [], mutCtx := {}, current }
 
 def storeIxon (ixon: Ixon): CompileM Address := do
   --dbg_trace "storeIxon ser {(<- get).store.size} {(<- read).current}"
@@ -349,15 +346,15 @@ def compileKVMaps (maps: List Lean.KVMap): CompileM Address := do
 def findLeanConst (name : Lean.Name) : CompileM Lean.ConstantInfo := do
   match (<- get).env.constants.find? name with
   | some const => pure const
-  | none => do
-    let name2 := name.append (Lean.Name.mkSimple "_cstage2")
-    match (<- get).env.constants.find? name2 with
-     | some const => do
-      let _ <- compileName name2
-      modifyGet fun stt => (const, { stt with
-        cstagePatch := stt.cstagePatch.insert name name2
-      })
-     | none => throw $ .unknownConstant name
+  | none => throw $ .unknownConstant name
+    --let name2 := name.append (Lean.Name.mkSimple "_cstage2")
+    --match (<- get).env.constants.find? name2 with
+    -- | some const => do
+    --  let _ <- compileName name2
+    --  modifyGet fun stt => (const, { stt with
+    --    cstagePatch := stt.cstagePatch.insert name name2
+    --  })
+    -- | none => 
 
 def MutConst.mkIndc (i: Lean.InductiveVal) : CompileM MutConst := do
   let ctors <- i.ctors.mapM getCtor
@@ -502,7 +499,7 @@ partial def compileConstName (name: Lean.Name): CompileM MetaAddress := do
 partial def compileConstant : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
 | c => do
 --dbg_trace "compileConstant {c.name}"
-  resetCtx c.name <| compileConstant' c
+  .resetCtx c.name <| compileConstant' c
 
 partial def compileConstant' : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
 | .defnInfo val => compileMutual (MutConst.mkDefn val)
@@ -519,14 +516,14 @@ partial def compileConstant' : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
 | .recInfo val => do
 --dbg_trace "compileConstant recInfo {val.name} mutCtx {repr <| (<- read).mutCtx}"
   compileMutual (MutConst.recr val)
-| .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => withLevels lvls do
+| .axiomInfo ⟨⟨name, lvls, type⟩, isUnsafe⟩ => .withLevels lvls do
   let n <- compileName name
   let ls <- lvls.mapM compileName
   let t <- compileExpr type
   let data := .axio ⟨isUnsafe, lvls.length, t.data⟩
   let meta := .meta ⟨[.link n, .links ls, .link t.meta]⟩
   pure (data, meta)
-| .quotInfo ⟨⟨name, lvls, type⟩, kind⟩ => withLevels lvls do
+| .quotInfo ⟨⟨name, lvls, type⟩, kind⟩ => .withLevels lvls do
   let n <- compileName name
   let ls <- lvls.mapM compileName
   let t <- compileExpr type
@@ -535,7 +532,7 @@ partial def compileConstant' : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
   pure (data, meta)
 
 partial def compileDefn: Ix.Def -> CompileM (Ixon.Definition × Ixon.Metadata)
-| d => withLevels d.levelParams do
+| d => .withLevels d.levelParams do
   let n <- compileName d.name
   let ls <- d.levelParams.mapM compileName
   let t <- compileExpr d.type
@@ -552,7 +549,7 @@ partial def compileRule: Lean.RecursorRule -> CompileM (Ixon.RecursorRule × (Ad
   pure (⟨r.nfields, rhs.data⟩, (n, rhs.meta))
 
 partial def compileRecr: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata)
-| r => withLevels r.levelParams <| do
+| r => .withLevels r.levelParams <| do
 --dbg_trace s!"compileRecr {(<- read).current} {repr <| r.name} mutCtx: {repr (<- read).mutCtx}"
   let n <- compileName r.name
   let ls <- r.levelParams.mapM compileName
@@ -566,7 +563,7 @@ partial def compileRecr: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata
 
 partial def compileConstructor (induct: Address)
 : Lean.ConstructorVal -> CompileM (Ixon.Constructor × Metadata)
-| c => withLevels c.levelParams <| do
+| c => .withLevels c.levelParams <| do
   let n <- compileName c.name
   let ls <- c.levelParams.mapM compileName
   let t <- compileExpr c.type
@@ -576,7 +573,7 @@ partial def compileConstructor (induct: Address)
 
 partial def compileIndc: Ix.Ind -> CompileM (Ixon.Inductive × Map Address Address)
 | ⟨name, lvls, type, ps, is, all, ctors, nest, rcr, refl, usafe⟩ =>
-  withLevels lvls do 
+  .withLevels lvls do 
   let n <- compileName name
   let ls <- lvls.mapM compileName
   let t <- compileExpr type
@@ -606,10 +603,10 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
     (const matches .defn _ || const matches .recr _) then do
     match const with
     | .defn d => do
-      let (data, meta) <- withMutCtx (.single d.name 0) <| compileDefn d
+      let (data, meta) <- .withMutCtx (.single d.name 0) <| compileDefn d
       pure (.defn data, .meta meta)
     | .recr r => do
-      let (data, meta) <- withMutCtx (.single r.name 0) <| compileRecr r
+      let (data, meta) <- .withMutCtx (.single r.name 0) <| compileRecr r
       pure (.recr data, .meta meta)
     | _ => unreachable!
   else
@@ -630,7 +627,7 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
   --dbg_trace s!"compileMutual {const.name} mutCtx: {repr mutCtx}"
     let mutMeta <- mutConsts.mapM fun m => m.mapM <| fun c => compileName c.name
     -- compile each constant with the mutCtx
-    let (data, metas) <- withMutCtx mutCtx (compileMutConsts mutConsts)
+    let (data, metas) <- .withMutCtx mutCtx (compileMutConsts mutConsts)
     -- add top-level mutual block to our state
     let ctx <- mutCtx.toList.mapM fun (n, i) => do
       pure (<- compileName n, <- storeNat i)
@@ -995,10 +992,12 @@ def CompileM.runIO (c : CompileM α)
   (maxHeartBeats: USize := 200000)
   (seed : Option Nat := .none)
   : IO (α × CompileState) := do
+  let gstt := GroundM.run env
+  let alls := CondenseM.run gstt.outRefs
   let seed <- match seed with
     | .none => IO.monoNanosNow
     | .some s => pure s
-  match <- c.run .init (.init env seed maxHeartBeats) with
+  match <- c.run .init (.init env alls seed maxHeartBeats) with
   | (.ok a, stt) => return (a, stt)
   | (.error e, _) => throw (IO.userError (<- e.pretty))
 
diff --git a/Ix/CondenseM.lean b/Ix/CondenseM.lean
index 34136060..cc26c20f 100644
--- a/Ix/CondenseM.lean
+++ b/Ix/CondenseM.lean
@@ -3,9 +3,10 @@ import Ix.Common
 
 namespace Ix
 
+structure CondenseEnv where
+  outRefs: Map Lean.Name (Set Lean.Name)
+
 structure CondenseState where
-  exprRefs: Map Lean.Expr (Set Lean.Name)
-  refs: Map Lean.Name (Set Lean.Name)
   names: Map Lean.Name UInt64
   ids: Map UInt64 Lean.Name
   lowLink: Map UInt64 UInt64
@@ -13,65 +14,14 @@ structure CondenseState where
   onStack: Set UInt64
   id : UInt64
 
-def CondenseState.init : CondenseState := ⟨{}, {}, {}, {}, {}, #[], {}, 0⟩
-
-abbrev CondenseM := ReaderT Lean.Environment <| StateT CondenseState Id
-
-def refsExpr : Lean.Expr -> CondenseM (Set Lean.Name)
-| expr => do match (<- get).exprRefs.find? expr with
-  | some x => pure x
-  | none => do
-    let refs <- go expr
-    modifyGet fun stt => (refs, { stt with
-      exprRefs := stt.exprRefs.insert expr refs
-    })
-  where
-    go : Lean.Expr -> CondenseM (Set Lean.Name)
-    | .const name _ => pure {name}
-    | .app f a => .union <$> refsExpr f <*> refsExpr a
-    | .lam _ t b _ => .union <$> refsExpr t <*> refsExpr b
-    | .forallE _ t b _ => .union <$> refsExpr t <*> refsExpr b
-    | .letE _ t v b _ => do
-      let t' <- refsExpr t
-      let v' <- refsExpr v
-      let b' <- refsExpr b
-      return t'.union (v'.union b')
-    | .proj n _ s => do return (<- refsExpr s).insert n
-    | .mdata _ x => refsExpr x
-    | _ => return {}
+def CondenseState.init : CondenseState := ⟨{}, {}, {}, #[], {}, 0⟩
 
-partial def refsConst : Lean.ConstantInfo -> CondenseM (Set Lean.Name)
-| const => do match (<- get).refs.find? const.name with
-  | some x => pure x
-  | none => do
-    let constRefs <- go const
-    modifyGet fun stt => (constRefs, { stt with
-      refs := stt.refs.insert const.name constRefs
-    })
-  where
-    go : Lean.ConstantInfo -> CondenseM (Set Lean.Name)
-    | .axiomInfo val => refsExpr val.type
-    | .defnInfo val => .union <$> refsExpr val.type <*> refsExpr val.value
-    | .thmInfo val => .union <$> refsExpr val.type <*> refsExpr val.value
-    | .opaqueInfo val => .union <$> refsExpr val.type <*> refsExpr val.value
-    | .quotInfo val => refsExpr val.type
-    | .inductInfo val => do
-      let env := (<- read).constants
-      let ctorTypes: Set Lean.Name <- val.ctors.foldrM (fun n acc => do
-        acc.union <$> refsConst (env.find! n)) {}
-      let type <- refsExpr val.type
-      return .union (.ofList val.ctors) (.union ctorTypes type)
-    | .ctorInfo val => refsExpr val.type
-    | .recInfo val => do
-      let t <- refsExpr val.type
-      let rs <- val.rules.foldrM (fun r s => .union s <$> refsExpr r.rhs) {}
-      return .union t rs
+abbrev CondenseM := ReaderT CondenseEnv <| StateT CondenseState Id
 
 partial def visit : Lean.Name -> CondenseM Unit
-| name => do match (<- read).constants.find? name with
+| name => do match (<- read).outRefs.find? name with
   | .none => return ()
-  | .some c => do
-    let refs <- refsConst c
+  | .some refs => do
     let id := (<- get).id
     modify fun stt => { stt with
       names := stt.names.insert name id
@@ -82,9 +32,7 @@ partial def visit : Lean.Name -> CondenseM Unit
       id := id + 1
     }
     for ref in refs do
-      match (<- read).constants.find? ref with
-      | none => continue
-      | some _ => do match (<- get).names.get? ref with
+      do match (<- get).names.get? ref with
         | .none => do
           visit ref
           modify fun stt =>
@@ -110,7 +58,7 @@ partial def visit : Lean.Name -> CondenseM Unit
 
 def condense: CondenseM (Map Lean.Name (Set Lean.Name)) := do
   let mut idx := 0
-  for (name,_) in (<- read).constants do
+  for (name,_) in (<- read).outRefs do
     idx := idx + 1
     match (<- get).names.get? name with
     | .some _ => continue
@@ -127,7 +75,8 @@ def condense: CondenseM (Map Lean.Name (Set Lean.Name)) := do
       blocks := blocks.insert n set
   return blocks
 
-def CondenseM.run (env: Lean.Environment): Map Lean.Name (Set Lean.Name) :=
- Id.run (StateT.run (ReaderT.run condense env) CondenseState.init).1
+def CondenseM.run (refs: Map Lean.Name (Set Lean.Name))
+  : Map Lean.Name (Set Lean.Name) :=
+  Id.run (StateT.run (ReaderT.run condense ⟨refs⟩) CondenseState.init).1
 
 end Ix
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index 29d54968..8fe855ba 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -208,20 +208,20 @@ def DecompileM.run (env: DecompileEnv) (stt: DecompileState) (c : DecompileM α)
   := EStateM.run (ReaderT.run c env) stt
 
 -- add binding name to local context
-def withBinder' (name: Lean.Name) : DecompileM α -> DecompileM α :=
+def DecompileM.withBinder (name: Lean.Name) : DecompileM α -> DecompileM α :=
   withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
 
 -- add levels to local context
-def withLevels' (lvls : List Lean.Name) : DecompileM α -> DecompileM α :=
+def DecompileM.withLevels (lvls : List Lean.Name) : DecompileM α -> DecompileM α :=
   withReader $ fun c => { c with univCtx := lvls }
 
 -- add mutual recursion info to local context
-def withMutCtx' (mutCtx : Std.HashMap Lean.Name Nat)
+def DecompileM.withMutCtx (mutCtx : Std.HashMap Lean.Name Nat)
   : DecompileM α -> DecompileM α :=
   withReader $ fun c => { c with mutCtx := mutCtx }
 
 -- reset local context
-def resetCtx' (name: Lean.Name) (meta: MetaAddress) 
+def DecompileM.resetCtx (name: Lean.Name) (meta: MetaAddress) 
   : DecompileM α -> DecompileM α :=
   withReader $ fun c => { c with 
     univCtx := [], bindCtx := [], mutCtx := {}, current := ⟨name, meta⟩
@@ -464,14 +464,14 @@ partial def decompileExpr (addr: MetaAddress): DecompileM Lean.Expr := do
       let name <- decompileName n
       let kvs <- decompileKVMaps md
       let t <- decompileExpr ⟨ta, tm⟩
-      let b <- withBinder' name (decompileExpr ⟨ba, bm⟩)
+      let b <- .withBinder name (decompileExpr ⟨ba, bm⟩)
       return mdata kvs (.lam name t b i)
     | .eall ta ba, .meta ⟨[.link md, .link n, .info i, .link tm, .link bm]⟩ => do
       --dbg_trace s!"decompileExpr eall"
       let name <- decompileName n
       let kvs <- decompileKVMaps md
       let t <- decompileExpr ⟨ta, tm⟩
-      let b <- withBinder' name (decompileExpr ⟨ba, bm⟩)
+      let b <- .withBinder name (decompileExpr ⟨ba, bm⟩)
       return mdata kvs (.forallE name t b i)
     | .elet nD ta va ba, .meta ⟨[.link md, .link n, .link tm, .link vm, .link bm]⟩ => do
       --dbg_trace s!"decompileExpr elet"
@@ -479,7 +479,7 @@ partial def decompileExpr (addr: MetaAddress): DecompileM Lean.Expr := do
       let kvs <- decompileKVMaps md
       let t <- decompileExpr ⟨ta, tm⟩
       let v <- decompileExpr ⟨va, vm⟩
-      let b <- withBinder' name (decompileExpr ⟨ba, bm⟩)
+      let b <- .withBinder name (decompileExpr ⟨ba, bm⟩)
       return mdata kvs (.letE name t v b nD)
     | .enat n, .meta ⟨[.link md]⟩ => do
       --dbg_trace s!"decompileExpr enat"
@@ -511,7 +511,7 @@ partial def decompileDef: Ixon.Definition -> Metadata -> DecompileM Def
   let name <- decompileName n
 --dbg_trace s!"decompileDef {(<- read).current} {name} {repr (<- read).mutCtx}"
   let lvls <- decompileLevels d.lvls ls
-  withLevels' lvls <| do
+  .withLevels lvls <| do
     let t <- decompileExpr ⟨d.type, tm⟩
     let v <- decompileExpr ⟨d.value, vm⟩
     let all <- as.mapM decompileName
@@ -532,7 +532,7 @@ partial def decompileRecr: Ixon.Recursor -> Metadata -> DecompileM Rec
   let name <- decompileName n
 --dbg_trace s!"decompileRecr {(<- read).current} {name} {repr (<- read).mutCtx}"
   let lvls <- decompileLevels r.lvls ls
-  withLevels' lvls <| do
+  .withLevels lvls <| do
     let t <- decompileExpr ⟨r.type, tm⟩
     let all <- as.mapM decompileName
     let rs <- decompileRules r.rules rs
@@ -560,7 +560,7 @@ partial def decompileIndc: Ixon.Inductive -> Metadata -> DecompileM Ind
   let name <- decompileName n
 --dbg_trace s!"decompileIndc {(<- read).current} {name} {repr (<- read).mutCtx}"
   let lvls <- decompileLevels i.lvls ls
-  withLevels' lvls <| do
+  .withLevels lvls <| do
     let t <- decompileExpr ⟨i.type, tm⟩
     let all <- as.mapM decompileName
     let ctors <- decompileCtors i.ctors cs
@@ -584,7 +584,7 @@ partial def decompileConst (addr: MetaAddress)
     | .defn d, .meta m@⟨(.link n)::_⟩ => do
       --dbg_trace s!"decompileConst defn"
       let name <- decompileName n
-      let d <- withMutCtx' {(name, 0)} <| decompileDef d m
+      let d <- .withMutCtx {(name, 0)} <| decompileDef d m
       return (d.name, .defn d)
     | .axio a, .meta ⟨[.link n, .links ls, .link tm]⟩ => do
       --dbg_trace s!"decompileConst axio"
@@ -601,7 +601,7 @@ partial def decompileConst (addr: MetaAddress)
     | .recr r, .meta m@⟨(.link n)::_⟩ => do 
       --dbg_trace s!"decompileConst recr"
       let name <- decompileName n
-      let r <- withMutCtx' {(name, 0)} <| decompileRecr r m
+      let r <- .withMutCtx {(name, 0)} <| decompileRecr r m
       return (r.name, .recr r)
     | .dprj ⟨idx, bd⟩, .meta ⟨[.link bm, .link m]⟩ => do
       match (<- readIxon m) with
@@ -657,7 +657,7 @@ partial def decompileNamedConst (name: Lean.Name) (addr: MetaAddress)
   : DecompileM (Lean.Name × Set Lean.Name) := do
   --dbg_trace s!"decompileNamedConst {name} {addr}"
 --dbg_trace s!"decompileNamedConst {name} {addr} {repr (<- read).mutCtx}"
-  let (n, set) <- resetCtx' name addr <| decompileConst addr
+  let (n, set) <- .resetCtx name addr <| decompileConst addr
   matchNames n name (pure (n, set))
 
 partial def decompileMutConst : Ixon.MutConst -> Metadata -> DecompileM MutConst
@@ -684,7 +684,7 @@ partial def decompileMuts: Ixon -> Ixon -> DecompileM Block
           let name <- decompileName n
         --dbg_trace s!"decompileMuts {(<- read).current} inner loop {name} {repr mutCtx}"
           let const' <- match map.get? name with
-            | .some meta => withMutCtx' mutCtx <| decompileMutConst const meta
+            | .some meta => .withMutCtx mutCtx <| decompileMutConst const meta
             | .none => do throw <| .badMuts (<- read).current ms m
           mutClass := mutClass.push const'
         mutClasses := mutClasses.push mutClass
diff --git a/Ix/GroundM.lean b/Ix/GroundM.lean
new file mode 100644
index 00000000..47f79389
--- /dev/null
+++ b/Ix/GroundM.lean
@@ -0,0 +1,194 @@
+import Lean
+import Ix.Common
+
+namespace Ix
+
+structure GroundEnv where
+  env : Lean.Environment
+  univCtx: List Lean.Name
+  bindCtx: List Lean.Name
+  current: Lean.Name
+
+def GroundEnv.init (env: Lean.Environment): GroundEnv := ⟨env, {}, {}, default⟩
+
+inductive GroundError where
+| level (x : Lean.Level) (ctx: List Lean.Name)
+| ref (x : Lean.Name)
+| mvar (x : Lean.Expr)
+| var (x : Lean.Expr) (ctx: List Lean.Name)
+| indc (i: Lean.InductiveVal) (c: Option Lean.ConstantInfo)
+deriving Inhabited, Repr, BEq, Hashable
+
+inductive Grounding where
+| grounded
+| ungrounded (xs: Set GroundError)
+deriving Inhabited, Repr
+
+def Grounding.add : Grounding -> Grounding -> Grounding
+| .grounded, .grounded => .grounded
+| .grounded, x => x
+| x, .grounded => x
+| .ungrounded xs, .ungrounded ys => .ungrounded (.union xs ys)
+
+structure GroundState where
+  exprRefs: Map Lean.Expr (Set Lean.Name)
+  outRefs : Map Lean.Name (Set Lean.Name)
+  inRefs: Map Lean.Name (Set Lean.Name)
+  ungrounded: Map Lean.Name Grounding
+  exprCache : Map (List Lean.Name × Lean.Expr) Grounding
+  univCache : Map (List Lean.Name × Lean.Level) Grounding
+
+def GroundState.init : GroundState := ⟨{}, {}, {}, {}, {}, {}⟩
+
+abbrev GroundM := ReaderT GroundEnv <| StateT GroundState Id
+
+def GroundM.withCurrent (name: Lean.Name) : GroundM α -> GroundM α :=
+  withReader $ fun c => { c with current := name }
+
+-- add binding name to local context
+def GroundM.withBinder (name: Lean.Name) : GroundM α -> GroundM α :=
+  withReader $ fun c => { c with bindCtx := name :: c.bindCtx }
+
+-- add levels to local context
+def GroundM.withLevels (lvls : List Lean.Name) : GroundM α -> GroundM α :=
+  withReader $ fun c => { c with univCtx := lvls }
+
+def groundLevel (lvl: Lean.Level) : GroundM Grounding := do
+  let ctx := (<- read).univCtx
+  match (<- get).univCache.find? (ctx, lvl) with
+  | some l => pure l
+  | none => do
+    let grounding <- go lvl
+    modifyGet fun stt => (grounding, { stt with
+      univCache := stt.univCache.insert (ctx, lvl) grounding
+    })
+  where
+    go : Lean.Level -> GroundM Grounding
+    | .zero => pure .grounded
+    | .succ x => groundLevel x
+    | .max x y => .add <$> groundLevel x <*> groundLevel y
+    | .imax x y => .add <$> groundLevel x <*> groundLevel y
+    | .param n => do
+      let lvls := (<- read).univCtx
+      match lvls.idxOf? n with
+      | some _ => pure .grounded
+      | none   => pure <| .ungrounded {.level (.param n) lvls}
+    | l@(.mvar ..) => do pure <| .ungrounded {.level l (<- read).univCtx}
+
+def addRef (current out: Lean.Name) : GroundM Unit := do
+  modify fun stt => { stt with 
+    outRefs := stt.outRefs.alter current fun x => match x with
+      | .some rs => .some (rs.insert out)
+      | .none => .some {out}
+    inRefs := stt.inRefs.alter out fun x => match x with
+      | .some rs => .some (rs.insert current)
+      | .none => .some {current}
+  }
+
+def groundExpr (expr: Lean.Expr) : GroundM Grounding := do
+  let ctx := (<- read).bindCtx
+  match (<- get).exprCache.find? (ctx, expr) with
+  | some l => pure l
+  | none => do
+    let grounding <- go expr
+    modifyGet fun stt => (grounding, { stt with
+      exprCache := stt.exprCache.insert (ctx, expr) grounding
+    })
+  where
+    go : Lean.Expr -> GroundM Grounding
+    | .mdata _ x => groundExpr x
+    | .bvar idx => do
+      let ctx := (<- read).bindCtx
+      match ctx[idx]? with
+      | .some _ => pure .grounded
+      | .none => pure <| .ungrounded {.var (.bvar idx) ctx}
+    | .sort lvl => groundLevel lvl
+    | .const name lvls => do
+      let ls <- lvls.foldrM (fun l g => .add g <$> groundLevel l) .grounded
+      match (<- read).env.constants.find? name with
+      | .some _ => addRef (<- read).current name *> pure ls
+      | .none => 
+        if name == .mkSimple "_obj"
+        || name == .mkSimple "_neutral"
+        || name == .mkSimple "_unreachable"
+        then pure <| .grounded
+        else pure <| .add ls (.ungrounded {.ref name})
+    | .app f a => .add <$> groundExpr f <*> groundExpr a
+    | .lam n t b _ => .add <$> groundExpr t <*> .withBinder n (groundExpr b)
+    | .forallE n t b _ => .add <$> groundExpr t <*> .withBinder n (groundExpr b)
+    | .letE n t v b _ => do
+      let t' <- groundExpr t
+      let v' <- groundExpr v
+      let b' <- .withBinder n (groundExpr b)
+      pure (.add t' (.add v' b'))
+    | .proj typeName _ s => do
+      let s' <- groundExpr s
+      match (<- read).env.constants.find? typeName with
+      | .some _ => addRef (<- read).current typeName *> pure s'
+      | .none => pure <| .add s' (.ungrounded {.ref typeName})
+    | .lit _ => pure .grounded
+    | x@(.mvar _) => pure <| .ungrounded {.mvar x}
+    | x@(.fvar _) => do pure <| .ungrounded {.var x (<- read).bindCtx}
+
+def groundConst: Lean.ConstantInfo -> GroundM Grounding
+| .axiomInfo val => .withLevels val.levelParams <| groundExpr val.type
+| .defnInfo val => .withLevels val.levelParams <|
+  .add <$> groundExpr val.type <*> groundExpr val.value
+| .thmInfo val => .withLevels val.levelParams <|
+  .add <$> groundExpr val.type <*> groundExpr val.value
+| .opaqueInfo val => .withLevels val.levelParams <|
+  .add <$> groundExpr val.type <*> groundExpr val.value
+| .quotInfo val => .withLevels val.levelParams <| groundExpr val.type
+| .inductInfo val => .withLevels val.levelParams <| do
+  let env := (<- read).env.constants
+  let mut ctors := .grounded
+  for ctor in val.ctors do
+    let g <- match env.find? ctor with
+    | .some (.ctorInfo ctorVal) => .withLevels ctorVal.levelParams <| do
+      addRef val.name ctor *> groundExpr ctorVal.type
+    | c => pure <| .ungrounded {.indc val c}
+    ctors := .add ctors g
+  let type <- groundExpr val.type
+  return .add ctors type
+| .ctorInfo val => .withLevels val.levelParams <| groundExpr val.type
+| .recInfo val => .withLevels val.levelParams <| do
+  let t <- groundExpr val.type
+  let rs <- val.rules.foldrM (fun r s => .add s <$> groundExpr r.rhs) .grounded
+  return .add t rs
+
+def groundEnv: GroundM Unit := do
+  let mut stack := #[]
+  for (n, c) in (<- read).env.constants do
+    dbg_trace s!"groundEnv {n}"
+    match (<- .withCurrent n (groundConst c)) with
+    | .grounded => continue
+    | u@(.ungrounded _) => 
+      dbg_trace s!"groundEnv {n} ungrounded {repr u}"
+      modify fun stt => { stt with
+        ungrounded := stt.ungrounded.insert n u
+      }
+    stack := stack.push n
+  while !stack.isEmpty do
+    let name := stack.back!
+    dbg_trace s!"groundEnv stack {name}"
+    stack := stack.pop
+    let inRefs := match ((<- get).inRefs.get? name) with
+    | .some x => x
+    | .none => {}
+    for ref in inRefs do
+      dbg_trace s!"groundEnv stack {name} {ref}"
+      match (<- get).ungrounded.get? ref with
+      | .some u =>
+        modify fun stt => { stt with
+          ungrounded := stt.ungrounded.insert ref (.add (.ungrounded {.ref name}) u)
+        }
+      | .none => do
+        stack := stack.push ref
+        modify fun stt => { stt with
+          ungrounded := stt.ungrounded.insert ref (.ungrounded {.ref name})
+        }
+
+def GroundM.run (env: Lean.Environment) : GroundState :=
+  Id.run (StateT.run (ReaderT.run groundEnv (.init env)) GroundState.init).2
+
+end Ix
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 8eaf0e92..4fc809ba 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -3,6 +3,8 @@ import LSpec
 import Ix.Ixon
 import Ix.Address
 import Ix.Common
+import Ix.CondenseM
+import Ix.GroundM
 import Ix.CompileM
 import Ix.DecompileM
 import Ix.Cronos
@@ -66,131 +68,143 @@ end Test.Ix.Mutual
 --  IO.println s!"Peano.add is {x}"
 --  return test "false" (true == false)
 
-def testMutual : IO TestSeq := do
-  let env <- get_env!
-  let mut cstt : CompileState := .init env 0
-  let all := (env.getDelta.find! `Test.Ix.Mutual.A).all
-  let consts <- all.mapM fun n => match env.getDelta.find! n with
-    | .defnInfo d => pure <| Ix.MutConst.mkDefn d
-    | .opaqueInfo d => pure <| Ix.MutConst.mkOpaq d
-    | .thmInfo d => pure <| Ix.MutConst.mkTheo d
-    | _ => throw (IO.userError "not a def")
-  let (dss, _) <- match (<- (sortConsts consts).run .init cstt) with
-    | (.ok a, stt) => do
-      pure (a, stt)
-    | (.error e, _) => do
-      throw (IO.userError (<- e.pretty))
-  let res := [[`Test.Ix.Mutual.B, `Test.Ix.Mutual.C],[`Test.Ix.Mutual.A]]
-  let nss := dss.map fun ds => ds.map (·.name)
-  return test "test mutual" (res == nss)
+--def testMutual : IO TestSeq := do
+--  let env <- get_env!
+--  let mut cstt : CompileState := .init env 0
+--  let all := (env.getDelta.find! `Test.Ix.Mutual.A).all
+--  let consts <- all.mapM fun n => match env.getDelta.find! n with
+--    | .defnInfo d => pure <| Ix.MutConst.mkDefn d
+--    | .opaqueInfo d => pure <| Ix.MutConst.mkOpaq d
+--    | .thmInfo d => pure <| Ix.MutConst.mkTheo d
+--    | _ => throw (IO.userError "not a def")
+--  let (dss, _) <- match (<- (sortConsts consts).run .init cstt) with
+--    | (.ok a, stt) => do
+--      pure (a, stt)
+--    | (.error e, _) => do
+--      throw (IO.userError (<- e.pretty))
+--  let res := [[`Test.Ix.Mutual.B, `Test.Ix.Mutual.C],[`Test.Ix.Mutual.A]]
+--  let nss := dss.map fun ds => ds.map (·.name)
+--  return test "test mutual" (res == nss)
 
 --#eval show Lean.MetaM _ from do
 --  let env ← Lean.getEnv
---  return env.find? `Std.DHashMap.Const.toList._rarg._cstage2
-
+--  return env.find? `Std.DHashMap.Const.toList
+--
 --#eval show Lean.MetaM _ from do
 --  let env ← Lean.getEnv
 --  return env.find? `Array.foldrMUnsafe.fold._at.Std.DHashMap.Const.toList._spec_2
 
+--def testInductives : IO TestSeq := do
+--  let env <- get_env!
+--  let mut cstt : CompileState := .init env 0
+--  --let delta := env.getDelta.filter fun n _ => namesp.isPrefixOf n
+--  --let consts := env.getConstMap.filter fun n _ => namesp.isPrefixOf n
+--  let all := (env.getDelta.find! `Test.Ix.Inductives.A).all
+--  let consts <- all.mapM fun n => match env.getDelta.find! n with
+--    | .inductInfo v => do match (<- (Ix.MutConst.mkIndc v).run .init cstt) with
+--      | (.ok a, _) => pure a
+--      | (.error e, _) => do throw (IO.userError (<- e.pretty))
+--    | _ => throw (IO.userError "not an inductive")
+--  let (dss, _) <- do match (<- (sortConsts consts).run .init cstt) with
+--    | (.ok a, stt) => do
+--      pure (a, stt)
+--    | (.error e, _) => do
+--      throw (IO.userError (<- e.pretty))
+--  let res := [[`Test.Ix.Inductives.C],[`Test.Ix.Inductives.B], [`Test.Ix.Inductives.A]]
+--  let nss := dss.map fun ds => ds.map (·.name)
+--  return test "test inductives" (res == nss)
 
-def testInductives : IO TestSeq := do
-  let env <- get_env!
-  let mut cstt : CompileState := .init env 0
-  --let delta := env.getDelta.filter fun n _ => namesp.isPrefixOf n
-  --let consts := env.getConstMap.filter fun n _ => namesp.isPrefixOf n
-  let all := (env.getDelta.find! `Test.Ix.Inductives.A).all
-  let consts <- all.mapM fun n => match env.getDelta.find! n with
-    | .inductInfo v => do match (<- (Ix.MutConst.mkIndc v).run .init cstt) with
-      | (.ok a, _) => pure a
-      | (.error e, _) => do throw (IO.userError (<- e.pretty))
-    | _ => throw (IO.userError "not an inductive")
-  let (dss, _) <- do match (<- (sortConsts consts).run .init cstt) with
-    | (.ok a, stt) => do
-      pure (a, stt)
-    | (.error e, _) => do
-      throw (IO.userError (<- e.pretty))
-  let res := [[`Test.Ix.Inductives.C],[`Test.Ix.Inductives.B], [`Test.Ix.Inductives.A]]
-  let nss := dss.map fun ds => ds.map (·.name)
-  return test "test inductives" (res == nss)
-
-def testEasy : IO TestSeq := do
-  let env <- get_env!
-  let easy := [
-    `Nat.add_comm
-  ]
-  let mut res := true
-  for name in easy do
-    IO.println s!"⚙️ Compiling {name}"
-    let mut cstt : CompileState := .init env 0
-    let start <- IO.monoNanosNow
-    let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
-    | (.ok a, stt) => pure (a, stt)
-    | (.error e, _) => IO.println s!"failed {name}" *> throw (IO.userError (<- e.pretty))
-    let done <- IO.monoNanosNow
-    IO.println s!"✅ {addr}"
-    IO.println s!"Elapsed {Cronos.nanoToSec (done - start)}"
-  return test "easy compile roundtrip" (res == true)
+--def testEasy : IO TestSeq := do
+--  let env <- get_env!
+--  let easy := [
+--    `Nat.add_comm
+--  ]
+--  let mut res := true
+--  for name in easy do
+--    IO.println s!"⚙️ Compiling {name}"
+--    let mut cstt : CompileState := .init env 0
+--    let start <- IO.monoNanosNow
+--    let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
+--    | (.ok a, stt) => pure (a, stt)
+--    | (.error e, _) => IO.println s!"failed {name}" *> throw (IO.userError (<- e.pretty))
+--    let done <- IO.monoNanosNow
+--    IO.println s!"✅ {addr}"
+--    IO.println s!"Elapsed {Cronos.nanoToSec (done - start)}"
+--  return test "easy compile roundtrip" (res == true)
 
-def testDifficult : IO TestSeq := do
-  let env <- get_env!
-  let difficult := [
-    `Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_blastDivSubtractShift_q
-  ]
-  let mut res := true
-  for name in difficult do
-    let mut cstt : CompileState := .init env 0
-    let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
-    | (.ok a, stt) => pure (a, stt)
-    | (.error e, _) => IO.println s!"failed {name}" *> throw (IO.userError (<- e.pretty))
-    IO.println s!"{name} -> {addr}"
-    --cstt := stt
-    --let mut store : Ixon.Store := {}
-    --for (_,(a, b)) in cstt.names do
-    --  let a_ixon <- (Store.readConst a).toIO
-    --  let b_ixon <- (Store.readConst b).toIO
-    --  store := store.insert a a_ixon
-    --  store := store.insert b b_ixon
-    --let denv := DecompileEnv.init cstt.names store
-    --let dstt <- match decompileEnv.run denv default with
-    --  | .ok _ s => pure s
-    --    --IO.println s!"✓ {n} @ {anon}:{meta}"
-    --  | .error e _ => do
-    --    throw (IO.userError e.pretty)
-    --IO.println s!"decompiled env"
-    --for (n, (anon, meta)) in denv.names do
-    --  let c <- match env.constants.find? n with
-    --  | .some c => pure c
-    --  | .none => throw (IO.userError "name {n} not in env")
-    --  match dstt.constants.get? n with
-    --  | .some c2 =>
-    --    if c.stripMData == c2.stripMData
-    --    then
-    --      IO.println s!"✓ {n} @ {anon}:{meta}"
-    --    else
-    --      IO.println s!"× {n} @ {anon}:{meta}"
-    --      IO.FS.writeFile "c.out" s!"{repr c.stripMData}"
-    --      IO.FS.writeFile "c2.out" s!"{repr c2.stripMData}"
-    --      res := false
-    --      break
-    --  | .none => do
-    --    let e' := (DecompileError.unknownName default n).pretty
-    --    throw (IO.userError e')
-  return test "difficult compile roundtrip" (res == true)
+--def testDifficult : IO TestSeq := do
+--  let env <- get_env!
+--  let difficult := [
+--    `Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_blastDivSubtractShift_q
+--  ]
+--  let mut res := true
+--  for name in difficult do
+--    let mut cstt : CompileState := .init env 0
+--    let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
+--    | (.ok a, stt) => pure (a, stt)
+--    | (.error e, _) => IO.println s!"failed {name}" *> throw (IO.userError (<- e.pretty))
+--    IO.println s!"{name} -> {addr}"
+--    --cstt := stt
+--    --let mut store : Ixon.Store := {}
+--    --for (_,(a, b)) in cstt.names do
+--    --  let a_ixon <- (Store.readConst a).toIO
+--    --  let b_ixon <- (Store.readConst b).toIO
+--    --  store := store.insert a a_ixon
+--    --  store := store.insert b b_ixon
+--    --let denv := DecompileEnv.init cstt.names store
+--    --let dstt <- match decompileEnv.run denv default with
+--    --  | .ok _ s => pure s
+--    --    --IO.println s!"✓ {n} @ {anon}:{meta}"
+--    --  | .error e _ => do
+--    --    throw (IO.userError e.pretty)
+--    --IO.println s!"decompiled env"
+--    --for (n, (anon, meta)) in denv.names do
+--    --  let c <- match env.constants.find? n with
+--    --  | .some c => pure c
+--    --  | .none => throw (IO.userError "name {n} not in env")
+--    --  match dstt.constants.get? n with
+--    --  | .some c2 =>
+--    --    if c.stripMData == c2.stripMData
+--    --    then
+--    --      IO.println s!"✓ {n} @ {anon}:{meta}"
+--    --    else
+--    --      IO.println s!"× {n} @ {anon}:{meta}"
+--    --      IO.FS.writeFile "c.out" s!"{repr c.stripMData}"
+--    --      IO.FS.writeFile "c2.out" s!"{repr c2.stripMData}"
+--    --      res := false
+--    --      break
+--    --  | .none => do
+--    --    let e' := (DecompileError.unknownName default n).pretty
+--    --    throw (IO.userError e')
+--  return test "difficult compile roundtrip" (res == true)
 
 def testRoundtripGetEnv : IO TestSeq := do
   IO.println s!"Getting env"
   let env <- get_env!
+  let gsttStart <- IO.monoNanosNow
+  IO.println s!"Ensuring well-groundedness of env"
+  let gstt := GroundM.run env
+  let gsttEnd <- IO.monoNanosNow
+  IO.println s!"Finished grounding in {Cronos.nanoToSec (gsttEnd - gsttStart)}"
+  for (n, u) in gstt.ungrounded do
+    IO.println s!"Found ungrounded {n}: {repr u}"
   let sccStart <- IO.monoNanosNow
   IO.println s!"Building condensation graph of env"
-  let numConst := env.constants.map₁.size + env.constants.map₂.stats.numNodes
-  let mut cstt : CompileState := .init env 0
-  let mut dstt : DecompileState := default
+  let alls := CondenseM.run gstt.outRefs
   let sccEnd <- IO.monoNanosNow
   IO.println s!"Condensation graph in {Cronos.nanoToSec (sccEnd - sccStart)}"
+  let numConst := env.constants.map₁.size + env.constants.map₂.stats.numNodes
+  let mut cstt : CompileState := .init env alls 0
+  let mut dstt : DecompileState := default
   IO.println s!"Compiling env"
   let mut inConst := 1
   let allStart <- IO.monoNanosNow
   for (name, _) in env.constants do
+    match gstt.ungrounded.get? name with
+    | .some u => do
+      IO.println s!"Skipping ungrounded {name} becase {repr u}"
+      inConst := inConst + 1
+    | none => do
     let start <- IO.monoNanosNow
     let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
     | (.ok a, stt) => pure (a, stt)

From e8454c40705ebf4cb69ac6845342252e66e48d21 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 23 Oct 2025 18:14:50 -0400
Subject: [PATCH 58/74] fix CondenseM, GroundM breaking

---
 Ix/CompileM.lean      |  2 +-
 Ix/CondenseM.lean     | 18 ++++++++++++------
 Ix/GroundM.lean       | 10 +++++++++-
 Tests/Ix/Compile.lean |  2 +-
 4 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index f4de6585..c16755f3 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -993,7 +993,7 @@ def CompileM.runIO (c : CompileM α)
   (seed : Option Nat := .none)
   : IO (α × CompileState) := do
   let gstt := GroundM.run env
-  let alls := CondenseM.run gstt.outRefs
+  let alls := CondenseM.run env gstt.outRefs
   let seed <- match seed with
     | .none => IO.monoNanosNow
     | .some s => pure s
diff --git a/Ix/CondenseM.lean b/Ix/CondenseM.lean
index cc26c20f..3888f085 100644
--- a/Ix/CondenseM.lean
+++ b/Ix/CondenseM.lean
@@ -4,6 +4,7 @@ import Ix.Common
 namespace Ix
 
 structure CondenseEnv where
+  env : Lean.Environment
   outRefs: Map Lean.Name (Set Lean.Name)
 
 structure CondenseState where
@@ -19,9 +20,12 @@ def CondenseState.init : CondenseState := ⟨{}, {}, {}, #[], {}, 0⟩
 abbrev CondenseM := ReaderT CondenseEnv <| StateT CondenseState Id
 
 partial def visit : Lean.Name -> CondenseM Unit
-| name => do match (<- read).outRefs.find? name with
+| name => do match (<- read).env.constants.find? name with
   | .none => return ()
-  | .some refs => do
+  | .some _ => do
+    let refs := match (<- read).outRefs.find? name with
+    | .some x => x
+    | .none => {}
     let id := (<- get).id
     modify fun stt => { stt with
       names := stt.names.insert name id
@@ -32,7 +36,9 @@ partial def visit : Lean.Name -> CondenseM Unit
       id := id + 1
     }
     for ref in refs do
-      do match (<- get).names.get? ref with
+      match (<- read).env.constants.find? ref with
+      | none => continue
+      | some _ => do match (<- get).names.get? ref with
         | .none => do
           visit ref
           modify fun stt =>
@@ -58,7 +64,7 @@ partial def visit : Lean.Name -> CondenseM Unit
 
 def condense: CondenseM (Map Lean.Name (Set Lean.Name)) := do
   let mut idx := 0
-  for (name,_) in (<- read).outRefs do
+  for (name,_) in (<- read).env.constants do
     idx := idx + 1
     match (<- get).names.get? name with
     | .some _ => continue
@@ -75,8 +81,8 @@ def condense: CondenseM (Map Lean.Name (Set Lean.Name)) := do
       blocks := blocks.insert n set
   return blocks
 
-def CondenseM.run (refs: Map Lean.Name (Set Lean.Name))
+def CondenseM.run (env: Lean.Environment) (refs: Map Lean.Name (Set Lean.Name))
   : Map Lean.Name (Set Lean.Name) :=
-  Id.run (StateT.run (ReaderT.run condense ⟨refs⟩) CondenseState.init).1
+  Id.run (StateT.run (ReaderT.run condense ⟨env, refs⟩) CondenseState.init).1
 
 end Ix
diff --git a/Ix/GroundM.lean b/Ix/GroundM.lean
index 47f79389..48daf154 100644
--- a/Ix/GroundM.lean
+++ b/Ix/GroundM.lean
@@ -107,7 +107,7 @@ def groundExpr (expr: Lean.Expr) : GroundM Grounding := do
       let ls <- lvls.foldrM (fun l g => .add g <$> groundLevel l) .grounded
       match (<- read).env.constants.find? name with
       | .some _ => addRef (<- read).current name *> pure ls
-      | .none => 
+      | .none =>
         if name == .mkSimple "_obj"
         || name == .mkSimple "_neutral"
         || name == .mkSimple "_unreachable"
@@ -160,6 +160,14 @@ def groundEnv: GroundM Unit := do
   let mut stack := #[]
   for (n, c) in (<- read).env.constants do
     dbg_trace s!"groundEnv {n}"
+    modify fun stt => { stt with
+      outRefs := stt.outRefs.alter n fun x => match x with
+      | .none => .some {}
+      | x => x
+      inRefs := stt.inRefs.alter n fun x => match x with
+      | .none => .some {}
+      | x => x
+    }
     match (<- .withCurrent n (groundConst c)) with
     | .grounded => continue
     | u@(.ungrounded _) => 
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 4fc809ba..b88b5e39 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -190,7 +190,7 @@ def testRoundtripGetEnv : IO TestSeq := do
     IO.println s!"Found ungrounded {n}: {repr u}"
   let sccStart <- IO.monoNanosNow
   IO.println s!"Building condensation graph of env"
-  let alls := CondenseM.run gstt.outRefs
+  let alls := CondenseM.run env gstt.outRefs
   let sccEnd <- IO.monoNanosNow
   IO.println s!"Condensation graph in {Cronos.nanoToSec (sccEnd - sccStart)}"
   let numConst := env.constants.map₁.size + env.constants.map₂.stats.numNodes

From b1559e4d8cf428dbef4b351c6ac09cbbee99611c Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 23 Oct 2025 18:31:36 -0400
Subject: [PATCH 59/74] wip

---
 Ix.lean         | 5 +++--
 Ix/GroundM.lean | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/Ix.lean b/Ix.lean
index cf563426..3d921300 100644
--- a/Ix.lean
+++ b/Ix.lean
@@ -2,6 +2,7 @@
 -- Import modules here that should be built as part of the library.
 import Ix.Ixon
 import Ix.Meta
-import Ix.CompileM
+import Ix.GroundM
 import Ix.CondenseM
---import Ix.DecompileM
+import Ix.CompileM
+import Ix.DecompileM
diff --git a/Ix/GroundM.lean b/Ix/GroundM.lean
index 48daf154..41b4f19c 100644
--- a/Ix/GroundM.lean
+++ b/Ix/GroundM.lean
@@ -172,10 +172,10 @@ def groundEnv: GroundM Unit := do
     | .grounded => continue
     | u@(.ungrounded _) => 
       dbg_trace s!"groundEnv {n} ungrounded {repr u}"
+      stack := stack.push n
       modify fun stt => { stt with
         ungrounded := stt.ungrounded.insert n u
       }
-    stack := stack.push n
   while !stack.isEmpty do
     let name := stack.back!
     dbg_trace s!"groundEnv stack {name}"

From bf563681cd63380af29bd9930a42b65eebb876dd Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 23 Oct 2025 20:20:17 -0400
Subject: [PATCH 60/74] GroundM and CondenseM working

---
 Ix/CompileM.lean      |  2 +-
 Ix/GroundM.lean       | 92 +++++++++++++++++++++++++------------------
 Tests/Ix/Compile.lean | 12 +++---
 3 files changed, 62 insertions(+), 44 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index c16755f3..47dacb72 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -992,7 +992,7 @@ def CompileM.runIO (c : CompileM α)
   (maxHeartBeats: USize := 200000)
   (seed : Option Nat := .none)
   : IO (α × CompileState) := do
-  let gstt := GroundM.run env
+  let gstt <- GroundM.env env
   let alls := CondenseM.run env gstt.outRefs
   let seed <- match seed with
     | .none => IO.monoNanosNow
diff --git a/Ix/GroundM.lean b/Ix/GroundM.lean
index 41b4f19c..737913fc 100644
--- a/Ix/GroundM.lean
+++ b/Ix/GroundM.lean
@@ -35,12 +35,13 @@ structure GroundState where
   outRefs : Map Lean.Name (Set Lean.Name)
   inRefs: Map Lean.Name (Set Lean.Name)
   ungrounded: Map Lean.Name Grounding
-  exprCache : Map (List Lean.Name × Lean.Expr) Grounding
+  constCache : Map Lean.Name Grounding
+  exprCache : Map (List Lean.Name × List Lean.Name × Lean.Expr) Grounding
   univCache : Map (List Lean.Name × Lean.Level) Grounding
 
-def GroundState.init : GroundState := ⟨{}, {}, {}, {}, {}, {}⟩
+def GroundState.init : GroundState := ⟨{}, {}, {}, {}, {}, {}, {}⟩
 
-abbrev GroundM := ReaderT GroundEnv <| StateT GroundState Id
+abbrev GroundM := ReaderT GroundEnv <| StateT GroundState IO
 
 def GroundM.withCurrent (name: Lean.Name) : GroundM α -> GroundM α :=
   withReader $ fun c => { c with current := name }
@@ -85,14 +86,15 @@ def addRef (current out: Lean.Name) : GroundM Unit := do
       | .none => .some {current}
   }
 
+mutual
 def groundExpr (expr: Lean.Expr) : GroundM Grounding := do
-  let ctx := (<- read).bindCtx
-  match (<- get).exprCache.find? (ctx, expr) with
+  let key := ((<- read).univCtx, (<- read).bindCtx, expr)
+  match (<- get).exprCache.find? key with
   | some l => pure l
   | none => do
     let grounding <- go expr
     modifyGet fun stt => (grounding, { stt with
-      exprCache := stt.exprCache.insert (ctx, expr) grounding
+      exprCache := stt.exprCache.insert key grounding
     })
   where
     go : Lean.Expr -> GroundM Grounding
@@ -130,36 +132,46 @@ def groundExpr (expr: Lean.Expr) : GroundM Grounding := do
     | x@(.mvar _) => pure <| .ungrounded {.mvar x}
     | x@(.fvar _) => do pure <| .ungrounded {.var x (<- read).bindCtx}
 
-def groundConst: Lean.ConstantInfo -> GroundM Grounding
-| .axiomInfo val => .withLevels val.levelParams <| groundExpr val.type
-| .defnInfo val => .withLevels val.levelParams <|
-  .add <$> groundExpr val.type <*> groundExpr val.value
-| .thmInfo val => .withLevels val.levelParams <|
-  .add <$> groundExpr val.type <*> groundExpr val.value
-| .opaqueInfo val => .withLevels val.levelParams <|
-  .add <$> groundExpr val.type <*> groundExpr val.value
-| .quotInfo val => .withLevels val.levelParams <| groundExpr val.type
-| .inductInfo val => .withLevels val.levelParams <| do
-  let env := (<- read).env.constants
-  let mut ctors := .grounded
-  for ctor in val.ctors do
-    let g <- match env.find? ctor with
-    | .some (.ctorInfo ctorVal) => .withLevels ctorVal.levelParams <| do
-      addRef val.name ctor *> groundExpr ctorVal.type
-    | c => pure <| .ungrounded {.indc val c}
-    ctors := .add ctors g
-  let type <- groundExpr val.type
-  return .add ctors type
-| .ctorInfo val => .withLevels val.levelParams <| groundExpr val.type
-| .recInfo val => .withLevels val.levelParams <| do
-  let t <- groundExpr val.type
-  let rs <- val.rules.foldrM (fun r s => .add s <$> groundExpr r.rhs) .grounded
-  return .add t rs
+def groundConst (const: Lean.ConstantInfo) : GroundM Grounding := do
+  match (<- get).constCache.find? const.name with
+  | some g => pure g
+  | none => do
+    let grounding <- .withCurrent const.name <| go const
+    modifyGet fun stt => (grounding, { stt with
+      constCache := stt.constCache.insert const.name grounding
+    })
+  where
+    go : Lean.ConstantInfo -> GroundM Grounding
+    | .axiomInfo val => .withLevels val.levelParams <| groundExpr val.type
+    | .defnInfo val => .withLevels val.levelParams <|
+      .add <$> groundExpr val.type <*> groundExpr val.value
+    | .thmInfo val => .withLevels val.levelParams <|
+      .add <$> groundExpr val.type <*> groundExpr val.value
+    | .opaqueInfo val => .withLevels val.levelParams <|
+      .add <$> groundExpr val.type <*> groundExpr val.value
+    | .quotInfo val => .withLevels val.levelParams <| groundExpr val.type
+    | .inductInfo val => .withLevels val.levelParams <| do
+      let env := (<- read).env.constants
+      let mut ctors := .grounded
+      for ctor in val.ctors do
+        let g <- match env.find? ctor with
+        | .some (.ctorInfo ctorVal) => .withLevels ctorVal.levelParams <| do
+          addRef val.name ctor *> groundExpr ctorVal.type
+        | c => pure <| .ungrounded {.indc val c}
+        ctors := .add ctors g
+      let type <- groundExpr val.type
+      return .add ctors type
+    | .ctorInfo val => .withLevels val.levelParams <| groundExpr val.type
+    | .recInfo val => .withLevels val.levelParams <| do
+      let t <- groundExpr val.type
+      let rs <- val.rules.foldrM (fun r s => .add s <$> groundExpr r.rhs) .grounded
+      return .add t rs
+end
 
 def groundEnv: GroundM Unit := do
   let mut stack := #[]
   for (n, c) in (<- read).env.constants do
-    dbg_trace s!"groundEnv {n}"
+    --dbg_trace s!"groundEnv {n}"
     modify fun stt => { stt with
       outRefs := stt.outRefs.alter n fun x => match x with
       | .none => .some {}
@@ -168,23 +180,23 @@ def groundEnv: GroundM Unit := do
       | .none => .some {}
       | x => x
     }
-    match (<- .withCurrent n (groundConst c)) with
+    match (<- groundConst c) with
     | .grounded => continue
     | u@(.ungrounded _) => 
-      dbg_trace s!"groundEnv {n} ungrounded {repr u}"
+      dbg_trace s!"groundEnv UNGROUNDED {n} {repr u}"
       stack := stack.push n
       modify fun stt => { stt with
         ungrounded := stt.ungrounded.insert n u
       }
   while !stack.isEmpty do
     let name := stack.back!
-    dbg_trace s!"groundEnv stack {name}"
+    --dbg_trace s!"groundEnv stack {name}"
     stack := stack.pop
     let inRefs := match ((<- get).inRefs.get? name) with
     | .some x => x
     | .none => {}
     for ref in inRefs do
-      dbg_trace s!"groundEnv stack {name} {ref}"
+      dbg_trace s!"groundEnv STACK {name} {ref}"
       match (<- get).ungrounded.get? ref with
       | .some u =>
         modify fun stt => { stt with
@@ -196,7 +208,11 @@ def groundEnv: GroundM Unit := do
           ungrounded := stt.ungrounded.insert ref (.ungrounded {.ref name})
         }
 
-def GroundM.run (env: Lean.Environment) : GroundState :=
-  Id.run (StateT.run (ReaderT.run groundEnv (.init env)) GroundState.init).2
+def GroundM.run (env: Lean.Environment) (g: GroundM α): IO (α × GroundState)
+  := (StateT.run (ReaderT.run g (.init env)) GroundState.init)
+
+def GroundM.env (env: Lean.Environment) : IO GroundState := do
+  let (_, stt) <- (GroundM.run env groundEnv)
+  return stt
 
 end Ix
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index b88b5e39..8a9be87b 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -88,7 +88,8 @@ end Test.Ix.Mutual
 
 --#eval show Lean.MetaM _ from do
 --  let env ← Lean.getEnv
---  return env.find? `Std.DHashMap.Const.toList
+--  let gstt := GroundM.run groundConst (env.find! `Array.mk)
+--  return gstt.
 --
 --#eval show Lean.MetaM _ from do
 --  let env ← Lean.getEnv
@@ -183,11 +184,12 @@ def testRoundtripGetEnv : IO TestSeq := do
   let env <- get_env!
   let gsttStart <- IO.monoNanosNow
   IO.println s!"Ensuring well-groundedness of env"
-  let gstt := GroundM.run env
+  let gstt <- GroundM.env env
   let gsttEnd <- IO.monoNanosNow
   IO.println s!"Finished grounding in {Cronos.nanoToSec (gsttEnd - gsttStart)}"
-  for (n, u) in gstt.ungrounded do
-    IO.println s!"Found ungrounded {n}: {repr u}"
+  IO.println s!"ungrounded {gstt.ungrounded.size}"
+  --for (n, u) in gstt.ungrounded do
+  --  IO.println s!"Found ungrounded {n}: {repr u}"
   let sccStart <- IO.monoNanosNow
   IO.println s!"Building condensation graph of env"
   let alls := CondenseM.run env gstt.outRefs
@@ -247,7 +249,7 @@ def testRoundtripGetEnv : IO TestSeq := do
     inConst := inConst + 1
     dstt := stt
   let allDone <- IO.monoNanosNow
-  IO.println s!"Compiled env in {Cronos.nanoToSec (allDone - allStart)}"
+  --IO.println s!"Compiled env in {Cronos.nanoToSec (allDone - allStart)}"
  -- IO.println s!"decompiling env"
  -- let mut store : Ixon.Store := {}
  -- for (_,(a, b)) in cstt.names do

From e886d17ab792f272c8d40a2958e23e20046f9586 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Thu, 23 Oct 2025 22:55:07 -0400
Subject: [PATCH 61/74] CompileM/DecompileM roundtrip provisionally working up
 to 5% of get_env!

---
 Ix/CompileM.lean      |  64 +++++++++++-----
 Ix/GroundM.lean       | 170 +++++++++++++++++++-----------------------
 Tests/Ix/Compile.lean |  94 +++++++++++------------
 3 files changed, 169 insertions(+), 159 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 47dacb72..ecd38275 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -198,11 +198,11 @@ def storeMeta (meta: Metadata): CompileM Address := do
 def compileName (name: Lean.Name): CompileM Address := do
   match (<- get).nameCache.find? name with
   | some addr =>
-  --dbg_trace "compileName cached {(<- read).current} {addr} {name}"
+    --dbg_trace "compileName cached {(<- read).current} {name}"
     pure addr
   | none => do
+    --dbg_trace "compileName {(<- read).current} {name}"
     let addr <- go name
-  --dbg_trace "compileName {(<- read).current} {addr} {name}"
     modifyGet fun stt => (addr, { stt with
       nameCache := stt.nameCache.insert name addr
     })
@@ -249,9 +249,11 @@ def compareLevel (xctx yctx: List Lean.Name)
 def compileLevel (lvl: Lean.Level): CompileM MetaAddress := do
   let ctx := (<- read).univCtx
   match (<- get).univCache.find? (ctx, lvl) with
-  | some l => pure l
+  | some l => 
+    --dbg_trace "compileLevel cached {(<- get).univCache.size} {(<- read).current}"
+    pure l
   | none => do
-    --dbg_trace "compileLevel go {(<- get).univAddrs.size} {(<- read).current}"
+    --dbg_trace "compileLevel {(<- get).univCache.size} {(<- read).current}"
     let (anon, meta) <- go lvl
     let anonAddr <- storeIxon anon
     let metaAddr <- storeIxon meta
@@ -333,13 +335,18 @@ def compileDataValue : Lean.DataValue -> CompileM Ixon.DataValue
 | .ofSyntax s => .ofSyntax <$> (compileSyntax s >>= storeSerial)
 
 def compileKVMaps (maps: List Lean.KVMap): CompileM Address := do
+  --dbg_trace "compileKVMaps"
   storeIxon (.meta ⟨<- maps.mapM go⟩)
   where
     go (map: Lean.KVMap): CompileM Metadatum := do
     let mut list := #[]
+    --dbg_trace "compileKVMaps go"
     for (name, dataValue) in map do
+      --dbg_trace "compileKVMaps entry {name}"
       let n <- compileName name
+      --dbg_trace "compileKVMaps entry {name} n"
       let d <- compileDataValue dataValue
+      --dbg_trace "compileKVMaps entry {name} d"
       list := list.push (n, d)
     pure <| .kvmap list.toList
 
@@ -385,6 +392,7 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
       match (<- get).exprCache.find? (ctx, expr) with
       | some x => pure x
       | none => do
+        --dbg_trace s!"compileExpr {(<- read).current} {(<- get).exprCache.size}"
         let (anon, meta) <- go kvs expr
         let anonAddr <- storeIxon anon
         let metaAddr <- storeIxon meta
@@ -395,23 +403,26 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
     go (kvs: List Lean.KVMap): Lean.Expr -> CompileM (Ixon × Ixon)
     | (.mdata kv x) => go (kv::kvs) x
     | .bvar idx => do
+      --dbg_trace s!"compileExpr {(<- read).current} bvar"
       let md <- compileKVMaps kvs
       let data := .evar idx
       let meta := .meta ⟨[.link md]⟩
       pure (data, meta)
     | .sort univ => do
+      --dbg_trace s!"compileExpr {(<- read).current} sort"
       let md <- compileKVMaps kvs
       let ⟨udata, umeta⟩ <- compileLevel univ
       let data := .esort udata
       let meta := .meta ⟨[.link md, .link umeta]⟩
       pure (data, meta)
     | .const name lvls => do
+      --dbg_trace s!"compileExpr {(<- read).current} const"
       let md <- compileKVMaps kvs
       let n <- compileName name
       let us <- lvls.mapM compileLevel
       match (← read).mutCtx.find? name with
       | some idx => 
-      --dbg_trace s!"compileExpr {(<- read).current}, const rec {name} {idx}, mutCtx: {repr (<- read).mutCtx}, md {md}, us: {repr us}, n: {n}"
+        --dbg_trace s!"compileExpr {(<- read).current} const rec"
         let data := .erec idx (us.map (·.data))
         let meta := .meta ⟨[.link md, .link n, .links (us.map (·.meta))]⟩
         pure (data, meta)
@@ -419,11 +430,12 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
         let ref <- match (<- get).comms.find? name with
           | some comm => pure comm
           | none => compileConstName name
-      --dbg_trace s!"compileExpr {(<- read).current}, const ref {name}, mutCtx: {repr (<- read).mutCtx}, md {md}, repr {us}, ref {ref}"
+        --dbg_trace s!"compileExpr {(<- read).current}, const ref {name}, mutCtx: {repr (<- read).mutCtx}"
         let data := .eref ref.data (us.map (·.data))
         let meta := .meta ⟨[.link md, .link n, .link ref.meta, .links (us.map (·.meta))]⟩
         pure (data, meta)
     | .app func argm => do
+      --dbg_trace s!"compileExpr {(<- read).current} app"
       let md <- compileKVMaps kvs
       let f <- compileExpr func
       let a <- compileExpr argm
@@ -431,6 +443,7 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
       let meta := .meta ⟨[.link md, .link f.meta, .link a.meta]⟩
       pure (data, meta)
     | .lam name type body info => do
+      --dbg_trace s!"compileExpr {(<- read).current} lam"
       let md <- compileKVMaps kvs
       let n <- compileName name
       let t <- compileExpr type
@@ -439,14 +452,20 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
       let meta := .meta ⟨[.link md, .link n, .info info, .link t.meta, .link b.meta]⟩
       pure (data, meta)
     | .forallE name type body info => do
+      --dbg_trace s!"compileExpr {(<- read).current} all"
       let md <- compileKVMaps kvs
+      --dbg_trace s!"compileExpr {(<- read).current} all md"
       let n <- compileName name
+      --dbg_trace s!"compileExpr {(<- read).current} all n"
       let t <- compileExpr type
+      --dbg_trace s!"compileExpr {(<- read).current} all t"
       let b <- compileExpr body
+      --dbg_trace s!"compileExpr {(<- read).current} all b"
       let data := .eall t.data b.data
       let meta := .meta ⟨[.link md, .link n, .info info, .link t.meta, .link b.meta]⟩
       pure (data, meta)
     | .letE name type value body nD => do
+      --dbg_trace s!"compileExpr {(<- read).current} let"
       let md <- compileKVMaps kvs
       let n <- compileName name
       let t <- compileExpr type
@@ -456,12 +475,15 @@ partial def compileExpr: Lean.Expr -> CompileM MetaAddress
       let meta := .meta ⟨[.link md, .link n, .link t.meta, .link v.meta, .link b.meta]⟩
       pure (data, meta)
     | .lit (.natVal n) => do
+      --dbg_trace s!"compileExpr {(<- read).current} lit nat"
       let md <- compileKVMaps kvs
       pure (.enat (<- storeNat n), .meta ⟨[.link md]⟩)
     | .lit (.strVal s) => do
+      --dbg_trace s!"compileExpr {(<- read).current} lit str"
       let md <- compileKVMaps kvs
       pure (.estr (<- storeString s), .meta ⟨[.link md]⟩)
     | .proj typeName idx struct => do
+      --dbg_trace s!"compileExpr {(<- read).current} lit proj"
       let md <- compileKVMaps kvs
       let t <- match (<- get).comms.find? typeName with
         | some comm => pure comm
@@ -478,13 +500,13 @@ partial def compileConstName (name: Lean.Name): CompileM MetaAddress := do
   match (<- get).constCache.find? name with
   | some x => pure x
   | none => do
+    --dbg_trace "compileConstName {name}"
     let (anon, meta) <- do
       if name == Lean.Name.mkSimple "_obj" then pure (.prim .obj, .meta ⟨[]⟩)
       else if name == Lean.Name.mkSimple "_neutral" then pure (.prim .neutral, .meta ⟨[]⟩)
       else if name == Lean.Name.mkSimple "_unreachable" then pure (.prim .unreachable, .meta ⟨[]⟩)
       else do findLeanConst name >>= compileConstant
     --let stt <- get
-    --dbg_trace "✓ compileConst {const.name}"
     --dbg_trace "store {stt.store.size}"
     --dbg_trace "constCache {stt.constCache.size}"
     --dbg_trace "exprCache {stt.exprCache.size}"
@@ -498,7 +520,7 @@ partial def compileConstName (name: Lean.Name): CompileM MetaAddress := do
     })
 partial def compileConstant : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
 | c => do
---dbg_trace "compileConstant {c.name}"
+  dbg_trace "compileConstant {c.name}"
   .resetCtx c.name <| compileConstant' c
 
 partial def compileConstant' : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
@@ -533,6 +555,7 @@ partial def compileConstant' : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
 
 partial def compileDefn: Ix.Def -> CompileM (Ixon.Definition × Ixon.Metadata)
 | d => .withLevels d.levelParams do
+  --dbg_trace "compileDefn"
   let n <- compileName d.name
   let ls <- d.levelParams.mapM compileName
   let t <- compileExpr d.type
@@ -544,13 +567,14 @@ partial def compileDefn: Ix.Def -> CompileM (Ixon.Definition × Ixon.Metadata)
 
 partial def compileRule: Lean.RecursorRule -> CompileM (Ixon.RecursorRule × (Address × Address))
 | r => do
+  --dbg_trace "compileRule"
   let n <- compileName r.ctor
   let rhs <- compileExpr r.rhs
   pure (⟨r.nfields, rhs.data⟩, (n, rhs.meta))
 
 partial def compileRecr: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata)
 | r => .withLevels r.levelParams <| do
---dbg_trace s!"compileRecr {(<- read).current} {repr <| r.name} mutCtx: {repr (<- read).mutCtx}"
+  --dbg_trace s!"compileRecr {(<- read).current} {repr <| r.name} mutCtx: {repr (<- read).mutCtx}"
   let n <- compileName r.name
   let ls <- r.levelParams.mapM compileName
   let t <- compileExpr r.type
@@ -564,6 +588,7 @@ partial def compileRecr: Lean.RecursorVal -> CompileM (Ixon.Recursor × Metadata
 partial def compileConstructor (induct: Address)
 : Lean.ConstructorVal -> CompileM (Ixon.Constructor × Metadata)
 | c => .withLevels c.levelParams <| do
+  --dbg_trace s!"compileCtor {(<- read).current} {repr <| c.name} mutCtx: {repr (<- read).mutCtx}"
   let n <- compileName c.name
   let ls <- c.levelParams.mapM compileName
   let t <- compileExpr c.type
@@ -574,6 +599,7 @@ partial def compileConstructor (induct: Address)
 partial def compileIndc: Ix.Ind -> CompileM (Ixon.Inductive × Map Address Address)
 | ⟨name, lvls, type, ps, is, all, ctors, nest, rcr, refl, usafe⟩ =>
   .withLevels lvls do 
+  --dbg_trace s!"compileIndc {(<- read).current} {repr <| name} mutCtx: {repr (<- read).mutCtx}"
   let n <- compileName name
   let ls <- lvls.mapM compileName
   let t <- compileExpr type
@@ -596,7 +622,7 @@ partial def compileIndc: Ix.Ind -> CompileM (Ixon.Inductive × Map Address Addre
 
 partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
 | const => do
---dbg_trace s!"compileMutual {const.name}"
+  --dbg_trace s!"compileMutual {const.name}"
   let all: Set Lean.Name <- getAll const.name
 --dbg_trace s!"compileMutual {const.name} all: {repr all}"
   if all == {const.name} &&
@@ -619,12 +645,12 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
       | .thmInfo val => consts := consts.push (MutConst.mkTheo val)
       | .recInfo val => consts := consts.push (MutConst.recr val)
       | _ => continue
-  --dbg_trace s!"compileMutual {const.name} consts: {repr <| consts.map (·.name)}"
+    --dbg_trace s!"compileMutual {const.name} consts: {repr <| consts.map (·.name)}"
     -- sort MutConsts into equivalence classes
     let mutConsts <- sortConsts consts.toList
-  --dbg_trace s!"compileMutual {const.name} mutConsts: {repr <| mutConsts.map (·.map (·.name))}"
+    --dbg_trace s!"compileMutual {const.name} mutConsts: {repr <| mutConsts.map (·.map (·.name))}"
     let mutCtx := MutConst.ctx mutConsts
-  --dbg_trace s!"compileMutual {const.name} mutCtx: {repr mutCtx}"
+    --dbg_trace s!"compileMutual {const.name} mutCtx: {repr mutCtx}"
     let mutMeta <- mutConsts.mapM fun m => m.mapM <| fun c => compileName c.name
     -- compile each constant with the mutCtx
     let (data, metas) <- .withMutCtx mutCtx (compileMutConsts mutConsts)
@@ -635,7 +661,6 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
     modify fun stt => { stt with blocks := stt.blocks.insert block () }
     -- then add all projections, returning the inductive we started with
     let mut ret? : Option (Ixon × Ixon) := none
-    --let mut projCtx := mkProjCtx mutConsts
     for const' in consts do
       let idx <- do match mutCtx.find? const'.name with
       | some idx => pure idx
@@ -671,7 +696,7 @@ partial def compileMutual : MutConst -> CompileM (Ixon × Ixon)
 partial def compileMutConsts: List (List MutConst)
   -> CompileM (Ixon × Map Address Address)
 | classes => do
---dbg_trace s!"compileMutConsts {(<- read).current} {repr <| classes.map (·.map (·.name))} mutCtx: {repr (<- read).mutCtx}"
+  --dbg_trace s!"compileMutConsts {(<- read).current} {repr <| classes.map (·.map (·.name))} mutCtx: {repr (<- read).mutCtx}"
   let mut data := #[]
   let mut meta := {}
   -- iterate through each equivalence class
@@ -734,6 +759,7 @@ partial def sortConsts (classes: List MutConst) : CompileM (List (List MutConst)
 /-- AST comparison of two Lean definitions. --/
 partial def compareConst (ctx: MutCtx) (x y: MutConst)
   : CompileM Ordering := do
+  --dbg_trace "compareConst"
   let key := match compare x.name y.name with
     | .lt => (x.name, y.name)
     | _ => (y.name, x.name)
@@ -800,7 +826,9 @@ partial def eqConst (ctx: MutCtx) (x y: MutConst) : CompileM Bool :=
 
 /-- A name-irrelevant ordering of Lean expressions --/
 partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
-  : Lean.Expr → Lean.Expr → CompileM SOrder
+  (x y: Lean.Expr): CompileM SOrder := do
+  --dbg_trace "compareExpr"
+  match x, y with
   | e@(.mvar ..), _ => throw $ .exprMetavariable e
   | _, e@(.mvar ..) => throw $ .exprMetavariable e
   | e@(.fvar ..), _ => throw $ .exprFreeVariable e
@@ -824,7 +852,7 @@ partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
     | none, none =>
       if x == y then return ⟨true, .eq⟩
       else do
-      --dbg_trace s!"compareExpr const {(<- read).current} consts {x} {y}"
+        --dbg_trace s!"compareExpr const {(<- read).current} consts {x} {y}"
         let x' <- compileConstName x
         let y' <- compileConstName y
         return ⟨true, compare x' y'⟩
@@ -863,7 +891,7 @@ partial def compareExpr (ctx: MutCtx) (xlvls ylvls: List Lean.Name)
     | none, none =>
       if tnx == tny then return ⟨true, .eq⟩
       else do
-      --dbg_trace s!"compareExpr proj {(<- read).current} consts {tnx} {tny}"
+        --dbg_trace s!"compareExpr proj {(<- read).current} consts {tnx} {tny}"
         let x' <- compileConstName tnx
         let y' <- compileConstName tny
         return ⟨true, compare x' y'⟩
diff --git a/Ix/GroundM.lean b/Ix/GroundM.lean
index 737913fc..8ea29348 100644
--- a/Ix/GroundM.lean
+++ b/Ix/GroundM.lean
@@ -19,29 +19,18 @@ inductive GroundError where
 | indc (i: Lean.InductiveVal) (c: Option Lean.ConstantInfo)
 deriving Inhabited, Repr, BEq, Hashable
 
-inductive Grounding where
-| grounded
-| ungrounded (xs: Set GroundError)
-deriving Inhabited, Repr
-
-def Grounding.add : Grounding -> Grounding -> Grounding
-| .grounded, .grounded => .grounded
-| .grounded, x => x
-| x, .grounded => x
-| .ungrounded xs, .ungrounded ys => .ungrounded (.union xs ys)
-
 structure GroundState where
   exprRefs: Map Lean.Expr (Set Lean.Name)
   outRefs : Map Lean.Name (Set Lean.Name)
   inRefs: Map Lean.Name (Set Lean.Name)
-  ungrounded: Map Lean.Name Grounding
-  constCache : Map Lean.Name Grounding
-  exprCache : Map (List Lean.Name × List Lean.Name × Lean.Expr) Grounding
-  univCache : Map (List Lean.Name × Lean.Level) Grounding
+  ungrounded: Map Lean.Name GroundError
+  constCache : Map Lean.Name (Set Lean.Name)
+  exprCache : Map (List Lean.Name × List Lean.Name × Lean.Expr) (Set Lean.Name)
+  univCache : Set (List Lean.Name × Lean.Level)
 
 def GroundState.init : GroundState := ⟨{}, {}, {}, {}, {}, {}, {}⟩
 
-abbrev GroundM := ReaderT GroundEnv <| StateT GroundState IO
+abbrev GroundM := ReaderT GroundEnv <| ExceptT GroundError <|  StateT GroundState IO
 
 def GroundM.withCurrent (name: Lean.Name) : GroundM α -> GroundM α :=
   withReader $ fun c => { c with current := name }
@@ -54,27 +43,27 @@ def GroundM.withBinder (name: Lean.Name) : GroundM α -> GroundM α :=
 def GroundM.withLevels (lvls : List Lean.Name) : GroundM α -> GroundM α :=
   withReader $ fun c => { c with univCtx := lvls }
 
-def groundLevel (lvl: Lean.Level) : GroundM Grounding := do
+def groundLevel (lvl: Lean.Level) : GroundM Unit := do
   let ctx := (<- read).univCtx
-  match (<- get).univCache.find? (ctx, lvl) with
-  | some l => pure l
-  | none => do
-    let grounding <- go lvl
-    modifyGet fun stt => (grounding, { stt with
-      univCache := stt.univCache.insert (ctx, lvl) grounding
-    })
+  match (<- get).univCache.contains (ctx, lvl) with
+  | true => pure ()
+  | false => do
+    let _ <- go lvl
+    modify fun stt => { stt with
+      univCache := stt.univCache.insert (ctx, lvl)
+    }
   where
-    go : Lean.Level -> GroundM Grounding
-    | .zero => pure .grounded
+    go : Lean.Level -> GroundM Unit
+    | .zero => pure ()
     | .succ x => groundLevel x
-    | .max x y => .add <$> groundLevel x <*> groundLevel y
-    | .imax x y => .add <$> groundLevel x <*> groundLevel y
+    | .max x y => groundLevel x *> groundLevel y
+    | .imax x y => groundLevel x *> groundLevel y
     | .param n => do
       let lvls := (<- read).univCtx
       match lvls.idxOf? n with
-      | some _ => pure .grounded
-      | none   => pure <| .ungrounded {.level (.param n) lvls}
-    | l@(.mvar ..) => do pure <| .ungrounded {.level l (<- read).univCtx}
+      | some _ => pure ()
+      | none   => throw <| .level (.param n) lvls
+    | l@(.mvar ..) => do throw <| .level l (<- read).univCtx
 
 def addRef (current out: Lean.Name) : GroundM Unit := do
   modify fun stt => { stt with 
@@ -86,108 +75,103 @@ def addRef (current out: Lean.Name) : GroundM Unit := do
       | .none => .some {current}
   }
 
-mutual
-def groundExpr (expr: Lean.Expr) : GroundM Grounding := do
+def groundExpr (expr: Lean.Expr) : GroundM (Set Lean.Name) := do
   let key := ((<- read).univCtx, (<- read).bindCtx, expr)
   match (<- get).exprCache.find? key with
-  | some l => pure l
+  | some x => pure x
   | none => do
-    let grounding <- go expr
-    modifyGet fun stt => (grounding, { stt with
-      exprCache := stt.exprCache.insert key grounding
+    let refs <- go expr
+    modifyGet fun stt => (refs, { stt with
+      exprCache := stt.exprCache.insert key refs
     })
   where
-    go : Lean.Expr -> GroundM Grounding
+    go : Lean.Expr -> GroundM (Set Lean.Name)
     | .mdata _ x => groundExpr x
     | .bvar idx => do
       let ctx := (<- read).bindCtx
       match ctx[idx]? with
-      | .some _ => pure .grounded
-      | .none => pure <| .ungrounded {.var (.bvar idx) ctx}
-    | .sort lvl => groundLevel lvl
+      | .some _ => pure {}
+      | .none => throw <| .var (.bvar idx) ctx
+    | .sort lvl => groundLevel lvl *> pure {}
     | .const name lvls => do
-      let ls <- lvls.foldrM (fun l g => .add g <$> groundLevel l) .grounded
+      lvls.forM groundLevel
       match (<- read).env.constants.find? name with
-      | .some _ => addRef (<- read).current name *> pure ls
+      | .some _ => pure {name}
       | .none =>
         if name == .mkSimple "_obj"
         || name == .mkSimple "_neutral"
         || name == .mkSimple "_unreachable"
-        then pure <| .grounded
-        else pure <| .add ls (.ungrounded {.ref name})
-    | .app f a => .add <$> groundExpr f <*> groundExpr a
-    | .lam n t b _ => .add <$> groundExpr t <*> .withBinder n (groundExpr b)
-    | .forallE n t b _ => .add <$> groundExpr t <*> .withBinder n (groundExpr b)
+        then pure <| {name}
+        else throw <| .ref name
+    | .app f a => .union <$> groundExpr f <*> groundExpr a
+    | .lam n t b _ => .union <$> groundExpr t <*> .withBinder n (groundExpr b)
+    | .forallE n t b _ => .union <$> groundExpr t <*> .withBinder n (groundExpr b)
     | .letE n t v b _ => do
       let t' <- groundExpr t
       let v' <- groundExpr v
       let b' <- .withBinder n (groundExpr b)
-      pure (.add t' (.add v' b'))
+      pure (.union t' (.union v' b'))
     | .proj typeName _ s => do
       let s' <- groundExpr s
       match (<- read).env.constants.find? typeName with
       | .some _ => addRef (<- read).current typeName *> pure s'
-      | .none => pure <| .add s' (.ungrounded {.ref typeName})
-    | .lit _ => pure .grounded
-    | x@(.mvar _) => pure <| .ungrounded {.mvar x}
-    | x@(.fvar _) => do pure <| .ungrounded {.var x (<- read).bindCtx}
+      | .none => throw (.ref typeName)
+    | .lit _ => pure {}
+    | x@(.mvar _) => throw <| .mvar x
+    | x@(.fvar _) => do throw <| .var x (<- read).bindCtx
 
-def groundConst (const: Lean.ConstantInfo) : GroundM Grounding := do
+def groundConst (const: Lean.ConstantInfo) : GroundM (Set Lean.Name) := do
   match (<- get).constCache.find? const.name with
-  | some g => pure g
+  | some x => pure x
   | none => do
-    let grounding <- .withCurrent const.name <| go const
-    modifyGet fun stt => (grounding, { stt with
-      constCache := stt.constCache.insert const.name grounding
+    let refs <- .withCurrent const.name <| go const
+    modifyGet fun stt => (refs, { stt with
+      constCache := stt.constCache.insert const.name refs
     })
   where
-    go : Lean.ConstantInfo -> GroundM Grounding
+    go : Lean.ConstantInfo -> GroundM (Set Lean.Name)
     | .axiomInfo val => .withLevels val.levelParams <| groundExpr val.type
     | .defnInfo val => .withLevels val.levelParams <|
-      .add <$> groundExpr val.type <*> groundExpr val.value
+      .union <$> groundExpr val.type <*> groundExpr val.value
     | .thmInfo val => .withLevels val.levelParams <|
-      .add <$> groundExpr val.type <*> groundExpr val.value
+      .union <$> groundExpr val.type <*> groundExpr val.value
     | .opaqueInfo val => .withLevels val.levelParams <|
-      .add <$> groundExpr val.type <*> groundExpr val.value
+      .union <$> groundExpr val.type <*> groundExpr val.value
     | .quotInfo val => .withLevels val.levelParams <| groundExpr val.type
     | .inductInfo val => .withLevels val.levelParams <| do
       let env := (<- read).env.constants
-      let mut ctors := .grounded
+      let mut ctors := {}
       for ctor in val.ctors do
-        let g <- match env.find? ctor with
-        | .some (.ctorInfo ctorVal) => .withLevels ctorVal.levelParams <| do
-          addRef val.name ctor *> groundExpr ctorVal.type
-        | c => pure <| .ungrounded {.indc val c}
-        ctors := .add ctors g
+        let crefs <- match env.find? ctor with
+        | .some (.ctorInfo ctorVal) => 
+          .withLevels ctorVal.levelParams <| groundExpr ctorVal.type
+        | c => throw <| .indc val c
+        ctors := ctors.union crefs
       let type <- groundExpr val.type
-      return .add ctors type
+      return .union ctors type
     | .ctorInfo val => .withLevels val.levelParams <| groundExpr val.type
     | .recInfo val => .withLevels val.levelParams <| do
       let t <- groundExpr val.type
-      let rs <- val.rules.foldrM (fun r s => .add s <$> groundExpr r.rhs) .grounded
-      return .add t rs
-end
+      let rs <- val.rules.foldrM (fun r s => .union s <$> groundExpr r.rhs) {}
+      return .union t rs
 
 def groundEnv: GroundM Unit := do
   let mut stack := #[]
   for (n, c) in (<- read).env.constants do
-    --dbg_trace s!"groundEnv {n}"
-    modify fun stt => { stt with
-      outRefs := stt.outRefs.alter n fun x => match x with
-      | .none => .some {}
-      | x => x
-      inRefs := stt.inRefs.alter n fun x => match x with
-      | .none => .some {}
-      | x => x
-    }
-    match (<- groundConst c) with
-    | .grounded => continue
-    | u@(.ungrounded _) => 
-      dbg_trace s!"groundEnv UNGROUNDED {n} {repr u}"
+    let refs <- observing (groundConst c)
+    match refs with
+    | .error e => do
       stack := stack.push n
       modify fun stt => { stt with
-        ungrounded := stt.ungrounded.insert n u
+        ungrounded := stt.ungrounded.insert n e
+        outRefs := stt.outRefs.alter n fun x => match x with
+          | .some rs => .some rs
+          | .none => .some {}
+        inRefs := stt.inRefs.alter n fun x => match x with
+          | .some rs => .some rs
+          | .none => .some {}
       }
+    | .ok refs => refs.toList.forM (fun r => addRef n r)
   while !stack.isEmpty do
     let name := stack.back!
     --dbg_trace s!"groundEnv stack {name}"
@@ -196,20 +180,18 @@ def groundEnv: GroundM Unit := do
     | .some x => x
     | .none => {}
     for ref in inRefs do
-      dbg_trace s!"groundEnv STACK {name} {ref}"
+      --dbg_trace s!"groundEnv STACK {name} {ref}"
       match (<- get).ungrounded.get? ref with
-      | .some u =>
-        modify fun stt => { stt with
-          ungrounded := stt.ungrounded.insert ref (.add (.ungrounded {.ref name}) u)
-        }
+      | .some _ => continue
       | .none => do
         stack := stack.push ref
         modify fun stt => { stt with
-          ungrounded := stt.ungrounded.insert ref (.ungrounded {.ref name})
+          ungrounded := stt.ungrounded.insert ref (.ref name)
         }
 
-def GroundM.run (env: Lean.Environment) (g: GroundM α): IO (α × GroundState)
-  := (StateT.run (ReaderT.run g (.init env)) GroundState.init)
+def GroundM.run (env: Lean.Environment) (g: GroundM α)
+  : IO (Except GroundError α × GroundState)
+  := (StateT.run (ExceptT.run (ReaderT.run g (GroundEnv.init env))) GroundState.init)
 
 def GroundM.env (env: Lean.Environment) : IO GroundState := do
   let (_, stt) <- (GroundM.run env groundEnv)
diff --git a/Tests/Ix/Compile.lean b/Tests/Ix/Compile.lean
index 8a9be87b..5f8d2fcb 100644
--- a/Tests/Ix/Compile.lean
+++ b/Tests/Ix/Compile.lean
@@ -188,14 +188,13 @@ def testRoundtripGetEnv : IO TestSeq := do
   let gsttEnd <- IO.monoNanosNow
   IO.println s!"Finished grounding in {Cronos.nanoToSec (gsttEnd - gsttStart)}"
   IO.println s!"ungrounded {gstt.ungrounded.size}"
-  --for (n, u) in gstt.ungrounded do
-  --  IO.println s!"Found ungrounded {n}: {repr u}"
   let sccStart <- IO.monoNanosNow
   IO.println s!"Building condensation graph of env"
   let alls := CondenseM.run env gstt.outRefs
   let sccEnd <- IO.monoNanosNow
   IO.println s!"Condensation graph in {Cronos.nanoToSec (sccEnd - sccStart)}"
-  let numConst := env.constants.map₁.size + env.constants.map₂.stats.numNodes
+  let numConst := 
+    env.constants.map₁.size + env.constants.map₂.stats.numNodes - gstt.ungrounded.size
   let mut cstt : CompileState := .init env alls 0
   let mut dstt : DecompileState := default
   IO.println s!"Compiling env"
@@ -204,52 +203,53 @@ def testRoundtripGetEnv : IO TestSeq := do
   for (name, _) in env.constants do
     match gstt.ungrounded.get? name with
     | .some u => do
-      IO.println s!"Skipping ungrounded {name} becase {repr u}"
+      IO.println s!"Skipping ungrounded {name} because {repr u}"
       inConst := inConst + 1
     | none => do
-    let start <- IO.monoNanosNow
-    let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
-    | (.ok a, stt) => pure (a, stt)
-    | (.error e, _) => do
-      IO.println s!"failed {name}"
-      throw (IO.userError (<- e.pretty))
-    let done <- IO.monoNanosNow
-    let pct := ((Float.ofNat inConst) / Float.ofNat numConst)
-    let total := done - allStart
-    IO.println s!"-> Compiled {pct * 100}%, {inConst}/{numConst},
-    Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec total},
-    Remaining {((Cronos.nanoToSec total) / pct) / 60} min
-    {name}
-    {addr}"
-    cstt := stt
-    let denv := DecompileEnv.init cstt.constCache cstt.store
-    let (name', stt) <- match DecompileM.run denv dstt (decompileNamedConst name addr) with
-    | .ok (n,_) stt => pure (n, stt)
-    | .error e _ => do
-      IO.println s!"failed {name}"
-      IO.println s!"cstt all: {repr <| cstt.alls.get? name}"
-      --let c := env.constants.find? name
-      --IO.println s!"{repr c}"
-      throw (IO.userError e.pretty)
-    match env.constants.find? name, stt.constants.find? name' with
-    | .some c, .some c' => if c == c then pure () else do
-        IO.println s!"failed {name} {repr c} {repr c'}"
-        throw (IO.userError "decompiled constant not equal")
-    | .some _, .none => do
-      throw (IO.userError s!"{name'} not found in dstt")
-    | .none, _ => do
-      throw (IO.userError "{name} not found in env")
-    let done2 <- IO.monoNanosNow
-    let total2 := done2 - allStart
-    IO.println s!"<- Decompiled {pct * 100}%, {inConst}/{numConst},
-    Elapsed {Cronos.nanoToSec (done2 - done)}/{Cronos.nanoToSec total},
-    Remaining {((Cronos.nanoToSec total2) / pct) / 60} min
-    {name}
-    {addr}"
-    inConst := inConst + 1
-    dstt := stt
-  let allDone <- IO.monoNanosNow
-  --IO.println s!"Compiled env in {Cronos.nanoToSec (allDone - allStart)}"
+      IO.println s!"Compiling {name} {inConst}/{numConst}"
+      let start <- IO.monoNanosNow
+      let (addr, stt) <- do match (<- (compileConstName name).run .init cstt) with
+      | (.ok a, stt) => pure (a, stt)
+      | (.error e, _) => do
+        IO.println s!"failed {name}"
+        throw (IO.userError (<- e.pretty))
+      let done <- IO.monoNanosNow
+      let pct := ((Float.ofNat inConst) / Float.ofNat numConst)
+      let total := done - allStart
+      IO.println s!"-> Compiled {pct * 100}%, {inConst}/{numConst},
+      Elapsed {Cronos.nanoToSec (done - start)}/{Cronos.nanoToSec total},
+      Remaining {((Cronos.nanoToSec total) / pct) / 60} min
+      {name}
+      {addr}"
+      cstt := stt
+      let denv := DecompileEnv.init cstt.constCache cstt.store
+      let (name', stt) <- match DecompileM.run denv dstt (decompileNamedConst name addr) with
+      | .ok (n,_) stt => pure (n, stt)
+      | .error e _ => do
+        IO.println s!"failed {name}"
+        IO.println s!"cstt all: {repr <| cstt.alls.get? name}"
+        --let c := env.constants.find? name
+        --IO.println s!"{repr c}"
+        throw (IO.userError e.pretty)
+      match env.constants.find? name, stt.constants.find? name' with
+      | .some c, .some c' => if c == c then pure () else do
+          IO.println s!"failed {name} {repr c} {repr c'}"
+          throw (IO.userError "decompiled constant not equal")
+      | .some _, .none => do
+        throw (IO.userError s!"{name'} not found in dstt")
+      | .none, _ => do
+        throw (IO.userError "{name} not found in env")
+      let done2 <- IO.monoNanosNow
+      let total2 := done2 - allStart
+      IO.println s!"<- Decompiled {pct * 100}%, {inConst}/{numConst},
+      Elapsed {Cronos.nanoToSec (done2 - done)}/{Cronos.nanoToSec total},
+      Remaining {((Cronos.nanoToSec total2) / pct) / 60} min
+      {name}
+      {addr}"
+      inConst := inConst + 1
+      dstt := stt
+    --let allDone <- IO.monoNanosNow
+    --IO.println s!"Compiled/decompiled {name} in {Cronos.nanoToSec (allDone - allStart)}"
  -- IO.println s!"decompiling env"
  -- let mut store : Ixon.Store := {}
  -- for (_,(a, b)) in cstt.names do

From e8d9b6ea8a313e0ae06c192febd5cbdfac137c48 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Fri, 24 Oct 2025 13:04:23 -0400
Subject: [PATCH 62/74] wip

---
 Ix/CompileM.lean |  2 +-
 Ix/GroundM.lean  | 62 ++++++++++++++++++++----------------------------
 2 files changed, 27 insertions(+), 37 deletions(-)

diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index ecd38275..fbb391e3 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -520,7 +520,7 @@ partial def compileConstName (name: Lean.Name): CompileM MetaAddress := do
     })
 partial def compileConstant : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
 | c => do
-  dbg_trace "compileConstant {c.name}"
+  --dbg_trace "compileConstant {c.name}"
   .resetCtx c.name <| compileConstant' c
 
 partial def compileConstant' : Lean.ConstantInfo -> CompileM (Ixon × Ixon)
diff --git a/Ix/GroundM.lean b/Ix/GroundM.lean
index 8ea29348..558f9880 100644
--- a/Ix/GroundM.lean
+++ b/Ix/GroundM.lean
@@ -24,11 +24,10 @@ structure GroundState where
   outRefs : Map Lean.Name (Set Lean.Name)
   inRefs: Map Lean.Name (Set Lean.Name)
   ungrounded: Map Lean.Name GroundError
-  constCache : Map Lean.Name (Set Lean.Name)
   exprCache : Map (List Lean.Name × List Lean.Name × Lean.Expr) (Set Lean.Name)
   univCache : Set (List Lean.Name × Lean.Level)
 
-def GroundState.init : GroundState := ⟨{}, {}, {}, {}, {}, {}, {}⟩
+def GroundState.init : GroundState := ⟨{}, {}, {}, {}, {}, {}⟩
 
 abbrev GroundM := ReaderT GroundEnv <| ExceptT GroundError <|  StateT GroundState IO
 
@@ -120,40 +119,31 @@ def groundExpr (expr: Lean.Expr) : GroundM (Set Lean.Name) := do
     | x@(.mvar _) => throw <| .mvar x
     | x@(.fvar _) => do throw <| .var x (<- read).bindCtx
 
-def groundConst (const: Lean.ConstantInfo) : GroundM (Set Lean.Name) := do
-  match (<- get).constCache.find? const.name with
-  | some x => pure x
-  | none => do
-    let refs <- .withCurrent const.name <| go const
-    modifyGet fun stt => (refs, { stt with
-      constCache := stt.constCache.insert const.name refs
-    })
-  where
-    go : Lean.ConstantInfo -> GroundM (Set Lean.Name)
-    | .axiomInfo val => .withLevels val.levelParams <| groundExpr val.type
-    | .defnInfo val => .withLevels val.levelParams <|
-      .union <$> groundExpr val.type <*> groundExpr val.value
-    | .thmInfo val => .withLevels val.levelParams <|
-      .union <$> groundExpr val.type <*> groundExpr val.value
-    | .opaqueInfo val => .withLevels val.levelParams <|
-      .union <$> groundExpr val.type <*> groundExpr val.value
-    | .quotInfo val => .withLevels val.levelParams <| groundExpr val.type
-    | .inductInfo val => .withLevels val.levelParams <| do
-      let env := (<- read).env.constants
-      let mut ctors := {}
-      for ctor in val.ctors do
-        let crefs <- match env.find? ctor with
-        | .some (.ctorInfo ctorVal) => 
-          .withLevels ctorVal.levelParams <| groundExpr ctorVal.type
-        | c => throw <| .indc val c
-        ctors := ctors.union crefs
-      let type <- groundExpr val.type
-      return .union ctors type
-    | .ctorInfo val => .withLevels val.levelParams <| groundExpr val.type
-    | .recInfo val => .withLevels val.levelParams <| do
-      let t <- groundExpr val.type
-      let rs <- val.rules.foldrM (fun r s => .union s <$> groundExpr r.rhs) {}
-      return .union t rs
+def groundConst: Lean.ConstantInfo -> GroundM (Set Lean.Name)
+| .axiomInfo val => .withLevels val.levelParams <| groundExpr val.type
+| .defnInfo val => .withLevels val.levelParams <|
+  .union <$> groundExpr val.type <*> groundExpr val.value
+| .thmInfo val => .withLevels val.levelParams <|
+  .union <$> groundExpr val.type <*> groundExpr val.value
+| .opaqueInfo val => .withLevels val.levelParams <|
+  .union <$> groundExpr val.type <*> groundExpr val.value
+| .quotInfo val => .withLevels val.levelParams <| groundExpr val.type
+| .inductInfo val => .withLevels val.levelParams <| do
+  let env := (<- read).env.constants
+  let mut ctors := {}
+  for ctor in val.ctors do
+    let crefs <- match env.find? ctor with
+    | .some (.ctorInfo ctorVal) => 
+      .withLevels ctorVal.levelParams <| groundExpr ctorVal.type
+    | c => throw <| .indc val c
+    ctors := ctors.union crefs
+  let type <- groundExpr val.type
+  return .union ctors type
+| .ctorInfo val => .withLevels val.levelParams <| groundExpr val.type
+| .recInfo val => .withLevels val.levelParams <| do
+  let t <- groundExpr val.type
+  let rs <- val.rules.foldrM (fun r s => .union s <$> groundExpr r.rhs) {}
+  return .union t rs
 
 def groundEnv: GroundM Unit := do
   let mut stack := #[]

From d7405d1a63078772fe273ebb8fceb940b77f533e Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 27 Oct 2025 15:52:32 -0400
Subject: [PATCH 63/74] fixup for comments and clippy

---
 Ix/Common.lean        |   82 --
 Ix/Ixon.lean          |  222 +---
 src/ixon.rs           | 2819 +++++++++++++++++++++--------------------
 src/ixon/claim.rs     |  320 ++---
 src/ixon/constant.rs  | 1031 +++++++--------
 src/ixon/meta.rs      |  404 +++---
 src/ixon/name.rs      |  114 +-
 src/ixon/nat.rs       |   94 +-
 src/ixon/serialize.rs |   46 +-
 src/ixon/univ.rs      |  398 +++---
 src/lean/ffi/ixon.rs  | 1072 ++++++++--------
 src/lib.rs            |   14 +-
 12 files changed, 3171 insertions(+), 3445 deletions(-)

diff --git a/Ix/Common.lean b/Ix/Common.lean
index e7104942..a7c0e222 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -177,88 +177,6 @@ def joinM [Monad μ] : List (List α) → μ (List α)
   | []      => return []
   | a :: as => do return a ++ (← joinM as)
 
--- Combined sort and group operations over (List (List α))
-
--- Merge two sorted lists of groups, combining groups with equal elements
-partial def mergeGroupsM [Monad μ] (cmp : α → α → μ Ordering)
-  : List (List α) → List (List α) → μ (List (List α))
-  | gs@((g@(a::_))::gs'), hs@((h@(b::_))::hs') => do
-    match (← cmp a b) with
-    | Ordering.lt => List.cons g <$> mergeGroupsM cmp gs' hs
-    | Ordering.gt => List.cons h <$> mergeGroupsM cmp gs hs'
-    | Ordering.eq => List.cons (g ++ h) <$> mergeGroupsM cmp gs' hs'  -- Combine equal groups
-  | [], hs => return hs
-  | gs, [] => return gs
-  | _, _ => return []
-
--- Merge pairs of grouped lists
-def mergePairsGroupsM [Monad μ] (cmp: α → α → μ Ordering) 
-  : List (List (List α)) → μ (List (List (List α)))
-  | a::b::xs => List.cons <$> (mergeGroupsM cmp a b) <*> mergePairsGroupsM cmp xs
-  | xs => return xs
-
--- Merge all grouped lists
-partial def mergeAllGroupsM [Monad μ] (cmp: α → α → μ Ordering) 
-  : List (List (List α)) → μ (List (List α))
-  | [] => return []
-  | [x] => return x
-  | xs => mergePairsGroupsM cmp xs >>= mergeAllGroupsM cmp
-
--- Helper to collect equal consecutive elements into a group
-def collectEqualM [Monad μ] (cmp : α → α → μ Ordering) (x : α)
-  : List α → μ (List α × List α)
-  | y::ys => do
-    if (← cmp x y) == Ordering.eq
-    then do
-      let (group, rest) ← collectEqualM cmp x ys
-      return (y::group, rest)
-    else return ([x], y::ys)
-  | [] => return ([x], [])
-
-mutual
-  -- Build sequences of groups (ascending/descending runs with grouping)
-  partial def sequencesGroupedM [Monad μ] (cmp : α → α → μ Ordering)
-    : List α → μ (List (List (List α)))
-    | [] => return []
-    | a::xs => do
-      let (aGroup, rest) ← collectEqualM cmp a xs
-      match rest with
-      | [] => return [[aGroup]]
-      | b::bs => do
-        let (bGroup, rest') ← collectEqualM cmp b bs
-        if (← cmp a b) == .gt
-        then descendingGroupedM cmp b bGroup [aGroup] rest'
-        else ascendingGroupedM cmp b bGroup (fun gs => aGroup :: gs) rest'
-
-  partial def descendingGroupedM [Monad μ]
-    (cmp : α → α → μ Ordering) (rep : α) (curr : List α) (acc : List (List α))
-    : List α → μ (List (List (List α)))
-    | [] => return [curr::acc]
-    | x::xs => do
-      let (xGroup, rest) ← collectEqualM cmp x xs
-      if (← cmp rep x) == .gt
-      then descendingGroupedM cmp x xGroup (curr::acc) rest
-      else List.cons (curr::acc) <$> sequencesGroupedM cmp (x::xs)
-
-  partial def ascendingGroupedM [Monad μ]
-    (cmp : α → α → μ Ordering) (rep : α) (curr : List α)
-    (acc : List (List α) → List (List α))
-    : List α → μ (List (List (List α)))
-    | [] => return [acc [curr]]
-    | x::xs => do
-      let (xGroup, rest) ← collectEqualM cmp x xs
-      if (← cmp rep x) != .gt
-      then ascendingGroupedM cmp x xGroup (fun gs => acc (curr :: gs)) rest
-      else List.cons (acc [curr]) <$> sequencesGroupedM cmp (x::xs)
-end
-
-def sortAndGroupByM [Monad μ] (xs: List α) (cmp: α -> α -> μ Ordering)
-  : μ (List (List α)) :=
-  sequencesGroupedM cmp xs >>= mergeAllGroupsM cmp
-
-def sortGroupsByM [Monad μ] (xs: List (List α)) (cmp: α -> α -> μ Ordering)
-  : μ (List (List α)) := sortAndGroupByM xs.flatten cmp
-
 end List
 
 def Std.HashMap.find? {A B} [BEq A] [Hashable A] (map: Std.HashMap A B) (a: A) 
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 1993aa78..58224b0a 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -842,10 +842,10 @@ inductive Ixon where
 | rprj : RecursorProj -> Ixon                           -- 0xA5, recr projection
 | iprj : InductiveProj -> Ixon                          -- 0xA6, indc projection
 | dprj : DefinitionProj -> Ixon                         -- 0xA7, defn projection
-| muts : List MutConst -> Ixon                          -- 0xBX, mutual inductive types
+| muts : List MutConst -> Ixon                          -- 0xBX, mutual constants
 | prof : Proof -> Ixon                                  -- 0xE0, zero-knowledge proof
-| eval : EvalClaim -> Ixon                              -- 0xE1, cryptographic claim
-| chck : CheckClaim -> Ixon                             -- 0xE2, cryptographic claim
+| eval : EvalClaim -> Ixon                              -- 0xE1, evaluation claim
+| chck : CheckClaim -> Ixon                             -- 0xE2, typechecking claim
 | comm : Comm -> Ixon                                   -- 0xE3, cryptographic commitment
 | envn : Env -> Ixon                                    -- 0xE4, Lean4 environment
 | prim : BuiltIn -> Ixon                                -- 0xE5, compiler builtins
@@ -949,220 +949,4 @@ instance : Serialize Ixon where
 
 def Ixon.address (ixon: Ixon): Address := Address.blake3 (ser ixon)
 
-
---
-----section FFI
-----
-----/--
-----# Ixon FFI types
-----
-----This section defines FFI-friendly versions of the original Ixon datatypes by
-----* Replacing `Nat` by `ByteArray` containing the corresponding bytes in LE
-----* Replacing `List` by `Array`
-----* Replacing maps by `Array`s of pairs
------/
-----
-----@[inline] def nat2Bytes (n : Nat) : ByteArray :=
-----  ⟨natToBytesLE n⟩
-----
-----structure DefinitionFFI where
-----  kind: Ix.DefKind
-----  safety : Lean.DefinitionSafety
-----  lvls : ByteArray
-----  type : Address
-----  value : Address
-----
-----def Definition.toFFI : Definition → DefinitionFFI
-----  | ⟨kind, safety, lvls, type, value⟩ =>
-----    ⟨kind, safety, nat2Bytes lvls, type, value⟩
-----
-----structure AxiomFFI where
-----  lvls : ByteArray
-----  type : Address
-----  isUnsafe: Bool
-----
-----def Axiom.toFFI : Axiom → AxiomFFI
-----  | ⟨isUnsafe, lvls, type⟩ => ⟨nat2Bytes lvls, type, isUnsafe⟩
-----
-----structure QuotientFFI where
-----  lvls : ByteArray
-----  type : Address
-----  kind : Lean.QuotKind
-----
-----def Quotient.toFFI : Quotient → QuotientFFI
-----  | ⟨kind, lvls, type⟩ => ⟨nat2Bytes lvls, type, kind⟩
-----
-----structure ConstructorProjFFI where
-----  block : Address
-----  idx : ByteArray
-----  cidx : ByteArray
-----
-----def ConstructorProj.toFFI : ConstructorProj → ConstructorProjFFI
-----  | ⟨idx, cidx, block⟩ => ⟨block, nat2Bytes idx, nat2Bytes cidx⟩
-----
-----structure RecursorProjFFI where
-----  block : Address
-----  idx : ByteArray
-----  ridx : ByteArray
-----
-----def RecursorProj.toFFI : RecursorProj → RecursorProjFFI
-----  | ⟨idx, ridx, block⟩ => ⟨block, nat2Bytes idx, nat2Bytes ridx⟩
-----
-----structure InductiveProjFFI where
-----  block : Address
-----  idx : ByteArray
-----
-----def InductiveProj.toFFI : InductiveProj → InductiveProjFFI
-----  | ⟨idx, block⟩ => ⟨block, nat2Bytes idx⟩
-----
-----structure DefinitionProjFFI where
-----  block : Address
-----  idx : ByteArray
-----
-----def DefinitionProj.toFFI : DefinitionProj → DefinitionProjFFI
-----  | ⟨idx, block⟩ => ⟨block, nat2Bytes idx⟩
-----
-----structure RecursorRuleFFI where
-----  fields : ByteArray
-----  rhs : Address
-----
-----def RecursorRule.toFFI : RecursorRule → RecursorRuleFFI
-----  | ⟨fields, rhs⟩ => ⟨nat2Bytes fields, rhs⟩
-----
-----structure RecursorFFI where
-----  lvls : ByteArray
-----  type : Address
-----  params : ByteArray
-----  indices : ByteArray
-----  motives : ByteArray
-----  minors : ByteArray
-----  rules : Array RecursorRuleFFI
-----  k : Bool
-----  isUnsafe: Bool
-----
-----def Recursor.toFFI : Recursor → RecursorFFI
-----  | ⟨k, isUnsafe, lvls, params, indices, motives, minors, type, rules⟩ =>
-----    ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
-----      nat2Bytes motives, nat2Bytes minors, rules.toArray.map RecursorRule.toFFI,
-----      k, isUnsafe⟩
-----
-----structure ConstructorFFI where
-----  lvls : ByteArray
-----  type : Address
-----  cidx : ByteArray
-----  params : ByteArray
-----  fields : ByteArray
-----  isUnsafe: Bool
-----
-----def Constructor.toFFI : Constructor → ConstructorFFI
-----  | ⟨isUnsafe, lvls, cidx, params, fields, type⟩ =>
-----    ⟨nat2Bytes lvls, type, nat2Bytes cidx, nat2Bytes params, nat2Bytes fields, isUnsafe⟩
-----
-----structure InductiveFFI where
-----  lvls : ByteArray
-----  type : Address
-----  params : ByteArray
-----  indices : ByteArray
-----  ctors : Array ConstructorFFI
-----  recrs : Array RecursorFFI
-----  nested : ByteArray
-----  recr : Bool
-----  refl : Bool
-----  isUnsafe: Bool
-----
-----def Inductive.toFFI : Inductive → InductiveFFI
-----  | ⟨recr, refl, isUnsafe, lvls, params, indices, nested, type, ctors, recrs⟩ =>
-----    ⟨nat2Bytes lvls, type, nat2Bytes params, nat2Bytes indices,
-----      ctors.toArray.map Constructor.toFFI, recrs.toArray.map Recursor.toFFI,
-----      nat2Bytes nested, recr, refl, isUnsafe⟩
-----
-----inductive NameFFI
-----  | anonymous
-----  | str : NameFFI → String → NameFFI
-----  | num : NameFFI → ByteArray → NameFFI
-----
-----def _root_.Lean.Name.toFFI : Lean.Name → NameFFI
-----  | .anonymous => .anonymous
-----  | .str name s => .str name.toFFI s
-----  | .num name n => .num name.toFFI (nat2Bytes n)
-----
-----inductive MetadatumFFI where
-----| name : NameFFI -> MetadatumFFI
-----| info : Lean.BinderInfo -> MetadatumFFI
-----| link : Address -> MetadatumFFI
-----| hints : Lean.ReducibilityHints -> MetadatumFFI
-----| all : Array NameFFI -> MetadatumFFI
-----| mutCtx : Array (Array NameFFI) -> MetadatumFFI
-----
-----def Metadatum.toFFI : Metadatum → MetadatumFFI
-----  | .name n => .name n.toFFI
-----  | .info i => .info i
-----  | .link addr => .link addr
-----  | .hints h => .hints h
-----  | .all ns => .all (ns.toArray.map Lean.Name.toFFI)
-----  | .mutCtx ctx => .mutCtx $ ctx.toArray.map (·.toArray.map Lean.Name.toFFI)
-----
-----inductive IxonFFI where
-----| vari : UInt64 -> IxonFFI
-----| refr : Address -> Array Univ -> IxonFFI
-----| recr : UInt64 -> Array Univ -> IxonFFI
-----| proj : Address -> UInt64 -> Address -> IxonFFI
-----| sort : Univ -> IxonFFI
-----| strl : Address -> IxonFFI
-----| natl : Address -> IxonFFI
-----| appl : Address -> Address -> IxonFFI
-----| lamb : Address -> Address -> IxonFFI
-----| allE : Address -> Address -> IxonFFI
-----| letE : Address -> Address -> Address -> IxonFFI
-----| letD : Address -> Address -> Address -> IxonFFI
-----| list : Array IxonFFI -> IxonFFI
-----| defn : DefinitionFFI -> IxonFFI
-----| axio : AxiomFFI -> IxonFFI
-----| quot : QuotientFFI -> IxonFFI
-----| cprj : ConstructorProjFFI -> IxonFFI
-----| rprj : RecursorProjFFI -> IxonFFI
-----| iprj : InductiveProjFFI -> IxonFFI
-----| dprj : DefinitionProjFFI -> IxonFFI
-----| inds : Array InductiveFFI -> IxonFFI
-----| defs : Array DefinitionFFI -> IxonFFI
-----| meta : Array (ByteArray × (Array MetadatumFFI)) -> IxonFFI
-----| prof : Proof -> IxonFFI
-----| eval : EvalClaim -> IxonFFI
-----| chck : CheckClaim -> IxonFFI
-----| comm : Comm -> IxonFFI
-----| envn : Array (Address × Address) -> IxonFFI
-----
-----def Ixon.toFFI : Ixon → IxonFFI
-----  | .vari i => .vari i
-----  | .sort u => .sort u
-----  | .refr addr univs => .refr addr univs.toArray
-----  | .recr i us => .recr i us.toArray
-----  | .appl f a => .appl f a
-----  | .lamb t b => .lamb t b
-----  | .allE t b => .allE t b
-----  | .proj addr i x => .proj addr i x
-----  | .strl s => .strl s
-----  | .natl n => .natl n
-----  | .letE v t b => .letE v t b
-----  | .letD v t b => .letD v t b
-----  | .list xs => .list (xs.map Ixon.toFFI).toArray
-----  | .defn d => .defn d.toFFI
-----  | .axio a => .axio a.toFFI
-----  | .quot q => .quot q.toFFI
-----  | .cprj c => .cprj c.toFFI
-----  | .rprj r => .rprj r.toFFI
-----  | .iprj i => .iprj i.toFFI
-----  | .dprj d => .dprj d.toFFI
-----  | .inds is => .inds (is.map Inductive.toFFI).toArray
-----  | .defs d => .defs (d.map Definition.toFFI).toArray
-----  | .meta ⟨map⟩ => .meta $ map.toArray.map
-----      fun (x, y) => (nat2Bytes x, y.toArray.map Metadatum.toFFI)
-----  | .prof p => .prof p
-----  | .eval x => .eval x
-----  | .chck x => .chck x
-----  | .comm x => .comm x
-----  | .envn x => .envn x.env.toArray
-----
-----end FFI
---
 end Ixon
diff --git a/src/ixon.rs b/src/ixon.rs
index 15e0d96b..2c770217 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -1,4 +1,4 @@
-use num_bigint::BigUint;
+//use num_bigint::BigUint;
 
 pub mod address;
 pub mod claim;
@@ -13,45 +13,56 @@ use address::*;
 use claim::*;
 use constant::*;
 use meta::*;
-use name::*;
+//use name::*;
 use nat::*;
-use serialize::*;
-use univ::*;
+//use serialize::*;
+//use univ::*;
+
+// TODO: Update Ixon
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Ixon {
-    Vari(u64),                                   // 0x0X, variables
-    Sort(Box<Univ>),                             // 0x90, universes
-    Refr(Address, Vec<Univ>),                    // 0x1X, global reference
-    Recr(u64, Vec<Univ>),                        // 0x2X, local const recursion
-    Apps(Box<Ixon>, Box<Ixon>, Vec<Ixon>),       // 0x3X, applications
-    Lams(Vec<Ixon>, Box<Ixon>),                  // 0x4X, lambdas
-    Alls(Vec<Ixon>, Box<Ixon>),                  // 0x5X, foralls
-    Proj(Address, u64, Box<Ixon>),               // 0x6X, structure projection
-    Strl(String),                                // 0x7X, unicode string
-    Natl(Nat),                                   // 0x8X, natural numbers
-    LetE(bool, Box<Ixon>, Box<Ixon>, Box<Ixon>), // 0x91, 0x92, local binder
-    List(Vec<Ixon>),                             // 0xA, list
-    Defn(Definition),                            // 0xB0, definition
-    Axio(Axiom),                                 // 0xB1, axiom
-    Quot(Quotient),                              // 0xB2, quotient
-    CPrj(ConstructorProj),                       // 0xB3, constructor projection
-    RPrj(RecursorProj),                          // 0xB4, recursor projection
-    IPrj(InductiveProj),                         // 0xB5, inductive projection
-    DPrj(DefinitionProj),                        // 0xB6, definition projection
-    Inds(Vec<Inductive>),                        // 0xCX, mutual inductive data
-    Defs(Vec<Definition>),                       // 0xDX, mutual definition
-    Meta(Metadata),                              // 0xE0, metadata
-    Prof(Proof),                                 // 0xE1, zero-knowledge proof
-    Eval(EvalClaim),                             // 0xE2, evaluation claim
-    Chck(CheckClaim),                            // 0xE3, typechecking claim
-    Comm(Comm),                                  // 0xE4, cryptographic commitment
-    Envn(Env),                                   // 0xE5, multi-claim environment
+    NAnon,                                 // 0x00, anonymous name
+    NStr(Address, Address),                // 0x01, string name
+    NNum(Address, Address),                // 0x02, number name
+    UZero,                                 // 0x03, universe zero
+    USucc(Address),                        // 0x04, universe successor
+    UMax(Address, Address),                // 0x05, universe max
+    UIMax(Address, Address),               // 0x06, universe impredicative max
+    UVar(Nat),                             // 0x1X, universe variable
+    EVar(Nat),                             // 0x2X, expression variable
+    ERef(Address, Vec<Address>),           // 0x3X, expression reference
+    ERec(Nat, Vec<Address>),               // 0x4X, expression recursion
+    EPrj(Address, Nat, Address),           // 0x5X, expression projection
+    ESort(Address),                        // 0x80, expression sort
+    EStr(Address),                         // 0x81, expression string
+    ENat(Address),                         // 0x82, expression natural
+    EApp(Address, Address),                // 0x83, expression application
+    ELam(Address, Address),                // 0x84, expression lambda
+    EAll(Address, Address),                // 0x85, expression forall
+    ELet(bool, Address, Address, Address), // 0x86, 0x87, expression let
+    Blob(Vec<u8>),                         // 0x9X, tagged bytes
+    Defn(Definition),                      // 0xA0, definition constant
+    Recr(Recursor),                        // 0xA1, recursor constant
+    Axio(Axiom),                           // 0xA2, axiom constant
+    Quot(Quotient),                        // 0xA3, quotient constant
+    CPrj(ConstructorProj),                 // 0xA4, constructor projection
+    RPrj(RecursorProj),                    // 0xA5, recursor projection
+    IPrj(InductiveProj),                   // 0xA6, inductive projection
+    DPrj(DefinitionProj),                  // 0xA7, definition projection
+    Muts(Vec<MutConst>),                   // 0xBX, mutual constants
+    Prof(Proof),                           // 0xE0, zero-knowledge proof
+    Eval(EvalClaim),                       // 0xE1, evaluation claim
+    Chck(CheckClaim),                      // 0xE2, typechecking claim
+    Comm(Comm),                            // 0xE3, cryptographic commitment
+    Envn(Env),                             // 0xE4, multi-claim environment
+    Prim(BuiltIn),                         // 0xE5, compiler built-ins
+    Meta(Metadata),                        // 0xFX, metadata
 }
 
 impl Default for Ixon {
     fn default() -> Self {
-        Self::Vari(0)
+        Self::NAnon
     }
 }
 
@@ -110,1381 +121,1381 @@ impl Ixon {
             .collect()
     }
 
-    fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
-        if val < 8 {
-            buf.push((tag << 4) | (val as u8));
-        } else {
-            buf.push((tag << 4) | 0b1000 | (Ixon::u64_byte_count(val) - 1));
-            Ixon::u64_put_trimmed_le(val, buf);
-        }
-    }
-
-    fn get_size(is_large: bool, small: u8, buf: &mut &[u8]) -> Result<u64, String> {
-        if is_large {
-            Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
-        } else {
-            Ok(small as u64)
-        }
-    }
-
-    // put_array and get_array are separated from Ixon's serialize implementation
-    // in order to create a generic Serialize impl for Vec<S>
-    pub fn put_array<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
-        Self::put_tag(0xA, xs.len() as u64, buf);
-        for x in xs {
-            x.put(buf)
-        }
-    }
-
-    pub fn get_array<S: Serialize>(buf: &mut &[u8]) -> Result<Vec<S>, String> {
-        let tag_byte = u8::get(buf)?;
-        let tag = tag_byte >> 4;
-        let small_size = tag_byte & 0b111;
-        let is_large = tag_byte & 0b1000 != 0;
-        match tag {
-            0xA => {
-                let len = Self::get_size(is_large, small_size, buf)?;
-                let mut vec = vec![];
-                for _ in 0..len {
-                    let s = S::get(buf)?;
-                    vec.push(s);
-                }
-                Ok(vec)
-            }
-            x => Err(format!("get array invalid tag {x}")),
-        }
-    }
-}
-
-impl Serialize for Ixon {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Vari(x) => Self::put_tag(0x0, *x, buf),
-            Self::Sort(x) => {
-                u8::put(&0x90, buf);
-                x.put(buf);
-            }
-            Self::Refr(addr, lvls) => {
-                Self::put_tag(0x1, lvls.len() as u64, buf);
-                addr.put(buf);
-                for l in lvls {
-                    l.put(buf);
-                }
-            }
-            Self::Recr(x, lvls) => {
-                Self::put_tag(0x2, *x, buf);
-                Ixon::put_array(lvls, buf);
-            }
-            Self::Apps(f, a, args) => {
-                Self::put_tag(0x3, args.len() as u64, buf);
-                f.put(buf);
-                a.put(buf);
-                for x in args {
-                    x.put(buf);
-                }
-            }
-            Self::Lams(ts, b) => {
-                Self::put_tag(0x4, ts.len() as u64, buf);
-                for t in ts {
-                    t.put(buf);
-                }
-                b.put(buf);
-            }
-            Self::Alls(ts, b) => {
-                Self::put_tag(0x5, ts.len() as u64, buf);
-                for t in ts {
-                    t.put(buf);
-                }
-                b.put(buf);
-            }
-            Self::Proj(t, n, x) => {
-                Self::put_tag(0x6, *n, buf);
-                t.put(buf);
-                x.put(buf);
-            }
-            Self::Strl(s) => {
-                let bytes = s.as_bytes();
-                Self::put_tag(0x7, bytes.len() as u64, buf);
-                buf.extend_from_slice(bytes);
-            }
-            Self::Natl(n) => {
-                let bytes = n.0.to_bytes_le();
-                Self::put_tag(0x8, bytes.len() as u64, buf);
-                buf.extend_from_slice(&bytes);
-            }
-            Self::LetE(nd, t, d, b) => {
-                if *nd {
-                    u8::put(&0x91, buf);
-                } else {
-                    u8::put(&0x92, buf);
-                }
-                t.put(buf);
-                d.put(buf);
-                b.put(buf);
-            }
-            Self::List(xs) => Ixon::put_array(xs, buf),
-            Self::Defn(x) => {
-                u8::put(&0xB0, buf);
-                x.put(buf);
-            }
-            Self::Axio(x) => {
-                u8::put(&0xB1, buf);
-                x.put(buf);
-            }
-            Self::Quot(x) => {
-                u8::put(&0xB2, buf);
-                x.put(buf);
-            }
-            Self::CPrj(x) => {
-                u8::put(&0xB3, buf);
-                x.put(buf);
-            }
-            Self::RPrj(x) => {
-                u8::put(&0xB4, buf);
-                x.put(buf);
-            }
-            Self::IPrj(x) => {
-                u8::put(&0xB5, buf);
-                x.put(buf);
-            }
-            Self::DPrj(x) => {
-                u8::put(&0xB6, buf);
-                x.put(buf);
-            }
-            Self::Inds(xs) => {
-                Self::put_tag(0xC, xs.len() as u64, buf);
-                for x in xs {
-                    x.put(buf);
-                }
-            }
-            Self::Defs(xs) => {
-                Self::put_tag(0xD, xs.len() as u64, buf);
-                for x in xs {
-                    x.put(buf);
-                }
-            }
-            Self::Meta(x) => {
-                u8::put(&0xE0, buf);
-                x.put(buf);
-            }
-            Self::Prof(x) => {
-                u8::put(&0xE1, buf);
-                x.put(buf);
-            }
-            Self::Eval(x) => {
-                u8::put(&0xE2, buf);
-                x.put(buf);
-            }
-            Self::Chck(x) => {
-                u8::put(&0xE3, buf);
-                x.put(buf);
-            }
-            Self::Comm(x) => {
-                u8::put(&0xE4, buf);
-                x.put(buf);
-            }
-            Self::Envn(x) => {
-                u8::put(&0xE5, buf);
-                x.put(buf);
-            }
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let tag_byte = u8::get(buf)?;
-        let small_size = tag_byte & 0b111;
-        let is_large = tag_byte & 0b1000 != 0;
-        match tag_byte {
-            0x00..=0x0F => {
-                let x = Ixon::get_size(is_large, small_size, buf)?;
-                Ok(Self::Vari(x))
-            }
-            0x90 => {
-                let u = Univ::get(buf)?;
-                Ok(Self::Sort(Box::new(u)))
-            }
-            0x10..=0x1F => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let a = Address::get(buf)?;
-                let mut lvls = Vec::new();
-                for _ in 0..n {
-                    let l = Univ::get(buf)?;
-                    lvls.push(l);
-                }
-                Ok(Self::Refr(a, lvls))
-            }
-            0x20..=0x2F => {
-                let x = Ixon::get_size(is_large, small_size, buf)?;
-                let lvls = Ixon::get_array(buf)?;
-                Ok(Self::Recr(x, lvls))
-            }
-            0x30..=0x3F => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let f = Ixon::get(buf)?;
-                let a = Ixon::get(buf)?;
-                let mut args = Vec::new();
-                for _ in 0..n {
-                    let x = Ixon::get(buf)?;
-                    args.push(x);
-                }
-                Ok(Self::Apps(Box::new(f), Box::new(a), args))
-            }
-            0x40..=0x4F => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let mut ts = Vec::new();
-                for _ in 0..n {
-                    let x = Ixon::get(buf)?;
-                    ts.push(x);
-                }
-                let b = Ixon::get(buf)?;
-                Ok(Self::Lams(ts, Box::new(b)))
-            }
-            0x50..=0x5F => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let mut ts = Vec::new();
-                for _ in 0..n {
-                    let x = Ixon::get(buf)?;
-                    ts.push(x);
-                }
-                let b = Ixon::get(buf)?;
-                Ok(Self::Alls(ts, Box::new(b)))
-            }
-            0x60..=0x6F => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let t = Address::get(buf)?;
-                let x = Ixon::get(buf)?;
-                Ok(Self::Proj(t, n, Box::new(x)))
-            }
-            0x70..=0x7F => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                match buf.split_at_checked(n as usize) {
-                    Some((head, rest)) => {
-                        *buf = rest;
-                        match String::from_utf8(head.to_owned()) {
-                            Ok(s) => Ok(Ixon::Strl(s)),
-                            Err(e) => Err(format!("UTF8 Error: {e}")),
-                        }
-                    }
-                    None => Err("get Ixon Strl EOF".to_string()),
-                }
-            }
-            0x80..=0x8F => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                match buf.split_at_checked(n as usize) {
-                    Some((head, rest)) => {
-                        *buf = rest;
-                        Ok(Ixon::Natl(Nat(BigUint::from_bytes_le(head))))
-                    }
-                    None => Err("get Expr Natl EOF".to_string()),
-                }
-            }
-            0x91..=0x92 => {
-                let nd = tag_byte == 0x91;
-                let t = Ixon::get(buf)?;
-                let d = Ixon::get(buf)?;
-                let b = Ixon::get(buf)?;
-                Ok(Self::LetE(nd, Box::new(t), Box::new(d), Box::new(b)))
-            }
-            0xA0..=0xAF => {
-                let len = Self::get_size(is_large, small_size, buf)?;
-                let mut vec = vec![];
-                for _ in 0..len {
-                    let s = Ixon::get(buf)?;
-                    vec.push(s);
-                }
-                Ok(Self::List(vec))
-            }
-            0xB0 => Ok(Self::Defn(Definition::get(buf)?)),
-            0xB1 => Ok(Self::Axio(Axiom::get(buf)?)),
-            0xB2 => Ok(Self::Quot(Quotient::get(buf)?)),
-            0xB3 => Ok(Self::CPrj(ConstructorProj::get(buf)?)),
-            0xB4 => Ok(Self::RPrj(RecursorProj::get(buf)?)),
-            0xB5 => Ok(Self::IPrj(InductiveProj::get(buf)?)),
-            0xB6 => Ok(Self::DPrj(DefinitionProj::get(buf)?)),
-            0xC0..=0xCF => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let mut inds = Vec::new();
-                for _ in 0..n {
-                    let x = Inductive::get(buf)?;
-                    inds.push(x);
-                }
-                Ok(Self::Inds(inds))
-            }
-            0xD0..=0xDF => {
-                let n = Ixon::get_size(is_large, small_size, buf)?;
-                let mut defs = Vec::new();
-                for _ in 0..n {
-                    let x = Definition::get(buf)?;
-                    defs.push(x);
-                }
-                Ok(Self::Defs(defs))
-            }
-            0xE0 => Ok(Self::Meta(Metadata::get(buf)?)),
-            0xE1 => Ok(Self::Prof(Proof::get(buf)?)),
-            0xE2 => Ok(Self::Eval(EvalClaim::get(buf)?)),
-            0xE3 => Ok(Self::Chck(CheckClaim::get(buf)?)),
-            0xE4 => Ok(Self::Comm(Comm::get(buf)?)),
-            0xE5 => Ok(Self::Envn(Env::get(buf)?)),
-            x => Err(format!("get Ixon invalid tag {x}")),
-        }
-    }
-}
-
-#[cfg(test)]
-pub mod tests {
-    use super::*;
-    use crate::ixon::nat::tests::arbitrary_nat;
-    use crate::ixon::univ::tests::arbitrary_univ;
-    use quickcheck::{Arbitrary, Gen};
-    use std::fmt::Write;
-    use std::ops::Range;
-    use std::ptr;
+    //fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
+    //    if val < 8 {
+    //        buf.push((tag << 4) | (val as u8));
+    //    } else {
+    //        buf.push((tag << 4) | 0b1000 | (Ixon::u64_byte_count(val) - 1));
+    //        Ixon::u64_put_trimmed_le(val, buf);
+    //    }
+    //}
 
-    pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
-        let res: usize = Arbitrary::arbitrary(g);
-        if range.is_empty() {
-            0
-        } else {
-            (res % (range.end - range.start)) + range.start
-        }
-    }
-
-    pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
-    where
-        F: FnMut(&mut Gen) -> A,
-    {
-        let len = gen_range(g, 0..size);
-        let mut vec = Vec::with_capacity(len);
-        for _ in 0..len {
-            vec.push(f(g));
-        }
-        vec
-    }
-
-    pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
-        let sum: usize = gens.iter().map(|x| x.0).sum();
-        let mut weight: usize = gen_range(g, 1..sum);
-        for (n, case) in gens {
-            if *n == 0 {
-                continue;
-            } else {
-                match weight.checked_sub(*n) {
-                    None | Some(0) => {
-                        return *case;
-                    }
-                    _ => {
-                        weight -= *n;
-                    }
-                }
-            }
-        }
-        unreachable!()
-    }
-
-    #[test]
-    fn unit_u64_trimmed() {
-        fn test(input: u64, expected: Vec<u8>) -> bool {
-            let mut tmp = Vec::new();
-            let n = Ixon::u64_byte_count(input);
-            Ixon::u64_put_trimmed_le(input, &mut tmp);
-            if tmp != expected {
-                return false;
-            }
-            match Ixon::u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
-                Ok(out) => input == out,
-                Err(e) => {
-                    println!("err: {e}");
-                    false
-                }
-            }
-        }
-        assert!(test(0x0, vec![]));
-        assert!(test(0x01, vec![0x01]));
-        assert!(test(0x0000000000000100, vec![0x00, 0x01]));
-        assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
-        assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
-        assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
-        assert!(test(
-            0x0000010000000000,
-            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-        ));
-        assert!(test(
-            0x0001000000000000,
-            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-        ));
-        assert!(test(
-            0x0100000000000000,
-            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-        ));
-        assert!(test(
-            0x0102030405060708,
-            vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
-        ));
-    }
-
-    #[quickcheck]
-    fn prop_u64_trimmed_le_readback(x: u64) -> bool {
-        let mut buf = Vec::new();
-        let n = Ixon::u64_byte_count(x);
-        Ixon::u64_put_trimmed_le(x, &mut buf);
-        match Ixon::u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
-            Ok(y) => x == y,
-            Err(e) => {
-                println!("err: {e}");
-                false
-            }
-        }
-    }
-
-    #[derive(Debug, Clone, Copy)]
-    pub enum IxonCase {
-        Vari,
-        Sort,
-        Refr,
-        Recr,
-        Apps,
-        Lams,
-        Alls,
-        Proj,
-        Strl,
-        Natl,
-        LetE,
-        List,
-        Defn,
-        Axio,
-        Quot,
-        CPrj,
-        RPrj,
-        IPrj,
-        DPrj,
-        Defs,
-        Inds,
-        Meta,
-        Prof,
-        Eval,
-        Chck,
-        Comm,
-        Envn,
-    }
-
-    pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
-        let mut s = String::new();
-        for _ in 0..cs {
-            s.push(char::arbitrary(g));
-        }
-        s
-    }
+    //fn get_size(is_large: bool, small: u8, buf: &mut &[u8]) -> Result<u64, String> {
+    //    if is_large {
+    //        Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
+    //    } else {
+    //        Ok(small as u64)
+    //    }
+    //}
 
-    // incremental tree generation without recursion stack overflows
-    pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
-        let mut root = Ixon::Vari(0);
-        let mut stack = vec![&mut root as *mut Ixon];
+    //// put_array and get_array are separated from Ixon's serialize implementation
+    //// in order to create a generic Serialize impl for Vec<S>
+    //pub fn put_array<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
+    //    Self::put_tag(0xA, xs.len() as u64, buf);
+    //    for x in xs {
+    //        x.put(buf)
+    //    }
+    //}
 
-        while let Some(ptr) = stack.pop() {
-            let gens: Vec<(usize, IxonCase)> = vec![
-                (100, IxonCase::Vari),
-                (100, IxonCase::Sort),
-                (15, IxonCase::Refr),
-                (15, IxonCase::Recr),
-                (15, IxonCase::Apps),
-                (15, IxonCase::Lams),
-                (15, IxonCase::Alls),
-                (20, IxonCase::LetE),
-                (50, IxonCase::Proj),
-                (100, IxonCase::Strl),
-                (100, IxonCase::Natl),
-                (10, IxonCase::List),
-                (100, IxonCase::Defn),
-                (100, IxonCase::Axio),
-                (100, IxonCase::Quot),
-                (100, IxonCase::CPrj),
-                (100, IxonCase::RPrj),
-                (100, IxonCase::IPrj),
-                (100, IxonCase::DPrj),
-                (15, IxonCase::Inds),
-                (15, IxonCase::Defs),
-                (100, IxonCase::Meta),
-                (100, IxonCase::Prof),
-                (100, IxonCase::Eval),
-                (100, IxonCase::Chck),
-                (100, IxonCase::Comm),
-                (100, IxonCase::Envn),
-            ];
-
-            match next_case(g, &gens) {
-                IxonCase::Vari => {
-                    let x: u64 = Arbitrary::arbitrary(g);
-                    unsafe {
-                        ptr::replace(ptr, Ixon::Vari(x));
-                    }
-                }
-                IxonCase::Sort => {
-                    let u = arbitrary_univ(g, ctx);
-                    unsafe {
-                        ptr::replace(ptr, Ixon::Sort(Box::new(u)));
-                    }
-                }
-                IxonCase::Refr => {
-                    let addr = Address::arbitrary(g);
-                    let mut lvls = vec![];
-                    for _ in 0..gen_range(g, 0..9) {
-                        lvls.push(arbitrary_univ(g, ctx));
-                    }
-                    unsafe {
-                        ptr::replace(ptr, Ixon::Refr(addr, lvls));
-                    }
-                }
-                IxonCase::Recr => {
-                    let n = u64::arbitrary(g);
-                    let mut lvls = vec![];
-                    for _ in 0..gen_range(g, 0..9) {
-                        lvls.push(arbitrary_univ(g, ctx));
-                    }
-                    unsafe {
-                        ptr::replace(ptr, Ixon::Recr(n, lvls));
-                    }
-                }
-                IxonCase::Apps => {
-                    let mut f_box = Box::new(Ixon::default());
-                    let f_ptr: *mut Ixon = &mut *f_box;
-                    stack.push(f_ptr);
-
-                    let mut a_box = Box::new(Ixon::default());
-                    let a_ptr: *mut Ixon = &mut *a_box;
-                    stack.push(a_ptr);
-
-                    let n = gen_range(g, 0..9);
-                    let mut xs: Vec<Ixon> = Vec::with_capacity(n);
-                    xs.resize(n, Ixon::Vari(0));
-                    for i in 0..n {
-                        let p = unsafe { xs.as_mut_ptr().add(i) };
-                        stack.push(p);
-                    }
-                    unsafe {
-                        std::ptr::replace(ptr, Ixon::Apps(f_box, a_box, xs));
-                    }
-                }
-                IxonCase::Lams => {
-                    let n = gen_range(g, 0..9);
-                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-                    ts.resize(n, Ixon::Vari(0));
-                    for i in 0..n {
-                        let p = unsafe { ts.as_mut_ptr().add(i) };
-                        stack.push(p);
-                    }
-                    let mut b_box = Box::new(Ixon::default());
-                    let b_ptr: *mut Ixon = &mut *b_box;
-                    stack.push(b_ptr);
-                    unsafe {
-                        std::ptr::replace(ptr, Ixon::Lams(ts, b_box));
-                    }
-                }
-                IxonCase::Alls => {
-                    let n = gen_range(g, 0..9);
-                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-                    ts.resize(n, Ixon::Vari(0));
-                    for i in 0..n {
-                        let p = unsafe { ts.as_mut_ptr().add(i) };
-                        stack.push(p);
-                    }
-                    let mut b_box = Box::new(Ixon::default());
-                    let b_ptr: *mut Ixon = &mut *b_box;
-                    stack.push(b_ptr);
-                    unsafe {
-                        std::ptr::replace(ptr, Ixon::Alls(ts, b_box));
-                    }
-                }
-                IxonCase::LetE => {
-                    let nd = bool::arbitrary(g);
-                    let mut t_box = Box::new(Ixon::default());
-                    let t_ptr: *mut Ixon = &mut *t_box;
-                    stack.push(t_ptr);
-                    let mut d_box = Box::new(Ixon::default());
-                    let d_ptr: *mut Ixon = &mut *d_box;
-                    stack.push(d_ptr);
-                    let mut b_box = Box::new(Ixon::default());
-                    let b_ptr: *mut Ixon = &mut *b_box;
-                    stack.push(b_ptr);
-                    unsafe {
-                        ptr::replace(ptr, Ixon::LetE(nd, t_box, d_box, b_box));
-                    }
-                }
-                IxonCase::Proj => {
-                    let addr = Address::arbitrary(g);
-                    let n = u64::arbitrary(g);
-                    let mut t_box = Box::new(Ixon::default());
-                    let t_ptr: *mut Ixon = &mut *t_box;
-                    stack.push(t_ptr);
-                    unsafe {
-                        ptr::replace(ptr, Ixon::Proj(addr, n, t_box));
-                    }
-                }
-                IxonCase::Strl => unsafe {
-                    let size = gen_range(g, 0..9);
-                    ptr::replace(ptr, Ixon::Strl(arbitrary_string(g, size)));
-                },
-                IxonCase::Natl => {
-                    let size = gen_range(g, 0..9);
-                    unsafe {
-                        ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
-                    }
-                }
-                IxonCase::List => {
-                    let n = gen_range(g, 0..9);
-                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-                    ts.resize(n, Ixon::Vari(0));
-                    for i in 0..n {
-                        let p = unsafe { ts.as_mut_ptr().add(i) };
-                        stack.push(p);
-                    }
-                    unsafe {
-                        std::ptr::replace(ptr, Ixon::List(ts));
-                    }
-                }
-                IxonCase::Quot => unsafe {
-                    std::ptr::replace(ptr, Ixon::Quot(Quotient::arbitrary(g)));
-                },
-                IxonCase::Axio => unsafe {
-                    std::ptr::replace(ptr, Ixon::Axio(Axiom::arbitrary(g)));
-                },
-                IxonCase::Defn => unsafe {
-                    std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
-                },
-                IxonCase::CPrj => unsafe {
-                    std::ptr::replace(ptr, Ixon::CPrj(ConstructorProj::arbitrary(g)));
-                },
-                IxonCase::RPrj => unsafe {
-                    std::ptr::replace(ptr, Ixon::RPrj(RecursorProj::arbitrary(g)));
-                },
-                IxonCase::DPrj => unsafe {
-                    std::ptr::replace(ptr, Ixon::DPrj(DefinitionProj::arbitrary(g)));
-                },
-                IxonCase::IPrj => unsafe {
-                    std::ptr::replace(ptr, Ixon::IPrj(InductiveProj::arbitrary(g)));
-                },
-                IxonCase::Inds => unsafe {
-                    let inds = gen_vec(g, 9, Inductive::arbitrary);
-                    std::ptr::replace(ptr, Ixon::Inds(inds));
-                },
-                IxonCase::Defs => unsafe {
-                    let defs = gen_vec(g, 9, Definition::arbitrary);
-                    std::ptr::replace(ptr, Ixon::Defs(defs));
-                },
-                IxonCase::Meta => unsafe {
-                    std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
-                },
-                IxonCase::Prof => unsafe {
-                    std::ptr::replace(ptr, Ixon::Prof(Proof::arbitrary(g)));
-                },
-                IxonCase::Eval => unsafe {
-                    std::ptr::replace(ptr, Ixon::Eval(EvalClaim::arbitrary(g)));
-                },
-                IxonCase::Chck => unsafe {
-                    std::ptr::replace(ptr, Ixon::Chck(CheckClaim::arbitrary(g)));
-                },
-                IxonCase::Comm => unsafe {
-                    std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
-                },
-                IxonCase::Envn => unsafe {
-                    std::ptr::replace(ptr, Ixon::Envn(Env::arbitrary(g)));
-                },
-            }
-        }
-        root
-    }
-
-    impl Arbitrary for Ixon {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let ctx: u64 = Arbitrary::arbitrary(g);
-            arbitrary_ixon(g, ctx)
-        }
-    }
-
-    #[quickcheck]
-    fn prop_ixon_readback(x: Ixon) -> bool {
-        let mut buf = Vec::new();
-        Ixon::put(&x, &mut buf);
-        match Ixon::get(&mut buf.as_slice()) {
-            Ok(y) => x == y,
-            Err(e) => {
-                println!("err: {e}");
-                false
-            }
-        }
-    }
-
-    /// Parse a hex string (optional `0x`/`0X` prefix, `_` separators OK) into bytes.
-    pub fn parse_hex(s: &str) -> Result<Vec<u8>, String> {
-        // Strip prefix, drop underscores, and require an even count of hex digits.
-        let s = s.trim();
-        let s = s
-            .strip_prefix("0x")
-            .or_else(|| s.strip_prefix("0X"))
-            .unwrap_or(s);
-        let clean: String = s.chars().filter(|&c| c != '_').collect();
-
-        if clean.len() % 2 != 0 {
-            return Err("odd number of hex digits".into());
-        }
-
-        // Parse each 2-char chunk as a byte.
-        (0..clean.len())
-            .step_by(2)
-            .map(|i| {
-                u8::from_str_radix(&clean[i..i + 2], 16)
-                    .map_err(|_| format!("invalid hex at chars {}..{}", i, i + 2))
-            })
-            .collect()
-    }
-
-    /// Format bytes as a lowercase hex string with a `0x` prefix.
-    pub fn to_hex(bytes: &[u8]) -> String {
-        let mut out = String::with_capacity(2 + bytes.len() * 2);
-        out.push_str("0x");
-        for b in bytes {
-            // `{:02x}` = two lowercase hex digits, zero-padded.
-            write!(&mut out, "{b:02x}").unwrap();
-        }
-        out
-    }
-
-    #[test]
-    fn unit_ixon() {
-        fn test(input: Ixon, expected: &str) -> bool {
-            let mut tmp = Vec::new();
-            let expect = parse_hex(expected).unwrap();
-            Serialize::put(&input, &mut tmp);
-            if tmp != expect {
-                println!(
-                    "serialied {input:?} as:\n {}\n test expects:\n {}",
-                    to_hex(&tmp),
-                    to_hex(&expect),
-                );
-                return false;
-            }
-            match Serialize::get(&mut tmp.as_slice()) {
-                Ok(output) => {
-                    if input != output {
-                        println!(
-                            "deserialized {} as {output:?}, expected {input:?}",
-                            to_hex(&tmp)
-                        );
-                        false
-                    } else {
-                        true
-                    }
-                }
-                Err(e) => {
-                    println!("err: {e}");
-                    false
-                }
-            }
-        }
-        assert!(test(Ixon::Vari(0x0), "0x00"));
-        assert!(test(Ixon::Vari(0x7), "0x07"));
-        assert!(test(Ixon::Vari(0x8), "0x0808"));
-        assert!(test(Ixon::Vari(0xff), "0x08FF"));
-        assert!(test(Ixon::Vari(0x0100), "0x090001"));
-        assert!(test(Ixon::Vari(0xFFFF), "0x09FFFF"));
-        assert!(test(Ixon::Vari(0x010000), "0x0A000001"));
-        assert!(test(Ixon::Vari(0xFFFFFF), "0x0AFFFFFF"));
-        assert!(test(Ixon::Vari(0x01000000), "0x0B00000001"));
-        assert!(test(Ixon::Vari(0xFFFFFFFF), "0x0BFFFFFFFF"));
-        assert!(test(Ixon::Vari(0x0100000000), "0x0C0000000001"));
-        assert!(test(Ixon::Vari(0xFFFFFFFFFF), "0x0CFFFFFFFFFF"));
-        assert!(test(Ixon::Vari(0x010000000000), "0x0D000000000001"));
-        assert!(test(Ixon::Vari(0xFFFFFFFFFFFF), "0x0DFFFFFFFFFFFF"));
-        assert!(test(Ixon::Vari(0x01000000000000), "0x0E00000000000001"));
-        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFF), "0x0EFFFFFFFFFFFFFF"));
-        assert!(test(Ixon::Vari(0x0100000000000000), "0x0F0000000000000001"));
-        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFFFF), "0x0FFFFFFFFFFFFFFFFF"));
-        // universes use 2-bit sub-tags
-        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x0))), "0x9000"));
-        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x1F))), "0x901F"));
-        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x20))), "0x902020"));
-        assert!(test(Ixon::Sort(Box::new(Univ::Const(0xFF))), "0x9020FF"));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0x0100))),
-            "0x90210001"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0xFFFF))),
-            "0x9021FFFF"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0x010000))),
-            "0x9022000001"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0xFFFFFF))),
-            "0x9022FFFFFF"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0x01000000))),
-            "0x902300000001"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFF))),
-            "0x9023FFFFFFFF"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0x0100000000))),
-            "0x90240000000001"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFF))),
-            "0x9024FFFFFFFFFF"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0x010000000000))),
-            "0x9025000000000001"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFF))),
-            "0x9025FFFFFFFFFFFF"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0x01000000000000))),
-            "0x902600000000000001"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFF))),
-            "0x9026FFFFFFFFFFFFFF"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0x0100000000000000))),
-            "0x90270000000000000001"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFFFF))),
-            "0x9027FFFFFFFFFFFFFFFF"
-        ));
-        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0))), "0x9040"));
-        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x1F))), "0x905F"));
-        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x20))), "0x906020"));
-        assert!(test(Ixon::Sort(Box::new(Univ::Var(0xFF))), "0x9060FF"));
-        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0100))), "0x90610001"));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Var(0xFFFFFFFFFFFFFFFF))),
-            "0x9067FFFFFFFFFFFFFFFF"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Const(0x0))))),
-            "0x908000"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Var(0x0))))),
-            "0x908040"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Add(0x1F, Box::new(Univ::Var(0x0))))),
-            "0x909F40"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Add(0x20, Box::new(Univ::Var(0x0))))),
-            "0x90A02040"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Add(0xFF, Box::new(Univ::Var(0x0))))),
-            "0x90A0FF40"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Add(
-                0xFFFF_FFFF_FFFF_FFFF,
-                Box::new(Univ::Var(0x0))
-            ))),
-            "0x90A7FFFFFFFFFFFFFFFF40"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Max(
-                Box::new(Univ::Var(0x0)),
-                Box::new(Univ::Var(0x0))
-            ))),
-            "0x90C04040"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Max(
-                Box::new(Univ::Var(0x0)),
-                Box::new(Univ::Var(0x1))
-            ))),
-            "0x90C04041"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Max(
-                Box::new(Univ::Var(0x1)),
-                Box::new(Univ::Var(0x0))
-            ))),
-            "0x90C04140"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::Max(
-                Box::new(Univ::Var(0x1)),
-                Box::new(Univ::Var(0x1))
-            ))),
-            "0x90C04141"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::IMax(
-                Box::new(Univ::Var(0x0)),
-                Box::new(Univ::Var(0x0))
-            ))),
-            "0x90C14040"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::IMax(
-                Box::new(Univ::Var(0x0)),
-                Box::new(Univ::Var(0x1))
-            ))),
-            "0x90C14041"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::IMax(
-                Box::new(Univ::Var(0x1)),
-                Box::new(Univ::Var(0x0))
-            ))),
-            "0x90C14140"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::IMax(
-                Box::new(Univ::Var(0x1)),
-                Box::new(Univ::Var(0x1))
-            ))),
-            "0x90C14141"
-        ));
-        assert!(test(
-            Ixon::Sort(Box::new(Univ::IMax(
-                Box::new(Univ::Var(0x1)),
-                Box::new(Univ::Var(0x1))
-            ))),
-            "0x90C14141"
-        ));
-        assert!(test(
-            Ixon::Refr(Address::hash(&[]), vec![]),
-            "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::Refr(Address::hash(&[]), vec![Univ::Var(0x0)]),
-            "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240"
-        ));
-        assert!(test(Ixon::Recr(0x0, vec![Univ::Var(0x0)]), "0x20A140"));
-        assert!(test(
-            Ixon::Recr(0x0, vec![Univ::Var(0x0), Univ::Var(0x1)]),
-            "0x20A24041"
-        ));
-        assert!(test(
-            Ixon::Recr(0x8, vec![Univ::Var(0x0), Univ::Var(0x1)]),
-            "0x2808A24041"
-        ));
-        assert!(test(
-            Ixon::Apps(Box::new(Ixon::Vari(0x0)), Box::new(Ixon::Vari(0x1)), vec![]),
-            "0x300001"
-        ));
-        assert!(test(
-            Ixon::Apps(
-                Box::new(Ixon::Vari(0x0)),
-                Box::new(Ixon::Vari(0x1)),
-                vec![Ixon::Vari(0x2)]
-            ),
-            "0x31000102"
-        ));
-        assert!(test(
-            Ixon::Apps(
-                Box::new(Ixon::Vari(0x0)),
-                Box::new(Ixon::Vari(0x1)),
-                vec![
-                    Ixon::Vari(0x2),
-                    Ixon::Vari(0x3),
-                    Ixon::Vari(0x4),
-                    Ixon::Vari(0x5),
-                    Ixon::Vari(0x6),
-                    Ixon::Vari(0x7),
-                    Ixon::Vari(0x8),
-                    Ixon::Vari(0x9),
-                ]
-            ),
-            "0x3808000102030405060708080809"
-        ));
-        assert!(test(
-            Ixon::Lams(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
-            "0x410001"
-        ));
-        assert!(test(
-            Ixon::Lams(
-                vec![
-                    Ixon::Vari(0x0),
-                    Ixon::Vari(0x1),
-                    Ixon::Vari(0x2),
-                    Ixon::Vari(0x3),
-                    Ixon::Vari(0x4),
-                    Ixon::Vari(0x5),
-                    Ixon::Vari(0x6),
-                    Ixon::Vari(0x7)
-                ],
-                Box::new(Ixon::Vari(0x8))
-            ),
-            "0x480800010203040506070808"
-        ));
-        assert!(test(
-            Ixon::Alls(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
-            "0x510001"
-        ));
-        assert!(test(
-            Ixon::Alls(
-                vec![
-                    Ixon::Vari(0x0),
-                    Ixon::Vari(0x1),
-                    Ixon::Vari(0x2),
-                    Ixon::Vari(0x3),
-                    Ixon::Vari(0x4),
-                    Ixon::Vari(0x5),
-                    Ixon::Vari(0x6),
-                    Ixon::Vari(0x7)
-                ],
-                Box::new(Ixon::Vari(0x8))
-            ),
-            "0x580800010203040506070808"
-        ));
-        assert!(test(
-            Ixon::Proj(Address::hash(&[]), 0x0, Box::new(Ixon::Vari(0x0))),
-            "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
-        ));
-        assert!(test(
-            Ixon::Proj(Address::hash(&[]), 0x8, Box::new(Ixon::Vari(0x0))),
-            "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
-        ));
-        assert!(test(Ixon::Strl("".to_string()), "0x70"));
-        assert!(test(Ixon::Strl("foobar".to_string()), "0x76666f6f626172"));
-        assert!(test(Ixon::Natl(Nat::new_le(&[])), "0x8100"));
-        assert!(test(Ixon::Natl(Nat::new_le(&[0x0])), "0x8100"));
-        assert!(test(Ixon::Natl(Nat::new_le(&[0xFF])), "0x81FF"));
-        assert!(test(Ixon::Natl(Nat::new_le(&[0x00, 0x01])), "0x820001"));
-        assert!(test(
-            Ixon::LetE(
-                true,
-                Box::new(Ixon::Vari(0x0)),
-                Box::new(Ixon::Vari(0x1)),
-                Box::new(Ixon::Vari(0x2))
-            ),
-            "0x91000102"
-        ));
-        assert!(test(Ixon::List(vec![]), "0xA0"));
-        assert!(test(
-            Ixon::List(vec![Ixon::Vari(0x0), Ixon::Vari(0x1), Ixon::Vari(0x2)]),
-            "0xA3000102"
-        ));
-        assert!(test(
-            Ixon::Defn(Definition {
-                kind: DefKind::Definition,
-                safety: DefSafety::Unsafe,
-                lvls: 0u64.into(),
-                typ: Address::hash(&[]),
-                value: Address::hash(&[]),
-            }),
-            "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::Defn(Definition {
-                kind: DefKind::Opaque,
-                safety: DefSafety::Safe,
-                lvls: 1u64.into(),
-                typ: Address::hash(&[]),
-                value: Address::hash(&[]),
-            }),
-            "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::Axio(Axiom {
-                is_unsafe: true,
-                lvls: 0u64.into(),
-                typ: Address::hash(&[]),
-            }),
-            "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::Quot(Quotient {
-                kind: QuotKind::Type,
-                lvls: 0u64.into(),
-                typ: Address::hash(&[]),
-            }),
-            "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::CPrj(ConstructorProj {
-                idx: 0u64.into(),
-                cidx: 0u64.into(),
-                block: Address::hash(&[]),
-            }),
-            "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::RPrj(RecursorProj {
-                idx: 0u64.into(),
-                ridx: 0u64.into(),
-                block: Address::hash(&[]),
-            }),
-            "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::IPrj(InductiveProj {
-                idx: 0u64.into(),
-                block: Address::hash(&[]),
-            }),
-            "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::DPrj(DefinitionProj {
-                idx: 0u64.into(),
-                block: Address::hash(&[]),
-            }),
-            "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(Ixon::Inds(vec![]), "0xC0"));
-        assert!(test(
-            Ixon::Inds(vec![Inductive {
-                recr: false,
-                refl: false,
-                is_unsafe: false,
-                lvls: 0u64.into(),
-                params: 0u64.into(),
-                indices: 0u64.into(),
-                nested: 0u64.into(),
-                typ: Address::hash(&[]),
-                ctors: vec![],
-                recrs: vec![],
-            }]),
-            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
-        ));
-        assert!(test(
-            Ixon::Inds(vec![Inductive {
-                recr: false,
-                refl: false,
-                is_unsafe: false,
-                lvls: 0u64.into(),
-                params: 0u64.into(),
-                indices: 0u64.into(),
-                nested: 0u64.into(),
-                typ: Address::hash(&[]),
-                ctors: vec![],
-                recrs: vec![],
-            }]),
-            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
-        ));
-        assert!(test(
-            Ixon::Inds(vec![Inductive {
-                recr: false,
-                refl: false,
-                is_unsafe: false,
-                lvls: 0u64.into(),
-                params: 0u64.into(),
-                indices: 0u64.into(),
-                nested: 0u64.into(),
-                typ: Address::hash(&[]),
-                ctors: vec![Constructor {
-                    is_unsafe: false,
-                    lvls: 0u64.into(),
-                    cidx: 0u64.into(),
-                    params: 0u64.into(),
-                    fields: 0u64.into(),
-                    typ: Address::hash(&[])
-                }],
-                recrs: vec![Recursor {
-                    k: false,
-                    is_unsafe: false,
-                    lvls: 0u64.into(),
-                    params: 0u64.into(),
-                    indices: 0u64.into(),
-                    motives: 0u64.into(),
-                    minors: 0u64.into(),
-                    typ: Address::hash(&[]),
-                    rules: vec![RecursorRule {
-                        fields: 0u64.into(),
-                        rhs: Address::hash(&[])
-                    }]
-                }],
-            }]),
-            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(Ixon::Defs(vec![]), "0xD0"));
-        assert!(test(
-            Ixon::Defs(vec![Definition {
-                kind: DefKind::Definition,
-                safety: DefSafety::Unsafe,
-                lvls: 0u64.into(),
-                typ: Address::hash(&[]),
-                value: Address::hash(&[]),
-            }]),
-            "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(Ixon::Meta(Metadata { map: vec![] }), "0xE0A0"));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(0u64.into(), vec![])]
-            }),
-            "0xE0A18100A0"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(0u64.into(), vec![Metadatum::Name(Name { parts: vec![] })])]
-            }),
-            "0xE0A18100A100A0"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(
-                    0u64.into(),
-                    vec![Metadatum::Name(Name {
-                        parts: vec![NamePart::Str("a".to_string())]
-                    })]
-                )]
-            }),
-            "0xE0A18100A100A17161"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(
-                    0u64.into(),
-                    vec![Metadatum::Name(Name {
-                        parts: vec![
-                            NamePart::Str("a".to_string()),
-                            NamePart::Str("b".to_string()),
-                        ]
-                    })]
-                )]
-            }),
-            "0xE0A18100A100A271617162"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(
-                    0u64.into(),
-                    vec![Metadatum::Name(Name {
-                        parts: vec![
-                            NamePart::Str("a".to_string()),
-                            NamePart::Str("b".to_string()),
-                            NamePart::Str("c".to_string()),
-                        ]
-                    })]
-                )]
-            }),
-            "0xE0A18100A100A3716171627163"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(
-                    0u64.into(),
-                    vec![Metadatum::Name(Name {
-                        parts: vec![NamePart::Num(165851424810452359u64.into())]
-                    })]
-                )]
-            }),
-            "0xE0A18100A100A1880887C551FDFD384D02"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(0u64.into(), vec![Metadatum::Info(BinderInfo::Default)])]
-            }),
-            "0xE0A18100A10100"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(0u64.into(), vec![Metadatum::Link(Address::hash(&[]))])]
-            }),
-            "0xE0A18100A102af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(
-                    0u64.into(),
-                    vec![
-                        Metadatum::Name(Name {
-                            parts: vec![NamePart::Str("d".to_string())]
-                        }),
-                        Metadatum::Link(Address::hash(&[])),
-                        Metadatum::Hints(ReducibilityHints::Regular(576554452)),
-                        Metadatum::Link(Address::hash(&[]))
-                    ]
-                )]
-            }),
-            "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(
-                    0u64.into(),
-                    vec![Metadatum::Hints(ReducibilityHints::Opaque)]
-                )]
-            }),
-            "0xE0A18100A10300"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(0u64.into(), vec![Metadatum::All(vec![])])]
-            }),
-            "0xE0A18100A104A0"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(0u64.into(), vec![Metadatum::MutCtx(vec![])])]
-            }),
-            "0xE0A18100A105A0"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![(
-                    0u64.into(),
-                    vec![Metadatum::Hints(ReducibilityHints::Regular(42))]
-                )]
-            }),
-            "0xe0a18100a103022a000000"
-        ));
-        assert!(test(
-            Ixon::Meta(Metadata {
-                map: vec![
-                    (
-                        0u64.into(),
-                        vec![
-                            Metadatum::Name(Name {
-                                parts: vec![NamePart::Str("d".to_string())]
-                            }),
-                            Metadatum::Link(Address::hash(&[])),
-                            Metadatum::Hints(ReducibilityHints::Regular(576554452)),
-                            Metadatum::Link(Address::hash(&[]))
-                        ]
-                    ),
-                    (
-                        1u64.into(),
-                        vec![
-                            Metadatum::Info(BinderInfo::InstImplicit),
-                            Metadatum::Info(BinderInfo::InstImplicit),
-                            Metadatum::Info(BinderInfo::StrictImplicit),
-                        ]
-                    ),
-                    (
-                        2u64.into(),
-                        vec![
-                            Metadatum::All(vec![Name {
-                                parts: vec![NamePart::Num(165851424810452359u64.into())]
-                            }]),
-                            Metadatum::Info(BinderInfo::Default)
-                        ]
-                    ),
-                    (3u64.into(), vec![]),
-                    (4u64.into(), vec![]),
-                    (
-                        5u64.into(),
-                        vec![Metadatum::Hints(ReducibilityHints::Opaque)]
-                    ),
-                    (
-                        6u64.into(),
-                        vec![Metadatum::Name(Name {
-                            parts: vec![NamePart::Num(871843802607008850u64.into())]
-                        })]
-                    )
-                ]
-            }),
-            "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
-        ));
-    }
+    //pub fn get_array<S: Serialize>(buf: &mut &[u8]) -> Result<Vec<S>, String> {
+    //    let tag_byte = u8::get(buf)?;
+    //    let tag = tag_byte >> 4;
+    //    let small_size = tag_byte & 0b111;
+    //    let is_large = tag_byte & 0b1000 != 0;
+    //    match tag {
+    //        0xA => {
+    //            let len = Self::get_size(is_large, small_size, buf)?;
+    //            let mut vec = vec![];
+    //            for _ in 0..len {
+    //                let s = S::get(buf)?;
+    //                vec.push(s);
+    //            }
+    //            Ok(vec)
+    //        }
+    //        x => Err(format!("get array invalid tag {x}")),
+    //    }
+    //}
 }
 
+//impl Serialize for Ixon {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Vari(x) => Self::put_tag(0x0, *x, buf),
+//            Self::Sort(x) => {
+//                u8::put(&0x90, buf);
+//                x.put(buf);
+//            }
+//            Self::Refr(addr, lvls) => {
+//                Self::put_tag(0x1, lvls.len() as u64, buf);
+//                addr.put(buf);
+//                for l in lvls {
+//                    l.put(buf);
+//                }
+//            }
+//            Self::Recr(x, lvls) => {
+//                Self::put_tag(0x2, *x, buf);
+//                Ixon::put_array(lvls, buf);
+//            }
+//            Self::Apps(f, a, args) => {
+//                Self::put_tag(0x3, args.len() as u64, buf);
+//                f.put(buf);
+//                a.put(buf);
+//                for x in args {
+//                    x.put(buf);
+//                }
+//            }
+//            Self::Lams(ts, b) => {
+//                Self::put_tag(0x4, ts.len() as u64, buf);
+//                for t in ts {
+//                    t.put(buf);
+//                }
+//                b.put(buf);
+//            }
+//            Self::Alls(ts, b) => {
+//                Self::put_tag(0x5, ts.len() as u64, buf);
+//                for t in ts {
+//                    t.put(buf);
+//                }
+//                b.put(buf);
+//            }
+//            Self::Proj(t, n, x) => {
+//                Self::put_tag(0x6, *n, buf);
+//                t.put(buf);
+//                x.put(buf);
+//            }
+//            Self::Strl(s) => {
+//                let bytes = s.as_bytes();
+//                Self::put_tag(0x7, bytes.len() as u64, buf);
+//                buf.extend_from_slice(bytes);
+//            }
+//            Self::Natl(n) => {
+//                let bytes = n.0.to_bytes_le();
+//                Self::put_tag(0x8, bytes.len() as u64, buf);
+//                buf.extend_from_slice(&bytes);
+//            }
+//            Self::LetE(nd, t, d, b) => {
+//                if *nd {
+//                    u8::put(&0x91, buf);
+//                } else {
+//                    u8::put(&0x92, buf);
+//                }
+//                t.put(buf);
+//                d.put(buf);
+//                b.put(buf);
+//            }
+//            Self::List(xs) => Ixon::put_array(xs, buf),
+//            Self::Defn(x) => {
+//                u8::put(&0xB0, buf);
+//                x.put(buf);
+//            }
+//            Self::Axio(x) => {
+//                u8::put(&0xB1, buf);
+//                x.put(buf);
+//            }
+//            Self::Quot(x) => {
+//                u8::put(&0xB2, buf);
+//                x.put(buf);
+//            }
+//            Self::CPrj(x) => {
+//                u8::put(&0xB3, buf);
+//                x.put(buf);
+//            }
+//            Self::RPrj(x) => {
+//                u8::put(&0xB4, buf);
+//                x.put(buf);
+//            }
+//            Self::IPrj(x) => {
+//                u8::put(&0xB5, buf);
+//                x.put(buf);
+//            }
+//            Self::DPrj(x) => {
+//                u8::put(&0xB6, buf);
+//                x.put(buf);
+//            }
+//            Self::Inds(xs) => {
+//                Self::put_tag(0xC, xs.len() as u64, buf);
+//                for x in xs {
+//                    x.put(buf);
+//                }
+//            }
+//            Self::Defs(xs) => {
+//                Self::put_tag(0xD, xs.len() as u64, buf);
+//                for x in xs {
+//                    x.put(buf);
+//                }
+//            }
+//            Self::Meta(x) => {
+//                u8::put(&0xE0, buf);
+//                x.put(buf);
+//            }
+//            Self::Prof(x) => {
+//                u8::put(&0xE1, buf);
+//                x.put(buf);
+//            }
+//            Self::Eval(x) => {
+//                u8::put(&0xE2, buf);
+//                x.put(buf);
+//            }
+//            Self::Chck(x) => {
+//                u8::put(&0xE3, buf);
+//                x.put(buf);
+//            }
+//            Self::Comm(x) => {
+//                u8::put(&0xE4, buf);
+//                x.put(buf);
+//            }
+//            Self::Envn(x) => {
+//                u8::put(&0xE5, buf);
+//                x.put(buf);
+//            }
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let tag_byte = u8::get(buf)?;
+//        let small_size = tag_byte & 0b111;
+//        let is_large = tag_byte & 0b1000 != 0;
+//        match tag_byte {
+//            0x00..=0x0F => {
+//                let x = Ixon::get_size(is_large, small_size, buf)?;
+//                Ok(Self::Vari(x))
+//            }
+//            0x90 => {
+//                let u = Univ::get(buf)?;
+//                Ok(Self::Sort(Box::new(u)))
+//            }
+//            0x10..=0x1F => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                let a = Address::get(buf)?;
+//                let mut lvls = Vec::new();
+//                for _ in 0..n {
+//                    let l = Univ::get(buf)?;
+//                    lvls.push(l);
+//                }
+//                Ok(Self::Refr(a, lvls))
+//            }
+//            0x20..=0x2F => {
+//                let x = Ixon::get_size(is_large, small_size, buf)?;
+//                let lvls = Ixon::get_array(buf)?;
+//                Ok(Self::Recr(x, lvls))
+//            }
+//            0x30..=0x3F => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                let f = Ixon::get(buf)?;
+//                let a = Ixon::get(buf)?;
+//                let mut args = Vec::new();
+//                for _ in 0..n {
+//                    let x = Ixon::get(buf)?;
+//                    args.push(x);
+//                }
+//                Ok(Self::Apps(Box::new(f), Box::new(a), args))
+//            }
+//            0x40..=0x4F => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                let mut ts = Vec::new();
+//                for _ in 0..n {
+//                    let x = Ixon::get(buf)?;
+//                    ts.push(x);
+//                }
+//                let b = Ixon::get(buf)?;
+//                Ok(Self::Lams(ts, Box::new(b)))
+//            }
+//            0x50..=0x5F => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                let mut ts = Vec::new();
+//                for _ in 0..n {
+//                    let x = Ixon::get(buf)?;
+//                    ts.push(x);
+//                }
+//                let b = Ixon::get(buf)?;
+//                Ok(Self::Alls(ts, Box::new(b)))
+//            }
+//            0x60..=0x6F => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                let t = Address::get(buf)?;
+//                let x = Ixon::get(buf)?;
+//                Ok(Self::Proj(t, n, Box::new(x)))
+//            }
+//            0x70..=0x7F => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                match buf.split_at_checked(n as usize) {
+//                    Some((head, rest)) => {
+//                        *buf = rest;
+//                        match String::from_utf8(head.to_owned()) {
+//                            Ok(s) => Ok(Ixon::Strl(s)),
+//                            Err(e) => Err(format!("UTF8 Error: {e}")),
+//                        }
+//                    }
+//                    None => Err("get Ixon Strl EOF".to_string()),
+//                }
+//            }
+//            0x80..=0x8F => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                match buf.split_at_checked(n as usize) {
+//                    Some((head, rest)) => {
+//                        *buf = rest;
+//                        Ok(Ixon::Natl(Nat(BigUint::from_bytes_le(head))))
+//                    }
+//                    None => Err("get Expr Natl EOF".to_string()),
+//                }
+//            }
+//            0x91..=0x92 => {
+//                let nd = tag_byte == 0x91;
+//                let t = Ixon::get(buf)?;
+//                let d = Ixon::get(buf)?;
+//                let b = Ixon::get(buf)?;
+//                Ok(Self::LetE(nd, Box::new(t), Box::new(d), Box::new(b)))
+//            }
+//            0xA0..=0xAF => {
+//                let len = Self::get_size(is_large, small_size, buf)?;
+//                let mut vec = vec![];
+//                for _ in 0..len {
+//                    let s = Ixon::get(buf)?;
+//                    vec.push(s);
+//                }
+//                Ok(Self::List(vec))
+//            }
+//            0xB0 => Ok(Self::Defn(Definition::get(buf)?)),
+//            0xB1 => Ok(Self::Axio(Axiom::get(buf)?)),
+//            0xB2 => Ok(Self::Quot(Quotient::get(buf)?)),
+//            0xB3 => Ok(Self::CPrj(ConstructorProj::get(buf)?)),
+//            0xB4 => Ok(Self::RPrj(RecursorProj::get(buf)?)),
+//            0xB5 => Ok(Self::IPrj(InductiveProj::get(buf)?)),
+//            0xB6 => Ok(Self::DPrj(DefinitionProj::get(buf)?)),
+//            0xC0..=0xCF => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                let mut inds = Vec::new();
+//                for _ in 0..n {
+//                    let x = Inductive::get(buf)?;
+//                    inds.push(x);
+//                }
+//                Ok(Self::Inds(inds))
+//            }
+//            0xD0..=0xDF => {
+//                let n = Ixon::get_size(is_large, small_size, buf)?;
+//                let mut defs = Vec::new();
+//                for _ in 0..n {
+//                    let x = Definition::get(buf)?;
+//                    defs.push(x);
+//                }
+//                Ok(Self::Defs(defs))
+//            }
+//            0xE0 => Ok(Self::Meta(Metadata::get(buf)?)),
+//            0xE1 => Ok(Self::Prof(Proof::get(buf)?)),
+//            0xE2 => Ok(Self::Eval(EvalClaim::get(buf)?)),
+//            0xE3 => Ok(Self::Chck(CheckClaim::get(buf)?)),
+//            0xE4 => Ok(Self::Comm(Comm::get(buf)?)),
+//            0xE5 => Ok(Self::Envn(Env::get(buf)?)),
+//            x => Err(format!("get Ixon invalid tag {x}")),
+//        }
+//    }
+//}
+//
+//#[cfg(test)]
+//pub mod tests {
+//    use super::*;
+//    use crate::ixon::nat::tests::arbitrary_nat;
+//    use crate::ixon::univ::tests::arbitrary_univ;
+//    use quickcheck::{Arbitrary, Gen};
+//    use std::fmt::Write;
+//    use std::ops::Range;
+//    use std::ptr;
+//
+//    pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
+//        let res: usize = Arbitrary::arbitrary(g);
+//        if range.is_empty() {
+//            0
+//        } else {
+//            (res % (range.end - range.start)) + range.start
+//        }
+//    }
+//
+//    pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
+//    where
+//        F: FnMut(&mut Gen) -> A,
+//    {
+//        let len = gen_range(g, 0..size);
+//        let mut vec = Vec::with_capacity(len);
+//        for _ in 0..len {
+//            vec.push(f(g));
+//        }
+//        vec
+//    }
+//
+//    pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
+//        let sum: usize = gens.iter().map(|x| x.0).sum();
+//        let mut weight: usize = gen_range(g, 1..sum);
+//        for (n, case) in gens {
+//            if *n == 0 {
+//                continue;
+//            } else {
+//                match weight.checked_sub(*n) {
+//                    None | Some(0) => {
+//                        return *case;
+//                    }
+//                    _ => {
+//                        weight -= *n;
+//                    }
+//                }
+//            }
+//        }
+//        unreachable!()
+//    }
+//
+//    #[test]
+//    fn unit_u64_trimmed() {
+//        fn test(input: u64, expected: Vec<u8>) -> bool {
+//            let mut tmp = Vec::new();
+//            let n = Ixon::u64_byte_count(input);
+//            Ixon::u64_put_trimmed_le(input, &mut tmp);
+//            if tmp != expected {
+//                return false;
+//            }
+//            match Ixon::u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
+//                Ok(out) => input == out,
+//                Err(e) => {
+//                    println!("err: {e}");
+//                    false
+//                }
+//            }
+//        }
+//        assert!(test(0x0, vec![]));
+//        assert!(test(0x01, vec![0x01]));
+//        assert!(test(0x0000000000000100, vec![0x00, 0x01]));
+//        assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
+//        assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
+//        assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
+//        assert!(test(
+//            0x0000010000000000,
+//            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+//        ));
+//        assert!(test(
+//            0x0001000000000000,
+//            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+//        ));
+//        assert!(test(
+//            0x0100000000000000,
+//            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+//        ));
+//        assert!(test(
+//            0x0102030405060708,
+//            vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+//        ));
+//    }
+//
+//    #[quickcheck]
+//    fn prop_u64_trimmed_le_readback(x: u64) -> bool {
+//        let mut buf = Vec::new();
+//        let n = Ixon::u64_byte_count(x);
+//        Ixon::u64_put_trimmed_le(x, &mut buf);
+//        match Ixon::u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
+//            Ok(y) => x == y,
+//            Err(e) => {
+//                println!("err: {e}");
+//                false
+//            }
+//        }
+//    }
+//
+//    #[derive(Debug, Clone, Copy)]
+//    pub enum IxonCase {
+//        Vari,
+//        Sort,
+//        Refr,
+//        Recr,
+//        Apps,
+//        Lams,
+//        Alls,
+//        Proj,
+//        Strl,
+//        Natl,
+//        LetE,
+//        List,
+//        Defn,
+//        Axio,
+//        Quot,
+//        CPrj,
+//        RPrj,
+//        IPrj,
+//        DPrj,
+//        Defs,
+//        Inds,
+//        Meta,
+//        Prof,
+//        Eval,
+//        Chck,
+//        Comm,
+//        Envn,
+//    }
+//
+//    pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
+//        let mut s = String::new();
+//        for _ in 0..cs {
+//            s.push(char::arbitrary(g));
+//        }
+//        s
+//    }
+//
+//    // incremental tree generation without recursion stack overflows
+//    pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
+//        let mut root = Ixon::Vari(0);
+//        let mut stack = vec![&mut root as *mut Ixon];
+//
+//        while let Some(ptr) = stack.pop() {
+//            let gens: Vec<(usize, IxonCase)> = vec![
+//                (100, IxonCase::Vari),
+//                (100, IxonCase::Sort),
+//                (15, IxonCase::Refr),
+//                (15, IxonCase::Recr),
+//                (15, IxonCase::Apps),
+//                (15, IxonCase::Lams),
+//                (15, IxonCase::Alls),
+//                (20, IxonCase::LetE),
+//                (50, IxonCase::Proj),
+//                (100, IxonCase::Strl),
+//                (100, IxonCase::Natl),
+//                (10, IxonCase::List),
+//                (100, IxonCase::Defn),
+//                (100, IxonCase::Axio),
+//                (100, IxonCase::Quot),
+//                (100, IxonCase::CPrj),
+//                (100, IxonCase::RPrj),
+//                (100, IxonCase::IPrj),
+//                (100, IxonCase::DPrj),
+//                (15, IxonCase::Inds),
+//                (15, IxonCase::Defs),
+//                (100, IxonCase::Meta),
+//                (100, IxonCase::Prof),
+//                (100, IxonCase::Eval),
+//                (100, IxonCase::Chck),
+//                (100, IxonCase::Comm),
+//                (100, IxonCase::Envn),
+//            ];
+//
+//            match next_case(g, &gens) {
+//                IxonCase::Vari => {
+//                    let x: u64 = Arbitrary::arbitrary(g);
+//                    unsafe {
+//                        ptr::replace(ptr, Ixon::Vari(x));
+//                    }
+//                }
+//                IxonCase::Sort => {
+//                    let u = arbitrary_univ(g, ctx);
+//                    unsafe {
+//                        ptr::replace(ptr, Ixon::Sort(Box::new(u)));
+//                    }
+//                }
+//                IxonCase::Refr => {
+//                    let addr = Address::arbitrary(g);
+//                    let mut lvls = vec![];
+//                    for _ in 0..gen_range(g, 0..9) {
+//                        lvls.push(arbitrary_univ(g, ctx));
+//                    }
+//                    unsafe {
+//                        ptr::replace(ptr, Ixon::Refr(addr, lvls));
+//                    }
+//                }
+//                IxonCase::Recr => {
+//                    let n = u64::arbitrary(g);
+//                    let mut lvls = vec![];
+//                    for _ in 0..gen_range(g, 0..9) {
+//                        lvls.push(arbitrary_univ(g, ctx));
+//                    }
+//                    unsafe {
+//                        ptr::replace(ptr, Ixon::Recr(n, lvls));
+//                    }
+//                }
+//                IxonCase::Apps => {
+//                    let mut f_box = Box::new(Ixon::default());
+//                    let f_ptr: *mut Ixon = &mut *f_box;
+//                    stack.push(f_ptr);
+//
+//                    let mut a_box = Box::new(Ixon::default());
+//                    let a_ptr: *mut Ixon = &mut *a_box;
+//                    stack.push(a_ptr);
+//
+//                    let n = gen_range(g, 0..9);
+//                    let mut xs: Vec<Ixon> = Vec::with_capacity(n);
+//                    xs.resize(n, Ixon::Vari(0));
+//                    for i in 0..n {
+//                        let p = unsafe { xs.as_mut_ptr().add(i) };
+//                        stack.push(p);
+//                    }
+//                    unsafe {
+//                        std::ptr::replace(ptr, Ixon::Apps(f_box, a_box, xs));
+//                    }
+//                }
+//                IxonCase::Lams => {
+//                    let n = gen_range(g, 0..9);
+//                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+//                    ts.resize(n, Ixon::Vari(0));
+//                    for i in 0..n {
+//                        let p = unsafe { ts.as_mut_ptr().add(i) };
+//                        stack.push(p);
+//                    }
+//                    let mut b_box = Box::new(Ixon::default());
+//                    let b_ptr: *mut Ixon = &mut *b_box;
+//                    stack.push(b_ptr);
+//                    unsafe {
+//                        std::ptr::replace(ptr, Ixon::Lams(ts, b_box));
+//                    }
+//                }
+//                IxonCase::Alls => {
+//                    let n = gen_range(g, 0..9);
+//                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+//                    ts.resize(n, Ixon::Vari(0));
+//                    for i in 0..n {
+//                        let p = unsafe { ts.as_mut_ptr().add(i) };
+//                        stack.push(p);
+//                    }
+//                    let mut b_box = Box::new(Ixon::default());
+//                    let b_ptr: *mut Ixon = &mut *b_box;
+//                    stack.push(b_ptr);
+//                    unsafe {
+//                        std::ptr::replace(ptr, Ixon::Alls(ts, b_box));
+//                    }
+//                }
+//                IxonCase::LetE => {
+//                    let nd = bool::arbitrary(g);
+//                    let mut t_box = Box::new(Ixon::default());
+//                    let t_ptr: *mut Ixon = &mut *t_box;
+//                    stack.push(t_ptr);
+//                    let mut d_box = Box::new(Ixon::default());
+//                    let d_ptr: *mut Ixon = &mut *d_box;
+//                    stack.push(d_ptr);
+//                    let mut b_box = Box::new(Ixon::default());
+//                    let b_ptr: *mut Ixon = &mut *b_box;
+//                    stack.push(b_ptr);
+//                    unsafe {
+//                        ptr::replace(ptr, Ixon::LetE(nd, t_box, d_box, b_box));
+//                    }
+//                }
+//                IxonCase::Proj => {
+//                    let addr = Address::arbitrary(g);
+//                    let n = u64::arbitrary(g);
+//                    let mut t_box = Box::new(Ixon::default());
+//                    let t_ptr: *mut Ixon = &mut *t_box;
+//                    stack.push(t_ptr);
+//                    unsafe {
+//                        ptr::replace(ptr, Ixon::Proj(addr, n, t_box));
+//                    }
+//                }
+//                IxonCase::Strl => unsafe {
+//                    let size = gen_range(g, 0..9);
+//                    ptr::replace(ptr, Ixon::Strl(arbitrary_string(g, size)));
+//                },
+//                IxonCase::Natl => {
+//                    let size = gen_range(g, 0..9);
+//                    unsafe {
+//                        ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
+//                    }
+//                }
+//                IxonCase::List => {
+//                    let n = gen_range(g, 0..9);
+//                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+//                    ts.resize(n, Ixon::Vari(0));
+//                    for i in 0..n {
+//                        let p = unsafe { ts.as_mut_ptr().add(i) };
+//                        stack.push(p);
+//                    }
+//                    unsafe {
+//                        std::ptr::replace(ptr, Ixon::List(ts));
+//                    }
+//                }
+//                IxonCase::Quot => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Quot(Quotient::arbitrary(g)));
+//                },
+//                IxonCase::Axio => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Axio(Axiom::arbitrary(g)));
+//                },
+//                IxonCase::Defn => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
+//                },
+//                IxonCase::CPrj => unsafe {
+//                    std::ptr::replace(ptr, Ixon::CPrj(ConstructorProj::arbitrary(g)));
+//                },
+//                IxonCase::RPrj => unsafe {
+//                    std::ptr::replace(ptr, Ixon::RPrj(RecursorProj::arbitrary(g)));
+//                },
+//                IxonCase::DPrj => unsafe {
+//                    std::ptr::replace(ptr, Ixon::DPrj(DefinitionProj::arbitrary(g)));
+//                },
+//                IxonCase::IPrj => unsafe {
+//                    std::ptr::replace(ptr, Ixon::IPrj(InductiveProj::arbitrary(g)));
+//                },
+//                IxonCase::Inds => unsafe {
+//                    let inds = gen_vec(g, 9, Inductive::arbitrary);
+//                    std::ptr::replace(ptr, Ixon::Inds(inds));
+//                },
+//                IxonCase::Defs => unsafe {
+//                    let defs = gen_vec(g, 9, Definition::arbitrary);
+//                    std::ptr::replace(ptr, Ixon::Defs(defs));
+//                },
+//                IxonCase::Meta => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
+//                },
+//                IxonCase::Prof => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Prof(Proof::arbitrary(g)));
+//                },
+//                IxonCase::Eval => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Eval(EvalClaim::arbitrary(g)));
+//                },
+//                IxonCase::Chck => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Chck(CheckClaim::arbitrary(g)));
+//                },
+//                IxonCase::Comm => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
+//                },
+//                IxonCase::Envn => unsafe {
+//                    std::ptr::replace(ptr, Ixon::Envn(Env::arbitrary(g)));
+//                },
+//            }
+//        }
+//        root
+//    }
+//
+//    impl Arbitrary for Ixon {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let ctx: u64 = Arbitrary::arbitrary(g);
+//            arbitrary_ixon(g, ctx)
+//        }
+//    }
+//
+//    #[quickcheck]
+//    fn prop_ixon_readback(x: Ixon) -> bool {
+//        let mut buf = Vec::new();
+//        Ixon::put(&x, &mut buf);
+//        match Ixon::get(&mut buf.as_slice()) {
+//            Ok(y) => x == y,
+//            Err(e) => {
+//                println!("err: {e}");
+//                false
+//            }
+//        }
+//    }
+//
+//    /// Parse a hex string (optional `0x`/`0X` prefix, `_` separators OK) into bytes.
+//    pub fn parse_hex(s: &str) -> Result<Vec<u8>, String> {
+//        // Strip prefix, drop underscores, and require an even count of hex digits.
+//        let s = s.trim();
+//        let s = s
+//            .strip_prefix("0x")
+//            .or_else(|| s.strip_prefix("0X"))
+//            .unwrap_or(s);
+//        let clean: String = s.chars().filter(|&c| c != '_').collect();
+//
+//        if clean.len() % 2 != 0 {
+//            return Err("odd number of hex digits".into());
+//        }
+//
+//        // Parse each 2-char chunk as a byte.
+//        (0..clean.len())
+//            .step_by(2)
+//            .map(|i| {
+//                u8::from_str_radix(&clean[i..i + 2], 16)
+//                    .map_err(|_| format!("invalid hex at chars {}..{}", i, i + 2))
+//            })
+//            .collect()
+//    }
+//
+//    /// Format bytes as a lowercase hex string with a `0x` prefix.
+//    pub fn to_hex(bytes: &[u8]) -> String {
+//        let mut out = String::with_capacity(2 + bytes.len() * 2);
+//        out.push_str("0x");
+//        for b in bytes {
+//            // `{:02x}` = two lowercase hex digits, zero-padded.
+//            write!(&mut out, "{b:02x}").unwrap();
+//        }
+//        out
+//    }
+//
+//    #[test]
+//    fn unit_ixon() {
+//        fn test(input: Ixon, expected: &str) -> bool {
+//            let mut tmp = Vec::new();
+//            let expect = parse_hex(expected).unwrap();
+//            Serialize::put(&input, &mut tmp);
+//            if tmp != expect {
+//                println!(
+//                    "serialied {input:?} as:\n {}\n test expects:\n {}",
+//                    to_hex(&tmp),
+//                    to_hex(&expect),
+//                );
+//                return false;
+//            }
+//            match Serialize::get(&mut tmp.as_slice()) {
+//                Ok(output) => {
+//                    if input != output {
+//                        println!(
+//                            "deserialized {} as {output:?}, expected {input:?}",
+//                            to_hex(&tmp)
+//                        );
+//                        false
+//                    } else {
+//                        true
+//                    }
+//                }
+//                Err(e) => {
+//                    println!("err: {e}");
+//                    false
+//                }
+//            }
+//        }
+//        assert!(test(Ixon::Vari(0x0), "0x00"));
+//        assert!(test(Ixon::Vari(0x7), "0x07"));
+//        assert!(test(Ixon::Vari(0x8), "0x0808"));
+//        assert!(test(Ixon::Vari(0xff), "0x08FF"));
+//        assert!(test(Ixon::Vari(0x0100), "0x090001"));
+//        assert!(test(Ixon::Vari(0xFFFF), "0x09FFFF"));
+//        assert!(test(Ixon::Vari(0x010000), "0x0A000001"));
+//        assert!(test(Ixon::Vari(0xFFFFFF), "0x0AFFFFFF"));
+//        assert!(test(Ixon::Vari(0x01000000), "0x0B00000001"));
+//        assert!(test(Ixon::Vari(0xFFFFFFFF), "0x0BFFFFFFFF"));
+//        assert!(test(Ixon::Vari(0x0100000000), "0x0C0000000001"));
+//        assert!(test(Ixon::Vari(0xFFFFFFFFFF), "0x0CFFFFFFFFFF"));
+//        assert!(test(Ixon::Vari(0x010000000000), "0x0D000000000001"));
+//        assert!(test(Ixon::Vari(0xFFFFFFFFFFFF), "0x0DFFFFFFFFFFFF"));
+//        assert!(test(Ixon::Vari(0x01000000000000), "0x0E00000000000001"));
+//        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFF), "0x0EFFFFFFFFFFFFFF"));
+//        assert!(test(Ixon::Vari(0x0100000000000000), "0x0F0000000000000001"));
+//        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFFFF), "0x0FFFFFFFFFFFFFFFFF"));
+//        // universes use 2-bit sub-tags
+//        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x0))), "0x9000"));
+//        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x1F))), "0x901F"));
+//        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x20))), "0x902020"));
+//        assert!(test(Ixon::Sort(Box::new(Univ::Const(0xFF))), "0x9020FF"));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0x0100))),
+//            "0x90210001"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0xFFFF))),
+//            "0x9021FFFF"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0x010000))),
+//            "0x9022000001"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFF))),
+//            "0x9022FFFFFF"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0x01000000))),
+//            "0x902300000001"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFF))),
+//            "0x9023FFFFFFFF"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0x0100000000))),
+//            "0x90240000000001"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFF))),
+//            "0x9024FFFFFFFFFF"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0x010000000000))),
+//            "0x9025000000000001"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFF))),
+//            "0x9025FFFFFFFFFFFF"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0x01000000000000))),
+//            "0x902600000000000001"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFF))),
+//            "0x9026FFFFFFFFFFFFFF"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0x0100000000000000))),
+//            "0x90270000000000000001"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFFFF))),
+//            "0x9027FFFFFFFFFFFFFFFF"
+//        ));
+//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0))), "0x9040"));
+//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x1F))), "0x905F"));
+//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x20))), "0x906020"));
+//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0xFF))), "0x9060FF"));
+//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0100))), "0x90610001"));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Var(0xFFFFFFFFFFFFFFFF))),
+//            "0x9067FFFFFFFFFFFFFFFF"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Const(0x0))))),
+//            "0x908000"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Var(0x0))))),
+//            "0x908040"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Add(0x1F, Box::new(Univ::Var(0x0))))),
+//            "0x909F40"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Add(0x20, Box::new(Univ::Var(0x0))))),
+//            "0x90A02040"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Add(0xFF, Box::new(Univ::Var(0x0))))),
+//            "0x90A0FF40"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Add(
+//                0xFFFF_FFFF_FFFF_FFFF,
+//                Box::new(Univ::Var(0x0))
+//            ))),
+//            "0x90A7FFFFFFFFFFFFFFFF40"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Max(
+//                Box::new(Univ::Var(0x0)),
+//                Box::new(Univ::Var(0x0))
+//            ))),
+//            "0x90C04040"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Max(
+//                Box::new(Univ::Var(0x0)),
+//                Box::new(Univ::Var(0x1))
+//            ))),
+//            "0x90C04041"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Max(
+//                Box::new(Univ::Var(0x1)),
+//                Box::new(Univ::Var(0x0))
+//            ))),
+//            "0x90C04140"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::Max(
+//                Box::new(Univ::Var(0x1)),
+//                Box::new(Univ::Var(0x1))
+//            ))),
+//            "0x90C04141"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::IMax(
+//                Box::new(Univ::Var(0x0)),
+//                Box::new(Univ::Var(0x0))
+//            ))),
+//            "0x90C14040"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::IMax(
+//                Box::new(Univ::Var(0x0)),
+//                Box::new(Univ::Var(0x1))
+//            ))),
+//            "0x90C14041"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::IMax(
+//                Box::new(Univ::Var(0x1)),
+//                Box::new(Univ::Var(0x0))
+//            ))),
+//            "0x90C14140"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::IMax(
+//                Box::new(Univ::Var(0x1)),
+//                Box::new(Univ::Var(0x1))
+//            ))),
+//            "0x90C14141"
+//        ));
+//        assert!(test(
+//            Ixon::Sort(Box::new(Univ::IMax(
+//                Box::new(Univ::Var(0x1)),
+//                Box::new(Univ::Var(0x1))
+//            ))),
+//            "0x90C14141"
+//        ));
+//        assert!(test(
+//            Ixon::Refr(Address::hash(&[]), vec![]),
+//            "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::Refr(Address::hash(&[]), vec![Univ::Var(0x0)]),
+//            "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240"
+//        ));
+//        assert!(test(Ixon::Recr(0x0, vec![Univ::Var(0x0)]), "0x20A140"));
+//        assert!(test(
+//            Ixon::Recr(0x0, vec![Univ::Var(0x0), Univ::Var(0x1)]),
+//            "0x20A24041"
+//        ));
+//        assert!(test(
+//            Ixon::Recr(0x8, vec![Univ::Var(0x0), Univ::Var(0x1)]),
+//            "0x2808A24041"
+//        ));
+//        assert!(test(
+//            Ixon::Apps(Box::new(Ixon::Vari(0x0)), Box::new(Ixon::Vari(0x1)), vec![]),
+//            "0x300001"
+//        ));
+//        assert!(test(
+//            Ixon::Apps(
+//                Box::new(Ixon::Vari(0x0)),
+//                Box::new(Ixon::Vari(0x1)),
+//                vec![Ixon::Vari(0x2)]
+//            ),
+//            "0x31000102"
+//        ));
+//        assert!(test(
+//            Ixon::Apps(
+//                Box::new(Ixon::Vari(0x0)),
+//                Box::new(Ixon::Vari(0x1)),
+//                vec![
+//                    Ixon::Vari(0x2),
+//                    Ixon::Vari(0x3),
+//                    Ixon::Vari(0x4),
+//                    Ixon::Vari(0x5),
+//                    Ixon::Vari(0x6),
+//                    Ixon::Vari(0x7),
+//                    Ixon::Vari(0x8),
+//                    Ixon::Vari(0x9),
+//                ]
+//            ),
+//            "0x3808000102030405060708080809"
+//        ));
+//        assert!(test(
+//            Ixon::Lams(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
+//            "0x410001"
+//        ));
+//        assert!(test(
+//            Ixon::Lams(
+//                vec![
+//                    Ixon::Vari(0x0),
+//                    Ixon::Vari(0x1),
+//                    Ixon::Vari(0x2),
+//                    Ixon::Vari(0x3),
+//                    Ixon::Vari(0x4),
+//                    Ixon::Vari(0x5),
+//                    Ixon::Vari(0x6),
+//                    Ixon::Vari(0x7)
+//                ],
+//                Box::new(Ixon::Vari(0x8))
+//            ),
+//            "0x480800010203040506070808"
+//        ));
+//        assert!(test(
+//            Ixon::Alls(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
+//            "0x510001"
+//        ));
+//        assert!(test(
+//            Ixon::Alls(
+//                vec![
+//                    Ixon::Vari(0x0),
+//                    Ixon::Vari(0x1),
+//                    Ixon::Vari(0x2),
+//                    Ixon::Vari(0x3),
+//                    Ixon::Vari(0x4),
+//                    Ixon::Vari(0x5),
+//                    Ixon::Vari(0x6),
+//                    Ixon::Vari(0x7)
+//                ],
+//                Box::new(Ixon::Vari(0x8))
+//            ),
+//            "0x580800010203040506070808"
+//        ));
+//        assert!(test(
+//            Ixon::Proj(Address::hash(&[]), 0x0, Box::new(Ixon::Vari(0x0))),
+//            "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
+//        ));
+//        assert!(test(
+//            Ixon::Proj(Address::hash(&[]), 0x8, Box::new(Ixon::Vari(0x0))),
+//            "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
+//        ));
+//        assert!(test(Ixon::Strl("".to_string()), "0x70"));
+//        assert!(test(Ixon::Strl("foobar".to_string()), "0x76666f6f626172"));
+//        assert!(test(Ixon::Natl(Nat::new_le(&[])), "0x8100"));
+//        assert!(test(Ixon::Natl(Nat::new_le(&[0x0])), "0x8100"));
+//        assert!(test(Ixon::Natl(Nat::new_le(&[0xFF])), "0x81FF"));
+//        assert!(test(Ixon::Natl(Nat::new_le(&[0x00, 0x01])), "0x820001"));
+//        assert!(test(
+//            Ixon::LetE(
+//                true,
+//                Box::new(Ixon::Vari(0x0)),
+//                Box::new(Ixon::Vari(0x1)),
+//                Box::new(Ixon::Vari(0x2))
+//            ),
+//            "0x91000102"
+//        ));
+//        assert!(test(Ixon::List(vec![]), "0xA0"));
+//        assert!(test(
+//            Ixon::List(vec![Ixon::Vari(0x0), Ixon::Vari(0x1), Ixon::Vari(0x2)]),
+//            "0xA3000102"
+//        ));
+//        assert!(test(
+//            Ixon::Defn(Definition {
+//                kind: DefKind::Definition,
+//                safety: DefSafety::Unsafe,
+//                lvls: 0u64.into(),
+//                typ: Address::hash(&[]),
+//                value: Address::hash(&[]),
+//            }),
+//            "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::Defn(Definition {
+//                kind: DefKind::Opaque,
+//                safety: DefSafety::Safe,
+//                lvls: 1u64.into(),
+//                typ: Address::hash(&[]),
+//                value: Address::hash(&[]),
+//            }),
+//            "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::Axio(Axiom {
+//                is_unsafe: true,
+//                lvls: 0u64.into(),
+//                typ: Address::hash(&[]),
+//            }),
+//            "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::Quot(Quotient {
+//                kind: QuotKind::Type,
+//                lvls: 0u64.into(),
+//                typ: Address::hash(&[]),
+//            }),
+//            "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::CPrj(ConstructorProj {
+//                idx: 0u64.into(),
+//                cidx: 0u64.into(),
+//                block: Address::hash(&[]),
+//            }),
+//            "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::RPrj(RecursorProj {
+//                idx: 0u64.into(),
+//                ridx: 0u64.into(),
+//                block: Address::hash(&[]),
+//            }),
+//            "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::IPrj(InductiveProj {
+//                idx: 0u64.into(),
+//                block: Address::hash(&[]),
+//            }),
+//            "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::DPrj(DefinitionProj {
+//                idx: 0u64.into(),
+//                block: Address::hash(&[]),
+//            }),
+//            "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(Ixon::Inds(vec![]), "0xC0"));
+//        assert!(test(
+//            Ixon::Inds(vec![Inductive {
+//                recr: false,
+//                refl: false,
+//                is_unsafe: false,
+//                lvls: 0u64.into(),
+//                params: 0u64.into(),
+//                indices: 0u64.into(),
+//                nested: 0u64.into(),
+//                typ: Address::hash(&[]),
+//                ctors: vec![],
+//                recrs: vec![],
+//            }]),
+//            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
+//        ));
+//        assert!(test(
+//            Ixon::Inds(vec![Inductive {
+//                recr: false,
+//                refl: false,
+//                is_unsafe: false,
+//                lvls: 0u64.into(),
+//                params: 0u64.into(),
+//                indices: 0u64.into(),
+//                nested: 0u64.into(),
+//                typ: Address::hash(&[]),
+//                ctors: vec![],
+//                recrs: vec![],
+//            }]),
+//            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
+//        ));
+//        assert!(test(
+//            Ixon::Inds(vec![Inductive {
+//                recr: false,
+//                refl: false,
+//                is_unsafe: false,
+//                lvls: 0u64.into(),
+//                params: 0u64.into(),
+//                indices: 0u64.into(),
+//                nested: 0u64.into(),
+//                typ: Address::hash(&[]),
+//                ctors: vec![Constructor {
+//                    is_unsafe: false,
+//                    lvls: 0u64.into(),
+//                    cidx: 0u64.into(),
+//                    params: 0u64.into(),
+//                    fields: 0u64.into(),
+//                    typ: Address::hash(&[])
+//                }],
+//                recrs: vec![Recursor {
+//                    k: false,
+//                    is_unsafe: false,
+//                    lvls: 0u64.into(),
+//                    params: 0u64.into(),
+//                    indices: 0u64.into(),
+//                    motives: 0u64.into(),
+//                    minors: 0u64.into(),
+//                    typ: Address::hash(&[]),
+//                    rules: vec![RecursorRule {
+//                        fields: 0u64.into(),
+//                        rhs: Address::hash(&[])
+//                    }]
+//                }],
+//            }]),
+//            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(Ixon::Defs(vec![]), "0xD0"));
+//        assert!(test(
+//            Ixon::Defs(vec![Definition {
+//                kind: DefKind::Definition,
+//                safety: DefSafety::Unsafe,
+//                lvls: 0u64.into(),
+//                typ: Address::hash(&[]),
+//                value: Address::hash(&[]),
+//            }]),
+//            "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(Ixon::Meta(Metadata { map: vec![] }), "0xE0A0"));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(0u64.into(), vec![])]
+//            }),
+//            "0xE0A18100A0"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(0u64.into(), vec![Metadatum::Name(Name { parts: vec![] })])]
+//            }),
+//            "0xE0A18100A100A0"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(
+//                    0u64.into(),
+//                    vec![Metadatum::Name(Name {
+//                        parts: vec![NamePart::Str("a".to_string())]
+//                    })]
+//                )]
+//            }),
+//            "0xE0A18100A100A17161"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(
+//                    0u64.into(),
+//                    vec![Metadatum::Name(Name {
+//                        parts: vec![
+//                            NamePart::Str("a".to_string()),
+//                            NamePart::Str("b".to_string()),
+//                        ]
+//                    })]
+//                )]
+//            }),
+//            "0xE0A18100A100A271617162"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(
+//                    0u64.into(),
+//                    vec![Metadatum::Name(Name {
+//                        parts: vec![
+//                            NamePart::Str("a".to_string()),
+//                            NamePart::Str("b".to_string()),
+//                            NamePart::Str("c".to_string()),
+//                        ]
+//                    })]
+//                )]
+//            }),
+//            "0xE0A18100A100A3716171627163"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(
+//                    0u64.into(),
+//                    vec![Metadatum::Name(Name {
+//                        parts: vec![NamePart::Num(165851424810452359u64.into())]
+//                    })]
+//                )]
+//            }),
+//            "0xE0A18100A100A1880887C551FDFD384D02"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(0u64.into(), vec![Metadatum::Info(BinderInfo::Default)])]
+//            }),
+//            "0xE0A18100A10100"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(0u64.into(), vec![Metadatum::Link(Address::hash(&[]))])]
+//            }),
+//            "0xE0A18100A102af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(
+//                    0u64.into(),
+//                    vec![
+//                        Metadatum::Name(Name {
+//                            parts: vec![NamePart::Str("d".to_string())]
+//                        }),
+//                        Metadatum::Link(Address::hash(&[])),
+//                        Metadatum::Hints(ReducibilityHints::Regular(576554452)),
+//                        Metadatum::Link(Address::hash(&[]))
+//                    ]
+//                )]
+//            }),
+//            "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(
+//                    0u64.into(),
+//                    vec![Metadatum::Hints(ReducibilityHints::Opaque)]
+//                )]
+//            }),
+//            "0xE0A18100A10300"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(0u64.into(), vec![Metadatum::All(vec![])])]
+//            }),
+//            "0xE0A18100A104A0"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(0u64.into(), vec![Metadatum::MutCtx(vec![])])]
+//            }),
+//            "0xE0A18100A105A0"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![(
+//                    0u64.into(),
+//                    vec![Metadatum::Hints(ReducibilityHints::Regular(42))]
+//                )]
+//            }),
+//            "0xe0a18100a103022a000000"
+//        ));
+//        assert!(test(
+//            Ixon::Meta(Metadata {
+//                map: vec![
+//                    (
+//                        0u64.into(),
+//                        vec![
+//                            Metadatum::Name(Name {
+//                                parts: vec![NamePart::Str("d".to_string())]
+//                            }),
+//                            Metadatum::Link(Address::hash(&[])),
+//                            Metadatum::Hints(ReducibilityHints::Regular(576554452)),
+//                            Metadatum::Link(Address::hash(&[]))
+//                        ]
+//                    ),
+//                    (
+//                        1u64.into(),
+//                        vec![
+//                            Metadatum::Info(BinderInfo::InstImplicit),
+//                            Metadatum::Info(BinderInfo::InstImplicit),
+//                            Metadatum::Info(BinderInfo::StrictImplicit),
+//                        ]
+//                    ),
+//                    (
+//                        2u64.into(),
+//                        vec![
+//                            Metadatum::All(vec![Name {
+//                                parts: vec![NamePart::Num(165851424810452359u64.into())]
+//                            }]),
+//                            Metadatum::Info(BinderInfo::Default)
+//                        ]
+//                    ),
+//                    (3u64.into(), vec![]),
+//                    (4u64.into(), vec![]),
+//                    (
+//                        5u64.into(),
+//                        vec![Metadatum::Hints(ReducibilityHints::Opaque)]
+//                    ),
+//                    (
+//                        6u64.into(),
+//                        vec![Metadatum::Name(Name {
+//                            parts: vec![NamePart::Num(871843802607008850u64.into())]
+//                        })]
+//                    )
+//                ]
+//            }),
+//            "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
+//        ));
+//    }
 //}
+//
+////}
diff --git a/src/ixon/claim.rs b/src/ixon/claim.rs
index 377f3af2..3a5a5ba7 100644
--- a/src/ixon/claim.rs
+++ b/src/ixon/claim.rs
@@ -1,5 +1,5 @@
 use crate::ixon::address::Address;
-use crate::ixon::serialize::Serialize;
+//use crate::ixon::serialize::Serialize;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EvalClaim {
@@ -33,162 +33,162 @@ pub struct Env {
     pub env: Vec<(Address, Address)>,
 }
 
-impl Serialize for EvalClaim {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.lvls.put(buf);
-        self.typ.put(buf);
-        self.input.put(buf);
-        self.output.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let lvls = Address::get(buf)?;
-        let typ = Address::get(buf)?;
-        let input = Address::get(buf)?;
-        let output = Address::get(buf)?;
-        Ok(Self {
-            lvls,
-            typ,
-            input,
-            output,
-        })
-    }
-}
-
-impl Serialize for CheckClaim {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.lvls.put(buf);
-        self.typ.put(buf);
-        self.value.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let lvls = Address::get(buf)?;
-        let typ = Address::get(buf)?;
-        let value = Address::get(buf)?;
-        Ok(Self { lvls, typ, value })
-    }
-}
-
-impl Serialize for Claim {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Evals(x) => {
-                u8::put(&0xE2, buf);
-                x.put(buf)
-            }
-            Self::Checks(x) => {
-                u8::put(&0xE3, buf);
-                x.put(buf)
-            }
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(1) {
-            Some((head, rest)) => {
-                *buf = rest;
-                match head[0] {
-                    0xE2 => {
-                        let x = EvalClaim::get(buf)?;
-                        Ok(Self::Evals(x))
-                    }
-                    0xE3 => {
-                        let x = CheckClaim::get(buf)?;
-                        Ok(Self::Checks(x))
-                    }
-                    x => Err(format!("get Claim invalid {x}")),
-                }
-            }
-            None => Err("get Claim EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for Proof {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.claim.put(buf);
-        self.proof.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let claim = Claim::get(buf)?;
-        let proof = Serialize::get(buf)?;
-        Ok(Proof { claim, proof })
-    }
-}
-
-impl Serialize for Env {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.env.put(buf)
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        Ok(Env {
-            env: Serialize::get(buf)?,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ixon::tests::gen_range;
-    use quickcheck::{Arbitrary, Gen};
-
-    impl Arbitrary for EvalClaim {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                lvls: Address::arbitrary(g),
-                typ: Address::arbitrary(g),
-                input: Address::arbitrary(g),
-                output: Address::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for CheckClaim {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                lvls: Address::arbitrary(g),
-                typ: Address::arbitrary(g),
-                value: Address::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for Claim {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..1);
-            match x {
-                0 => Self::Evals(EvalClaim::arbitrary(g)),
-                _ => Self::Checks(CheckClaim::arbitrary(g)),
-            }
-        }
-    }
-
-    impl Arbitrary for Proof {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..32);
-            let mut bytes = vec![];
-            for _ in 0..x {
-                bytes.push(u8::arbitrary(g));
-            }
-            Proof {
-                claim: Claim::arbitrary(g),
-                proof: bytes,
-            }
-        }
-    }
-
-    impl Arbitrary for Env {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..32);
-            let mut env = vec![];
-            for _ in 0..x {
-                env.push((Address::arbitrary(g), Address::arbitrary(g)));
-            }
-            Env { env }
-        }
-    }
-}
+//impl Serialize for EvalClaim {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.lvls.put(buf);
+//        self.typ.put(buf);
+//        self.input.put(buf);
+//        self.output.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let lvls = Address::get(buf)?;
+//        let typ = Address::get(buf)?;
+//        let input = Address::get(buf)?;
+//        let output = Address::get(buf)?;
+//        Ok(Self {
+//            lvls,
+//            typ,
+//            input,
+//            output,
+//        })
+//    }
+//}
+//
+//impl Serialize for CheckClaim {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.lvls.put(buf);
+//        self.typ.put(buf);
+//        self.value.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let lvls = Address::get(buf)?;
+//        let typ = Address::get(buf)?;
+//        let value = Address::get(buf)?;
+//        Ok(Self { lvls, typ, value })
+//    }
+//}
+//
+//impl Serialize for Claim {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Evals(x) => {
+//                u8::put(&0xE2, buf);
+//                x.put(buf)
+//            }
+//            Self::Checks(x) => {
+//                u8::put(&0xE3, buf);
+//                x.put(buf)
+//            }
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match buf.split_at_checked(1) {
+//            Some((head, rest)) => {
+//                *buf = rest;
+//                match head[0] {
+//                    0xE2 => {
+//                        let x = EvalClaim::get(buf)?;
+//                        Ok(Self::Evals(x))
+//                    }
+//                    0xE3 => {
+//                        let x = CheckClaim::get(buf)?;
+//                        Ok(Self::Checks(x))
+//                    }
+//                    x => Err(format!("get Claim invalid {x}")),
+//                }
+//            }
+//            None => Err("get Claim EOF".to_string()),
+//        }
+//    }
+//}
+//
+//impl Serialize for Proof {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.claim.put(buf);
+//        self.proof.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let claim = Claim::get(buf)?;
+//        let proof = Serialize::get(buf)?;
+//        Ok(Proof { claim, proof })
+//    }
+//}
+//
+//impl Serialize for Env {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.env.put(buf)
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        Ok(Env {
+//            env: Serialize::get(buf)?,
+//        })
+//    }
+//}
+//
+//#[cfg(test)]
+//mod tests {
+//    use super::*;
+//    use crate::ixon::tests::gen_range;
+//    use quickcheck::{Arbitrary, Gen};
+//
+//    impl Arbitrary for EvalClaim {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                lvls: Address::arbitrary(g),
+//                typ: Address::arbitrary(g),
+//                input: Address::arbitrary(g),
+//                output: Address::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for CheckClaim {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                lvls: Address::arbitrary(g),
+//                typ: Address::arbitrary(g),
+//                value: Address::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Claim {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..1);
+//            match x {
+//                0 => Self::Evals(EvalClaim::arbitrary(g)),
+//                _ => Self::Checks(CheckClaim::arbitrary(g)),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Proof {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..32);
+//            let mut bytes = vec![];
+//            for _ in 0..x {
+//                bytes.push(u8::arbitrary(g));
+//            }
+//            Proof {
+//                claim: Claim::arbitrary(g),
+//                proof: bytes,
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Env {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..32);
+//            let mut env = vec![];
+//            for _ in 0..x {
+//                env.push((Address::arbitrary(g), Address::arbitrary(g)));
+//            }
+//            Env { env }
+//        }
+//    }
+//}
diff --git a/src/ixon/constant.rs b/src/ixon/constant.rs
index 178d5435..44ba6ab2 100644
--- a/src/ixon/constant.rs
+++ b/src/ixon/constant.rs
@@ -1,7 +1,7 @@
 use crate::ixon::address::Address;
 use crate::ixon::nat::Nat;
-use crate::ixon::serialize::Serialize;
-use crate::ixon::*;
+//use crate::ixon::serialize::Serialize;
+//use crate::ixon::*;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum QuotKind {
@@ -88,7 +88,13 @@ pub struct Inductive {
     pub nested: Nat,
     pub typ: Address,
     pub ctors: Vec<Constructor>,
-    pub recrs: Vec<Recursor>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MutConst {
+    Defn(Definition),
+    Indc(Inductive),
+    Recr(Recursor),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -123,511 +129,518 @@ pub struct Comm {
     pub payload: Address,
 }
 
-impl Serialize for QuotKind {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Type => buf.push(0),
-            Self::Ctor => buf.push(1),
-            Self::Lift => buf.push(2),
-            Self::Ind => buf.push(3),
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(1) {
-            Some((head, rest)) => {
-                *buf = rest;
-                match head[0] {
-                    0 => Ok(Self::Type),
-                    1 => Ok(Self::Ctor),
-                    2 => Ok(Self::Lift),
-                    3 => Ok(Self::Ind),
-                    x => Err(format!("get QuotKind invalid {x}")),
-                }
-            }
-            None => Err("get QuotKind EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for Quotient {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.kind.put(buf);
-        self.lvls.put(buf);
-        self.typ.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let kind = QuotKind::get(buf)?;
-        let lvls = Nat::get(buf)?;
-        let typ = Address::get(buf)?;
-        Ok(Quotient { kind, lvls, typ })
-    }
-}
-
-impl Serialize for Axiom {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.is_unsafe.put(buf);
-        self.lvls.put(buf);
-        self.typ.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let is_unsafe = bool::get(buf)?;
-        let lvls = Nat::get(buf)?;
-        let typ = Address::get(buf)?;
-        Ok(Axiom {
-            lvls,
-            typ,
-            is_unsafe,
-        })
-    }
-}
-
-impl Serialize for DefKind {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Definition => buf.push(0),
-            Self::Opaque => buf.push(1),
-            Self::Theorem => buf.push(2),
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(1) {
-            Some((head, rest)) => {
-                *buf = rest;
-                match head[0] {
-                    0 => Ok(Self::Definition),
-                    1 => Ok(Self::Opaque),
-                    2 => Ok(Self::Theorem),
-                    x => Err(format!("get DefKind invalid {x}")),
-                }
-            }
-            None => Err("get DefKind EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for DefSafety {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Unsafe => buf.push(0),
-            Self::Safe => buf.push(1),
-            Self::Partial => buf.push(2),
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(1) {
-            Some((head, rest)) => {
-                *buf = rest;
-                match head[0] {
-                    0 => Ok(Self::Unsafe),
-                    1 => Ok(Self::Safe),
-                    2 => Ok(Self::Partial),
-                    x => Err(format!("get DefSafety invalid {x}")),
-                }
-            }
-            None => Err("get DefSafety EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for Definition {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.kind.put(buf);
-        self.safety.put(buf);
-        self.lvls.put(buf);
-        self.typ.put(buf);
-        self.value.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let kind = DefKind::get(buf)?;
-        let safety = DefSafety::get(buf)?;
-        let lvls = Nat::get(buf)?;
-        let typ = Address::get(buf)?;
-        let value = Address::get(buf)?;
-        Ok(Definition {
-            kind,
-            safety,
-            lvls,
-            typ,
-            value,
-        })
-    }
-}
-
-impl Serialize for Constructor {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.is_unsafe.put(buf);
-        self.lvls.put(buf);
-        self.cidx.put(buf);
-        self.params.put(buf);
-        self.fields.put(buf);
-        self.typ.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let is_unsafe = bool::get(buf)?;
-        let lvls = Nat::get(buf)?;
-        let cidx = Nat::get(buf)?;
-        let params = Nat::get(buf)?;
-        let fields = Nat::get(buf)?;
-        let typ = Address::get(buf)?;
-        Ok(Constructor {
-            lvls,
-            typ,
-            cidx,
-            params,
-            fields,
-            is_unsafe,
-        })
-    }
-}
-
-impl Serialize for RecursorRule {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.fields.put(buf);
-        self.rhs.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let fields = Nat::get(buf)?;
-        let rhs = Address::get(buf)?;
-        Ok(RecursorRule { fields, rhs })
-    }
-}
-
-impl Serialize for Recursor {
-    fn put(&self, buf: &mut Vec<u8>) {
-        Ixon::pack_bools(vec![self.k, self.is_unsafe]).put(buf);
-        self.lvls.put(buf);
-        self.params.put(buf);
-        self.indices.put(buf);
-        self.motives.put(buf);
-        self.minors.put(buf);
-        self.typ.put(buf);
-        self.rules.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let bools = Ixon::unpack_bools(2, u8::get(buf)?);
-        let lvls = Nat::get(buf)?;
-        let params = Nat::get(buf)?;
-        let indices = Nat::get(buf)?;
-        let motives = Nat::get(buf)?;
-        let minors = Nat::get(buf)?;
-        let typ = Serialize::get(buf)?;
-        let rules = Serialize::get(buf)?;
-        Ok(Recursor {
-            lvls,
-            typ,
-            params,
-            indices,
-            motives,
-            minors,
-            rules,
-            k: bools[0],
-            is_unsafe: bools[1],
-        })
-    }
-}
-
-impl Serialize for Inductive {
-    fn put(&self, buf: &mut Vec<u8>) {
-        Ixon::pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
-        self.lvls.put(buf);
-        self.params.put(buf);
-        self.indices.put(buf);
-        self.nested.put(buf);
-        self.typ.put(buf);
-        Serialize::put(&self.ctors, buf);
-        Serialize::put(&self.recrs, buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let bools = Ixon::unpack_bools(3, u8::get(buf)?);
-        let lvls = Nat::get(buf)?;
-        let params = Nat::get(buf)?;
-        let indices = Nat::get(buf)?;
-        let nested = Nat::get(buf)?;
-        let typ = Address::get(buf)?;
-        let ctors = Serialize::get(buf)?;
-        let recrs = Serialize::get(buf)?;
-        Ok(Inductive {
-            recr: bools[0],
-            refl: bools[1],
-            is_unsafe: bools[2],
-            lvls,
-            params,
-            indices,
-            nested,
-            typ,
-            ctors,
-            recrs,
-        })
-    }
-}
-
-impl Serialize for InductiveProj {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.idx.put(buf);
-        self.block.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let idx = Nat::get(buf)?;
-        let block = Address::get(buf)?;
-        Ok(InductiveProj { idx, block })
-    }
-}
-
-impl Serialize for ConstructorProj {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.idx.put(buf);
-        self.cidx.put(buf);
-        self.block.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let idx = Nat::get(buf)?;
-        let cidx = Nat::get(buf)?;
-        let block = Address::get(buf)?;
-        Ok(ConstructorProj { idx, cidx, block })
-    }
-}
-
-impl Serialize for RecursorProj {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.idx.put(buf);
-        self.ridx.put(buf);
-        self.block.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let idx = Nat::get(buf)?;
-        let ridx = Nat::get(buf)?;
-        let block = Address::get(buf)?;
-        Ok(RecursorProj { idx, ridx, block })
-    }
-}
-
-impl Serialize for DefinitionProj {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.idx.put(buf);
-        self.block.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let idx = Nat::get(buf)?;
-        let block = Address::get(buf)?;
-        Ok(DefinitionProj { idx, block })
-    }
-}
-
-impl Serialize for Comm {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.secret.put(buf);
-        self.payload.put(buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let secret = Address::get(buf)?;
-        let payload = Address::get(buf)?;
-        Ok(Comm { secret, payload })
-    }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BuiltIn {
+    Obj,
+    Neutral,
+    Unreachable,
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ixon::tests::gen_range;
-    use quickcheck::{Arbitrary, Gen};
-
-    use std::ptr;
-
-    impl Arbitrary for QuotKind {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..3);
-            match x {
-                0 => Self::Type,
-                1 => Self::Ctor,
-                2 => Self::Lift,
-                _ => Self::Ind,
-            }
-        }
-    }
-
-    impl Arbitrary for Quotient {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                lvls: Nat::arbitrary(g),
-                typ: Address::arbitrary(g),
-                kind: QuotKind::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for Axiom {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                lvls: Nat::arbitrary(g),
-                typ: Address::arbitrary(g),
-                is_unsafe: bool::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for DefKind {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..2);
-            match x {
-                0 => Self::Definition,
-                1 => Self::Opaque,
-                _ => Self::Theorem,
-            }
-        }
-    }
-
-    impl Arbitrary for DefSafety {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..2);
-            match x {
-                0 => Self::Unsafe,
-                1 => Self::Safe,
-                _ => Self::Partial,
-            }
-        }
-    }
-
-    impl Arbitrary for Definition {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                kind: DefKind::arbitrary(g),
-                safety: DefSafety::arbitrary(g),
-                lvls: Nat::arbitrary(g),
-                typ: Address::arbitrary(g),
-                value: Address::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for Constructor {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                lvls: Nat::arbitrary(g),
-                typ: Address::arbitrary(g),
-                cidx: Nat::arbitrary(g),
-                params: Nat::arbitrary(g),
-                fields: Nat::arbitrary(g),
-                is_unsafe: bool::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for RecursorRule {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                fields: Nat::arbitrary(g),
-                rhs: Address::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for Recursor {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..9);
-            let mut rules = vec![];
-            for _ in 0..x {
-                rules.push(RecursorRule::arbitrary(g));
-            }
-            Self {
-                lvls: Nat::arbitrary(g),
-                typ: Address::arbitrary(g),
-                params: Nat::arbitrary(g),
-                indices: Nat::arbitrary(g),
-                motives: Nat::arbitrary(g),
-                minors: Nat::arbitrary(g),
-                rules,
-                k: bool::arbitrary(g),
-                is_unsafe: bool::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for Inductive {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..9);
-            let y = gen_range(g, 0..9);
-            let mut ctors = vec![];
-            let mut recrs = vec![];
-            for _ in 0..x {
-                ctors.push(Constructor::arbitrary(g));
-            }
-            for _ in 0..y {
-                recrs.push(Recursor::arbitrary(g));
-            }
-            Self {
-                lvls: Nat::arbitrary(g),
-                typ: Address::arbitrary(g),
-                params: Nat::arbitrary(g),
-                indices: Nat::arbitrary(g),
-                ctors,
-                recrs,
-                nested: Nat::arbitrary(g),
-                recr: bool::arbitrary(g),
-                refl: bool::arbitrary(g),
-                is_unsafe: bool::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for InductiveProj {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                block: Address::arbitrary(g),
-                idx: Nat::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for ConstructorProj {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                block: Address::arbitrary(g),
-                idx: Nat::arbitrary(g),
-                cidx: Nat::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for RecursorProj {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                block: Address::arbitrary(g),
-                idx: Nat::arbitrary(g),
-                ridx: Nat::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for DefinitionProj {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                block: Address::arbitrary(g),
-                idx: Nat::arbitrary(g),
-            }
-        }
-    }
-
-    impl Arbitrary for Comm {
-        fn arbitrary(g: &mut Gen) -> Self {
-            Self {
-                secret: Address::arbitrary(g),
-                payload: Address::arbitrary(g),
-            }
-        }
-    }
-}
+//impl Serialize for QuotKind {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Type => buf.push(0),
+//            Self::Ctor => buf.push(1),
+//            Self::Lift => buf.push(2),
+//            Self::Ind => buf.push(3),
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match buf.split_at_checked(1) {
+//            Some((head, rest)) => {
+//                *buf = rest;
+//                match head[0] {
+//                    0 => Ok(Self::Type),
+//                    1 => Ok(Self::Ctor),
+//                    2 => Ok(Self::Lift),
+//                    3 => Ok(Self::Ind),
+//                    x => Err(format!("get QuotKind invalid {x}")),
+//                }
+//            }
+//            None => Err("get QuotKind EOF".to_string()),
+//        }
+//    }
+//}
+//
+//impl Serialize for Quotient {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.kind.put(buf);
+//        self.lvls.put(buf);
+//        self.typ.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let kind = QuotKind::get(buf)?;
+//        let lvls = Nat::get(buf)?;
+//        let typ = Address::get(buf)?;
+//        Ok(Quotient { kind, lvls, typ })
+//    }
+//}
+//
+//impl Serialize for Axiom {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.is_unsafe.put(buf);
+//        self.lvls.put(buf);
+//        self.typ.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let is_unsafe = bool::get(buf)?;
+//        let lvls = Nat::get(buf)?;
+//        let typ = Address::get(buf)?;
+//        Ok(Axiom {
+//            lvls,
+//            typ,
+//            is_unsafe,
+//        })
+//    }
+//}
+//
+//impl Serialize for DefKind {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Definition => buf.push(0),
+//            Self::Opaque => buf.push(1),
+//            Self::Theorem => buf.push(2),
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match buf.split_at_checked(1) {
+//            Some((head, rest)) => {
+//                *buf = rest;
+//                match head[0] {
+//                    0 => Ok(Self::Definition),
+//                    1 => Ok(Self::Opaque),
+//                    2 => Ok(Self::Theorem),
+//                    x => Err(format!("get DefKind invalid {x}")),
+//                }
+//            }
+//            None => Err("get DefKind EOF".to_string()),
+//        }
+//    }
+//}
+//
+//impl Serialize for DefSafety {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Unsafe => buf.push(0),
+//            Self::Safe => buf.push(1),
+//            Self::Partial => buf.push(2),
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match buf.split_at_checked(1) {
+//            Some((head, rest)) => {
+//                *buf = rest;
+//                match head[0] {
+//                    0 => Ok(Self::Unsafe),
+//                    1 => Ok(Self::Safe),
+//                    2 => Ok(Self::Partial),
+//                    x => Err(format!("get DefSafety invalid {x}")),
+//                }
+//            }
+//            None => Err("get DefSafety EOF".to_string()),
+//        }
+//    }
+//}
+//
+//impl Serialize for Definition {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.kind.put(buf);
+//        self.safety.put(buf);
+//        self.lvls.put(buf);
+//        self.typ.put(buf);
+//        self.value.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let kind = DefKind::get(buf)?;
+//        let safety = DefSafety::get(buf)?;
+//        let lvls = Nat::get(buf)?;
+//        let typ = Address::get(buf)?;
+//        let value = Address::get(buf)?;
+//        Ok(Definition {
+//            kind,
+//            safety,
+//            lvls,
+//            typ,
+//            value,
+//        })
+//    }
+//}
+//
+//impl Serialize for Constructor {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.is_unsafe.put(buf);
+//        self.lvls.put(buf);
+//        self.cidx.put(buf);
+//        self.params.put(buf);
+//        self.fields.put(buf);
+//        self.typ.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let is_unsafe = bool::get(buf)?;
+//        let lvls = Nat::get(buf)?;
+//        let cidx = Nat::get(buf)?;
+//        let params = Nat::get(buf)?;
+//        let fields = Nat::get(buf)?;
+//        let typ = Address::get(buf)?;
+//        Ok(Constructor {
+//            lvls,
+//            typ,
+//            cidx,
+//            params,
+//            fields,
+//            is_unsafe,
+//        })
+//    }
+//}
+//
+//impl Serialize for RecursorRule {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.fields.put(buf);
+//        self.rhs.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let fields = Nat::get(buf)?;
+//        let rhs = Address::get(buf)?;
+//        Ok(RecursorRule { fields, rhs })
+//    }
+//}
+//
+//impl Serialize for Recursor {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        Ixon::pack_bools(vec![self.k, self.is_unsafe]).put(buf);
+//        self.lvls.put(buf);
+//        self.params.put(buf);
+//        self.indices.put(buf);
+//        self.motives.put(buf);
+//        self.minors.put(buf);
+//        self.typ.put(buf);
+//        self.rules.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let bools = Ixon::unpack_bools(2, u8::get(buf)?);
+//        let lvls = Nat::get(buf)?;
+//        let params = Nat::get(buf)?;
+//        let indices = Nat::get(buf)?;
+//        let motives = Nat::get(buf)?;
+//        let minors = Nat::get(buf)?;
+//        let typ = Serialize::get(buf)?;
+//        let rules = Serialize::get(buf)?;
+//        Ok(Recursor {
+//            lvls,
+//            typ,
+//            params,
+//            indices,
+//            motives,
+//            minors,
+//            rules,
+//            k: bools[0],
+//            is_unsafe: bools[1],
+//        })
+//    }
+//}
+//
+//impl Serialize for Inductive {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        Ixon::pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
+//        self.lvls.put(buf);
+//        self.params.put(buf);
+//        self.indices.put(buf);
+//        self.nested.put(buf);
+//        self.typ.put(buf);
+//        Serialize::put(&self.ctors, buf);
+//        Serialize::put(&self.recrs, buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let bools = Ixon::unpack_bools(3, u8::get(buf)?);
+//        let lvls = Nat::get(buf)?;
+//        let params = Nat::get(buf)?;
+//        let indices = Nat::get(buf)?;
+//        let nested = Nat::get(buf)?;
+//        let typ = Address::get(buf)?;
+//        let ctors = Serialize::get(buf)?;
+//        let recrs = Serialize::get(buf)?;
+//        Ok(Inductive {
+//            recr: bools[0],
+//            refl: bools[1],
+//            is_unsafe: bools[2],
+//            lvls,
+//            params,
+//            indices,
+//            nested,
+//            typ,
+//            ctors,
+//            recrs,
+//        })
+//    }
+//}
+
+//impl Serialize for InductiveProj {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.idx.put(buf);
+//        self.block.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let idx = Nat::get(buf)?;
+//        let block = Address::get(buf)?;
+//        Ok(InductiveProj { idx, block })
+//    }
+//}
+//
+//impl Serialize for ConstructorProj {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.idx.put(buf);
+//        self.cidx.put(buf);
+//        self.block.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let idx = Nat::get(buf)?;
+//        let cidx = Nat::get(buf)?;
+//        let block = Address::get(buf)?;
+//        Ok(ConstructorProj { idx, cidx, block })
+//    }
+//}
+//
+//impl Serialize for RecursorProj {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.idx.put(buf);
+//        self.ridx.put(buf);
+//        self.block.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let idx = Nat::get(buf)?;
+//        let ridx = Nat::get(buf)?;
+//        let block = Address::get(buf)?;
+//        Ok(RecursorProj { idx, ridx, block })
+//    }
+//}
+//
+//impl Serialize for DefinitionProj {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.idx.put(buf);
+//        self.block.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let idx = Nat::get(buf)?;
+//        let block = Address::get(buf)?;
+//        Ok(DefinitionProj { idx, block })
+//    }
+//}
+//
+//impl Serialize for Comm {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.secret.put(buf);
+//        self.payload.put(buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let secret = Address::get(buf)?;
+//        let payload = Address::get(buf)?;
+//        Ok(Comm { secret, payload })
+//    }
+//}
+
+//#[cfg(test)]
+//mod tests {
+//    use super::*;
+//    use crate::ixon::tests::gen_range;
+//    use quickcheck::{Arbitrary, Gen};
+//
+//    use std::ptr;
+//
+//    impl Arbitrary for QuotKind {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..3);
+//            match x {
+//                0 => Self::Type,
+//                1 => Self::Ctor,
+//                2 => Self::Lift,
+//                _ => Self::Ind,
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Quotient {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                lvls: Nat::arbitrary(g),
+//                typ: Address::arbitrary(g),
+//                kind: QuotKind::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Axiom {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                lvls: Nat::arbitrary(g),
+//                typ: Address::arbitrary(g),
+//                is_unsafe: bool::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for DefKind {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..2);
+//            match x {
+//                0 => Self::Definition,
+//                1 => Self::Opaque,
+//                _ => Self::Theorem,
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for DefSafety {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..2);
+//            match x {
+//                0 => Self::Unsafe,
+//                1 => Self::Safe,
+//                _ => Self::Partial,
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Definition {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                kind: DefKind::arbitrary(g),
+//                safety: DefSafety::arbitrary(g),
+//                lvls: Nat::arbitrary(g),
+//                typ: Address::arbitrary(g),
+//                value: Address::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Constructor {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                lvls: Nat::arbitrary(g),
+//                typ: Address::arbitrary(g),
+//                cidx: Nat::arbitrary(g),
+//                params: Nat::arbitrary(g),
+//                fields: Nat::arbitrary(g),
+//                is_unsafe: bool::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for RecursorRule {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                fields: Nat::arbitrary(g),
+//                rhs: Address::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Recursor {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..9);
+//            let mut rules = vec![];
+//            for _ in 0..x {
+//                rules.push(RecursorRule::arbitrary(g));
+//            }
+//            Self {
+//                lvls: Nat::arbitrary(g),
+//                typ: Address::arbitrary(g),
+//                params: Nat::arbitrary(g),
+//                indices: Nat::arbitrary(g),
+//                motives: Nat::arbitrary(g),
+//                minors: Nat::arbitrary(g),
+//                rules,
+//                k: bool::arbitrary(g),
+//                is_unsafe: bool::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Inductive {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..9);
+//            let y = gen_range(g, 0..9);
+//            let mut ctors = vec![];
+//            let mut recrs = vec![];
+//            for _ in 0..x {
+//                ctors.push(Constructor::arbitrary(g));
+//            }
+//            for _ in 0..y {
+//                recrs.push(Recursor::arbitrary(g));
+//            }
+//            Self {
+//                lvls: Nat::arbitrary(g),
+//                typ: Address::arbitrary(g),
+//                params: Nat::arbitrary(g),
+//                indices: Nat::arbitrary(g),
+//                ctors,
+//                recrs,
+//                nested: Nat::arbitrary(g),
+//                recr: bool::arbitrary(g),
+//                refl: bool::arbitrary(g),
+//                is_unsafe: bool::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for InductiveProj {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                block: Address::arbitrary(g),
+//                idx: Nat::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for ConstructorProj {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                block: Address::arbitrary(g),
+//                idx: Nat::arbitrary(g),
+//                cidx: Nat::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for RecursorProj {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                block: Address::arbitrary(g),
+//                idx: Nat::arbitrary(g),
+//                ridx: Nat::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for DefinitionProj {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                block: Address::arbitrary(g),
+//                idx: Nat::arbitrary(g),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Comm {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            Self {
+//                secret: Address::arbitrary(g),
+//                payload: Address::arbitrary(g),
+//            }
+//        }
+//    }
+//}
diff --git a/src/ixon/meta.rs b/src/ixon/meta.rs
index 0c6b8b26..d6723293 100644
--- a/src/ixon/meta.rs
+++ b/src/ixon/meta.rs
@@ -1,7 +1,7 @@
 use crate::ixon::address::Address;
 use crate::ixon::name::Name;
 use crate::ixon::nat::Nat;
-use crate::ixon::serialize::Serialize;
+//use crate::ixon::serialize::Serialize;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BinderInfo {
@@ -34,204 +34,204 @@ pub struct Metadata {
     pub map: Vec<(Nat, Vec<Metadatum>)>,
 }
 
-impl Serialize for BinderInfo {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Default => buf.push(0),
-            Self::Implicit => buf.push(1),
-            Self::StrictImplicit => buf.push(2),
-            Self::InstImplicit => buf.push(3),
-            Self::AuxDecl => buf.push(3),
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(1) {
-            Some((head, rest)) => {
-                *buf = rest;
-                match head[0] {
-                    0 => Ok(Self::Default),
-                    1 => Ok(Self::Implicit),
-                    2 => Ok(Self::StrictImplicit),
-                    3 => Ok(Self::InstImplicit),
-                    4 => Ok(Self::AuxDecl),
-                    x => Err(format!("get BinderInfo invalid {x}")),
-                }
-            }
-            None => Err("get BinderInfo EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for ReducibilityHints {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Opaque => buf.push(0),
-            Self::Abbrev => buf.push(1),
-            Self::Regular(x) => {
-                buf.push(2);
-                x.put(buf);
-            }
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(1) {
-            Some((head, rest)) => {
-                *buf = rest;
-                match head[0] {
-                    0 => Ok(Self::Opaque),
-                    1 => Ok(Self::Abbrev),
-                    2 => {
-                        let x: u32 = Serialize::get(buf)?;
-                        Ok(Self::Regular(x))
-                    }
-                    x => Err(format!("get ReducibilityHints invalid {x}")),
-                }
-            }
-            None => Err("get ReducibilityHints EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for Metadatum {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Name(x) => {
-                buf.push(0);
-                x.put(buf);
-            }
-            Self::Info(x) => {
-                buf.push(1);
-                x.put(buf);
-            }
-            Self::Link(x) => {
-                buf.push(2);
-                x.put(buf);
-            }
-            Self::Hints(x) => {
-                buf.push(3);
-                x.put(buf);
-            }
-            Self::All(x) => {
-                buf.push(4);
-                x.put(buf);
-            }
-            Self::MutCtx(x) => {
-                buf.push(5);
-                x.put(buf);
-            }
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(1) {
-            Some((head, rest)) => {
-                *buf = rest;
-                match head[0] {
-                    0 => {
-                        let x = Name::get(buf)?;
-                        Ok(Self::Name(x))
-                    }
-                    1 => {
-                        let x = BinderInfo::get(buf)?;
-                        Ok(Self::Info(x))
-                    }
-                    2 => {
-                        let x = Address::get(buf)?;
-                        Ok(Self::Link(x))
-                    }
-                    3 => {
-                        let x = ReducibilityHints::get(buf)?;
-                        Ok(Self::Hints(x))
-                    }
-                    4 => {
-                        let x = Serialize::get(buf)?;
-                        Ok(Self::All(x))
-                    }
-                    5 => {
-                        let x = Serialize::get(buf)?;
-                        Ok(Self::MutCtx(x))
-                    }
-                    x => Err(format!("get Metadata invalid {x}")),
-                }
-            }
-            None => Err("get Metadata EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for Metadata {
-    fn put(&self, buf: &mut Vec<u8>) {
-        Serialize::put(&self.map, buf)
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        Ok(Metadata {
-            map: Serialize::get(buf)?,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ixon::tests::{gen_range, gen_vec};
-    use quickcheck::{Arbitrary, Gen};
-
-    impl Arbitrary for BinderInfo {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..4);
-            match x {
-                0 => Self::Default,
-                1 => Self::Implicit,
-                2 => Self::StrictImplicit,
-                3 => Self::InstImplicit,
-                _ => Self::AuxDecl,
-            }
-        }
-    }
-
-    impl Arbitrary for ReducibilityHints {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..2);
-            match x {
-                0 => Self::Opaque,
-                1 => Self::Abbrev,
-                _ => Self::Regular(Arbitrary::arbitrary(g)),
-            }
-        }
-    }
-
-    impl Arbitrary for Metadatum {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..5);
-            match x {
-                0 => Self::Name(Name::arbitrary(g)),
-                1 => Self::Info(BinderInfo::arbitrary(g)),
-                2 => Self::Link(Address::arbitrary(g)),
-                3 => Self::Hints(ReducibilityHints::arbitrary(g)),
-                4 => Self::All(gen_vec(g, 9, Arbitrary::arbitrary)),
-                _ => {
-                    let x = gen_range(g, 0..9);
-                    let mut res = vec![];
-                    for _ in 0..x {
-                        res.push(gen_vec(g, 9, Arbitrary::arbitrary))
-                    }
-                    Self::MutCtx(res)
-                }
-            }
-        }
-    }
-
-    impl Arbitrary for Metadata {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..9);
-            let mut map = Vec::new();
-            for _ in 0..x {
-                map.push((Nat::arbitrary(g), gen_vec(g, 9, Metadatum::arbitrary)));
-            }
-            Metadata { map }
-        }
-    }
-}
+//impl Serialize for BinderInfo {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Default => buf.push(0),
+//            Self::Implicit => buf.push(1),
+//            Self::StrictImplicit => buf.push(2),
+//            Self::InstImplicit => buf.push(3),
+//            Self::AuxDecl => buf.push(3),
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match buf.split_at_checked(1) {
+//            Some((head, rest)) => {
+//                *buf = rest;
+//                match head[0] {
+//                    0 => Ok(Self::Default),
+//                    1 => Ok(Self::Implicit),
+//                    2 => Ok(Self::StrictImplicit),
+//                    3 => Ok(Self::InstImplicit),
+//                    4 => Ok(Self::AuxDecl),
+//                    x => Err(format!("get BinderInfo invalid {x}")),
+//                }
+//            }
+//            None => Err("get BinderInfo EOF".to_string()),
+//        }
+//    }
+//}
+//
+//impl Serialize for ReducibilityHints {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Opaque => buf.push(0),
+//            Self::Abbrev => buf.push(1),
+//            Self::Regular(x) => {
+//                buf.push(2);
+//                x.put(buf);
+//            }
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match buf.split_at_checked(1) {
+//            Some((head, rest)) => {
+//                *buf = rest;
+//                match head[0] {
+//                    0 => Ok(Self::Opaque),
+//                    1 => Ok(Self::Abbrev),
+//                    2 => {
+//                        let x: u32 = Serialize::get(buf)?;
+//                        Ok(Self::Regular(x))
+//                    }
+//                    x => Err(format!("get ReducibilityHints invalid {x}")),
+//                }
+//            }
+//            None => Err("get ReducibilityHints EOF".to_string()),
+//        }
+//    }
+//}
+
+//impl Serialize for Metadatum {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Name(x) => {
+//                buf.push(0);
+//                x.put(buf);
+//            }
+//            Self::Info(x) => {
+//                buf.push(1);
+//                x.put(buf);
+//            }
+//            Self::Link(x) => {
+//                buf.push(2);
+//                x.put(buf);
+//            }
+//            Self::Hints(x) => {
+//                buf.push(3);
+//                x.put(buf);
+//            }
+//            Self::All(x) => {
+//                buf.push(4);
+//                x.put(buf);
+//            }
+//            Self::MutCtx(x) => {
+//                buf.push(5);
+//                x.put(buf);
+//            }
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match buf.split_at_checked(1) {
+//            Some((head, rest)) => {
+//                *buf = rest;
+//                match head[0] {
+//                    0 => {
+//                        let x = Name::get(buf)?;
+//                        Ok(Self::Name(x))
+//                    }
+//                    1 => {
+//                        let x = BinderInfo::get(buf)?;
+//                        Ok(Self::Info(x))
+//                    }
+//                    2 => {
+//                        let x = Address::get(buf)?;
+//                        Ok(Self::Link(x))
+//                    }
+//                    3 => {
+//                        let x = ReducibilityHints::get(buf)?;
+//                        Ok(Self::Hints(x))
+//                    }
+//                    4 => {
+//                        let x = Serialize::get(buf)?;
+//                        Ok(Self::All(x))
+//                    }
+//                    5 => {
+//                        let x = Serialize::get(buf)?;
+//                        Ok(Self::MutCtx(x))
+//                    }
+//                    x => Err(format!("get Metadata invalid {x}")),
+//                }
+//            }
+//            None => Err("get Metadata EOF".to_string()),
+//        }
+//    }
+//}
+
+//impl Serialize for Metadata {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        Serialize::put(&self.map, buf)
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        Ok(Metadata {
+//            map: Serialize::get(buf)?,
+//        })
+//    }
+//}
+//
+//#[cfg(test)]
+//mod tests {
+//    use super::*;
+//    use crate::ixon::tests::{gen_range, gen_vec};
+//    use quickcheck::{Arbitrary, Gen};
+//
+//    impl Arbitrary for BinderInfo {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..4);
+//            match x {
+//                0 => Self::Default,
+//                1 => Self::Implicit,
+//                2 => Self::StrictImplicit,
+//                3 => Self::InstImplicit,
+//                _ => Self::AuxDecl,
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for ReducibilityHints {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..2);
+//            match x {
+//                0 => Self::Opaque,
+//                1 => Self::Abbrev,
+//                _ => Self::Regular(Arbitrary::arbitrary(g)),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Metadatum {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..5);
+//            match x {
+//                0 => Self::Name(Name::arbitrary(g)),
+//                1 => Self::Info(BinderInfo::arbitrary(g)),
+//                2 => Self::Link(Address::arbitrary(g)),
+//                3 => Self::Hints(ReducibilityHints::arbitrary(g)),
+//                4 => Self::All(gen_vec(g, 9, Arbitrary::arbitrary)),
+//                _ => {
+//                    let x = gen_range(g, 0..9);
+//                    let mut res = vec![];
+//                    for _ in 0..x {
+//                        res.push(gen_vec(g, 9, Arbitrary::arbitrary))
+//                    }
+//                    Self::MutCtx(res)
+//                }
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Metadata {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..9);
+//            let mut map = Vec::new();
+//            for _ in 0..x {
+//                map.push((Nat::arbitrary(g), gen_vec(g, 9, Metadatum::arbitrary)));
+//            }
+//            Metadata { map }
+//        }
+//    }
+//}
diff --git a/src/ixon/name.rs b/src/ixon/name.rs
index 203dc2c4..ead6871f 100644
--- a/src/ixon/name.rs
+++ b/src/ixon/name.rs
@@ -1,6 +1,6 @@
 use crate::ixon::nat::Nat;
-use crate::ixon::serialize::Serialize;
-use crate::ixon::*;
+//use crate::ixon::serialize::Serialize;
+//use crate::ixon::*;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum NamePart {
@@ -13,58 +13,58 @@ pub struct Name {
     pub parts: Vec<NamePart>,
 }
 
-impl Serialize for NamePart {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            // TODO: do we need to clone here?
-            Self::Str(x) => Ixon::Strl(x.clone()).put(buf),
-            Self::Num(x) => Ixon::Natl(x.clone()).put(buf),
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match Ixon::get(buf)? {
-            Ixon::Strl(x) => Ok(Self::Str(x)),
-            Ixon::Natl(x) => Ok(Self::Num(x)),
-            x => Err(format!("get NamePart invalid {x:?}")),
-        }
-    }
-}
-
-impl Serialize for Name {
-    fn put(&self, buf: &mut Vec<u8>) {
-        self.parts.put(buf)
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        Ok(Name {
-            parts: Serialize::get(buf)?,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ixon::nat::tests::arbitrary_nat;
-    use crate::ixon::tests::{arbitrary_string, gen_range, gen_vec};
-    use quickcheck::{Arbitrary, Gen};
-
-    impl Arbitrary for NamePart {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let x = gen_range(g, 0..1);
-            let len = gen_range(g, 0..9);
-            match x {
-                0 => Self::Str(arbitrary_string(g, len)),
-                _ => Self::Num(arbitrary_nat(g, len)),
-            }
-        }
-    }
-
-    impl Arbitrary for Name {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let parts = gen_vec(g, 9, NamePart::arbitrary);
-            Name { parts }
-        }
-    }
-}
+//impl Serialize for NamePart {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            // TODO: do we need to clone here?
+//            Self::Str(x) => Ixon::Strl(x.clone()).put(buf),
+//            Self::Num(x) => Ixon::Natl(x.clone()).put(buf),
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match Ixon::get(buf)? {
+//            Ixon::Strl(x) => Ok(Self::Str(x)),
+//            Ixon::Natl(x) => Ok(Self::Num(x)),
+//            x => Err(format!("get NamePart invalid {x:?}")),
+//        }
+//    }
+//}
+//
+//impl Serialize for Name {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        self.parts.put(buf)
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        Ok(Name {
+//            parts: Serialize::get(buf)?,
+//        })
+//    }
+//}
+//
+//#[cfg(test)]
+//mod tests {
+//    use super::*;
+//    use crate::ixon::nat::tests::arbitrary_nat;
+//    use crate::ixon::tests::{arbitrary_string, gen_range, gen_vec};
+//    use quickcheck::{Arbitrary, Gen};
+//
+//    impl Arbitrary for NamePart {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let x = gen_range(g, 0..1);
+//            let len = gen_range(g, 0..9);
+//            match x {
+//                0 => Self::Str(arbitrary_string(g, len)),
+//                _ => Self::Num(arbitrary_nat(g, len)),
+//            }
+//        }
+//    }
+//
+//    impl Arbitrary for Name {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let parts = gen_vec(g, 9, NamePart::arbitrary);
+//            Name { parts }
+//        }
+//    }
+//}
diff --git a/src/ixon/nat.rs b/src/ixon/nat.rs
index f8278709..a4f55e9a 100644
--- a/src/ixon/nat.rs
+++ b/src/ixon/nat.rs
@@ -1,5 +1,5 @@
-use crate::ixon::serialize::Serialize;
-use crate::ixon::*;
+//use crate::ixon::serialize::Serialize;
+//use crate::ixon::*;
 use num_bigint::BigUint;
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
@@ -11,19 +11,19 @@ impl Nat {
     }
 }
 
-impl Serialize for Nat {
-    fn put(&self, buf: &mut Vec<u8>) {
-        Ixon::Natl(self.clone()).put(buf)
-    }
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match Ixon::get(buf) {
-            Ok(Ixon::Natl(x)) => Ok(x),
-            Ok(x) => Err(format!("get Nat invalid {x:?}")),
-            Err(e) => Err(e),
-        }
-    }
-}
-
+//impl Serialize for Nat {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        Ixon::Natl(self.clone()).put(buf)
+//    }
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        match Ixon::get(buf) {
+//            Ok(Ixon::Natl(x)) => Ok(x),
+//            Ok(x) => Err(format!("get Nat invalid {x:?}")),
+//            Err(e) => Err(e),
+//        }
+//    }
+//}
+//
 impl<T> From<T> for Nat
 where
     T: Into<BigUint>,
@@ -32,35 +32,35 @@ where
         Nat(x.into())
     }
 }
-
-#[cfg(test)]
-pub mod tests {
-    use super::*;
-    use crate::ixon::tests::gen_range;
-    use quickcheck::{Arbitrary, Gen};
-
-    pub fn arbitrary_nat(g: &mut Gen, size: usize) -> Nat {
-        let mut bytes = vec![];
-
-        let b = u8::arbitrary(g);
-
-        if b == 0 {
-            bytes.push(b + 1);
-        } else {
-            bytes.push(b);
-        }
-
-        for _ in 0..size {
-            bytes.push(u8::arbitrary(g));
-        }
-
-        Nat(BigUint::from_bytes_be(&bytes))
-    }
-
-    impl Arbitrary for Nat {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let size = gen_range(g, 0..4);
-            arbitrary_nat(g, size)
-        }
-    }
-}
+//
+//#[cfg(test)]
+//pub mod tests {
+//    use super::*;
+//    use crate::ixon::tests::gen_range;
+//    use quickcheck::{Arbitrary, Gen};
+//
+//    pub fn arbitrary_nat(g: &mut Gen, size: usize) -> Nat {
+//        let mut bytes = vec![];
+//
+//        let b = u8::arbitrary(g);
+//
+//        if b == 0 {
+//            bytes.push(b + 1);
+//        } else {
+//            bytes.push(b);
+//        }
+//
+//        for _ in 0..size {
+//            bytes.push(u8::arbitrary(g));
+//        }
+//
+//        Nat(BigUint::from_bytes_be(&bytes))
+//    }
+//
+//    impl Arbitrary for Nat {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let size = gen_range(g, 0..4);
+//            arbitrary_nat(g, size)
+//        }
+//    }
+//}
diff --git a/src/ixon/serialize.rs b/src/ixon/serialize.rs
index 12606528..835cf7df 100644
--- a/src/ixon/serialize.rs
+++ b/src/ixon/serialize.rs
@@ -1,4 +1,4 @@
-use crate::ixon::*;
+//use crate::ixon::*;
 
 pub trait Serialize: Sized {
     fn put(&self, buf: &mut Vec<u8>);
@@ -93,25 +93,25 @@ impl Serialize for bool {
     }
 }
 
-impl<S: Serialize> Serialize for Vec<S> {
-    fn put(&self, buf: &mut Vec<u8>) {
-        Ixon::put_array(self, buf)
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        Ixon::get_array(buf)
-    }
-}
-
-impl<X: Serialize, Y: Serialize> Serialize for (X, Y) {
-    fn put(&self, buf: &mut Vec<u8>) {
-        Serialize::put(&self.0, buf);
-        Serialize::put(&self.1, buf);
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let x = Serialize::get(buf)?;
-        let y = Serialize::get(buf)?;
-        Ok((x, y))
-    }
-}
+//impl<S: Serialize> Serialize for Vec<S> {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        Ixon::put_array(self, buf)
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        Ixon::get_array(buf)
+//    }
+//}
+//
+//impl<X: Serialize, Y: Serialize> Serialize for (X, Y) {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        Serialize::put(&self.0, buf);
+//        Serialize::put(&self.1, buf);
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let x = Serialize::get(buf)?;
+//        let y = Serialize::get(buf)?;
+//        Ok((x, y))
+//    }
+//}
diff --git a/src/ixon/univ.rs b/src/ixon/univ.rs
index 4d7050e4..e9ae3d76 100644
--- a/src/ixon/univ.rs
+++ b/src/ixon/univ.rs
@@ -1,199 +1,199 @@
-use crate::ixon::Ixon;
-use crate::ixon::serialize::Serialize;
-
-// 0xTTLX_XXXX
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[repr(C)]
-pub enum Univ {
-    // 0x0X, 1
-    Const(u64),
-    // 0x1, ^1
-    Var(u64),
-    // 0x2, (+ x y)
-    Add(u64, Box<Univ>),
-    // 0x3, size=0 (max x y)
-    Max(Box<Univ>, Box<Univ>),
-    // 0x3, size=1 (imax x y)
-    IMax(Box<Univ>, Box<Univ>),
-}
-
-impl Default for Univ {
-    fn default() -> Self {
-        Self::Const(0)
-    }
-}
-
-impl Univ {
-    fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
-        if val < 32 {
-            buf.push((tag << 6) | (val as u8));
-        } else {
-            buf.push((tag << 6) | 0b10_0000 | (Ixon::u64_byte_count(val) - 1));
-            Ixon::u64_put_trimmed_le(val, buf);
-        }
-    }
-
-    fn get_tag(is_large: bool, small: u8, buf: &mut &[u8]) -> Result<u64, String> {
-        if is_large {
-            Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
-        } else {
-            Ok(small as u64)
-        }
-    }
-}
-
-impl Serialize for Univ {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            Self::Const(x) => Univ::put_tag(0x0, *x, buf),
-            Self::Var(x) => Univ::put_tag(0x1, *x, buf),
-            Self::Add(x, y) => {
-                Univ::put_tag(0x2, *x, buf);
-                y.put(buf)
-            }
-            Self::Max(x, y) => {
-                Univ::put_tag(0x3, 0, buf);
-                x.put(buf);
-                y.put(buf);
-            }
-            Self::IMax(x, y) => {
-                Univ::put_tag(0x3, 1, buf);
-                x.put(buf);
-                y.put(buf);
-            }
-        }
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        let tag_byte = u8::get(buf)?;
-        let tag = tag_byte >> 6;
-        let is_large = tag_byte & 0b10_0000 != 0;
-        let small_size = tag_byte & 0b1_1111;
-        match tag {
-            0x0 => {
-                let x = Univ::get_tag(is_large, small_size, buf)?;
-                Ok(Self::Const(x))
-            }
-            0x1 => {
-                let x = Univ::get_tag(is_large, small_size, buf)?;
-                Ok(Self::Var(x))
-            }
-            0x2 => {
-                let x = Univ::get_tag(is_large, small_size, buf)?;
-                let y = Univ::get(buf)?;
-                Ok(Self::Add(x, Box::new(y)))
-            }
-            0x3 => {
-                let x = Univ::get(buf)?;
-                let y = Univ::get(buf)?;
-                if small_size == 0 {
-                    Ok(Self::Max(Box::new(x), Box::new(y)))
-                } else {
-                    Ok(Self::IMax(Box::new(x), Box::new(y)))
-                }
-            }
-            x => Err(format!("get Univ invalid tag {x}")),
-        }
-    }
-}
-
-#[cfg(test)]
-pub mod tests {
-    use super::*;
-    use crate::ixon::tests::{gen_range, next_case};
-    use quickcheck::{Arbitrary, Gen};
-
-    use std::ptr;
-
-    #[derive(Debug, Clone, Copy)]
-    pub enum UnivCase {
-        Const,
-        Var,
-        Add,
-        Max,
-        IMax,
-    }
-
-    // incremental tree generation without recursion stack overflows
-    pub fn arbitrary_univ(g: &mut Gen, ctx: u64) -> Univ {
-        let mut root = Univ::Const(0);
-        let mut stack: Vec<*mut Univ> = vec![&mut root as *mut Univ];
-
-        while let Some(ptr) = stack.pop() {
-            let gens: Vec<(usize, UnivCase)> = vec![
-                (100, UnivCase::Const),
-                (100, UnivCase::Var),
-                (75, UnivCase::Add),
-                (50, UnivCase::Max),
-                (50, UnivCase::IMax),
-            ];
-
-            match next_case(g, &gens) {
-                UnivCase::Const => {
-                    let x: u64 = Arbitrary::arbitrary(g);
-                    unsafe {
-                        ptr::replace(ptr, Univ::Const(x));
-                    }
-                }
-                UnivCase::Var => {
-                    let x: u64 = gen_range(g, 0..(ctx as usize)) as u64;
-                    unsafe {
-                        ptr::replace(ptr, Univ::Var(x));
-                    }
-                }
-                UnivCase::Add => {
-                    let x: u64 = Arbitrary::arbitrary(g);
-                    let mut y_box = Box::new(Univ::Const(0));
-                    let y_ptr: *mut Univ = &mut *y_box;
-                    stack.push(y_ptr);
-                    unsafe {
-                        ptr::replace(ptr, Univ::Add(x, y_box));
-                    }
-                }
-                UnivCase::Max => {
-                    let mut x_box = Box::new(Univ::Const(0));
-                    let x_ptr: *mut Univ = &mut *x_box;
-                    stack.push(x_ptr);
-                    let mut y_box = Box::new(Univ::Const(0));
-                    let y_ptr: *mut Univ = &mut *y_box;
-                    stack.push(y_ptr);
-                    unsafe {
-                        ptr::replace(ptr, Univ::Max(x_box, y_box));
-                    }
-                }
-                UnivCase::IMax => {
-                    let mut x_box = Box::new(Univ::Const(0));
-                    let x_ptr: *mut Univ = &mut *x_box;
-                    stack.push(x_ptr);
-                    let mut y_box = Box::new(Univ::Const(0));
-                    let y_ptr: *mut Univ = &mut *y_box;
-                    stack.push(y_ptr);
-                    unsafe {
-                        ptr::replace(ptr, Univ::Max(x_box, y_box));
-                    }
-                }
-            }
-        }
-        root
-    }
-
-    impl Arbitrary for Univ {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let ctx: u64 = Arbitrary::arbitrary(g);
-            arbitrary_univ(g, ctx)
-        }
-    }
-
-    #[quickcheck]
-    fn prop_univ_readback(x: Univ) -> bool {
-        let mut buf = Vec::new();
-        Univ::put(&x, &mut buf);
-        match Univ::get(&mut buf.as_slice()) {
-            Ok(y) => x == y,
-            Err(e) => {
-                println!("err: {e}");
-                false
-            }
-        }
-    }
-}
+//use crate::ixon::Ixon;
+//use crate::ixon::serialize::Serialize;
+//
+//// 0xTTLX_XXXX
+//#[derive(Debug, Clone, PartialEq, Eq)]
+//#[repr(C)]
+//pub enum Univ {
+//    // 0x0X, 1
+//    Const(u64),
+//    // 0x1, ^1
+//    Var(u64),
+//    // 0x2, (+ x y)
+//    Add(u64, Box<Univ>),
+//    // 0x3, size=0 (max x y)
+//    Max(Box<Univ>, Box<Univ>),
+//    // 0x3, size=1 (imax x y)
+//    IMax(Box<Univ>, Box<Univ>),
+//}
+//
+//impl Default for Univ {
+//    fn default() -> Self {
+//        Self::Const(0)
+//    }
+//}
+//
+//impl Univ {
+//    fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
+//        if val < 32 {
+//            buf.push((tag << 6) | (val as u8));
+//        } else {
+//            buf.push((tag << 6) | 0b10_0000 | (Ixon::u64_byte_count(val) - 1));
+//            Ixon::u64_put_trimmed_le(val, buf);
+//        }
+//    }
+//
+//    fn get_tag(is_large: bool, small: u8, buf: &mut &[u8]) -> Result<u64, String> {
+//        if is_large {
+//            Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
+//        } else {
+//            Ok(small as u64)
+//        }
+//    }
+//}
+//
+//impl Serialize for Univ {
+//    fn put(&self, buf: &mut Vec<u8>) {
+//        match self {
+//            Self::Const(x) => Univ::put_tag(0x0, *x, buf),
+//            Self::Var(x) => Univ::put_tag(0x1, *x, buf),
+//            Self::Add(x, y) => {
+//                Univ::put_tag(0x2, *x, buf);
+//                y.put(buf)
+//            }
+//            Self::Max(x, y) => {
+//                Univ::put_tag(0x3, 0, buf);
+//                x.put(buf);
+//                y.put(buf);
+//            }
+//            Self::IMax(x, y) => {
+//                Univ::put_tag(0x3, 1, buf);
+//                x.put(buf);
+//                y.put(buf);
+//            }
+//        }
+//    }
+//
+//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+//        let tag_byte = u8::get(buf)?;
+//        let tag = tag_byte >> 6;
+//        let is_large = tag_byte & 0b10_0000 != 0;
+//        let small_size = tag_byte & 0b1_1111;
+//        match tag {
+//            0x0 => {
+//                let x = Univ::get_tag(is_large, small_size, buf)?;
+//                Ok(Self::Const(x))
+//            }
+//            0x1 => {
+//                let x = Univ::get_tag(is_large, small_size, buf)?;
+//                Ok(Self::Var(x))
+//            }
+//            0x2 => {
+//                let x = Univ::get_tag(is_large, small_size, buf)?;
+//                let y = Univ::get(buf)?;
+//                Ok(Self::Add(x, Box::new(y)))
+//            }
+//            0x3 => {
+//                let x = Univ::get(buf)?;
+//                let y = Univ::get(buf)?;
+//                if small_size == 0 {
+//                    Ok(Self::Max(Box::new(x), Box::new(y)))
+//                } else {
+//                    Ok(Self::IMax(Box::new(x), Box::new(y)))
+//                }
+//            }
+//            x => Err(format!("get Univ invalid tag {x}")),
+//        }
+//    }
+//}
+//
+//#[cfg(test)]
+//pub mod tests {
+//    use super::*;
+//    use crate::ixon::tests::{gen_range, next_case};
+//    use quickcheck::{Arbitrary, Gen};
+//
+//    use std::ptr;
+//
+//    #[derive(Debug, Clone, Copy)]
+//    pub enum UnivCase {
+//        Const,
+//        Var,
+//        Add,
+//        Max,
+//        IMax,
+//    }
+//
+//    // incremental tree generation without recursion stack overflows
+//    pub fn arbitrary_univ(g: &mut Gen, ctx: u64) -> Univ {
+//        let mut root = Univ::Const(0);
+//        let mut stack: Vec<*mut Univ> = vec![&mut root as *mut Univ];
+//
+//        while let Some(ptr) = stack.pop() {
+//            let gens: Vec<(usize, UnivCase)> = vec![
+//                (100, UnivCase::Const),
+//                (100, UnivCase::Var),
+//                (75, UnivCase::Add),
+//                (50, UnivCase::Max),
+//                (50, UnivCase::IMax),
+//            ];
+//
+//            match next_case(g, &gens) {
+//                UnivCase::Const => {
+//                    let x: u64 = Arbitrary::arbitrary(g);
+//                    unsafe {
+//                        ptr::replace(ptr, Univ::Const(x));
+//                    }
+//                }
+//                UnivCase::Var => {
+//                    let x: u64 = gen_range(g, 0..(ctx as usize)) as u64;
+//                    unsafe {
+//                        ptr::replace(ptr, Univ::Var(x));
+//                    }
+//                }
+//                UnivCase::Add => {
+//                    let x: u64 = Arbitrary::arbitrary(g);
+//                    let mut y_box = Box::new(Univ::Const(0));
+//                    let y_ptr: *mut Univ = &mut *y_box;
+//                    stack.push(y_ptr);
+//                    unsafe {
+//                        ptr::replace(ptr, Univ::Add(x, y_box));
+//                    }
+//                }
+//                UnivCase::Max => {
+//                    let mut x_box = Box::new(Univ::Const(0));
+//                    let x_ptr: *mut Univ = &mut *x_box;
+//                    stack.push(x_ptr);
+//                    let mut y_box = Box::new(Univ::Const(0));
+//                    let y_ptr: *mut Univ = &mut *y_box;
+//                    stack.push(y_ptr);
+//                    unsafe {
+//                        ptr::replace(ptr, Univ::Max(x_box, y_box));
+//                    }
+//                }
+//                UnivCase::IMax => {
+//                    let mut x_box = Box::new(Univ::Const(0));
+//                    let x_ptr: *mut Univ = &mut *x_box;
+//                    stack.push(x_ptr);
+//                    let mut y_box = Box::new(Univ::Const(0));
+//                    let y_ptr: *mut Univ = &mut *y_box;
+//                    stack.push(y_ptr);
+//                    unsafe {
+//                        ptr::replace(ptr, Univ::Max(x_box, y_box));
+//                    }
+//                }
+//            }
+//        }
+//        root
+//    }
+//
+//    impl Arbitrary for Univ {
+//        fn arbitrary(g: &mut Gen) -> Self {
+//            let ctx: u64 = Arbitrary::arbitrary(g);
+//            arbitrary_univ(g, ctx)
+//        }
+//    }
+//
+//    #[quickcheck]
+//    fn prop_univ_readback(x: Univ) -> bool {
+//        let mut buf = Vec::new();
+//        Univ::put(&x, &mut buf);
+//        match Univ::get(&mut buf.as_slice()) {
+//            Ok(y) => x == y,
+//            Err(e) => {
+//                println!("err: {e}");
+//                false
+//            }
+//        }
+//    }
+//}
diff --git a/src/lean/ffi/ixon.rs b/src/lean/ffi/ixon.rs
index 9a3908bd..975bf969 100644
--- a/src/lean/ffi/ixon.rs
+++ b/src/lean/ffi/ixon.rs
@@ -1,537 +1,537 @@
-use blake3::Hash;
-use num_bigint::BigUint;
-use std::ffi::c_void;
+//use blake3::Hash;
+//use num_bigint::BigUint;
+//use std::ffi::c_void;
 
-use crate::{
-    ixon::{
-        Ixon,
-        address::Address,
-        claim::{CheckClaim, Claim, Env, EvalClaim, Proof},
-        constant::{
-            Axiom, Comm, Constructor, ConstructorProj, DefKind, DefSafety, Definition,
-            DefinitionProj, Inductive, InductiveProj, QuotKind, Quotient, Recursor, RecursorProj,
-            RecursorRule,
-        },
-        meta::{BinderInfo, Metadata, Metadatum, ReducibilityHints},
-        name::{Name, NamePart},
-        nat::Nat,
-        serialize::Serialize,
-        univ::Univ,
-    },
-    lean::{
-        array::LeanArrayObject, as_ref_unsafe, ctor::LeanCtorObject, lean_is_scalar,
-        sarray::LeanSArrayObject, string::LeanStringObject,
-    },
-    lean_unbox,
-};
-
-fn lean_ctor_to_univ(ctor: &LeanCtorObject) -> Univ {
-    match ctor.tag() {
-        0 => {
-            let [val] = ctor.objs();
-            Univ::Const(val as u64)
-        }
-        1 => {
-            let [idx] = ctor.objs();
-            Univ::Var(idx as u64)
-        }
-        2 => {
-            let [b_ptr, a_idx] = ctor.objs();
-            let a_idx = a_idx as u64;
-            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
-            Univ::Add(a_idx, b.into())
-        }
-        3 => {
-            let [a_ptr, b_ptr] = ctor.objs();
-            let a = lean_ctor_to_univ(as_ref_unsafe(a_ptr.cast()));
-            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
-            Univ::Max(a.into(), b.into())
-        }
-        4 => {
-            let [a_ptr, b_ptr] = ctor.objs();
-            let a = lean_ctor_to_univ(as_ref_unsafe(a_ptr.cast()));
-            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
-            Univ::IMax(a.into(), b.into())
-        }
-        _ => unreachable!(),
-    }
-}
-
-fn lean_ptr_to_address(ptr: *const c_void) -> Address {
-    let sarray: &LeanSArrayObject = as_ref_unsafe(ptr.cast());
-    let hash = Hash::from_slice(sarray.data()).unwrap();
-    Address { hash }
-}
-
-fn lean_ptr_to_univs(ptr: *const c_void) -> Vec<Univ> {
-    let univs: &LeanArrayObject = as_ref_unsafe(ptr.cast());
-    univs.to_vec(|ptr| lean_ctor_to_univ(as_ref_unsafe(ptr.cast())))
-}
-
-fn lean_ptr_to_nat(ptr: *const c_void) -> Nat {
-    let nat_bytes: &LeanSArrayObject = as_ref_unsafe(ptr.cast());
-    Nat(BigUint::from_bytes_le(nat_bytes.data()))
-}
-
-fn lean_ptr_to_definition(ptr: *const c_void) -> Definition {
-    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [lvls, typ, value, mode_safety] = ctor.objs();
-    let lvls = lean_ptr_to_nat(lvls);
-    let typ = lean_ptr_to_address(typ);
-    let value = lean_ptr_to_address(value);
-    let [kind, safety, ..] = (mode_safety as usize).to_le_bytes();
-    let kind = match kind {
-        0 => DefKind::Definition,
-        1 => DefKind::Opaque,
-        2 => DefKind::Theorem,
-        _ => unreachable!(),
-    };
-    let safety = match safety {
-        0 => DefSafety::Unsafe,
-        1 => DefSafety::Safe,
-        2 => DefSafety::Partial,
-        _ => unreachable!(),
-    };
-    Definition {
-        lvls,
-        typ,
-        kind,
-        value,
-        safety,
-    }
-}
-
-fn lean_ptr_to_constructor(ptr: *const c_void) -> Constructor {
-    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [lvls, typ, cidx, params, fields, is_unsafe] = ctor.objs();
-    let lvls = lean_ptr_to_nat(lvls);
-    let typ = lean_ptr_to_address(typ);
-    let cidx = lean_ptr_to_nat(cidx);
-    let params = lean_ptr_to_nat(params);
-    let fields = lean_ptr_to_nat(fields);
-    let is_unsafe = is_unsafe as usize == 1;
-    Constructor {
-        lvls,
-        typ,
-        cidx,
-        params,
-        fields,
-        is_unsafe,
-    }
-}
-
-fn lean_ptr_to_recursor_rule(ptr: *const c_void) -> RecursorRule {
-    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [fields, rhs] = ctor.objs();
-    let fields = lean_ptr_to_nat(fields);
-    let rhs = lean_ptr_to_address(rhs);
-    RecursorRule { fields, rhs }
-}
-
-fn lean_ptr_to_recursor(ptr: *const c_void) -> Recursor {
-    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [
-        lvls,
-        typ,
-        params,
-        indices,
-        motives,
-        minors,
-        rules,
-        k_isunsafe,
-    ] = ctor.objs();
-    let lvls = lean_ptr_to_nat(lvls);
-    let typ = lean_ptr_to_address(typ);
-    let params = lean_ptr_to_nat(params);
-    let indices = lean_ptr_to_nat(indices);
-    let motives = lean_ptr_to_nat(motives);
-    let minors = lean_ptr_to_nat(minors);
-    let rules: &LeanArrayObject = as_ref_unsafe(rules.cast());
-    let rules = rules.to_vec(lean_ptr_to_recursor_rule);
-    let [k, is_unsafe, ..] = (k_isunsafe as usize).to_le_bytes();
-    let k = k == 1;
-    let is_unsafe = is_unsafe == 1;
-    Recursor {
-        lvls,
-        typ,
-        params,
-        indices,
-        motives,
-        minors,
-        rules,
-        k,
-        is_unsafe,
-    }
-}
-
-fn lean_ptr_to_inductive(ptr: *const c_void) -> Inductive {
-    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [
-        lvls,
-        typ,
-        params,
-        indices,
-        ctors,
-        recrs,
-        nested,
-        recr_refl_isunsafe,
-    ] = ctor.objs();
-    let lvls = lean_ptr_to_nat(lvls);
-    let typ = lean_ptr_to_address(typ);
-    let params = lean_ptr_to_nat(params);
-    let indices = lean_ptr_to_nat(indices);
-    let ctors: &LeanArrayObject = as_ref_unsafe(ctors.cast());
-    let ctors = ctors.to_vec(lean_ptr_to_constructor);
-    let recrs: &LeanArrayObject = as_ref_unsafe(recrs.cast());
-    let recrs = recrs.to_vec(lean_ptr_to_recursor);
-    let nested = lean_ptr_to_nat(nested);
-    let [recr, refl, is_unsafe, ..] = (recr_refl_isunsafe as usize).to_le_bytes();
-    let recr = recr == 1;
-    let refl = refl == 1;
-    let is_unsafe = is_unsafe == 1;
-    Inductive {
-        lvls,
-        typ,
-        params,
-        indices,
-        ctors,
-        recrs,
-        nested,
-        recr,
-        refl,
-        is_unsafe,
-    }
-}
-
-fn lean_ptr_to_name_parts(ptr: *const c_void) -> Vec<NamePart> {
-    if lean_is_scalar(ptr) {
-        Vec::new()
-    } else {
-        let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-        match ctor.tag() {
-            1 => {
-                let [prefix_ptr, str_ptr] = ctor.objs();
-                let mut parts = lean_ptr_to_name_parts(prefix_ptr);
-                let str_obj: &LeanStringObject = as_ref_unsafe(str_ptr.cast());
-                parts.push(NamePart::Str(str_obj.as_string()));
-                parts
-            }
-            2 => {
-                let [prefix_ptr, num_ptr] = ctor.objs();
-                let mut parts = lean_ptr_to_name_parts(prefix_ptr);
-                parts.push(NamePart::Num(lean_ptr_to_nat(num_ptr)));
-                parts
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-fn lean_ptr_to_name(ptr: *const c_void) -> Name {
-    let mut parts = lean_ptr_to_name_parts(ptr);
-    parts.reverse();
-    Name { parts }
-}
-
-fn lean_ptr_to_metadatum(ptr: *const c_void) -> Metadatum {
-    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    match ctor.tag() {
-        0 => {
-            let [name] = ctor.objs();
-            let name = lean_ptr_to_name(name);
-            Metadatum::Name(name)
-        }
-        1 => {
-            let [info] = ctor.objs();
-            let info = match info as usize {
-                0 => BinderInfo::Default,
-                1 => BinderInfo::Implicit,
-                2 => BinderInfo::StrictImplicit,
-                3 => BinderInfo::InstImplicit,
-                _ => unreachable!(),
-            };
-            Metadatum::Info(info)
-        }
-        2 => {
-            let [addr] = ctor.objs();
-            let addr = lean_ptr_to_address(addr);
-            Metadatum::Link(addr)
-        }
-        3 => {
-            let [hints] = ctor.objs();
-            let hints = if lean_is_scalar(hints) {
-                match lean_unbox!(usize, hints) {
-                    0 => ReducibilityHints::Opaque,
-                    1 => ReducibilityHints::Abbrev,
-                    _ => unreachable!(),
-                }
-            } else {
-                let ctor: &LeanCtorObject = as_ref_unsafe(hints.cast());
-                let [height] = ctor.objs();
-                ReducibilityHints::Regular(height as u32)
-            };
-            Metadatum::Hints(hints)
-        }
-        4 => {
-            let [all] = ctor.objs();
-            let all: &LeanArrayObject = as_ref_unsafe(all.cast());
-            let all = all.to_vec(lean_ptr_to_name);
-            Metadatum::All(all)
-        }
-        5 => {
-            let [mut_ctx] = ctor.objs();
-            let mut_ctx: &LeanArrayObject = as_ref_unsafe(mut_ctx.cast());
-            let mut_ctx = mut_ctx.to_vec(|names| {
-                let names: &LeanArrayObject = as_ref_unsafe(names.cast());
-                names.to_vec(lean_ptr_to_name)
-            });
-            Metadatum::MutCtx(mut_ctx)
-        }
-        _ => unreachable!(),
-    }
-}
-
-fn lean_ptr_to_metadata_entry(ptr: *const c_void) -> (Nat, Vec<Metadatum>) {
-    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [fst, snd] = ctor.objs();
-    let fst = lean_ptr_to_nat(fst);
-    let snd: &LeanArrayObject = as_ref_unsafe(snd.cast());
-    let snd = snd.to_vec(lean_ptr_to_metadatum);
-    (fst, snd)
-}
-
-fn lean_ptr_to_env_entry(ptr: *const c_void) -> (Address, Address) {
-    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [fst, snd] = ctor.objs().map(lean_ptr_to_address);
-    (fst, snd)
-}
-
-fn lean_ptr_to_eval_claim(ptr: *const c_void) -> EvalClaim {
-    let evals: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [lvls, input, output, typ] = evals.objs().map(lean_ptr_to_address);
-    EvalClaim {
-        lvls,
-        typ,
-        input,
-        output,
-    }
-}
-
-fn lean_ptr_to_check_claim(ptr: *const c_void) -> CheckClaim {
-    let checks: &LeanCtorObject = as_ref_unsafe(ptr.cast());
-    let [lvls, typ, value] = checks.objs().map(lean_ptr_to_address);
-    CheckClaim { lvls, typ, value }
-}
-
-fn lean_ptr_to_ixon(ptr: *const c_void) -> Ixon {
-    lean_ctor_to_ixon(as_ref_unsafe(ptr.cast()))
-}
-
-fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
-    match ctor.tag() {
-        0 => {
-            let [idx] = ctor.objs();
-            Ixon::Vari(idx as u64)
-        }
-        1 => {
-            let [univ_ptr] = ctor.objs();
-            let univ_ctor = as_ref_unsafe(univ_ptr.cast());
-            Ixon::Sort(lean_ctor_to_univ(univ_ctor).into())
-        }
-        2 => {
-            let [addr_ptr, univs_ptr] = ctor.objs();
-            let addr = lean_ptr_to_address(addr_ptr);
-            Ixon::Refr(addr, lean_ptr_to_univs(univs_ptr))
-        }
-        3 => {
-            let [univs_ptr, idx] = ctor.objs();
-            Ixon::Recr(idx as u64, lean_ptr_to_univs(univs_ptr))
-        }
-        4 => {
-            let [f, x, xs] = ctor.objs();
-            let f = lean_ptr_to_ixon(f).into();
-            let x = lean_ptr_to_ixon(x).into();
-            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
-            let xs = xs_array.to_vec(lean_ptr_to_ixon);
-            Ixon::Apps(f, x, xs)
-        }
-        5 => {
-            let [xs, x] = ctor.objs();
-            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
-            let xs = xs_array.to_vec(lean_ptr_to_ixon);
-            let x = lean_ptr_to_ixon(x);
-            Ixon::Lams(xs, x.into())
-        }
-        6 => {
-            let [xs, x] = ctor.objs();
-            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
-            let xs = xs_array.to_vec(lean_ptr_to_ixon);
-            let x = lean_ptr_to_ixon(x).into();
-            Ixon::Alls(xs, x)
-        }
-        7 => {
-            let [addr_ptr, ptr, idx] = ctor.objs();
-            let addr = lean_ptr_to_address(addr_ptr);
-            let term = lean_ptr_to_ixon(ptr).into();
-            Ixon::Proj(addr, idx as u64, term)
-        }
-        8 => {
-            let [str_ptr] = ctor.objs();
-            let str: &LeanStringObject = as_ref_unsafe(str_ptr.cast());
-            Ixon::Strl(str.as_string())
-        }
-        9 => {
-            let [nat_bytes_ptr] = ctor.objs();
-            Ixon::Natl(lean_ptr_to_nat(nat_bytes_ptr))
-        }
-        10 => {
-            let [v, t, b, x] = ctor.objs();
-            let v = lean_ptr_to_ixon(v).into();
-            let t = lean_ptr_to_ixon(t).into();
-            let b = lean_ptr_to_ixon(b).into();
-            Ixon::LetE(x as usize == 1, v, t, b)
-        }
-        11 => {
-            let [xs] = ctor.objs();
-            let xs: &LeanArrayObject = as_ref_unsafe(xs.cast());
-            Ixon::List(xs.to_vec(lean_ptr_to_ixon))
-        }
-        12 => {
-            let [defn_ptr] = ctor.objs();
-            Ixon::Defn(lean_ptr_to_definition(defn_ptr))
-        }
-        13 => {
-            let [axio_ptr] = ctor.objs();
-            let axio_ctor: &LeanCtorObject = as_ref_unsafe(axio_ptr.cast());
-            let [lvls, typ, is_unsafe] = axio_ctor.objs();
-            let lvls = lean_ptr_to_nat(lvls);
-            let typ = lean_ptr_to_address(typ);
-            let is_unsafe = is_unsafe as usize == 1;
-            Ixon::Axio(Axiom {
-                lvls,
-                typ,
-                is_unsafe,
-            })
-        }
-        14 => {
-            let [quot_ptr] = ctor.objs();
-            let quot_ctor: &LeanCtorObject = as_ref_unsafe(quot_ptr.cast());
-            let [lvls, typ, kind] = quot_ctor.objs();
-            let lvls = lean_ptr_to_nat(lvls);
-            let typ = lean_ptr_to_address(typ);
-            let kind = match kind as usize {
-                0 => QuotKind::Type,
-                1 => QuotKind::Ctor,
-                2 => QuotKind::Lift,
-                3 => QuotKind::Ind,
-                _ => unreachable!(),
-            };
-            Ixon::Quot(Quotient { lvls, typ, kind })
-        }
-        15 => {
-            let [cprj_ptr] = ctor.objs();
-            let cprj_ctor: &LeanCtorObject = as_ref_unsafe(cprj_ptr.cast());
-            let [block, idx, cidx] = cprj_ctor.objs();
-            let block = lean_ptr_to_address(block);
-            let idx = lean_ptr_to_nat(idx);
-            let cidx = lean_ptr_to_nat(cidx);
-            Ixon::CPrj(ConstructorProj { block, idx, cidx })
-        }
-        16 => {
-            let [rprj_ptr] = ctor.objs();
-            let rprj_ctor: &LeanCtorObject = as_ref_unsafe(rprj_ptr.cast());
-            let [block, idx, ridx] = rprj_ctor.objs();
-            let block = lean_ptr_to_address(block);
-            let idx = lean_ptr_to_nat(idx);
-            let ridx = lean_ptr_to_nat(ridx);
-            Ixon::RPrj(RecursorProj { block, idx, ridx })
-        }
-        17 => {
-            let [iprj_ptr] = ctor.objs();
-            let iprj_ctor: &LeanCtorObject = as_ref_unsafe(iprj_ptr.cast());
-            let [block, idx] = iprj_ctor.objs();
-            let block = lean_ptr_to_address(block);
-            let idx = lean_ptr_to_nat(idx);
-            Ixon::IPrj(InductiveProj { block, idx })
-        }
-        18 => {
-            let [dprj_ptr] = ctor.objs();
-            let dprj_ctor: &LeanCtorObject = as_ref_unsafe(dprj_ptr.cast());
-            let [block, idx] = dprj_ctor.objs();
-            let block = lean_ptr_to_address(block);
-            let idx = lean_ptr_to_nat(idx);
-            Ixon::DPrj(DefinitionProj { block, idx })
-        }
-        19 => {
-            let [inds_ptr] = ctor.objs();
-            let inds: &LeanArrayObject = as_ref_unsafe(inds_ptr.cast());
-            let inds = inds.to_vec(lean_ptr_to_inductive);
-            Ixon::Inds(inds)
-        }
-        20 => {
-            let [defs_ptr] = ctor.objs();
-            let defs: &LeanArrayObject = as_ref_unsafe(defs_ptr.cast());
-            let defs = defs.to_vec(lean_ptr_to_definition);
-            Ixon::Defs(defs)
-        }
-        21 => {
-            let [pairs_ptr] = ctor.objs();
-            let pairs: &LeanArrayObject = as_ref_unsafe(pairs_ptr.cast());
-            let map = pairs.to_vec(lean_ptr_to_metadata_entry);
-            Ixon::Meta(Metadata { map })
-        }
-        22 => {
-            let [proof] = ctor.objs();
-            let proof: &LeanCtorObject = as_ref_unsafe(proof.cast());
-            let [claim, bin] = proof.objs();
-            let claim: &LeanCtorObject = as_ref_unsafe(claim.cast());
-            let claim = match claim.tag() {
-                0 => {
-                    let [evals] = claim.objs();
-                    Claim::Evals(lean_ptr_to_eval_claim(evals))
-                }
-                1 => {
-                    let [checks] = claim.objs();
-                    Claim::Checks(lean_ptr_to_check_claim(checks))
-                }
-                _ => unreachable!(),
-            };
-            let bin: &LeanSArrayObject = as_ref_unsafe(bin.cast());
-            Ixon::Prof(Proof {
-                claim,
-                proof: bin.data().to_vec(),
-            })
-        }
-        23 => {
-            let [evals] = ctor.objs();
-            Ixon::Eval(lean_ptr_to_eval_claim(evals))
-        }
-        24 => {
-            let [checks] = ctor.objs();
-            Ixon::Chck(lean_ptr_to_check_claim(checks))
-        }
-        25 => {
-            let [comm] = ctor.objs();
-            let comm: &LeanCtorObject = as_ref_unsafe(comm.cast());
-            let [secret, payload] = comm.objs().map(lean_ptr_to_address);
-            Ixon::Comm(Comm { secret, payload })
-        }
-        26 => {
-            let [map_ptr] = ctor.objs();
-            let map: &LeanArrayObject = as_ref_unsafe(map_ptr.cast());
-            let env = map.to_vec(lean_ptr_to_env_entry);
-            Ixon::Envn(Env { env })
-        }
-        _ => unreachable!(),
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn rs_eq_lean_rust_serialization(
-    ixon: &LeanCtorObject,
-    bytes: &LeanSArrayObject,
-) -> bool {
-    let mut buf = Vec::new();
-    lean_ctor_to_ixon(ixon).put(&mut buf);
-    buf == bytes.data()
-}
+//use crate::{
+//    ixon::{
+//        Ixon,
+//        address::Address,
+//        claim::{CheckClaim, Claim, Env, EvalClaim, Proof},
+//        constant::{
+//            Axiom, Comm, Constructor, ConstructorProj, DefKind, DefSafety, Definition,
+//            DefinitionProj, Inductive, InductiveProj, QuotKind, Quotient, Recursor, RecursorProj,
+//            RecursorRule,
+//        },
+//        meta::{BinderInfo, Metadata, Metadatum, ReducibilityHints},
+//        name::{Name, NamePart},
+//        nat::Nat,
+//        serialize::Serialize,
+//        univ::Univ,
+//    },
+//    lean::{
+//        array::LeanArrayObject, as_ref_unsafe, ctor::LeanCtorObject, lean_is_scalar,
+//        sarray::LeanSArrayObject, string::LeanStringObject,
+//    },
+//    lean_unbox,
+//};
+//
+//fn lean_ctor_to_univ(ctor: &LeanCtorObject) -> Univ {
+//    match ctor.tag() {
+//        0 => {
+//            let [val] = ctor.objs();
+//            Univ::Const(val as u64)
+//        }
+//        1 => {
+//            let [idx] = ctor.objs();
+//            Univ::Var(idx as u64)
+//        }
+//        2 => {
+//            let [b_ptr, a_idx] = ctor.objs();
+//            let a_idx = a_idx as u64;
+//            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
+//            Univ::Add(a_idx, b.into())
+//        }
+//        3 => {
+//            let [a_ptr, b_ptr] = ctor.objs();
+//            let a = lean_ctor_to_univ(as_ref_unsafe(a_ptr.cast()));
+//            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
+//            Univ::Max(a.into(), b.into())
+//        }
+//        4 => {
+//            let [a_ptr, b_ptr] = ctor.objs();
+//            let a = lean_ctor_to_univ(as_ref_unsafe(a_ptr.cast()));
+//            let b = lean_ctor_to_univ(as_ref_unsafe(b_ptr.cast()));
+//            Univ::IMax(a.into(), b.into())
+//        }
+//        _ => unreachable!(),
+//    }
+//}
+//
+//fn lean_ptr_to_address(ptr: *const c_void) -> Address {
+//    let sarray: &LeanSArrayObject = as_ref_unsafe(ptr.cast());
+//    let hash = Hash::from_slice(sarray.data()).unwrap();
+//    Address { hash }
+//}
+//
+//fn lean_ptr_to_univs(ptr: *const c_void) -> Vec<Univ> {
+//    let univs: &LeanArrayObject = as_ref_unsafe(ptr.cast());
+//    univs.to_vec(|ptr| lean_ctor_to_univ(as_ref_unsafe(ptr.cast())))
+//}
+//
+//fn lean_ptr_to_nat(ptr: *const c_void) -> Nat {
+//    let nat_bytes: &LeanSArrayObject = as_ref_unsafe(ptr.cast());
+//    Nat(BigUint::from_bytes_le(nat_bytes.data()))
+//}
+//
+//fn lean_ptr_to_definition(ptr: *const c_void) -> Definition {
+//    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [lvls, typ, value, mode_safety] = ctor.objs();
+//    let lvls = lean_ptr_to_nat(lvls);
+//    let typ = lean_ptr_to_address(typ);
+//    let value = lean_ptr_to_address(value);
+//    let [kind, safety, ..] = (mode_safety as usize).to_le_bytes();
+//    let kind = match kind {
+//        0 => DefKind::Definition,
+//        1 => DefKind::Opaque,
+//        2 => DefKind::Theorem,
+//        _ => unreachable!(),
+//    };
+//    let safety = match safety {
+//        0 => DefSafety::Unsafe,
+//        1 => DefSafety::Safe,
+//        2 => DefSafety::Partial,
+//        _ => unreachable!(),
+//    };
+//    Definition {
+//        lvls,
+//        typ,
+//        kind,
+//        value,
+//        safety,
+//    }
+//}
+//
+//fn lean_ptr_to_constructor(ptr: *const c_void) -> Constructor {
+//    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [lvls, typ, cidx, params, fields, is_unsafe] = ctor.objs();
+//    let lvls = lean_ptr_to_nat(lvls);
+//    let typ = lean_ptr_to_address(typ);
+//    let cidx = lean_ptr_to_nat(cidx);
+//    let params = lean_ptr_to_nat(params);
+//    let fields = lean_ptr_to_nat(fields);
+//    let is_unsafe = is_unsafe as usize == 1;
+//    Constructor {
+//        lvls,
+//        typ,
+//        cidx,
+//        params,
+//        fields,
+//        is_unsafe,
+//    }
+//}
+//
+//fn lean_ptr_to_recursor_rule(ptr: *const c_void) -> RecursorRule {
+//    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [fields, rhs] = ctor.objs();
+//    let fields = lean_ptr_to_nat(fields);
+//    let rhs = lean_ptr_to_address(rhs);
+//    RecursorRule { fields, rhs }
+//}
+//
+//fn lean_ptr_to_recursor(ptr: *const c_void) -> Recursor {
+//    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [
+//        lvls,
+//        typ,
+//        params,
+//        indices,
+//        motives,
+//        minors,
+//        rules,
+//        k_isunsafe,
+//    ] = ctor.objs();
+//    let lvls = lean_ptr_to_nat(lvls);
+//    let typ = lean_ptr_to_address(typ);
+//    let params = lean_ptr_to_nat(params);
+//    let indices = lean_ptr_to_nat(indices);
+//    let motives = lean_ptr_to_nat(motives);
+//    let minors = lean_ptr_to_nat(minors);
+//    let rules: &LeanArrayObject = as_ref_unsafe(rules.cast());
+//    let rules = rules.to_vec(lean_ptr_to_recursor_rule);
+//    let [k, is_unsafe, ..] = (k_isunsafe as usize).to_le_bytes();
+//    let k = k == 1;
+//    let is_unsafe = is_unsafe == 1;
+//    Recursor {
+//        lvls,
+//        typ,
+//        params,
+//        indices,
+//        motives,
+//        minors,
+//        rules,
+//        k,
+//        is_unsafe,
+//    }
+//}
+//
+//fn lean_ptr_to_inductive(ptr: *const c_void) -> Inductive {
+//    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [
+//        lvls,
+//        typ,
+//        params,
+//        indices,
+//        ctors,
+//        recrs,
+//        nested,
+//        recr_refl_isunsafe,
+//    ] = ctor.objs();
+//    let lvls = lean_ptr_to_nat(lvls);
+//    let typ = lean_ptr_to_address(typ);
+//    let params = lean_ptr_to_nat(params);
+//    let indices = lean_ptr_to_nat(indices);
+//    let ctors: &LeanArrayObject = as_ref_unsafe(ctors.cast());
+//    let ctors = ctors.to_vec(lean_ptr_to_constructor);
+//    let recrs: &LeanArrayObject = as_ref_unsafe(recrs.cast());
+//    let recrs = recrs.to_vec(lean_ptr_to_recursor);
+//    let nested = lean_ptr_to_nat(nested);
+//    let [recr, refl, is_unsafe, ..] = (recr_refl_isunsafe as usize).to_le_bytes();
+//    let recr = recr == 1;
+//    let refl = refl == 1;
+//    let is_unsafe = is_unsafe == 1;
+//    Inductive {
+//        lvls,
+//        typ,
+//        params,
+//        indices,
+//        ctors,
+//        recrs,
+//        nested,
+//        recr,
+//        refl,
+//        is_unsafe,
+//    }
+//}
+//
+//fn lean_ptr_to_name_parts(ptr: *const c_void) -> Vec<NamePart> {
+//    if lean_is_scalar(ptr) {
+//        Vec::new()
+//    } else {
+//        let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//        match ctor.tag() {
+//            1 => {
+//                let [prefix_ptr, str_ptr] = ctor.objs();
+//                let mut parts = lean_ptr_to_name_parts(prefix_ptr);
+//                let str_obj: &LeanStringObject = as_ref_unsafe(str_ptr.cast());
+//                parts.push(NamePart::Str(str_obj.as_string()));
+//                parts
+//            }
+//            2 => {
+//                let [prefix_ptr, num_ptr] = ctor.objs();
+//                let mut parts = lean_ptr_to_name_parts(prefix_ptr);
+//                parts.push(NamePart::Num(lean_ptr_to_nat(num_ptr)));
+//                parts
+//            }
+//            _ => unreachable!(),
+//        }
+//    }
+//}
+//
+//fn lean_ptr_to_name(ptr: *const c_void) -> Name {
+//    let mut parts = lean_ptr_to_name_parts(ptr);
+//    parts.reverse();
+//    Name { parts }
+//}
+//
+//fn lean_ptr_to_metadatum(ptr: *const c_void) -> Metadatum {
+//    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    match ctor.tag() {
+//        0 => {
+//            let [name] = ctor.objs();
+//            let name = lean_ptr_to_name(name);
+//            Metadatum::Name(name)
+//        }
+//        1 => {
+//            let [info] = ctor.objs();
+//            let info = match info as usize {
+//                0 => BinderInfo::Default,
+//                1 => BinderInfo::Implicit,
+//                2 => BinderInfo::StrictImplicit,
+//                3 => BinderInfo::InstImplicit,
+//                _ => unreachable!(),
+//            };
+//            Metadatum::Info(info)
+//        }
+//        2 => {
+//            let [addr] = ctor.objs();
+//            let addr = lean_ptr_to_address(addr);
+//            Metadatum::Link(addr)
+//        }
+//        3 => {
+//            let [hints] = ctor.objs();
+//            let hints = if lean_is_scalar(hints) {
+//                match lean_unbox!(usize, hints) {
+//                    0 => ReducibilityHints::Opaque,
+//                    1 => ReducibilityHints::Abbrev,
+//                    _ => unreachable!(),
+//                }
+//            } else {
+//                let ctor: &LeanCtorObject = as_ref_unsafe(hints.cast());
+//                let [height] = ctor.objs();
+//                ReducibilityHints::Regular(height as u32)
+//            };
+//            Metadatum::Hints(hints)
+//        }
+//        4 => {
+//            let [all] = ctor.objs();
+//            let all: &LeanArrayObject = as_ref_unsafe(all.cast());
+//            let all = all.to_vec(lean_ptr_to_name);
+//            Metadatum::All(all)
+//        }
+//        5 => {
+//            let [mut_ctx] = ctor.objs();
+//            let mut_ctx: &LeanArrayObject = as_ref_unsafe(mut_ctx.cast());
+//            let mut_ctx = mut_ctx.to_vec(|names| {
+//                let names: &LeanArrayObject = as_ref_unsafe(names.cast());
+//                names.to_vec(lean_ptr_to_name)
+//            });
+//            Metadatum::MutCtx(mut_ctx)
+//        }
+//        _ => unreachable!(),
+//    }
+//}
+//
+//fn lean_ptr_to_metadata_entry(ptr: *const c_void) -> (Nat, Vec<Metadatum>) {
+//    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [fst, snd] = ctor.objs();
+//    let fst = lean_ptr_to_nat(fst);
+//    let snd: &LeanArrayObject = as_ref_unsafe(snd.cast());
+//    let snd = snd.to_vec(lean_ptr_to_metadatum);
+//    (fst, snd)
+//}
+//
+//fn lean_ptr_to_env_entry(ptr: *const c_void) -> (Address, Address) {
+//    let ctor: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [fst, snd] = ctor.objs().map(lean_ptr_to_address);
+//    (fst, snd)
+//}
+//
+//fn lean_ptr_to_eval_claim(ptr: *const c_void) -> EvalClaim {
+//    let evals: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [lvls, input, output, typ] = evals.objs().map(lean_ptr_to_address);
+//    EvalClaim {
+//        lvls,
+//        typ,
+//        input,
+//        output,
+//    }
+//}
+//
+//fn lean_ptr_to_check_claim(ptr: *const c_void) -> CheckClaim {
+//    let checks: &LeanCtorObject = as_ref_unsafe(ptr.cast());
+//    let [lvls, typ, value] = checks.objs().map(lean_ptr_to_address);
+//    CheckClaim { lvls, typ, value }
+//}
+//
+//fn lean_ptr_to_ixon(ptr: *const c_void) -> Ixon {
+//    lean_ctor_to_ixon(as_ref_unsafe(ptr.cast()))
+//}
+//
+//fn lean_ctor_to_ixon(ctor: &LeanCtorObject) -> Ixon {
+//    match ctor.tag() {
+//        0 => {
+//            let [idx] = ctor.objs();
+//            Ixon::Vari(idx as u64)
+//        }
+//        1 => {
+//            let [univ_ptr] = ctor.objs();
+//            let univ_ctor = as_ref_unsafe(univ_ptr.cast());
+//            Ixon::Sort(lean_ctor_to_univ(univ_ctor).into())
+//        }
+//        2 => {
+//            let [addr_ptr, univs_ptr] = ctor.objs();
+//            let addr = lean_ptr_to_address(addr_ptr);
+//            Ixon::Refr(addr, lean_ptr_to_univs(univs_ptr))
+//        }
+//        3 => {
+//            let [univs_ptr, idx] = ctor.objs();
+//            Ixon::Recr(idx as u64, lean_ptr_to_univs(univs_ptr))
+//        }
+//        4 => {
+//            let [f, x, xs] = ctor.objs();
+//            let f = lean_ptr_to_ixon(f).into();
+//            let x = lean_ptr_to_ixon(x).into();
+//            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
+//            let xs = xs_array.to_vec(lean_ptr_to_ixon);
+//            Ixon::Apps(f, x, xs)
+//        }
+//        5 => {
+//            let [xs, x] = ctor.objs();
+//            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
+//            let xs = xs_array.to_vec(lean_ptr_to_ixon);
+//            let x = lean_ptr_to_ixon(x);
+//            Ixon::Lams(xs, x.into())
+//        }
+//        6 => {
+//            let [xs, x] = ctor.objs();
+//            let xs_array: &LeanArrayObject = as_ref_unsafe(xs.cast());
+//            let xs = xs_array.to_vec(lean_ptr_to_ixon);
+//            let x = lean_ptr_to_ixon(x).into();
+//            Ixon::Alls(xs, x)
+//        }
+//        7 => {
+//            let [addr_ptr, ptr, idx] = ctor.objs();
+//            let addr = lean_ptr_to_address(addr_ptr);
+//            let term = lean_ptr_to_ixon(ptr).into();
+//            Ixon::Proj(addr, idx as u64, term)
+//        }
+//        8 => {
+//            let [str_ptr] = ctor.objs();
+//            let str: &LeanStringObject = as_ref_unsafe(str_ptr.cast());
+//            Ixon::Strl(str.as_string())
+//        }
+//        9 => {
+//            let [nat_bytes_ptr] = ctor.objs();
+//            Ixon::Natl(lean_ptr_to_nat(nat_bytes_ptr))
+//        }
+//        10 => {
+//            let [v, t, b, x] = ctor.objs();
+//            let v = lean_ptr_to_ixon(v).into();
+//            let t = lean_ptr_to_ixon(t).into();
+//            let b = lean_ptr_to_ixon(b).into();
+//            Ixon::LetE(x as usize == 1, v, t, b)
+//        }
+//        11 => {
+//            let [xs] = ctor.objs();
+//            let xs: &LeanArrayObject = as_ref_unsafe(xs.cast());
+//            Ixon::List(xs.to_vec(lean_ptr_to_ixon))
+//        }
+//        12 => {
+//            let [defn_ptr] = ctor.objs();
+//            Ixon::Defn(lean_ptr_to_definition(defn_ptr))
+//        }
+//        13 => {
+//            let [axio_ptr] = ctor.objs();
+//            let axio_ctor: &LeanCtorObject = as_ref_unsafe(axio_ptr.cast());
+//            let [lvls, typ, is_unsafe] = axio_ctor.objs();
+//            let lvls = lean_ptr_to_nat(lvls);
+//            let typ = lean_ptr_to_address(typ);
+//            let is_unsafe = is_unsafe as usize == 1;
+//            Ixon::Axio(Axiom {
+//                lvls,
+//                typ,
+//                is_unsafe,
+//            })
+//        }
+//        14 => {
+//            let [quot_ptr] = ctor.objs();
+//            let quot_ctor: &LeanCtorObject = as_ref_unsafe(quot_ptr.cast());
+//            let [lvls, typ, kind] = quot_ctor.objs();
+//            let lvls = lean_ptr_to_nat(lvls);
+//            let typ = lean_ptr_to_address(typ);
+//            let kind = match kind as usize {
+//                0 => QuotKind::Type,
+//                1 => QuotKind::Ctor,
+//                2 => QuotKind::Lift,
+//                3 => QuotKind::Ind,
+//                _ => unreachable!(),
+//            };
+//            Ixon::Quot(Quotient { lvls, typ, kind })
+//        }
+//        15 => {
+//            let [cprj_ptr] = ctor.objs();
+//            let cprj_ctor: &LeanCtorObject = as_ref_unsafe(cprj_ptr.cast());
+//            let [block, idx, cidx] = cprj_ctor.objs();
+//            let block = lean_ptr_to_address(block);
+//            let idx = lean_ptr_to_nat(idx);
+//            let cidx = lean_ptr_to_nat(cidx);
+//            Ixon::CPrj(ConstructorProj { block, idx, cidx })
+//        }
+//        16 => {
+//            let [rprj_ptr] = ctor.objs();
+//            let rprj_ctor: &LeanCtorObject = as_ref_unsafe(rprj_ptr.cast());
+//            let [block, idx, ridx] = rprj_ctor.objs();
+//            let block = lean_ptr_to_address(block);
+//            let idx = lean_ptr_to_nat(idx);
+//            let ridx = lean_ptr_to_nat(ridx);
+//            Ixon::RPrj(RecursorProj { block, idx, ridx })
+//        }
+//        17 => {
+//            let [iprj_ptr] = ctor.objs();
+//            let iprj_ctor: &LeanCtorObject = as_ref_unsafe(iprj_ptr.cast());
+//            let [block, idx] = iprj_ctor.objs();
+//            let block = lean_ptr_to_address(block);
+//            let idx = lean_ptr_to_nat(idx);
+//            Ixon::IPrj(InductiveProj { block, idx })
+//        }
+//        18 => {
+//            let [dprj_ptr] = ctor.objs();
+//            let dprj_ctor: &LeanCtorObject = as_ref_unsafe(dprj_ptr.cast());
+//            let [block, idx] = dprj_ctor.objs();
+//            let block = lean_ptr_to_address(block);
+//            let idx = lean_ptr_to_nat(idx);
+//            Ixon::DPrj(DefinitionProj { block, idx })
+//        }
+//        19 => {
+//            let [inds_ptr] = ctor.objs();
+//            let inds: &LeanArrayObject = as_ref_unsafe(inds_ptr.cast());
+//            let inds = inds.to_vec(lean_ptr_to_inductive);
+//            Ixon::Inds(inds)
+//        }
+//        20 => {
+//            let [defs_ptr] = ctor.objs();
+//            let defs: &LeanArrayObject = as_ref_unsafe(defs_ptr.cast());
+//            let defs = defs.to_vec(lean_ptr_to_definition);
+//            Ixon::Defs(defs)
+//        }
+//        21 => {
+//            let [pairs_ptr] = ctor.objs();
+//            let pairs: &LeanArrayObject = as_ref_unsafe(pairs_ptr.cast());
+//            let map = pairs.to_vec(lean_ptr_to_metadata_entry);
+//            Ixon::Meta(Metadata { map })
+//        }
+//        22 => {
+//            let [proof] = ctor.objs();
+//            let proof: &LeanCtorObject = as_ref_unsafe(proof.cast());
+//            let [claim, bin] = proof.objs();
+//            let claim: &LeanCtorObject = as_ref_unsafe(claim.cast());
+//            let claim = match claim.tag() {
+//                0 => {
+//                    let [evals] = claim.objs();
+//                    Claim::Evals(lean_ptr_to_eval_claim(evals))
+//                }
+//                1 => {
+//                    let [checks] = claim.objs();
+//                    Claim::Checks(lean_ptr_to_check_claim(checks))
+//                }
+//                _ => unreachable!(),
+//            };
+//            let bin: &LeanSArrayObject = as_ref_unsafe(bin.cast());
+//            Ixon::Prof(Proof {
+//                claim,
+//                proof: bin.data().to_vec(),
+//            })
+//        }
+//        23 => {
+//            let [evals] = ctor.objs();
+//            Ixon::Eval(lean_ptr_to_eval_claim(evals))
+//        }
+//        24 => {
+//            let [checks] = ctor.objs();
+//            Ixon::Chck(lean_ptr_to_check_claim(checks))
+//        }
+//        25 => {
+//            let [comm] = ctor.objs();
+//            let comm: &LeanCtorObject = as_ref_unsafe(comm.cast());
+//            let [secret, payload] = comm.objs().map(lean_ptr_to_address);
+//            Ixon::Comm(Comm { secret, payload })
+//        }
+//        26 => {
+//            let [map_ptr] = ctor.objs();
+//            let map: &LeanArrayObject = as_ref_unsafe(map_ptr.cast());
+//            let env = map.to_vec(lean_ptr_to_env_entry);
+//            Ixon::Envn(Env { env })
+//        }
+//        _ => unreachable!(),
+//    }
+//}
+//
+//#[unsafe(no_mangle)]
+//extern "C" fn rs_eq_lean_rust_serialization(
+//    ixon: &LeanCtorObject,
+//    bytes: &LeanSArrayObject,
+//) -> bool {
+//    let mut buf = Vec::new();
+//    lean_ctor_to_ixon(ixon).put(&mut buf);
+//    buf == bytes.data()
+//}
diff --git a/src/lib.rs b/src/lib.rs
index 45c3cec3..7d662030 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,10 @@
-#[cfg(test)]
-extern crate quickcheck;
-#[cfg(test)]
-#[macro_use(quickcheck)]
-extern crate quickcheck_macros;
-#[cfg(test)]
-extern crate rand;
+//#[cfg(test)]
+//extern crate quickcheck;
+//#[cfg(test)]
+//#[macro_use(quickcheck)]
+//extern crate quickcheck_macros;
+//#[cfg(test)]
+//extern crate rand;
 
 use indexmap::{IndexMap, IndexSet};
 use rustc_hash::FxBuildHasher;

From 9e5a66f4b83265f824034558c4127cec2bb40714 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 27 Oct 2025 16:02:19 -0400
Subject: [PATCH 64/74] disable aiur benchmarks due to Ixon format change

---
 Benchmarks/Aiur.lean    | 255 ++++++++--------
 Ix/Benchmark/Bench.lean | 645 ++++++++++++++++++++--------------------
 Ix/Benchmark/Serde.lean | 164 +++++-----
 3 files changed, 532 insertions(+), 532 deletions(-)

diff --git a/Benchmarks/Aiur.lean b/Benchmarks/Aiur.lean
index 86a70e05..2369431a 100644
--- a/Benchmarks/Aiur.lean
+++ b/Benchmarks/Aiur.lean
@@ -1,128 +1,129 @@
-import Ix.Aiur.Meta
-import Ix.Aiur.Simple
-import Ix.Aiur.Compile
-import Ix.Aiur.Protocol
-import Ix.Benchmark.Bench
-
-def toplevel := ⟦
-  enum Nat {
-    Zero,
-    Succ(&Nat)
-  }
-
-  fn g_to_nat(g: G) -> Nat {
-    match g {
-      0 => Nat.Zero,
-      _ => Nat.Succ(store(g_to_nat(g - 1))),
-    }
-  }
-
-  fn nat_to_g(n: Nat) -> G {
-    match n {
-      Nat.Zero => 0,
-      Nat.Succ(ptr) => nat_to_g(load(ptr)) + 1,
-    }
-  }
-
-  fn nat_add(a: Nat, b: Nat) -> Nat {
-    match b {
-      Nat.Zero => a,
-      Nat.Succ(b'ptr) => nat_add(Nat.Succ(store(a)), load(b'ptr)),
-    }
-  }
-
-  fn nat_fib(n: Nat) -> Nat {
-    match n {
-      Nat.Zero => Nat.Succ(store(Nat.Zero)),
-      Nat.Succ(n'ptr) =>
-        let n' = load(n'ptr);
-        match n' {
-          Nat.Zero => Nat.Succ(store(Nat.Zero)),
-          Nat.Succ(n''ptr) =>
-            let n'' = load(n''ptr);
-            nat_add(nat_fib(n'), nat_fib(n'')),
-        },
-    }
-  }
-
-  fn main(g: G) -> G {
-    nat_to_g(nat_fib(g_to_nat(g)))
-  }
-⟧
-
-def commitmentParameters : Aiur.CommitmentParameters := {
-  logBlowup := 1
-}
-
-def friParameters : Aiur.FriParameters := {
-  logFinalPolyLen := 0
-  numQueries := 100
-  proofOfWorkBits := 20
-}
-
-def proveE2E (name: Lean.Name) : IO UInt32 := do
-  match toplevel.checkAndSimplify with
-  | .error e => IO.eprintln e; return 1
-  | .ok decls =>
-    let bytecode := decls.compile
-    let system := Aiur.AiurSystem.build bytecode commitmentParameters
-    let funIdx := toplevel.getFuncIdx name |>.get!
-    let (claim, proof, _) := system.prove friParameters funIdx #[10] default
-    match system.verify friParameters claim proof with
-    | .ok _ => return 0
-    | .error e => IO.eprintln e; return 1
-
-
--- End-to-end proof generation and verification benchmark
-def proveE2EBench := bgroup "prove E2E" [
-  benchIO "fib 10" proveE2E `main
-] { samplingMode := .flat }
-
--- Individual benchmarks of each step from `proveE2E`
-
-def toplevelBench := bgroup "nat_fib" [
-  bench "simplify toplevel" Aiur.Toplevel.checkAndSimplify toplevel
-]
-
-def compileBench : IO Unit := do
-  match toplevel.checkAndSimplify with
-  | .error e => IO.eprintln e
-  | .ok decls =>
-    bgroup "nat_fib" [
-      bench "compile decls" Aiur.TypedDecls.compile decls
-    ]
-
-def buildAiurSystemBench : IO Unit := do
-  match toplevel.checkAndSimplify with
-  | .error e => IO.eprintln e
-  | .ok decls =>
-    let bytecode := decls.compile
-    bgroup "nat_fib" [
-      bench "build AiurSystem" (Aiur.AiurSystem.build bytecode) commitmentParameters
-    ]
-
-def proveBench : IO Unit := do
-  match toplevel.checkAndSimplify with
-  | .error e => IO.eprintln e
-  | .ok decls =>
-    let bytecode := decls.compile
-    let system := Aiur.AiurSystem.build bytecode commitmentParameters
-    let funIdx := toplevel.getFuncIdx `main |>.get!
-    bgroup "nat_fib" [
-      bench "prove fib 10" (Aiur.AiurSystem.prove system friParameters funIdx) #[10]
-    ]
-
-def verifyBench : IO Unit := do
-  match toplevel.checkAndSimplify with
-  | .error e => IO.eprintln e
-  | .ok decls =>
-    let bytecode := decls.compile
-    let system := Aiur.AiurSystem.build bytecode commitmentParameters
-    let funIdx := toplevel.getFuncIdx `main |>.get!
-    let (claim, proof, _) := system.prove friParameters funIdx #[10] default
-    bgroup "nat_fib" [
-      bench "verify fib 10" (Aiur.AiurSystem.verify system friParameters claim) proof
-    ]
-
+--import Ix.Aiur.Meta
+--import Ix.Aiur.Simple
+--import Ix.Aiur.Compile
+--import Ix.Aiur.Protocol
+--import Ix.Benchmark.Bench
+--
+--def toplevel := ⟦
+--  enum Nat {
+--    Zero,
+--    Succ(&Nat)
+--  }
+--
+--  fn g_to_nat(g: G) -> Nat {
+--    match g {
+--      0 => Nat.Zero,
+--      _ => Nat.Succ(store(g_to_nat(g - 1))),
+--    }
+--  }
+--
+--  fn nat_to_g(n: Nat) -> G {
+--    match n {
+--      Nat.Zero => 0,
+--      Nat.Succ(ptr) => nat_to_g(load(ptr)) + 1,
+--    }
+--  }
+--
+--  fn nat_add(a: Nat, b: Nat) -> Nat {
+--    match b {
+--      Nat.Zero => a,
+--      Nat.Succ(b'ptr) => nat_add(Nat.Succ(store(a)), load(b'ptr)),
+--    }
+--  }
+--
+--  fn nat_fib(n: Nat) -> Nat {
+--    match n {
+--      Nat.Zero => Nat.Succ(store(Nat.Zero)),
+--      Nat.Succ(n'ptr) =>
+--        let n' = load(n'ptr);
+--        match n' {
+--          Nat.Zero => Nat.Succ(store(Nat.Zero)),
+--          Nat.Succ(n''ptr) =>
+--            let n'' = load(n''ptr);
+--            nat_add(nat_fib(n'), nat_fib(n'')),
+--        },
+--    }
+--  }
+--
+--  fn main(g: G) -> G {
+--    nat_to_g(nat_fib(g_to_nat(g)))
+--  }
+--⟧
+--
+--def commitmentParameters : Aiur.CommitmentParameters := {
+--  logBlowup := 1
+--}
+--
+--def friParameters : Aiur.FriParameters := {
+--  logFinalPolyLen := 0
+--  numQueries := 100
+--  proofOfWorkBits := 20
+--}
+--
+--def proveE2E (name: Lean.Name) : IO UInt32 := do
+--  match toplevel.checkAndSimplify with
+--  | .error e => IO.eprintln e; return 1
+--  | .ok decls =>
+--    let bytecode := decls.compile
+--    let system := Aiur.AiurSystem.build bytecode commitmentParameters
+--    let funIdx := toplevel.getFuncIdx name |>.get!
+--    let (claim, proof, _) := system.prove friParameters funIdx #[10] default
+--    match system.verify friParameters claim proof with
+--    | .ok _ => return 0
+--    | .error e => IO.eprintln e; return 1
+--
+--
+---- End-to-end proof generation and verification benchmark
+--def proveE2EBench := bgroup "prove E2E" [
+--  benchIO "fib 10" proveE2E `main
+--] { samplingMode := .flat }
+--
+---- Individual benchmarks of each step from `proveE2E`
+--
+--def toplevelBench := bgroup "nat_fib" [
+--  bench "simplify toplevel" Aiur.Toplevel.checkAndSimplify toplevel
+--]
+--
+--def compileBench : IO Unit := do
+--  match toplevel.checkAndSimplify with
+--  | .error e => IO.eprintln e
+--  | .ok decls =>
+--    bgroup "nat_fib" [
+--      bench "compile decls" Aiur.TypedDecls.compile decls
+--    ]
+--
+--def buildAiurSystemBench : IO Unit := do
+--  match toplevel.checkAndSimplify with
+--  | .error e => IO.eprintln e
+--  | .ok decls =>
+--    let bytecode := decls.compile
+--    bgroup "nat_fib" [
+--      bench "build AiurSystem" (Aiur.AiurSystem.build bytecode) commitmentParameters
+--    ]
+--
+--def proveBench : IO Unit := do
+--  match toplevel.checkAndSimplify with
+--  | .error e => IO.eprintln e
+--  | .ok decls =>
+--    let bytecode := decls.compile
+--    let system := Aiur.AiurSystem.build bytecode commitmentParameters
+--    let funIdx := toplevel.getFuncIdx `main |>.get!
+--    bgroup "nat_fib" [
+--      bench "prove fib 10" (Aiur.AiurSystem.prove system friParameters funIdx) #[10]
+--    ]
+--
+--def verifyBench : IO Unit := do
+--  match toplevel.checkAndSimplify with
+--  | .error e => IO.eprintln e
+--  | .ok decls =>
+--    let bytecode := decls.compile
+--    let system := Aiur.AiurSystem.build bytecode commitmentParameters
+--    let funIdx := toplevel.getFuncIdx `main |>.get!
+--    let (claim, proof, _) := system.prove friParameters funIdx #[10] default
+--    bgroup "nat_fib" [
+--      bench "verify fib 10" (Aiur.AiurSystem.verify system friParameters claim) proof
+--    ]
+--
 def main (_args : List String) : IO Unit := do
-  let _result ← proveBench
+    return ()
+--  let _result ← proveBench
diff --git a/Ix/Benchmark/Bench.lean b/Ix/Benchmark/Bench.lean
index 66145ec3..ab170b86 100644
--- a/Ix/Benchmark/Bench.lean
+++ b/Ix/Benchmark/Bench.lean
@@ -1,323 +1,322 @@
-import Ix.Ixon
-import Ix.Address
-import Ix.Meta
-import Ix.CompileM
-import Ix.Cronos
-import Ix.Ixon.Expr
-import Ix.Address
-import Batteries
-
-import Ix.Benchmark.Serde
-import Ix.Benchmark.Tukey
-
-open Batteries (RBMap)
-
-/-!
-# Benchmarking library modeled after Criterion in Haskell and Rust
-
-## Limitations
-- Measures time in nanoseconds using `IO.monoNanosNow`, which is less precise than the picoseconds used in Criterion.rs
--/
-
-/--
-Computes the result and then wraps the return type in IO. This prevents Lean from optimizing away the function call due to an unused return value.
--/
-@[never_extract, noinline]
-def blackBoxIO (f : α → β) (a : α) : IO β := do
-  pure $ f a
-
-/--
-A benchmark group defines a collection of related benchmarks that share a configuration, such as number of samples and noise threshold
--/
-structure BenchGroup where
-  name : String
-  config : Config
-
-inductive BenchFn ( α β : Type) where
-| pure (fn : α → β)
-| io (fn : α → IO β)
-
-structure Benchmarkable (α β : Type) where
-  name : String
-  func : BenchFn α β
-  arg : α
-
-/--
-Creates a `Benchmarkable` instance. Use with pure functions, which will later be called with `blackBoxIO` to prevent compiler optimizations.
--/
-def bench (name : String) (fn : α → β) (arg : α) : Benchmarkable α β := { name, func := BenchFn.pure fn, arg }
-
-/--
-Creates a `Benchmarkable` instance. Use with functions that return IO, as they don't need to be black boxed.
--/
-def benchIO (name : String) (fn : α → IO β) (arg : α) : Benchmarkable α β :=  { name, func := BenchFn.io fn, arg }
-
-/-- If the function is pure, we need to wrap it in `blackBoxIO` so that Lean doesn't optimize away the result -/
-def Benchmarkable.getFn ( bench: Benchmarkable α β) : α → IO β :=
-  match bench.func with
-  | .pure f => blackBoxIO f
-  | .io f => f
-
--- TODO: According to Criterion.rs docs the warmup iterations should increase linearly until the warmup time is reached, rather than one iteration per time check
-def BenchGroup.warmup (bg : BenchGroup) (bench : Benchmarkable α β) : IO Float := do
-  IO.println s!"Warming up for {bg.config.warmupTime.floatPretty 2}s"
-  let mut count := 0
-  let warmupNanos := Cronos.secToNano bg.config.warmupTime
-  let mut elapsed := 0
-  let func := bench.getFn
-  let startTime ← IO.monoNanosNow
-  while elapsed < warmupNanos do
-    let _res ← func bench.arg
-    let now ← IO.monoNanosNow
-    count := count + 1
-    elapsed := now - startTime
-  let mean := Float.ofNat elapsed / Float.ofNat count
-  --IO.println s!"{bench.name} warmup avg: {mean}ns"
-  return mean
-
--- TODO: Combine with other sampling functions, DRY
--- TODO: Recommend sample count if expectedTime >>> bg.config.sampleTime (i.e. itersPerSample == 1)
-/--
-Runs the sample as a sequence of constant iterations per data point, where the iteration count attempts to fit into the configurable `sampleTime` but cannot be less than 1.
-
-Returns the iteration counts and elapsed time per data point.
--/
-def BenchGroup.sampleFlat (bg : BenchGroup) (bench : Benchmarkable α β)
-(warmupMean : Float) : IO (Array Nat × Array Nat) := do
-  let targetTime := bg.config.sampleTime.toNanos
-  let timePerSample := targetTime / (Float.ofNat bg.config.numSamples)
-  let itersPerSample := (timePerSample / warmupMean).ceil.toUInt64.toNat.max 1
-  let totalIters := itersPerSample * bg.config.numSamples
-  let expectedTime := warmupMean * Float.ofNat itersPerSample * bg.config.numSamples.toSeconds
-  if itersPerSample == 1
-  then
-    IO.eprintln s!"Warning: Unable to complete {bg.config.numSamples} samples in {bg.config.sampleTime.floatPretty 2}s. You may wish to increase target time to {expectedTime.floatPretty 2}s"
-  IO.println s!"Running {bg.config.numSamples} samples in {expectedTime.floatPretty 2}s ({totalIters.natPretty} iterations)\n"
-  --IO.println s!"Flat sample. Iters per sample: {itersPerSample}"
-  let func := bench.getFn
-  let mut timings : Array Nat := #[]
-  -- TODO: `mkArray` deprecated in favor of `replicate` in Lean v4.19
-  let sampleIters := Array.mkArray bg.config.numSamples itersPerSample
-  for iters in sampleIters do
-    let start ← IO.monoNanosNow
-    for _i in Array.range iters do
-      let _res ← func bench.arg
-    let finish ← IO.monoNanosNow
-    timings := timings.push (finish - start)
-  return (sampleIters, timings)
-
-/--
-Runs the sample as a sequence of linearly increasing iterations [d, 2d, 3d, ..., Nd] where `N` is the total number of samples and `d` is a factor derived from the warmup iteration time.
-
-The sum of this series should be roughly equivalent to the total `sampleTime`.
-
-Returns the iteration counts and elapsed time per sample.
--/
-def BenchGroup.sampleLinear (bg : BenchGroup) (bench : Benchmarkable α β) (warmupMean : Float) : IO (Array Nat × Array Nat) := do
-  let totalRuns := bg.config.numSamples * (bg.config.numSamples + 1) / 2
-  let targetTime := bg.config.sampleTime.toNanos
-  let d := (targetTime / warmupMean / (Float.ofNat totalRuns)).ceil.toUInt64.toNat.max 1
-  let expectedTime := (Float.ofNat totalRuns) * (Float.ofNat d) * warmupMean.toSeconds
-  let sampleIters := (Array.range bg.config.numSamples).map (fun x => (x + 1) * d)
-  -- `d` has a minimum value of 1 if the `warmupMean` is sufficiently large
-  -- If so, that likely means the benchmark takes too long and target time should be increased, as well as other config options like flat sampling mode
-  if d == 1
-  then
-    IO.eprintln s!"Warning: Unable to complete {bg.config.numSamples} samples in {bg.config.sampleTime.floatPretty 2}s. You may wish to increase target time to {expectedTime.floatPretty 2}s"
-  IO.println s!"Running {bg.config.numSamples} samples in {expectedTime.floatPretty 2}s ({sampleIters.sum.natPretty} iterations)\n"
-  --IO.println s!"Linear sample. Iters increase by a factor of {d} per sample"
-  let func := bench.getFn
-  let mut timings : Array Nat := #[]
-  for iters in sampleIters do
-    let start ← IO.monoNanosNow
-    for _i in Array.range iters do
-      let _res ← func bench.arg
-    let finish ← IO.monoNanosNow
-    timings := timings.push (finish - start)
-  return (sampleIters, timings)
-
-def BenchGroup.sample (bg : BenchGroup) (bench : Benchmarkable α β) (warmupMean : Float) : IO (Array Nat × Array Nat) := do
-  match bg.config.samplingMode with
-  | .flat => bg.sampleFlat bench warmupMean
-  | .linear => bg.sampleLinear bench warmupMean
-
--- TODO
-inductive Throughput where
-| Bytes (n : UInt64)
-| BytesDecimal (n : UInt64)
-| Elements (n : UInt64)
-| Bits (n : UInt64)
-
-structure MeasurementData where
-  data : Data
-  avgTimes : Distribution
-  absoluteEstimates : Estimates
-  distributions : Distributions
-  comparison : Option ComparisonData
-  throughput : Option Throughput
-
-/-- Compare performance against prior run -/
-def BenchGroup.compare (bg : BenchGroup) (baseSample : Data) (baseEstimates : Estimates) (avgTimes : Distribution) (gen : StdGen) : ComparisonData :=
-  -- Get `base` data for comparison
-  let baseAvgTimes : Distribution := { d := baseSample.d.map (fun (x,y) => Float.ofNat y / Float.ofNat x) }
-  -- Then perform statistical analysis
-  let (tValue, tDistribution) := tTest avgTimes baseAvgTimes bg.config gen
-  let (relativeEstimates, relativeDistributions) := changeEstimates avgTimes baseAvgTimes bg.config gen
-  let pValue := tDistribution.pValue tValue
-  {
-    pValue,
-    tDistribution,
-    tValue,
-    relativeEstimates,
-    relativeDistributions,
-    significanceThreshold := bg.config.significanceLevel,
-    noiseThreshold := bg.config.noiseThreshold,
-    baseSample,
-    baseAvgTimes,
-    baseEstimates
-  }
-
--- TODO: Don't compare if different sampling modes were used
-def BenchGroup.getComparison (bg : BenchGroup) (benchName : String) (avgTimes : Distribution) : IO (Option ComparisonData) := do
-  let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
-  let basePath := benchPath / "base"
-  if (← System.FilePath.pathExists basePath)
-  then do
-    let newPath := benchPath / "new"
-    -- If 2 or more prior runs, then the base data was stored in `new`
-    let basePath' := if (← System.FilePath.pathExists newPath)
-    then
-      newPath
-    else
-      basePath
-    let baseEstimateBytes ← IO.FS.readBinFile (basePath' / "estimates.ixon")
-    let baseEstimates ← match (Ixon.Serialize.get baseEstimateBytes : Except String Estimates) with
-    | .ok bd' => pure bd'
-    | e => throw $ IO.userError s!"expected `Estimates`, got {repr e}"
-    let baseSampleBytes ← IO.FS.readBinFile (basePath' / "sample.ixon")
-    let baseSample ← match (Ixon.Serialize.get baseSampleBytes : Except String Data) with
-    | .ok bd' => pure bd'
-    | e => throw $ IO.userError s!"expected `Data`, got {repr e}"
-    let gen ← IO.stdGenRef.get
-    return some $ bg.compare baseSample baseEstimates avgTimes gen
-  else
-    return none
-
-inductive ComparisonResult where
-| Improved
-| Regressed
-| NonSignificant
-
-def compareToThreshold (estimate : Estimate) (noiseThreshold : Float) : ComparisonResult :=
-  let ci := estimate.confidenceInterval
-  let (lb, ub) := (ci.lowerBound, ci.upperBound)
-  let noiseNeg := noiseThreshold.neg
-
-  if lb < noiseNeg && ub < noiseNeg
-  then
-    ComparisonResult.Improved
-  else if lb > noiseThreshold && ub > noiseThreshold
-  then
-    ComparisonResult.Regressed
-  else
-    ComparisonResult.NonSignificant
-
--- TODO: Print ~24 whitespace characters before time, change, regression
-def BenchGroup.printResults (bg : BenchGroup) (benchName : String) (m : MeasurementData) : IO Unit := do
-  let estimates := m.absoluteEstimates
-  let typicalEstimate := estimates.slope.getD estimates.mean
-  IO.println s!"{bg.name}/{benchName}"
-  let lb := typicalEstimate.confidenceInterval.lowerBound.formatNanos
-  let pointEst := typicalEstimate.pointEstimate.formatNanos
-  let ub := typicalEstimate.confidenceInterval.upperBound.formatNanos
-  IO.println s!"time:   [{lb} {pointEst} {ub}]"
-  if let some comp := m.comparison
-  then
-    let diffMean := comp.pValue < comp.significanceThreshold
-    let meanEst := comp.relativeEstimates.mean
-    let pointEst := (meanEst.pointEstimate * 100).floatPretty 4
-    let lb := (meanEst.confidenceInterval.lowerBound * 100).floatPretty 4
-    let ub := (meanEst.confidenceInterval.upperBound * 100).floatPretty 4
-    let symbol := if diffMean then "<" else ">"
-    IO.println s!"change: [{lb}% {pointEst}% {ub}%] (p = {comp.pValue.floatPretty 2} {symbol} {comp.significanceThreshold.floatPretty 2})"
-    let explanation := if diffMean
-    then
-      "No change in performance detected"
-    else
-      match compareToThreshold meanEst comp.noiseThreshold with
-      | ComparisonResult.Improved => "Performance has improved"
-      | ComparisonResult.Regressed => "Performance has regressed"
-      | ComparisonResult.NonSignificant => "Change within noise threshold"
-    IO.println explanation
-  IO.println ""
-  m.avgTimes.tukey
-
-def saveComparison! (benchName : String) (comparison : Option ComparisonData) : IO Unit := do
-  match comparison with
-  | some comp => do
-    let changeIxon := Ixon.Serialize.put comp.relativeEstimates
-    let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
-    let changePath := benchPath / "change"
-    let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", changePath.toString ] }
-    IO.FS.writeBinFile (changePath / "estimates.ixon") changeIxon
-  | none => IO.eprintln s!"Error: expected `comparisonData` to write but found none"
-
--- TODO: Write sampling mode in `sample.json` for comparison
-def saveResults (benchName : String) (m : MeasurementData) : IO Unit := do
-  let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
-  let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", benchPath.toString] }
-  let basePath := benchPath / "base"
-  let baseDir := basePath.toString
-  -- If prior results were saved to disk, don't overwrite them
-  let newPath ← if (← System.FilePath.pathExists basePath)
-    then do
-      let newPath := benchPath / "new"
-      let newDir := newPath.toString
-      -- If 2 or more prior runs, then the base data was stored in `new`
-      -- Move the base data to `base`
-      if (← System.FilePath.pathExists newPath)
-      then do
-        let _out ← IO.Process.run {cmd := "rm", args := #["-r", baseDir] }
-        let _out ← IO.Process.run {cmd := "mv", args := #[newDir, baseDir] }
-      let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", newPath.toString] }
-      saveComparison! benchName m.comparison
-      pure newPath
-  else do
-    let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", baseDir] }
-    pure basePath
-  let sampleIxon := Ixon.Serialize.put m.data
-  IO.FS.writeBinFile (newPath / "sample.ixon") sampleIxon
-  let estimateIxon := Ixon.Serialize.put m.absoluteEstimates
-  IO.FS.writeBinFile (newPath / "estimates.ixon") estimateIxon
-
--- TODO: Make sure compiler isn't caching partial evaluation result for future runs of the same function (measure first vs subsequent runs)
-/-- Runs each benchmark in a `BenchGroup` and analyzes the results -/
-def bgroup {α β : Type} (name: String) (benches : List (Benchmarkable α β)) (config : Config := {}) : IO Unit := do
-  let bg : BenchGroup := { name, config }
-  IO.println s!"Running bench group {name}\n"
-  for b in benches do
-    let warmupMean ← bg.warmup b
-    IO.println s!"Running {b.name}"
-    let (iters, times) ← bg.sample b warmupMean
-    let data := iters.zip times
-    let avgTimes : Distribution := { d := data.map (fun (x,y) => Float.ofNat y / Float.ofNat x) }
-    let gen ← IO.stdGenRef.get
-    let mut (distributions, estimates) := avgTimes.estimates bg.config gen
-    if bg.config.samplingMode == .linear
-    then
-      let data' : Data := { d := data }
-      let (distribution, slope) := data'.regression bg.config gen
-      estimates := { estimates with slope := .some slope }
-      distributions := { distributions with slope := .some distribution }
-    let comparisonData : Option ComparisonData ← bg.getComparison b.name avgTimes
-    let m :=  {
-      data := { d := data },
-      avgTimes,
-      absoluteEstimates := estimates,
-      distributions,
-      comparison := comparisonData
-      throughput := none
-    }
-    bg.printResults b.name m
-    IO.println ""
-    saveResults b.name m
+--import Ix.Ixon
+--import Ix.Address
+--import Ix.Meta
+--import Ix.CompileM
+--import Ix.Cronos
+--import Ix.Address
+--import Batteries
+--
+--import Ix.Benchmark.Serde
+--import Ix.Benchmark.Tukey
+--
+--open Batteries (RBMap)
+--
+--/-!
+--# Benchmarking library modeled after Criterion in Haskell and Rust
+--
+--## Limitations
+--- Measures time in nanoseconds using `IO.monoNanosNow`, which is less precise than the picoseconds used in Criterion.rs
+---/
+--
+--/--
+--Computes the result and then wraps the return type in IO. This prevents Lean from optimizing away the function call due to an unused return value.
+---/
+--@[never_extract, noinline]
+--def blackBoxIO (f : α → β) (a : α) : IO β := do
+--  pure $ f a
+--
+--/--
+--A benchmark group defines a collection of related benchmarks that share a configuration, such as number of samples and noise threshold
+---/
+--structure BenchGroup where
+--  name : String
+--  config : Config
+--
+--inductive BenchFn ( α β : Type) where
+--| pure (fn : α → β)
+--| io (fn : α → IO β)
+--
+--structure Benchmarkable (α β : Type) where
+--  name : String
+--  func : BenchFn α β
+--  arg : α
+--
+--/--
+--Creates a `Benchmarkable` instance. Use with pure functions, which will later be called with `blackBoxIO` to prevent compiler optimizations.
+---/
+--def bench (name : String) (fn : α → β) (arg : α) : Benchmarkable α β := { name, func := BenchFn.pure fn, arg }
+--
+--/--
+--Creates a `Benchmarkable` instance. Use with functions that return IO, as they don't need to be black boxed.
+---/
+--def benchIO (name : String) (fn : α → IO β) (arg : α) : Benchmarkable α β :=  { name, func := BenchFn.io fn, arg }
+--
+--/-- If the function is pure, we need to wrap it in `blackBoxIO` so that Lean doesn't optimize away the result -/
+--def Benchmarkable.getFn ( bench: Benchmarkable α β) : α → IO β :=
+--  match bench.func with
+--  | .pure f => blackBoxIO f
+--  | .io f => f
+--
+---- TODO: According to Criterion.rs docs the warmup iterations should increase linearly until the warmup time is reached, rather than one iteration per time check
+--def BenchGroup.warmup (bg : BenchGroup) (bench : Benchmarkable α β) : IO Float := do
+--  IO.println s!"Warming up for {bg.config.warmupTime.floatPretty 2}s"
+--  let mut count := 0
+--  let warmupNanos := Cronos.secToNano bg.config.warmupTime
+--  let mut elapsed := 0
+--  let func := bench.getFn
+--  let startTime ← IO.monoNanosNow
+--  while elapsed < warmupNanos do
+--    let _res ← func bench.arg
+--    let now ← IO.monoNanosNow
+--    count := count + 1
+--    elapsed := now - startTime
+--  let mean := Float.ofNat elapsed / Float.ofNat count
+--  --IO.println s!"{bench.name} warmup avg: {mean}ns"
+--  return mean
+--
+---- TODO: Combine with other sampling functions, DRY
+---- TODO: Recommend sample count if expectedTime >>> bg.config.sampleTime (i.e. itersPerSample == 1)
+--/--
+--Runs the sample as a sequence of constant iterations per data point, where the iteration count attempts to fit into the configurable `sampleTime` but cannot be less than 1.
+--
+--Returns the iteration counts and elapsed time per data point.
+---/
+--def BenchGroup.sampleFlat (bg : BenchGroup) (bench : Benchmarkable α β)
+--(warmupMean : Float) : IO (Array Nat × Array Nat) := do
+--  let targetTime := bg.config.sampleTime.toNanos
+--  let timePerSample := targetTime / (Float.ofNat bg.config.numSamples)
+--  let itersPerSample := (timePerSample / warmupMean).ceil.toUInt64.toNat.max 1
+--  let totalIters := itersPerSample * bg.config.numSamples
+--  let expectedTime := warmupMean * Float.ofNat itersPerSample * bg.config.numSamples.toSeconds
+--  if itersPerSample == 1
+--  then
+--    IO.eprintln s!"Warning: Unable to complete {bg.config.numSamples} samples in {bg.config.sampleTime.floatPretty 2}s. You may wish to increase target time to {expectedTime.floatPretty 2}s"
+--  IO.println s!"Running {bg.config.numSamples} samples in {expectedTime.floatPretty 2}s ({totalIters.natPretty} iterations)\n"
+--  --IO.println s!"Flat sample. Iters per sample: {itersPerSample}"
+--  let func := bench.getFn
+--  let mut timings : Array Nat := #[]
+--  -- TODO: `mkArray` deprecated in favor of `replicate` in Lean v4.19
+--  let sampleIters := Array.mkArray bg.config.numSamples itersPerSample
+--  for iters in sampleIters do
+--    let start ← IO.monoNanosNow
+--    for _i in Array.range iters do
+--      let _res ← func bench.arg
+--    let finish ← IO.monoNanosNow
+--    timings := timings.push (finish - start)
+--  return (sampleIters, timings)
+--
+--/--
+--Runs the sample as a sequence of linearly increasing iterations [d, 2d, 3d, ..., Nd] where `N` is the total number of samples and `d` is a factor derived from the warmup iteration time.
+--
+--The sum of this series should be roughly equivalent to the total `sampleTime`.
+--
+--Returns the iteration counts and elapsed time per sample.
+---/
+--def BenchGroup.sampleLinear (bg : BenchGroup) (bench : Benchmarkable α β) (warmupMean : Float) : IO (Array Nat × Array Nat) := do
+--  let totalRuns := bg.config.numSamples * (bg.config.numSamples + 1) / 2
+--  let targetTime := bg.config.sampleTime.toNanos
+--  let d := (targetTime / warmupMean / (Float.ofNat totalRuns)).ceil.toUInt64.toNat.max 1
+--  let expectedTime := (Float.ofNat totalRuns) * (Float.ofNat d) * warmupMean.toSeconds
+--  let sampleIters := (Array.range bg.config.numSamples).map (fun x => (x + 1) * d)
+--  -- `d` has a minimum value of 1 if the `warmupMean` is sufficiently large
+--  -- If so, that likely means the benchmark takes too long and target time should be increased, as well as other config options like flat sampling mode
+--  if d == 1
+--  then
+--    IO.eprintln s!"Warning: Unable to complete {bg.config.numSamples} samples in {bg.config.sampleTime.floatPretty 2}s. You may wish to increase target time to {expectedTime.floatPretty 2}s"
+--  IO.println s!"Running {bg.config.numSamples} samples in {expectedTime.floatPretty 2}s ({sampleIters.sum.natPretty} iterations)\n"
+--  --IO.println s!"Linear sample. Iters increase by a factor of {d} per sample"
+--  let func := bench.getFn
+--  let mut timings : Array Nat := #[]
+--  for iters in sampleIters do
+--    let start ← IO.monoNanosNow
+--    for _i in Array.range iters do
+--      let _res ← func bench.arg
+--    let finish ← IO.monoNanosNow
+--    timings := timings.push (finish - start)
+--  return (sampleIters, timings)
+--
+--def BenchGroup.sample (bg : BenchGroup) (bench : Benchmarkable α β) (warmupMean : Float) : IO (Array Nat × Array Nat) := do
+--  match bg.config.samplingMode with
+--  | .flat => bg.sampleFlat bench warmupMean
+--  | .linear => bg.sampleLinear bench warmupMean
+--
+---- TODO
+--inductive Throughput where
+--| Bytes (n : UInt64)
+--| BytesDecimal (n : UInt64)
+--| Elements (n : UInt64)
+--| Bits (n : UInt64)
+--
+--structure MeasurementData where
+--  data : Data
+--  avgTimes : Distribution
+--  absoluteEstimates : Estimates
+--  distributions : Distributions
+--  comparison : Option ComparisonData
+--  throughput : Option Throughput
+--
+--/-- Compare performance against prior run -/
+--def BenchGroup.compare (bg : BenchGroup) (baseSample : Data) (baseEstimates : Estimates) (avgTimes : Distribution) (gen : StdGen) : ComparisonData :=
+--  -- Get `base` data for comparison
+--  let baseAvgTimes : Distribution := { d := baseSample.d.map (fun (x,y) => Float.ofNat y / Float.ofNat x) }
+--  -- Then perform statistical analysis
+--  let (tValue, tDistribution) := tTest avgTimes baseAvgTimes bg.config gen
+--  let (relativeEstimates, relativeDistributions) := changeEstimates avgTimes baseAvgTimes bg.config gen
+--  let pValue := tDistribution.pValue tValue
+--  {
+--    pValue,
+--    tDistribution,
+--    tValue,
+--    relativeEstimates,
+--    relativeDistributions,
+--    significanceThreshold := bg.config.significanceLevel,
+--    noiseThreshold := bg.config.noiseThreshold,
+--    baseSample,
+--    baseAvgTimes,
+--    baseEstimates
+--  }
+--
+---- TODO: Don't compare if different sampling modes were used
+--def BenchGroup.getComparison (bg : BenchGroup) (benchName : String) (avgTimes : Distribution) : IO (Option ComparisonData) := do
+--  let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
+--  let basePath := benchPath / "base"
+--  if (← System.FilePath.pathExists basePath)
+--  then do
+--    let newPath := benchPath / "new"
+--    -- If 2 or more prior runs, then the base data was stored in `new`
+--    let basePath' := if (← System.FilePath.pathExists newPath)
+--    then
+--      newPath
+--    else
+--      basePath
+--    let baseEstimateBytes ← IO.FS.readBinFile (basePath' / "estimates.ixon")
+--    let baseEstimates ← match (Ixon.Serialize.get baseEstimateBytes : Except String Estimates) with
+--    | .ok bd' => pure bd'
+--    | e => throw $ IO.userError s!"expected `Estimates`, got {repr e}"
+--    let baseSampleBytes ← IO.FS.readBinFile (basePath' / "sample.ixon")
+--    let baseSample ← match (Ixon.Serialize.get baseSampleBytes : Except String Data) with
+--    | .ok bd' => pure bd'
+--    | e => throw $ IO.userError s!"expected `Data`, got {repr e}"
+--    let gen ← IO.stdGenRef.get
+--    return some $ bg.compare baseSample baseEstimates avgTimes gen
+--  else
+--    return none
+--
+--inductive ComparisonResult where
+--| Improved
+--| Regressed
+--| NonSignificant
+--
+--def compareToThreshold (estimate : Estimate) (noiseThreshold : Float) : ComparisonResult :=
+--  let ci := estimate.confidenceInterval
+--  let (lb, ub) := (ci.lowerBound, ci.upperBound)
+--  let noiseNeg := noiseThreshold.neg
+--
+--  if lb < noiseNeg && ub < noiseNeg
+--  then
+--    ComparisonResult.Improved
+--  else if lb > noiseThreshold && ub > noiseThreshold
+--  then
+--    ComparisonResult.Regressed
+--  else
+--    ComparisonResult.NonSignificant
+--
+---- TODO: Print ~24 whitespace characters before time, change, regression
+--def BenchGroup.printResults (bg : BenchGroup) (benchName : String) (m : MeasurementData) : IO Unit := do
+--  let estimates := m.absoluteEstimates
+--  let typicalEstimate := estimates.slope.getD estimates.mean
+--  IO.println s!"{bg.name}/{benchName}"
+--  let lb := typicalEstimate.confidenceInterval.lowerBound.formatNanos
+--  let pointEst := typicalEstimate.pointEstimate.formatNanos
+--  let ub := typicalEstimate.confidenceInterval.upperBound.formatNanos
+--  IO.println s!"time:   [{lb} {pointEst} {ub}]"
+--  if let some comp := m.comparison
+--  then
+--    let diffMean := comp.pValue < comp.significanceThreshold
+--    let meanEst := comp.relativeEstimates.mean
+--    let pointEst := (meanEst.pointEstimate * 100).floatPretty 4
+--    let lb := (meanEst.confidenceInterval.lowerBound * 100).floatPretty 4
+--    let ub := (meanEst.confidenceInterval.upperBound * 100).floatPretty 4
+--    let symbol := if diffMean then "<" else ">"
+--    IO.println s!"change: [{lb}% {pointEst}% {ub}%] (p = {comp.pValue.floatPretty 2} {symbol} {comp.significanceThreshold.floatPretty 2})"
+--    let explanation := if diffMean
+--    then
+--      "No change in performance detected"
+--    else
+--      match compareToThreshold meanEst comp.noiseThreshold with
+--      | ComparisonResult.Improved => "Performance has improved"
+--      | ComparisonResult.Regressed => "Performance has regressed"
+--      | ComparisonResult.NonSignificant => "Change within noise threshold"
+--    IO.println explanation
+--  IO.println ""
+--  m.avgTimes.tukey
+--
+--def saveComparison! (benchName : String) (comparison : Option ComparisonData) : IO Unit := do
+--  match comparison with
+--  | some comp => do
+--    let changeIxon := Ixon.Serialize.put comp.relativeEstimates
+--    let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
+--    let changePath := benchPath / "change"
+--    let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", changePath.toString ] }
+--    IO.FS.writeBinFile (changePath / "estimates.ixon") changeIxon
+--  | none => IO.eprintln s!"Error: expected `comparisonData` to write but found none"
+--
+---- TODO: Write sampling mode in `sample.json` for comparison
+--def saveResults (benchName : String) (m : MeasurementData) : IO Unit := do
+--  let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
+--  let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", benchPath.toString] }
+--  let basePath := benchPath / "base"
+--  let baseDir := basePath.toString
+--  -- If prior results were saved to disk, don't overwrite them
+--  let newPath ← if (← System.FilePath.pathExists basePath)
+--    then do
+--      let newPath := benchPath / "new"
+--      let newDir := newPath.toString
+--      -- If 2 or more prior runs, then the base data was stored in `new`
+--      -- Move the base data to `base`
+--      if (← System.FilePath.pathExists newPath)
+--      then do
+--        let _out ← IO.Process.run {cmd := "rm", args := #["-r", baseDir] }
+--        let _out ← IO.Process.run {cmd := "mv", args := #[newDir, baseDir] }
+--      let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", newPath.toString] }
+--      saveComparison! benchName m.comparison
+--      pure newPath
+--  else do
+--    let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", baseDir] }
+--    pure basePath
+--  let sampleIxon := Ixon.Serialize.put m.data
+--  IO.FS.writeBinFile (newPath / "sample.ixon") sampleIxon
+--  let estimateIxon := Ixon.Serialize.put m.absoluteEstimates
+--  IO.FS.writeBinFile (newPath / "estimates.ixon") estimateIxon
+--
+---- TODO: Make sure compiler isn't caching partial evaluation result for future runs of the same function (measure first vs subsequent runs)
+--/-- Runs each benchmark in a `BenchGroup` and analyzes the results -/
+--def bgroup {α β : Type} (name: String) (benches : List (Benchmarkable α β)) (config : Config := {}) : IO Unit := do
+--  let bg : BenchGroup := { name, config }
+--  IO.println s!"Running bench group {name}\n"
+--  for b in benches do
+--    let warmupMean ← bg.warmup b
+--    IO.println s!"Running {b.name}"
+--    let (iters, times) ← bg.sample b warmupMean
+--    let data := iters.zip times
+--    let avgTimes : Distribution := { d := data.map (fun (x,y) => Float.ofNat y / Float.ofNat x) }
+--    let gen ← IO.stdGenRef.get
+--    let mut (distributions, estimates) := avgTimes.estimates bg.config gen
+--    if bg.config.samplingMode == .linear
+--    then
+--      let data' : Data := { d := data }
+--      let (distribution, slope) := data'.regression bg.config gen
+--      estimates := { estimates with slope := .some slope }
+--      distributions := { distributions with slope := .some distribution }
+--    let comparisonData : Option ComparisonData ← bg.getComparison b.name avgTimes
+--    let m :=  {
+--      data := { d := data },
+--      avgTimes,
+--      absoluteEstimates := estimates,
+--      distributions,
+--      comparison := comparisonData
+--      throughput := none
+--    }
+--    bg.printResults b.name m
+--    IO.println ""
+--    saveResults b.name m
diff --git a/Ix/Benchmark/Serde.lean b/Ix/Benchmark/Serde.lean
index 1777a50f..75056d11 100644
--- a/Ix/Benchmark/Serde.lean
+++ b/Ix/Benchmark/Serde.lean
@@ -1,82 +1,82 @@
-import Ix.Ixon.Expr
-import Ix.Benchmark.Change
-
-@[inline] def putFloat (x : Float): Ixon.PutM := Ixon.putUInt64LE x.toBits
-@[inline] def getFloat : Ixon.GetM Float := Ixon.getUInt64LE.map Float.ofBits
-
-instance : Ixon.Serialize Float where
-  put := Ixon.runPut ∘ putFloat
-  get := Ixon.runGet getFloat
-
-def putTupleNat (xy : Nat × Nat) : Ixon.PutM := do
-  Ixon.putNatl xy.fst
-  Ixon.putNatl xy.snd
-
-def putData (data : Data) : Ixon.PutM := do
-  Ixon.putArray putTupleNat data.d.toList
-
-def getTupleNat : Ixon.GetM (Nat × Nat) := do
-  return (← Ixon.getNatl, ← Ixon.getNatl)
-
-def getData : Ixon.GetM Data := do
-  let data ← Ixon.getArray getTupleNat
-  return { d := data.toArray }
-
-instance : Ixon.Serialize Data where
-  put := Ixon.runPut ∘ putData
-  get := Ixon.runGet getData
-
-def putConfidenceInterval (ci : ConfidenceInterval) : Ixon.PutM := do
-  putFloat ci.confidenceLevel
-  putFloat ci.lowerBound
-  putFloat ci.upperBound
-
-def getConfidenceInterval : Ixon.GetM ConfidenceInterval := do
-  return { confidenceLevel := (← getFloat), lowerBound := (← getFloat), upperBound := (← getFloat)}
-
-def putEstimate (est : Estimate) : Ixon.PutM := do
-  putConfidenceInterval est.confidenceInterval
-  putFloat est.pointEstimate
-  putFloat est.stdErr
-
-def getEstimate : Ixon.GetM Estimate := do
-  return { confidenceInterval := (← getConfidenceInterval), pointEstimate := (← getFloat), stdErr := (← getFloat)}
-
-def putEstimates (est : Estimates) : Ixon.PutM := do
-  putEstimate est.mean
-  putEstimate est.median
-  putEstimate est.medianAbsDev
-  if let .some x := est.slope
-  then
-    Ixon.putUInt8 1
-    putEstimate x
-  else
-    Ixon.putUInt8 0
-  putEstimate est.stdDev
-
-def getEstimates : Ixon.GetM Estimates := do
-  let mean ← getEstimate
-  let median ← getEstimate
-  let medianAbsDev ← getEstimate
-  let slope ← match (← Ixon.getUInt8) with
-    | 1 => pure $ some (← getEstimate)
-    | _ => pure none
-  let stdDev ← getEstimate
-  return { mean, median, medianAbsDev, slope, stdDev }
-
-instance : Ixon.Serialize Estimates where
-  put := Ixon.runPut ∘ putEstimates
-  get := Ixon.runGet getEstimates
-
-def putChangeEstimates (changeEst : ChangeEstimates) : Ixon.PutM := do
-  putEstimate changeEst.mean
-  putEstimate changeEst.median
-
-def getChangeEstimates : Ixon.GetM ChangeEstimates := do
-  let mean ← getEstimate
-  let median ← getEstimate
-  return { mean, median }
-
-instance : Ixon.Serialize ChangeEstimates where
-  put := Ixon.runPut ∘ putChangeEstimates
-  get := Ixon.runGet getChangeEstimates
+--import Ix.Ixon.Expr
+--import Ix.Benchmark.Change
+--
+--@[inline] def putFloat (x : Float): Ixon.PutM := Ixon.putUInt64LE x.toBits
+--@[inline] def getFloat : Ixon.GetM Float := Ixon.getUInt64LE.map Float.ofBits
+--
+--instance : Ixon.Serialize Float where
+--  put := Ixon.runPut ∘ putFloat
+--  get := Ixon.runGet getFloat
+--
+--def putTupleNat (xy : Nat × Nat) : Ixon.PutM := do
+--  Ixon.putNatl xy.fst
+--  Ixon.putNatl xy.snd
+--
+--def putData (data : Data) : Ixon.PutM := do
+--  Ixon.putArray putTupleNat data.d.toList
+--
+--def getTupleNat : Ixon.GetM (Nat × Nat) := do
+--  return (← Ixon.getNatl, ← Ixon.getNatl)
+--
+--def getData : Ixon.GetM Data := do
+--  let data ← Ixon.getArray getTupleNat
+--  return { d := data.toArray }
+--
+--instance : Ixon.Serialize Data where
+--  put := Ixon.runPut ∘ putData
+--  get := Ixon.runGet getData
+--
+--def putConfidenceInterval (ci : ConfidenceInterval) : Ixon.PutM := do
+--  putFloat ci.confidenceLevel
+--  putFloat ci.lowerBound
+--  putFloat ci.upperBound
+--
+--def getConfidenceInterval : Ixon.GetM ConfidenceInterval := do
+--  return { confidenceLevel := (← getFloat), lowerBound := (← getFloat), upperBound := (← getFloat)}
+--
+--def putEstimate (est : Estimate) : Ixon.PutM := do
+--  putConfidenceInterval est.confidenceInterval
+--  putFloat est.pointEstimate
+--  putFloat est.stdErr
+--
+--def getEstimate : Ixon.GetM Estimate := do
+--  return { confidenceInterval := (← getConfidenceInterval), pointEstimate := (← getFloat), stdErr := (← getFloat)}
+--
+--def putEstimates (est : Estimates) : Ixon.PutM := do
+--  putEstimate est.mean
+--  putEstimate est.median
+--  putEstimate est.medianAbsDev
+--  if let .some x := est.slope
+--  then
+--    Ixon.putUInt8 1
+--    putEstimate x
+--  else
+--    Ixon.putUInt8 0
+--  putEstimate est.stdDev
+--
+--def getEstimates : Ixon.GetM Estimates := do
+--  let mean ← getEstimate
+--  let median ← getEstimate
+--  let medianAbsDev ← getEstimate
+--  let slope ← match (← Ixon.getUInt8) with
+--    | 1 => pure $ some (← getEstimate)
+--    | _ => pure none
+--  let stdDev ← getEstimate
+--  return { mean, median, medianAbsDev, slope, stdDev }
+--
+--instance : Ixon.Serialize Estimates where
+--  put := Ixon.runPut ∘ putEstimates
+--  get := Ixon.runGet getEstimates
+--
+--def putChangeEstimates (changeEst : ChangeEstimates) : Ixon.PutM := do
+--  putEstimate changeEst.mean
+--  putEstimate changeEst.median
+--
+--def getChangeEstimates : Ixon.GetM ChangeEstimates := do
+--  let mean ← getEstimate
+--  let median ← getEstimate
+--  return { mean, median }
+--
+--instance : Ixon.Serialize ChangeEstimates where
+--  put := Ixon.runPut ∘ putChangeEstimates
+--  get := Ixon.runGet getChangeEstimates

From be93efaa13d3e9db79061531f938f96c8f5f85c5 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 27 Oct 2025 16:07:40 -0400
Subject: [PATCH 65/74] xclippy warnings

---
 src/ixon.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/ixon.rs b/src/ixon.rs
index 2c770217..4c8cc213 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -101,6 +101,7 @@ impl Ixon {
         }
     }
 
+    #[allow(clippy::cast_possible_truncation)]
     pub fn pack_bools<I>(bools: I) -> u8
     where
         I: IntoIterator<Item = bool>,
@@ -116,7 +117,7 @@ impl Ixon {
 
     pub fn unpack_bools(n: usize, b: u8) -> Vec<bool> {
         (0..8)
-            .map(|i| (b & (1u8 << (i as u32))) != 0)
+            .map(|i: u32| (b & (1u8 << i)) != 0)
             .take(n.min(8))
             .collect()
     }

From 3c25eb2de43b2cf5c07c26b80ebc0e774e92481f Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Mon, 27 Oct 2025 16:10:52 -0400
Subject: [PATCH 66/74] disable Cli test suite

---
 Tests/Cli.lean  | 38 +++++++++++++++++++-------------------
 Tests/Main.lean |  2 +-
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Tests/Cli.lean b/Tests/Cli.lean
index 26ea66b6..5064a94e 100644
--- a/Tests/Cli.lean
+++ b/Tests/Cli.lean
@@ -1,21 +1,21 @@
 /-! Integration tests for the Ix CLI -/
 
-def Tests.Cli.run (buildCmd: String) (buildArgs : Array String) (buildDir : Option System.FilePath) : IO Unit := do
-  let proc : IO.Process.SpawnArgs :=
-    match buildDir with
-    | some bd => { cmd := buildCmd, args := buildArgs, cwd := bd }
-    | none => { cmd := buildCmd, args := buildArgs }
-  let out ← IO.Process.output proc
-  if out.exitCode ≠ 0 then
-    IO.eprintln out.stderr
-    throw $ IO.userError out.stderr
-  else
-    IO.println out.stdout
-
-def Tests.Cli.suite : IO UInt32 := do
-  Tests.Cli.run "lake" (#["run", "install"]) none
-  let ixTestDir := (← IO.currentDir) / "ix_test"
-  Tests.Cli.run "lake" (#["build"]) (some ixTestDir)
-  Tests.Cli.run "ix" (#["store", "ix_test/IxTest.lean"]) none
-  Tests.Cli.run "ix" (#["prove", "ix_test/IxTest.lean", "one"]) none
-  return 0
+--def Tests.Cli.run (buildCmd: String) (buildArgs : Array String) (buildDir : Option System.FilePath) : IO Unit := do
+--  let proc : IO.Process.SpawnArgs :=
+--    match buildDir with
+--    | some bd => { cmd := buildCmd, args := buildArgs, cwd := bd }
+--    | none => { cmd := buildCmd, args := buildArgs }
+--  let out ← IO.Process.output proc
+--  if out.exitCode ≠ 0 then
+--    IO.eprintln out.stderr
+--    throw $ IO.userError out.stderr
+--  else
+--    IO.println out.stdout
+--
+--def Tests.Cli.suite : IO UInt32 := do
+--  Tests.Cli.run "lake" (#["run", "install"]) none
+--  let ixTestDir := (← IO.currentDir) / "ix_test"
+--  Tests.Cli.run "lake" (#["build"]) (some ixTestDir)
+--  Tests.Cli.run "ix" (#["store", "ix_test/IxTest.lean"]) none
+--  Tests.Cli.run "ix" (#["prove", "ix_test/IxTest.lean", "one"]) none
+--  return 0
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 90ca93d7..014c79c4 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -10,7 +10,7 @@ import Tests.Cli
 
 def main (args: List String) : IO UInt32 := do
   if args.contains "compile" then LSpec.lspecEachIO Tests.Ix.Compile.suiteIO id
-  else if args.contains "cli" then Tests.Cli.suite
+  else if args.contains "cli" then return 0 -- Tests.Cli.suite
   else
     LSpec.lspecIO (.ofList [
        ("aiur", Tests.Aiur.suite),

From 1f886380c96d54762df387b5fab1f71e5c0d4f9d Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 28 Oct 2025 12:35:59 -0400
Subject: [PATCH 67/74] metadata type

---
 src/ixon/meta.rs | 51 ++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 45 insertions(+), 6 deletions(-)

diff --git a/src/ixon/meta.rs b/src/ixon/meta.rs
index d6723293..1dcf0e14 100644
--- a/src/ixon/meta.rs
+++ b/src/ixon/meta.rs
@@ -1,8 +1,46 @@
 use crate::ixon::address::Address;
-use crate::ixon::name::Name;
+//use crate::ixon::name::Name;
 use crate::ixon::nat::Nat;
 //use crate::ixon::serialize::Serialize;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Substring {
+    pub str: Address,
+    pub start_pos: Nat,
+    pub stop_pos: Nat,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SourceInfo {
+    Original(Substring, Nat, Substring, Nat),
+    Synthetic(Nat, Nat, bool),
+    None,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Preresolved {
+    Namespace(Address),
+    Decl(Address, Vec<Address>),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Syntax {
+    Missing,
+    Node(SourceInfo, Address, Vec<Address>),
+    Atom(SourceInfo, Address),
+    Ident(SourceInfo, Substring, Address, Vec<Preresolved>),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DataValue {
+    OfString(Address),
+    OfBool(bool),
+    OfName(Address),
+    OfNat(Address),
+    OfInt(Address),
+    OfSyntax(Address),
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BinderInfo {
     Default,
@@ -21,17 +59,18 @@ pub enum ReducibilityHints {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Metadatum {
-    Name(Name),
-    Info(BinderInfo),
     Link(Address),
+    Info(BinderInfo),
     Hints(ReducibilityHints),
-    All(Vec<Name>),
-    MutCtx(Vec<Vec<Name>>),
+    Links(Vec<Address>),
+    Map(Vec<(Address, Address)>),
+    KVMap(Vec<(Address, DataValue)>),
+    Muts(Vec<Vec<Address>>),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Metadata {
-    pub map: Vec<(Nat, Vec<Metadatum>)>,
+    pub nodes: Vec<Metadatum>,
 }
 
 //impl Serialize for BinderInfo {

From ef821df9fc1464e553a1560a41f30caa55a2a4d1 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 28 Oct 2025 16:09:00 -0400
Subject: [PATCH 68/74] ixon serialization w/o testing

---
 Ix/Ixon.lean          |    1 -
 src/ixon.rs           | 4438 +++++++++++++++++++++++++++--------------
 src/ixon/address.rs   |   71 +-
 src/ixon/nat.rs       |   66 -
 src/ixon/serialize.rs |  117 --
 src/ixon/tag.rs       |  118 --
 src/lean/nat.rs       |   71 +-
 7 files changed, 3030 insertions(+), 1852 deletions(-)
 delete mode 100644 src/ixon/nat.rs
 delete mode 100644 src/ixon/serialize.rs
 delete mode 100644 src/ixon/tag.rs

diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 58224b0a..326ffbb0 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -474,7 +474,6 @@ structure Inductive where
   nested : Nat
   type : Address
   ctors : List Constructor
-  --recrs : List Recursor
   deriving BEq, Repr, Inhabited, Ord, Hashable
 
 instance : Serialize Inductive where
diff --git a/src/ixon.rs b/src/ixon.rs
index 4c8cc213..10d3b151 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -1,1502 +1,2992 @@
-//use num_bigint::BigUint;
+use crate::lean::nat::*;
+use blake3::Hash;
+use num_bigint::BigUint;
 
 pub mod address;
-pub mod claim;
-pub mod constant;
-pub mod meta;
-pub mod name;
-pub mod nat;
-pub mod serialize;
-pub mod univ;
 
 use address::*;
-use claim::*;
-use constant::*;
-use meta::*;
-//use name::*;
-use nat::*;
-//use serialize::*;
-//use univ::*;
 
-// TODO: Update Ixon
+pub trait Serialize: Sized {
+  fn put(&self, buf: &mut Vec<u8>);
+  fn get(buf: &mut &[u8]) -> Result<Self, String>;
+}
+
+impl Serialize for u8 {
+  fn put(&self, buf: &mut Vec<u8>) {
+    buf.push(*self)
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_first() {
+      Some((&x, rest)) => {
+        *buf = rest;
+        Ok(x)
+      },
+      None => Err("get u8 EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for u16 {
+  fn put(&self, buf: &mut Vec<u8>) {
+    buf.extend_from_slice(&self.to_le_bytes());
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(2) {
+      Some((head, rest)) => {
+        *buf = rest;
+        Ok(u16::from_le_bytes([head[0], head[1]]))
+      },
+      None => Err("get u16 EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for u32 {
+  fn put(&self, buf: &mut Vec<u8>) {
+    buf.extend_from_slice(&self.to_le_bytes());
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(4) {
+      Some((head, rest)) => {
+        *buf = rest;
+        Ok(u32::from_le_bytes([head[0], head[1], head[2], head[3]]))
+      },
+      None => Err("get u32 EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for u64 {
+  fn put(&self, buf: &mut Vec<u8>) {
+    buf.extend_from_slice(&self.to_le_bytes());
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(8) {
+      Some((head, rest)) => {
+        *buf = rest;
+        Ok(u64::from_le_bytes([
+          head[0], head[1], head[2], head[3], head[4], head[5], head[6],
+          head[7],
+        ]))
+      },
+      None => Err("get u64 EOF".to_string()),
+    }
+  }
+}
+
+impl Serialize for bool {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      false => buf.push(0),
+      true => buf.push(1),
+    }
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(false),
+          1 => Ok(true),
+          x => Err(format!("get bool invalid {x}")),
+        }
+      },
+      None => Err("get bool EOF".to_string()),
+    }
+  }
+}
+
+pub fn u64_byte_count(x: u64) -> u8 {
+  match x {
+    0 => 0,
+    x if x < 0x0000000000000100 => 1,
+    x if x < 0x0000000000010000 => 2,
+    x if x < 0x0000000001000000 => 3,
+    x if x < 0x0000000100000000 => 4,
+    x if x < 0x0000010000000000 => 5,
+    x if x < 0x0001000000000000 => 6,
+    x if x < 0x0100000000000000 => 7,
+    _ => 8,
+  }
+}
+
+pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
+  let n = u64_byte_count(x) as usize;
+  buf.extend_from_slice(&x.to_le_bytes()[..n])
+}
+
+pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
+  let mut res = [0u8; 8];
+  if len > 8 {
+    return Err("get trimmed_le_64 len > 8".to_string());
+  }
+  match buf.split_at_checked(len) {
+    Some((head, rest)) => {
+      *buf = rest;
+      res[..len].copy_from_slice(head);
+      Ok(u64::from_le_bytes(res))
+    },
+    None => Err("get trimmed_le_u64 EOF".to_string()),
+  }
+}
+
+//  F := flag, L := large-bit, X := small-field, A := large_field
+// 0xFFFF_LXXX {AAAA_AAAA, ...}
+// "Tag" means the whole thing
+// "Head" means the first byte of the tag
+// "Flag" means the first nibble of the head
+#[derive(Clone, Debug)]
+pub struct Tag4 {
+  flag: u8,
+  size: u64,
+}
+
+impl Tag4 {
+  pub fn encode_head(&self) -> u8 {
+    if self.size < 8 {
+      (self.flag << 4) + (self.size as u8)
+    } else {
+      (self.flag << 4) + 0b1000 + u64_byte_count(self.size) - 1
+    }
+  }
+  pub fn decode_head(head: u8) -> (u8, bool, u8) {
+    (head >> 4, head & 0b1000 == 0, head % 0b1000)
+  }
+}
+
+impl Serialize for Tag4 {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.encode_head().put(buf);
+    if self.size >= 8 {
+      u64_put_trimmed_le(self.size, buf)
+    }
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let head = u8::get(buf)?;
+    let (flag, large, small) = Tag4::decode_head(head);
+    let size = if large {
+      u64_get_trimmed_le((small + 1) as usize, buf)?
+    } else {
+      small as u64
+    };
+    Ok(Tag4 { flag, size })
+  }
+}
+pub struct ByteArray(pub Vec<u8>);
+
+impl Serialize for ByteArray {
+  fn put(&self, buf: &mut Vec<u8>) {
+    Tag4 { flag: 0x9, size: self.0.len() as u64 }.put(buf);
+    buf.extend_from_slice(&self.0);
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let tag = Tag4::get(buf)?;
+    match tag {
+      Tag4 { flag: 0x9, size } => {
+        let mut res = vec![];
+        for _ in 0..size {
+          res.push(u8::get(buf)?)
+        }
+        Ok(ByteArray(res))
+      },
+      _ => Err("expected Tag4 0x9 for Vec<u8>".to_string()),
+    }
+  }
+}
+
+impl Serialize for String {
+  fn put(&self, buf: &mut Vec<u8>) {
+    let bytes = self.as_bytes();
+    Tag4 { flag: 0x9, size: bytes.len() as u64 }.put(buf);
+    buf.extend_from_slice(bytes);
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let bytes = ByteArray::get(buf)?;
+    String::from_utf8(bytes.0).map_err(|e| format!("Invalid UTF-8: {e}"))
+  }
+}
+
+impl Serialize for Nat {
+  fn put(&self, buf: &mut Vec<u8>) {
+    let bytes = self.to_le_bytes();
+    Tag4 { flag: 0x9, size: bytes.len() as u64 }.put(buf);
+    buf.extend_from_slice(&bytes);
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let bytes = ByteArray::get(buf)?;
+    Ok(Nat::from_le_bytes(&bytes.0))
+  }
+}
+
+impl Serialize for Int {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::OfNat(x) => {
+        buf.push(0);
+        x.put(buf);
+      },
+      Self::NegSucc(x) => {
+        buf.push(1);
+        x.put(buf);
+      },
+    }
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::OfNat(Nat::get(buf)?)),
+          1 => Ok(Self::NegSucc(Nat::get(buf)?)),
+          x => Err(format!("get Int invalid {x}")),
+        }
+      },
+      None => Err("get Int EOF".to_string()),
+    }
+  }
+}
+
+impl<S: Serialize> Serialize for Vec<S> {
+  fn put(&self, buf: &mut Vec<u8>) {
+    Nat(BigUint::from(self.len())).put(buf);
+    for x in self {
+      x.put(buf)
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let mut res = vec![];
+    let len = Nat::get(buf)?.0;
+    let mut i = BigUint::from(0u32);
+    while i < len {
+      res.push(S::get(buf)?);
+      i += 1u32;
+    }
+    Ok(res)
+  }
+}
+
+#[allow(clippy::cast_possible_truncation)]
+pub fn pack_bools<I>(bools: I) -> u8
+where
+  I: IntoIterator<Item = bool>,
+{
+  let mut acc: u8 = 0;
+  for (i, b) in bools.into_iter().take(8).enumerate() {
+    if b {
+      acc |= 1u8 << (i as u32);
+    }
+  }
+  acc
+}
+
+pub fn unpack_bools(n: usize, b: u8) -> Vec<bool> {
+  (0..8).map(|i: u32| (b & (1u8 << i)) != 0).take(n.min(8)).collect()
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Ixon {
-    NAnon,                                 // 0x00, anonymous name
-    NStr(Address, Address),                // 0x01, string name
-    NNum(Address, Address),                // 0x02, number name
-    UZero,                                 // 0x03, universe zero
-    USucc(Address),                        // 0x04, universe successor
-    UMax(Address, Address),                // 0x05, universe max
-    UIMax(Address, Address),               // 0x06, universe impredicative max
-    UVar(Nat),                             // 0x1X, universe variable
-    EVar(Nat),                             // 0x2X, expression variable
-    ERef(Address, Vec<Address>),           // 0x3X, expression reference
-    ERec(Nat, Vec<Address>),               // 0x4X, expression recursion
-    EPrj(Address, Nat, Address),           // 0x5X, expression projection
-    ESort(Address),                        // 0x80, expression sort
-    EStr(Address),                         // 0x81, expression string
-    ENat(Address),                         // 0x82, expression natural
-    EApp(Address, Address),                // 0x83, expression application
-    ELam(Address, Address),                // 0x84, expression lambda
-    EAll(Address, Address),                // 0x85, expression forall
-    ELet(bool, Address, Address, Address), // 0x86, 0x87, expression let
-    Blob(Vec<u8>),                         // 0x9X, tagged bytes
-    Defn(Definition),                      // 0xA0, definition constant
-    Recr(Recursor),                        // 0xA1, recursor constant
-    Axio(Axiom),                           // 0xA2, axiom constant
-    Quot(Quotient),                        // 0xA3, quotient constant
-    CPrj(ConstructorProj),                 // 0xA4, constructor projection
-    RPrj(RecursorProj),                    // 0xA5, recursor projection
-    IPrj(InductiveProj),                   // 0xA6, inductive projection
-    DPrj(DefinitionProj),                  // 0xA7, definition projection
-    Muts(Vec<MutConst>),                   // 0xBX, mutual constants
-    Prof(Proof),                           // 0xE0, zero-knowledge proof
-    Eval(EvalClaim),                       // 0xE1, evaluation claim
-    Chck(CheckClaim),                      // 0xE2, typechecking claim
-    Comm(Comm),                            // 0xE3, cryptographic commitment
-    Envn(Env),                             // 0xE4, multi-claim environment
-    Prim(BuiltIn),                         // 0xE5, compiler built-ins
-    Meta(Metadata),                        // 0xFX, metadata
+pub enum QuotKind {
+  Type,
+  Ctor,
+  Lift,
+  Ind,
 }
 
-impl Default for Ixon {
-    fn default() -> Self {
-        Self::NAnon
+impl Serialize for QuotKind {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Type => buf.push(0),
+      Self::Ctor => buf.push(1),
+      Self::Lift => buf.push(2),
+      Self::Ind => buf.push(3),
     }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Type),
+          1 => Ok(Self::Ctor),
+          2 => Ok(Self::Lift),
+          3 => Ok(Self::Ind),
+          x => Err(format!("get QuotKind invalid {x}")),
+        }
+      },
+      None => Err("get QuotKind EOF".to_string()),
+    }
+  }
 }
 
-impl Ixon {
-    pub fn u64_byte_count(x: u64) -> u8 {
-        match x {
-            0 => 0,
-            x if x < 0x0000000000000100 => 1,
-            x if x < 0x0000000000010000 => 2,
-            x if x < 0x0000000001000000 => 3,
-            x if x < 0x0000000100000000 => 4,
-            x if x < 0x0000010000000000 => 5,
-            x if x < 0x0001000000000000 => 6,
-            x if x < 0x0100000000000000 => 7,
-            _ => 8,
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DefKind {
+  Definition,
+  Opaque,
+  Theorem,
+}
+
+impl Serialize for DefKind {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Definition => buf.push(0),
+      Self::Opaque => buf.push(1),
+      Self::Theorem => buf.push(2),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Definition),
+          1 => Ok(Self::Opaque),
+          2 => Ok(Self::Theorem),
+          x => Err(format!("get DefKind invalid {x}")),
         }
+      },
+      None => Err("get DefKind EOF".to_string()),
     }
+  }
+}
 
-    pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
-        let n = Ixon::u64_byte_count(x) as usize;
-        buf.extend_from_slice(&x.to_le_bytes()[..n])
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BinderInfo {
+  Default,
+  Implicit,
+  StrictImplicit,
+  InstImplicit,
+  AuxDecl,
+}
+
+impl Serialize for BinderInfo {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Default => buf.push(0),
+      Self::Implicit => buf.push(1),
+      Self::StrictImplicit => buf.push(2),
+      Self::InstImplicit => buf.push(3),
+      Self::AuxDecl => buf.push(3),
     }
+  }
 
-    pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
-        let mut res = [0u8; 8];
-        if len > 8 {
-            return Err("get trimmed_le_64 len > 8".to_string());
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Default),
+          1 => Ok(Self::Implicit),
+          2 => Ok(Self::StrictImplicit),
+          3 => Ok(Self::InstImplicit),
+          4 => Ok(Self::AuxDecl),
+          x => Err(format!("get BinderInfo invalid {x}")),
         }
-        match buf.split_at_checked(len) {
-            Some((head, rest)) => {
-                *buf = rest;
-                res[..len].copy_from_slice(head);
-                Ok(u64::from_le_bytes(res))
-            }
-            None => Err("get trimmed_le_u64 EOF".to_string()),
+      },
+      None => Err("get BinderInfo EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ReducibilityHints {
+  Opaque,
+  Abbrev,
+  Regular(u32),
+}
+
+impl Serialize for ReducibilityHints {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Opaque => buf.push(0),
+      Self::Abbrev => buf.push(1),
+      Self::Regular(x) => {
+        buf.push(2);
+        x.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Opaque),
+          1 => Ok(Self::Abbrev),
+          2 => {
+            let x: u32 = Serialize::get(buf)?;
+            Ok(Self::Regular(x))
+          },
+          x => Err(format!("get ReducibilityHints invalid {x}")),
         }
+      },
+      None => Err("get ReducibilityHints EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DefSafety {
+  Unsafe,
+  Safe,
+  Partial,
+}
+
+impl Serialize for DefSafety {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Unsafe => buf.push(0),
+      Self::Safe => buf.push(1),
+      Self::Partial => buf.push(2),
     }
+  }
 
-    #[allow(clippy::cast_possible_truncation)]
-    pub fn pack_bools<I>(bools: I) -> u8
-    where
-        I: IntoIterator<Item = bool>,
-    {
-        let mut acc: u8 = 0;
-        for (i, b) in bools.into_iter().take(8).enumerate() {
-            if b {
-                acc |= 1u8 << (i as u32);
-            }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Unsafe),
+          1 => Ok(Self::Safe),
+          2 => Ok(Self::Partial),
+          x => Err(format!("get DefSafety invalid {x}")),
         }
-        acc
+      },
+      None => Err("get DefSafety EOF".to_string()),
     }
+  }
+}
+
+impl<A: Serialize, B: Serialize> Serialize for (A, B) {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.0.put(buf);
+    self.1.put(buf);
+  }
 
-    pub fn unpack_bools(n: usize, b: u8) -> Vec<bool> {
-        (0..8)
-            .map(|i: u32| (b & (1u8 << i)) != 0)
-            .take(n.min(8))
-            .collect()
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    Ok((A::get(buf)?, B::get(buf)?))
+  }
+}
+
+impl Serialize for Address {
+  fn put(&self, buf: &mut Vec<u8>) {
+    buf.extend_from_slice(self.hash.as_bytes())
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(32) {
+      Some((head, rest)) => {
+        *buf = rest;
+        Ok(Address { hash: Hash::from_slice(head).unwrap() })
+      },
+      None => Err("get Address out of input".to_string()),
     }
+  }
+}
 
-    //fn put_tag(tag: u8, val: u64, buf: &mut Vec<u8>) {
-    //    if val < 8 {
-    //        buf.push((tag << 4) | (val as u8));
-    //    } else {
-    //        buf.push((tag << 4) | 0b1000 | (Ixon::u64_byte_count(val) - 1));
-    //        Ixon::u64_put_trimmed_le(val, buf);
-    //    }
-    //}
-
-    //fn get_size(is_large: bool, small: u8, buf: &mut &[u8]) -> Result<u64, String> {
-    //    if is_large {
-    //        Ixon::u64_get_trimmed_le((small + 1) as usize, buf)
-    //    } else {
-    //        Ok(small as u64)
-    //    }
-    //}
-
-    //// put_array and get_array are separated from Ixon's serialize implementation
-    //// in order to create a generic Serialize impl for Vec<S>
-    //pub fn put_array<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
-    //    Self::put_tag(0xA, xs.len() as u64, buf);
-    //    for x in xs {
-    //        x.put(buf)
-    //    }
-    //}
-
-    //pub fn get_array<S: Serialize>(buf: &mut &[u8]) -> Result<Vec<S>, String> {
-    //    let tag_byte = u8::get(buf)?;
-    //    let tag = tag_byte >> 4;
-    //    let small_size = tag_byte & 0b111;
-    //    let is_large = tag_byte & 0b1000 != 0;
-    //    match tag {
-    //        0xA => {
-    //            let len = Self::get_size(is_large, small_size, buf)?;
-    //            let mut vec = vec![];
-    //            for _ in 0..len {
-    //                let s = S::get(buf)?;
-    //                vec.push(s);
-    //            }
-    //            Ok(vec)
-    //        }
-    //        x => Err(format!("get array invalid tag {x}")),
-    //    }
-    //}
-}
-
-//impl Serialize for Ixon {
-//    fn put(&self, buf: &mut Vec<u8>) {
-//        match self {
-//            Self::Vari(x) => Self::put_tag(0x0, *x, buf),
-//            Self::Sort(x) => {
-//                u8::put(&0x90, buf);
-//                x.put(buf);
-//            }
-//            Self::Refr(addr, lvls) => {
-//                Self::put_tag(0x1, lvls.len() as u64, buf);
-//                addr.put(buf);
-//                for l in lvls {
-//                    l.put(buf);
-//                }
-//            }
-//            Self::Recr(x, lvls) => {
-//                Self::put_tag(0x2, *x, buf);
-//                Ixon::put_array(lvls, buf);
-//            }
-//            Self::Apps(f, a, args) => {
-//                Self::put_tag(0x3, args.len() as u64, buf);
-//                f.put(buf);
-//                a.put(buf);
-//                for x in args {
-//                    x.put(buf);
-//                }
-//            }
-//            Self::Lams(ts, b) => {
-//                Self::put_tag(0x4, ts.len() as u64, buf);
-//                for t in ts {
-//                    t.put(buf);
-//                }
-//                b.put(buf);
-//            }
-//            Self::Alls(ts, b) => {
-//                Self::put_tag(0x5, ts.len() as u64, buf);
-//                for t in ts {
-//                    t.put(buf);
-//                }
-//                b.put(buf);
-//            }
-//            Self::Proj(t, n, x) => {
-//                Self::put_tag(0x6, *n, buf);
-//                t.put(buf);
-//                x.put(buf);
-//            }
-//            Self::Strl(s) => {
-//                let bytes = s.as_bytes();
-//                Self::put_tag(0x7, bytes.len() as u64, buf);
-//                buf.extend_from_slice(bytes);
-//            }
-//            Self::Natl(n) => {
-//                let bytes = n.0.to_bytes_le();
-//                Self::put_tag(0x8, bytes.len() as u64, buf);
-//                buf.extend_from_slice(&bytes);
-//            }
-//            Self::LetE(nd, t, d, b) => {
-//                if *nd {
-//                    u8::put(&0x91, buf);
-//                } else {
-//                    u8::put(&0x92, buf);
-//                }
-//                t.put(buf);
-//                d.put(buf);
-//                b.put(buf);
-//            }
-//            Self::List(xs) => Ixon::put_array(xs, buf),
-//            Self::Defn(x) => {
-//                u8::put(&0xB0, buf);
-//                x.put(buf);
-//            }
-//            Self::Axio(x) => {
-//                u8::put(&0xB1, buf);
-//                x.put(buf);
-//            }
-//            Self::Quot(x) => {
-//                u8::put(&0xB2, buf);
-//                x.put(buf);
-//            }
-//            Self::CPrj(x) => {
-//                u8::put(&0xB3, buf);
-//                x.put(buf);
-//            }
-//            Self::RPrj(x) => {
-//                u8::put(&0xB4, buf);
-//                x.put(buf);
-//            }
-//            Self::IPrj(x) => {
-//                u8::put(&0xB5, buf);
-//                x.put(buf);
-//            }
-//            Self::DPrj(x) => {
-//                u8::put(&0xB6, buf);
-//                x.put(buf);
-//            }
-//            Self::Inds(xs) => {
-//                Self::put_tag(0xC, xs.len() as u64, buf);
-//                for x in xs {
-//                    x.put(buf);
-//                }
-//            }
-//            Self::Defs(xs) => {
-//                Self::put_tag(0xD, xs.len() as u64, buf);
-//                for x in xs {
-//                    x.put(buf);
-//                }
-//            }
-//            Self::Meta(x) => {
-//                u8::put(&0xE0, buf);
-//                x.put(buf);
-//            }
-//            Self::Prof(x) => {
-//                u8::put(&0xE1, buf);
-//                x.put(buf);
-//            }
-//            Self::Eval(x) => {
-//                u8::put(&0xE2, buf);
-//                x.put(buf);
-//            }
-//            Self::Chck(x) => {
-//                u8::put(&0xE3, buf);
-//                x.put(buf);
-//            }
-//            Self::Comm(x) => {
-//                u8::put(&0xE4, buf);
-//                x.put(buf);
-//            }
-//            Self::Envn(x) => {
-//                u8::put(&0xE5, buf);
-//                x.put(buf);
-//            }
-//        }
-//    }
-//
-//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-//        let tag_byte = u8::get(buf)?;
-//        let small_size = tag_byte & 0b111;
-//        let is_large = tag_byte & 0b1000 != 0;
-//        match tag_byte {
-//            0x00..=0x0F => {
-//                let x = Ixon::get_size(is_large, small_size, buf)?;
-//                Ok(Self::Vari(x))
-//            }
-//            0x90 => {
-//                let u = Univ::get(buf)?;
-//                Ok(Self::Sort(Box::new(u)))
-//            }
-//            0x10..=0x1F => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                let a = Address::get(buf)?;
-//                let mut lvls = Vec::new();
-//                for _ in 0..n {
-//                    let l = Univ::get(buf)?;
-//                    lvls.push(l);
-//                }
-//                Ok(Self::Refr(a, lvls))
-//            }
-//            0x20..=0x2F => {
-//                let x = Ixon::get_size(is_large, small_size, buf)?;
-//                let lvls = Ixon::get_array(buf)?;
-//                Ok(Self::Recr(x, lvls))
-//            }
-//            0x30..=0x3F => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                let f = Ixon::get(buf)?;
-//                let a = Ixon::get(buf)?;
-//                let mut args = Vec::new();
-//                for _ in 0..n {
-//                    let x = Ixon::get(buf)?;
-//                    args.push(x);
-//                }
-//                Ok(Self::Apps(Box::new(f), Box::new(a), args))
-//            }
-//            0x40..=0x4F => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                let mut ts = Vec::new();
-//                for _ in 0..n {
-//                    let x = Ixon::get(buf)?;
-//                    ts.push(x);
-//                }
-//                let b = Ixon::get(buf)?;
-//                Ok(Self::Lams(ts, Box::new(b)))
-//            }
-//            0x50..=0x5F => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                let mut ts = Vec::new();
-//                for _ in 0..n {
-//                    let x = Ixon::get(buf)?;
-//                    ts.push(x);
-//                }
-//                let b = Ixon::get(buf)?;
-//                Ok(Self::Alls(ts, Box::new(b)))
-//            }
-//            0x60..=0x6F => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                let t = Address::get(buf)?;
-//                let x = Ixon::get(buf)?;
-//                Ok(Self::Proj(t, n, Box::new(x)))
-//            }
-//            0x70..=0x7F => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                match buf.split_at_checked(n as usize) {
-//                    Some((head, rest)) => {
-//                        *buf = rest;
-//                        match String::from_utf8(head.to_owned()) {
-//                            Ok(s) => Ok(Ixon::Strl(s)),
-//                            Err(e) => Err(format!("UTF8 Error: {e}")),
-//                        }
-//                    }
-//                    None => Err("get Ixon Strl EOF".to_string()),
-//                }
-//            }
-//            0x80..=0x8F => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                match buf.split_at_checked(n as usize) {
-//                    Some((head, rest)) => {
-//                        *buf = rest;
-//                        Ok(Ixon::Natl(Nat(BigUint::from_bytes_le(head))))
-//                    }
-//                    None => Err("get Expr Natl EOF".to_string()),
-//                }
-//            }
-//            0x91..=0x92 => {
-//                let nd = tag_byte == 0x91;
-//                let t = Ixon::get(buf)?;
-//                let d = Ixon::get(buf)?;
-//                let b = Ixon::get(buf)?;
-//                Ok(Self::LetE(nd, Box::new(t), Box::new(d), Box::new(b)))
-//            }
-//            0xA0..=0xAF => {
-//                let len = Self::get_size(is_large, small_size, buf)?;
-//                let mut vec = vec![];
-//                for _ in 0..len {
-//                    let s = Ixon::get(buf)?;
-//                    vec.push(s);
-//                }
-//                Ok(Self::List(vec))
-//            }
-//            0xB0 => Ok(Self::Defn(Definition::get(buf)?)),
-//            0xB1 => Ok(Self::Axio(Axiom::get(buf)?)),
-//            0xB2 => Ok(Self::Quot(Quotient::get(buf)?)),
-//            0xB3 => Ok(Self::CPrj(ConstructorProj::get(buf)?)),
-//            0xB4 => Ok(Self::RPrj(RecursorProj::get(buf)?)),
-//            0xB5 => Ok(Self::IPrj(InductiveProj::get(buf)?)),
-//            0xB6 => Ok(Self::DPrj(DefinitionProj::get(buf)?)),
-//            0xC0..=0xCF => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                let mut inds = Vec::new();
-//                for _ in 0..n {
-//                    let x = Inductive::get(buf)?;
-//                    inds.push(x);
-//                }
-//                Ok(Self::Inds(inds))
-//            }
-//            0xD0..=0xDF => {
-//                let n = Ixon::get_size(is_large, small_size, buf)?;
-//                let mut defs = Vec::new();
-//                for _ in 0..n {
-//                    let x = Definition::get(buf)?;
-//                    defs.push(x);
-//                }
-//                Ok(Self::Defs(defs))
-//            }
-//            0xE0 => Ok(Self::Meta(Metadata::get(buf)?)),
-//            0xE1 => Ok(Self::Prof(Proof::get(buf)?)),
-//            0xE2 => Ok(Self::Eval(EvalClaim::get(buf)?)),
-//            0xE3 => Ok(Self::Chck(CheckClaim::get(buf)?)),
-//            0xE4 => Ok(Self::Comm(Comm::get(buf)?)),
-//            0xE5 => Ok(Self::Envn(Env::get(buf)?)),
-//            x => Err(format!("get Ixon invalid tag {x}")),
-//        }
-//    }
-//}
-//
-//#[cfg(test)]
-//pub mod tests {
-//    use super::*;
-//    use crate::ixon::nat::tests::arbitrary_nat;
-//    use crate::ixon::univ::tests::arbitrary_univ;
-//    use quickcheck::{Arbitrary, Gen};
-//    use std::fmt::Write;
-//    use std::ops::Range;
-//    use std::ptr;
-//
-//    pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
-//        let res: usize = Arbitrary::arbitrary(g);
-//        if range.is_empty() {
-//            0
-//        } else {
-//            (res % (range.end - range.start)) + range.start
-//        }
-//    }
-//
-//    pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
-//    where
-//        F: FnMut(&mut Gen) -> A,
-//    {
-//        let len = gen_range(g, 0..size);
-//        let mut vec = Vec::with_capacity(len);
-//        for _ in 0..len {
-//            vec.push(f(g));
-//        }
-//        vec
-//    }
-//
-//    pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
-//        let sum: usize = gens.iter().map(|x| x.0).sum();
-//        let mut weight: usize = gen_range(g, 1..sum);
-//        for (n, case) in gens {
-//            if *n == 0 {
-//                continue;
-//            } else {
-//                match weight.checked_sub(*n) {
-//                    None | Some(0) => {
-//                        return *case;
-//                    }
-//                    _ => {
-//                        weight -= *n;
-//                    }
-//                }
-//            }
-//        }
-//        unreachable!()
-//    }
-//
-//    #[test]
-//    fn unit_u64_trimmed() {
-//        fn test(input: u64, expected: Vec<u8>) -> bool {
-//            let mut tmp = Vec::new();
-//            let n = Ixon::u64_byte_count(input);
-//            Ixon::u64_put_trimmed_le(input, &mut tmp);
-//            if tmp != expected {
-//                return false;
-//            }
-//            match Ixon::u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
-//                Ok(out) => input == out,
-//                Err(e) => {
-//                    println!("err: {e}");
-//                    false
-//                }
-//            }
-//        }
-//        assert!(test(0x0, vec![]));
-//        assert!(test(0x01, vec![0x01]));
-//        assert!(test(0x0000000000000100, vec![0x00, 0x01]));
-//        assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
-//        assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
-//        assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
-//        assert!(test(
-//            0x0000010000000000,
-//            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-//        ));
-//        assert!(test(
-//            0x0001000000000000,
-//            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-//        ));
-//        assert!(test(
-//            0x0100000000000000,
-//            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-//        ));
-//        assert!(test(
-//            0x0102030405060708,
-//            vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
-//        ));
-//    }
-//
-//    #[quickcheck]
-//    fn prop_u64_trimmed_le_readback(x: u64) -> bool {
-//        let mut buf = Vec::new();
-//        let n = Ixon::u64_byte_count(x);
-//        Ixon::u64_put_trimmed_le(x, &mut buf);
-//        match Ixon::u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
-//            Ok(y) => x == y,
-//            Err(e) => {
-//                println!("err: {e}");
-//                false
-//            }
-//        }
-//    }
-//
-//    #[derive(Debug, Clone, Copy)]
-//    pub enum IxonCase {
-//        Vari,
-//        Sort,
-//        Refr,
-//        Recr,
-//        Apps,
-//        Lams,
-//        Alls,
-//        Proj,
-//        Strl,
-//        Natl,
-//        LetE,
-//        List,
-//        Defn,
-//        Axio,
-//        Quot,
-//        CPrj,
-//        RPrj,
-//        IPrj,
-//        DPrj,
-//        Defs,
-//        Inds,
-//        Meta,
-//        Prof,
-//        Eval,
-//        Chck,
-//        Comm,
-//        Envn,
-//    }
-//
-//    pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
-//        let mut s = String::new();
-//        for _ in 0..cs {
-//            s.push(char::arbitrary(g));
-//        }
-//        s
-//    }
-//
-//    // incremental tree generation without recursion stack overflows
-//    pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
-//        let mut root = Ixon::Vari(0);
-//        let mut stack = vec![&mut root as *mut Ixon];
-//
-//        while let Some(ptr) = stack.pop() {
-//            let gens: Vec<(usize, IxonCase)> = vec![
-//                (100, IxonCase::Vari),
-//                (100, IxonCase::Sort),
-//                (15, IxonCase::Refr),
-//                (15, IxonCase::Recr),
-//                (15, IxonCase::Apps),
-//                (15, IxonCase::Lams),
-//                (15, IxonCase::Alls),
-//                (20, IxonCase::LetE),
-//                (50, IxonCase::Proj),
-//                (100, IxonCase::Strl),
-//                (100, IxonCase::Natl),
-//                (10, IxonCase::List),
-//                (100, IxonCase::Defn),
-//                (100, IxonCase::Axio),
-//                (100, IxonCase::Quot),
-//                (100, IxonCase::CPrj),
-//                (100, IxonCase::RPrj),
-//                (100, IxonCase::IPrj),
-//                (100, IxonCase::DPrj),
-//                (15, IxonCase::Inds),
-//                (15, IxonCase::Defs),
-//                (100, IxonCase::Meta),
-//                (100, IxonCase::Prof),
-//                (100, IxonCase::Eval),
-//                (100, IxonCase::Chck),
-//                (100, IxonCase::Comm),
-//                (100, IxonCase::Envn),
-//            ];
-//
-//            match next_case(g, &gens) {
-//                IxonCase::Vari => {
-//                    let x: u64 = Arbitrary::arbitrary(g);
-//                    unsafe {
-//                        ptr::replace(ptr, Ixon::Vari(x));
-//                    }
-//                }
-//                IxonCase::Sort => {
-//                    let u = arbitrary_univ(g, ctx);
-//                    unsafe {
-//                        ptr::replace(ptr, Ixon::Sort(Box::new(u)));
-//                    }
-//                }
-//                IxonCase::Refr => {
-//                    let addr = Address::arbitrary(g);
-//                    let mut lvls = vec![];
-//                    for _ in 0..gen_range(g, 0..9) {
-//                        lvls.push(arbitrary_univ(g, ctx));
-//                    }
-//                    unsafe {
-//                        ptr::replace(ptr, Ixon::Refr(addr, lvls));
-//                    }
-//                }
-//                IxonCase::Recr => {
-//                    let n = u64::arbitrary(g);
-//                    let mut lvls = vec![];
-//                    for _ in 0..gen_range(g, 0..9) {
-//                        lvls.push(arbitrary_univ(g, ctx));
-//                    }
-//                    unsafe {
-//                        ptr::replace(ptr, Ixon::Recr(n, lvls));
-//                    }
-//                }
-//                IxonCase::Apps => {
-//                    let mut f_box = Box::new(Ixon::default());
-//                    let f_ptr: *mut Ixon = &mut *f_box;
-//                    stack.push(f_ptr);
-//
-//                    let mut a_box = Box::new(Ixon::default());
-//                    let a_ptr: *mut Ixon = &mut *a_box;
-//                    stack.push(a_ptr);
-//
-//                    let n = gen_range(g, 0..9);
-//                    let mut xs: Vec<Ixon> = Vec::with_capacity(n);
-//                    xs.resize(n, Ixon::Vari(0));
-//                    for i in 0..n {
-//                        let p = unsafe { xs.as_mut_ptr().add(i) };
-//                        stack.push(p);
-//                    }
-//                    unsafe {
-//                        std::ptr::replace(ptr, Ixon::Apps(f_box, a_box, xs));
-//                    }
-//                }
-//                IxonCase::Lams => {
-//                    let n = gen_range(g, 0..9);
-//                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-//                    ts.resize(n, Ixon::Vari(0));
-//                    for i in 0..n {
-//                        let p = unsafe { ts.as_mut_ptr().add(i) };
-//                        stack.push(p);
-//                    }
-//                    let mut b_box = Box::new(Ixon::default());
-//                    let b_ptr: *mut Ixon = &mut *b_box;
-//                    stack.push(b_ptr);
-//                    unsafe {
-//                        std::ptr::replace(ptr, Ixon::Lams(ts, b_box));
-//                    }
-//                }
-//                IxonCase::Alls => {
-//                    let n = gen_range(g, 0..9);
-//                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-//                    ts.resize(n, Ixon::Vari(0));
-//                    for i in 0..n {
-//                        let p = unsafe { ts.as_mut_ptr().add(i) };
-//                        stack.push(p);
-//                    }
-//                    let mut b_box = Box::new(Ixon::default());
-//                    let b_ptr: *mut Ixon = &mut *b_box;
-//                    stack.push(b_ptr);
-//                    unsafe {
-//                        std::ptr::replace(ptr, Ixon::Alls(ts, b_box));
-//                    }
-//                }
-//                IxonCase::LetE => {
-//                    let nd = bool::arbitrary(g);
-//                    let mut t_box = Box::new(Ixon::default());
-//                    let t_ptr: *mut Ixon = &mut *t_box;
-//                    stack.push(t_ptr);
-//                    let mut d_box = Box::new(Ixon::default());
-//                    let d_ptr: *mut Ixon = &mut *d_box;
-//                    stack.push(d_ptr);
-//                    let mut b_box = Box::new(Ixon::default());
-//                    let b_ptr: *mut Ixon = &mut *b_box;
-//                    stack.push(b_ptr);
-//                    unsafe {
-//                        ptr::replace(ptr, Ixon::LetE(nd, t_box, d_box, b_box));
-//                    }
-//                }
-//                IxonCase::Proj => {
-//                    let addr = Address::arbitrary(g);
-//                    let n = u64::arbitrary(g);
-//                    let mut t_box = Box::new(Ixon::default());
-//                    let t_ptr: *mut Ixon = &mut *t_box;
-//                    stack.push(t_ptr);
-//                    unsafe {
-//                        ptr::replace(ptr, Ixon::Proj(addr, n, t_box));
-//                    }
-//                }
-//                IxonCase::Strl => unsafe {
-//                    let size = gen_range(g, 0..9);
-//                    ptr::replace(ptr, Ixon::Strl(arbitrary_string(g, size)));
-//                },
-//                IxonCase::Natl => {
-//                    let size = gen_range(g, 0..9);
-//                    unsafe {
-//                        ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
-//                    }
-//                }
-//                IxonCase::List => {
-//                    let n = gen_range(g, 0..9);
-//                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-//                    ts.resize(n, Ixon::Vari(0));
-//                    for i in 0..n {
-//                        let p = unsafe { ts.as_mut_ptr().add(i) };
-//                        stack.push(p);
-//                    }
-//                    unsafe {
-//                        std::ptr::replace(ptr, Ixon::List(ts));
-//                    }
-//                }
-//                IxonCase::Quot => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Quot(Quotient::arbitrary(g)));
-//                },
-//                IxonCase::Axio => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Axio(Axiom::arbitrary(g)));
-//                },
-//                IxonCase::Defn => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
-//                },
-//                IxonCase::CPrj => unsafe {
-//                    std::ptr::replace(ptr, Ixon::CPrj(ConstructorProj::arbitrary(g)));
-//                },
-//                IxonCase::RPrj => unsafe {
-//                    std::ptr::replace(ptr, Ixon::RPrj(RecursorProj::arbitrary(g)));
-//                },
-//                IxonCase::DPrj => unsafe {
-//                    std::ptr::replace(ptr, Ixon::DPrj(DefinitionProj::arbitrary(g)));
-//                },
-//                IxonCase::IPrj => unsafe {
-//                    std::ptr::replace(ptr, Ixon::IPrj(InductiveProj::arbitrary(g)));
-//                },
-//                IxonCase::Inds => unsafe {
-//                    let inds = gen_vec(g, 9, Inductive::arbitrary);
-//                    std::ptr::replace(ptr, Ixon::Inds(inds));
-//                },
-//                IxonCase::Defs => unsafe {
-//                    let defs = gen_vec(g, 9, Definition::arbitrary);
-//                    std::ptr::replace(ptr, Ixon::Defs(defs));
-//                },
-//                IxonCase::Meta => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
-//                },
-//                IxonCase::Prof => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Prof(Proof::arbitrary(g)));
-//                },
-//                IxonCase::Eval => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Eval(EvalClaim::arbitrary(g)));
-//                },
-//                IxonCase::Chck => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Chck(CheckClaim::arbitrary(g)));
-//                },
-//                IxonCase::Comm => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
-//                },
-//                IxonCase::Envn => unsafe {
-//                    std::ptr::replace(ptr, Ixon::Envn(Env::arbitrary(g)));
-//                },
-//            }
-//        }
-//        root
-//    }
-//
-//    impl Arbitrary for Ixon {
-//        fn arbitrary(g: &mut Gen) -> Self {
-//            let ctx: u64 = Arbitrary::arbitrary(g);
-//            arbitrary_ixon(g, ctx)
-//        }
-//    }
-//
-//    #[quickcheck]
-//    fn prop_ixon_readback(x: Ixon) -> bool {
-//        let mut buf = Vec::new();
-//        Ixon::put(&x, &mut buf);
-//        match Ixon::get(&mut buf.as_slice()) {
-//            Ok(y) => x == y,
-//            Err(e) => {
-//                println!("err: {e}");
-//                false
-//            }
-//        }
-//    }
-//
-//    /// Parse a hex string (optional `0x`/`0X` prefix, `_` separators OK) into bytes.
-//    pub fn parse_hex(s: &str) -> Result<Vec<u8>, String> {
-//        // Strip prefix, drop underscores, and require an even count of hex digits.
-//        let s = s.trim();
-//        let s = s
-//            .strip_prefix("0x")
-//            .or_else(|| s.strip_prefix("0X"))
-//            .unwrap_or(s);
-//        let clean: String = s.chars().filter(|&c| c != '_').collect();
-//
-//        if clean.len() % 2 != 0 {
-//            return Err("odd number of hex digits".into());
-//        }
-//
-//        // Parse each 2-char chunk as a byte.
-//        (0..clean.len())
-//            .step_by(2)
-//            .map(|i| {
-//                u8::from_str_radix(&clean[i..i + 2], 16)
-//                    .map_err(|_| format!("invalid hex at chars {}..{}", i, i + 2))
-//            })
-//            .collect()
-//    }
-//
-//    /// Format bytes as a lowercase hex string with a `0x` prefix.
-//    pub fn to_hex(bytes: &[u8]) -> String {
-//        let mut out = String::with_capacity(2 + bytes.len() * 2);
-//        out.push_str("0x");
-//        for b in bytes {
-//            // `{:02x}` = two lowercase hex digits, zero-padded.
-//            write!(&mut out, "{b:02x}").unwrap();
-//        }
-//        out
-//    }
-//
-//    #[test]
-//    fn unit_ixon() {
-//        fn test(input: Ixon, expected: &str) -> bool {
-//            let mut tmp = Vec::new();
-//            let expect = parse_hex(expected).unwrap();
-//            Serialize::put(&input, &mut tmp);
-//            if tmp != expect {
-//                println!(
-//                    "serialied {input:?} as:\n {}\n test expects:\n {}",
-//                    to_hex(&tmp),
-//                    to_hex(&expect),
-//                );
-//                return false;
-//            }
-//            match Serialize::get(&mut tmp.as_slice()) {
-//                Ok(output) => {
-//                    if input != output {
-//                        println!(
-//                            "deserialized {} as {output:?}, expected {input:?}",
-//                            to_hex(&tmp)
-//                        );
-//                        false
-//                    } else {
-//                        true
-//                    }
-//                }
-//                Err(e) => {
-//                    println!("err: {e}");
-//                    false
-//                }
-//            }
-//        }
-//        assert!(test(Ixon::Vari(0x0), "0x00"));
-//        assert!(test(Ixon::Vari(0x7), "0x07"));
-//        assert!(test(Ixon::Vari(0x8), "0x0808"));
-//        assert!(test(Ixon::Vari(0xff), "0x08FF"));
-//        assert!(test(Ixon::Vari(0x0100), "0x090001"));
-//        assert!(test(Ixon::Vari(0xFFFF), "0x09FFFF"));
-//        assert!(test(Ixon::Vari(0x010000), "0x0A000001"));
-//        assert!(test(Ixon::Vari(0xFFFFFF), "0x0AFFFFFF"));
-//        assert!(test(Ixon::Vari(0x01000000), "0x0B00000001"));
-//        assert!(test(Ixon::Vari(0xFFFFFFFF), "0x0BFFFFFFFF"));
-//        assert!(test(Ixon::Vari(0x0100000000), "0x0C0000000001"));
-//        assert!(test(Ixon::Vari(0xFFFFFFFFFF), "0x0CFFFFFFFFFF"));
-//        assert!(test(Ixon::Vari(0x010000000000), "0x0D000000000001"));
-//        assert!(test(Ixon::Vari(0xFFFFFFFFFFFF), "0x0DFFFFFFFFFFFF"));
-//        assert!(test(Ixon::Vari(0x01000000000000), "0x0E00000000000001"));
-//        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFF), "0x0EFFFFFFFFFFFFFF"));
-//        assert!(test(Ixon::Vari(0x0100000000000000), "0x0F0000000000000001"));
-//        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFFFF), "0x0FFFFFFFFFFFFFFFFF"));
-//        // universes use 2-bit sub-tags
-//        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x0))), "0x9000"));
-//        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x1F))), "0x901F"));
-//        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x20))), "0x902020"));
-//        assert!(test(Ixon::Sort(Box::new(Univ::Const(0xFF))), "0x9020FF"));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0x0100))),
-//            "0x90210001"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0xFFFF))),
-//            "0x9021FFFF"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0x010000))),
-//            "0x9022000001"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFF))),
-//            "0x9022FFFFFF"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0x01000000))),
-//            "0x902300000001"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFF))),
-//            "0x9023FFFFFFFF"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0x0100000000))),
-//            "0x90240000000001"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFF))),
-//            "0x9024FFFFFFFFFF"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0x010000000000))),
-//            "0x9025000000000001"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFF))),
-//            "0x9025FFFFFFFFFFFF"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0x01000000000000))),
-//            "0x902600000000000001"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFF))),
-//            "0x9026FFFFFFFFFFFFFF"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0x0100000000000000))),
-//            "0x90270000000000000001"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFFFF))),
-//            "0x9027FFFFFFFFFFFFFFFF"
-//        ));
-//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0))), "0x9040"));
-//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x1F))), "0x905F"));
-//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x20))), "0x906020"));
-//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0xFF))), "0x9060FF"));
-//        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0100))), "0x90610001"));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Var(0xFFFFFFFFFFFFFFFF))),
-//            "0x9067FFFFFFFFFFFFFFFF"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Const(0x0))))),
-//            "0x908000"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Var(0x0))))),
-//            "0x908040"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Add(0x1F, Box::new(Univ::Var(0x0))))),
-//            "0x909F40"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Add(0x20, Box::new(Univ::Var(0x0))))),
-//            "0x90A02040"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Add(0xFF, Box::new(Univ::Var(0x0))))),
-//            "0x90A0FF40"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Add(
-//                0xFFFF_FFFF_FFFF_FFFF,
-//                Box::new(Univ::Var(0x0))
-//            ))),
-//            "0x90A7FFFFFFFFFFFFFFFF40"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Max(
-//                Box::new(Univ::Var(0x0)),
-//                Box::new(Univ::Var(0x0))
-//            ))),
-//            "0x90C04040"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Max(
-//                Box::new(Univ::Var(0x0)),
-//                Box::new(Univ::Var(0x1))
-//            ))),
-//            "0x90C04041"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Max(
-//                Box::new(Univ::Var(0x1)),
-//                Box::new(Univ::Var(0x0))
-//            ))),
-//            "0x90C04140"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::Max(
-//                Box::new(Univ::Var(0x1)),
-//                Box::new(Univ::Var(0x1))
-//            ))),
-//            "0x90C04141"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::IMax(
-//                Box::new(Univ::Var(0x0)),
-//                Box::new(Univ::Var(0x0))
-//            ))),
-//            "0x90C14040"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::IMax(
-//                Box::new(Univ::Var(0x0)),
-//                Box::new(Univ::Var(0x1))
-//            ))),
-//            "0x90C14041"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::IMax(
-//                Box::new(Univ::Var(0x1)),
-//                Box::new(Univ::Var(0x0))
-//            ))),
-//            "0x90C14140"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::IMax(
-//                Box::new(Univ::Var(0x1)),
-//                Box::new(Univ::Var(0x1))
-//            ))),
-//            "0x90C14141"
-//        ));
-//        assert!(test(
-//            Ixon::Sort(Box::new(Univ::IMax(
-//                Box::new(Univ::Var(0x1)),
-//                Box::new(Univ::Var(0x1))
-//            ))),
-//            "0x90C14141"
-//        ));
-//        assert!(test(
-//            Ixon::Refr(Address::hash(&[]), vec![]),
-//            "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::Refr(Address::hash(&[]), vec![Univ::Var(0x0)]),
-//            "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240"
-//        ));
-//        assert!(test(Ixon::Recr(0x0, vec![Univ::Var(0x0)]), "0x20A140"));
-//        assert!(test(
-//            Ixon::Recr(0x0, vec![Univ::Var(0x0), Univ::Var(0x1)]),
-//            "0x20A24041"
-//        ));
-//        assert!(test(
-//            Ixon::Recr(0x8, vec![Univ::Var(0x0), Univ::Var(0x1)]),
-//            "0x2808A24041"
-//        ));
-//        assert!(test(
-//            Ixon::Apps(Box::new(Ixon::Vari(0x0)), Box::new(Ixon::Vari(0x1)), vec![]),
-//            "0x300001"
-//        ));
-//        assert!(test(
-//            Ixon::Apps(
-//                Box::new(Ixon::Vari(0x0)),
-//                Box::new(Ixon::Vari(0x1)),
-//                vec![Ixon::Vari(0x2)]
-//            ),
-//            "0x31000102"
-//        ));
-//        assert!(test(
-//            Ixon::Apps(
-//                Box::new(Ixon::Vari(0x0)),
-//                Box::new(Ixon::Vari(0x1)),
-//                vec![
-//                    Ixon::Vari(0x2),
-//                    Ixon::Vari(0x3),
-//                    Ixon::Vari(0x4),
-//                    Ixon::Vari(0x5),
-//                    Ixon::Vari(0x6),
-//                    Ixon::Vari(0x7),
-//                    Ixon::Vari(0x8),
-//                    Ixon::Vari(0x9),
-//                ]
-//            ),
-//            "0x3808000102030405060708080809"
-//        ));
-//        assert!(test(
-//            Ixon::Lams(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
-//            "0x410001"
-//        ));
-//        assert!(test(
-//            Ixon::Lams(
-//                vec![
-//                    Ixon::Vari(0x0),
-//                    Ixon::Vari(0x1),
-//                    Ixon::Vari(0x2),
-//                    Ixon::Vari(0x3),
-//                    Ixon::Vari(0x4),
-//                    Ixon::Vari(0x5),
-//                    Ixon::Vari(0x6),
-//                    Ixon::Vari(0x7)
-//                ],
-//                Box::new(Ixon::Vari(0x8))
-//            ),
-//            "0x480800010203040506070808"
-//        ));
-//        assert!(test(
-//            Ixon::Alls(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
-//            "0x510001"
-//        ));
-//        assert!(test(
-//            Ixon::Alls(
-//                vec![
-//                    Ixon::Vari(0x0),
-//                    Ixon::Vari(0x1),
-//                    Ixon::Vari(0x2),
-//                    Ixon::Vari(0x3),
-//                    Ixon::Vari(0x4),
-//                    Ixon::Vari(0x5),
-//                    Ixon::Vari(0x6),
-//                    Ixon::Vari(0x7)
-//                ],
-//                Box::new(Ixon::Vari(0x8))
-//            ),
-//            "0x580800010203040506070808"
-//        ));
-//        assert!(test(
-//            Ixon::Proj(Address::hash(&[]), 0x0, Box::new(Ixon::Vari(0x0))),
-//            "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
-//        ));
-//        assert!(test(
-//            Ixon::Proj(Address::hash(&[]), 0x8, Box::new(Ixon::Vari(0x0))),
-//            "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
-//        ));
-//        assert!(test(Ixon::Strl("".to_string()), "0x70"));
-//        assert!(test(Ixon::Strl("foobar".to_string()), "0x76666f6f626172"));
-//        assert!(test(Ixon::Natl(Nat::new_le(&[])), "0x8100"));
-//        assert!(test(Ixon::Natl(Nat::new_le(&[0x0])), "0x8100"));
-//        assert!(test(Ixon::Natl(Nat::new_le(&[0xFF])), "0x81FF"));
-//        assert!(test(Ixon::Natl(Nat::new_le(&[0x00, 0x01])), "0x820001"));
-//        assert!(test(
-//            Ixon::LetE(
-//                true,
-//                Box::new(Ixon::Vari(0x0)),
-//                Box::new(Ixon::Vari(0x1)),
-//                Box::new(Ixon::Vari(0x2))
-//            ),
-//            "0x91000102"
-//        ));
-//        assert!(test(Ixon::List(vec![]), "0xA0"));
-//        assert!(test(
-//            Ixon::List(vec![Ixon::Vari(0x0), Ixon::Vari(0x1), Ixon::Vari(0x2)]),
-//            "0xA3000102"
-//        ));
-//        assert!(test(
-//            Ixon::Defn(Definition {
-//                kind: DefKind::Definition,
-//                safety: DefSafety::Unsafe,
-//                lvls: 0u64.into(),
-//                typ: Address::hash(&[]),
-//                value: Address::hash(&[]),
-//            }),
-//            "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::Defn(Definition {
-//                kind: DefKind::Opaque,
-//                safety: DefSafety::Safe,
-//                lvls: 1u64.into(),
-//                typ: Address::hash(&[]),
-//                value: Address::hash(&[]),
-//            }),
-//            "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::Axio(Axiom {
-//                is_unsafe: true,
-//                lvls: 0u64.into(),
-//                typ: Address::hash(&[]),
-//            }),
-//            "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::Quot(Quotient {
-//                kind: QuotKind::Type,
-//                lvls: 0u64.into(),
-//                typ: Address::hash(&[]),
-//            }),
-//            "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::CPrj(ConstructorProj {
-//                idx: 0u64.into(),
-//                cidx: 0u64.into(),
-//                block: Address::hash(&[]),
-//            }),
-//            "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::RPrj(RecursorProj {
-//                idx: 0u64.into(),
-//                ridx: 0u64.into(),
-//                block: Address::hash(&[]),
-//            }),
-//            "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::IPrj(InductiveProj {
-//                idx: 0u64.into(),
-//                block: Address::hash(&[]),
-//            }),
-//            "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::DPrj(DefinitionProj {
-//                idx: 0u64.into(),
-//                block: Address::hash(&[]),
-//            }),
-//            "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(Ixon::Inds(vec![]), "0xC0"));
-//        assert!(test(
-//            Ixon::Inds(vec![Inductive {
-//                recr: false,
-//                refl: false,
-//                is_unsafe: false,
-//                lvls: 0u64.into(),
-//                params: 0u64.into(),
-//                indices: 0u64.into(),
-//                nested: 0u64.into(),
-//                typ: Address::hash(&[]),
-//                ctors: vec![],
-//                recrs: vec![],
-//            }]),
-//            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
-//        ));
-//        assert!(test(
-//            Ixon::Inds(vec![Inductive {
-//                recr: false,
-//                refl: false,
-//                is_unsafe: false,
-//                lvls: 0u64.into(),
-//                params: 0u64.into(),
-//                indices: 0u64.into(),
-//                nested: 0u64.into(),
-//                typ: Address::hash(&[]),
-//                ctors: vec![],
-//                recrs: vec![],
-//            }]),
-//            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
-//        ));
-//        assert!(test(
-//            Ixon::Inds(vec![Inductive {
-//                recr: false,
-//                refl: false,
-//                is_unsafe: false,
-//                lvls: 0u64.into(),
-//                params: 0u64.into(),
-//                indices: 0u64.into(),
-//                nested: 0u64.into(),
-//                typ: Address::hash(&[]),
-//                ctors: vec![Constructor {
-//                    is_unsafe: false,
-//                    lvls: 0u64.into(),
-//                    cidx: 0u64.into(),
-//                    params: 0u64.into(),
-//                    fields: 0u64.into(),
-//                    typ: Address::hash(&[])
-//                }],
-//                recrs: vec![Recursor {
-//                    k: false,
-//                    is_unsafe: false,
-//                    lvls: 0u64.into(),
-//                    params: 0u64.into(),
-//                    indices: 0u64.into(),
-//                    motives: 0u64.into(),
-//                    minors: 0u64.into(),
-//                    typ: Address::hash(&[]),
-//                    rules: vec![RecursorRule {
-//                        fields: 0u64.into(),
-//                        rhs: Address::hash(&[])
-//                    }]
-//                }],
-//            }]),
-//            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(Ixon::Defs(vec![]), "0xD0"));
-//        assert!(test(
-//            Ixon::Defs(vec![Definition {
-//                kind: DefKind::Definition,
-//                safety: DefSafety::Unsafe,
-//                lvls: 0u64.into(),
-//                typ: Address::hash(&[]),
-//                value: Address::hash(&[]),
-//            }]),
-//            "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(Ixon::Meta(Metadata { map: vec![] }), "0xE0A0"));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(0u64.into(), vec![])]
-//            }),
-//            "0xE0A18100A0"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(0u64.into(), vec![Metadatum::Name(Name { parts: vec![] })])]
-//            }),
-//            "0xE0A18100A100A0"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(
-//                    0u64.into(),
-//                    vec![Metadatum::Name(Name {
-//                        parts: vec![NamePart::Str("a".to_string())]
-//                    })]
-//                )]
-//            }),
-//            "0xE0A18100A100A17161"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(
-//                    0u64.into(),
-//                    vec![Metadatum::Name(Name {
-//                        parts: vec![
-//                            NamePart::Str("a".to_string()),
-//                            NamePart::Str("b".to_string()),
-//                        ]
-//                    })]
-//                )]
-//            }),
-//            "0xE0A18100A100A271617162"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(
-//                    0u64.into(),
-//                    vec![Metadatum::Name(Name {
-//                        parts: vec![
-//                            NamePart::Str("a".to_string()),
-//                            NamePart::Str("b".to_string()),
-//                            NamePart::Str("c".to_string()),
-//                        ]
-//                    })]
-//                )]
-//            }),
-//            "0xE0A18100A100A3716171627163"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(
-//                    0u64.into(),
-//                    vec![Metadatum::Name(Name {
-//                        parts: vec![NamePart::Num(165851424810452359u64.into())]
-//                    })]
-//                )]
-//            }),
-//            "0xE0A18100A100A1880887C551FDFD384D02"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(0u64.into(), vec![Metadatum::Info(BinderInfo::Default)])]
-//            }),
-//            "0xE0A18100A10100"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(0u64.into(), vec![Metadatum::Link(Address::hash(&[]))])]
-//            }),
-//            "0xE0A18100A102af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(
-//                    0u64.into(),
-//                    vec![
-//                        Metadatum::Name(Name {
-//                            parts: vec![NamePart::Str("d".to_string())]
-//                        }),
-//                        Metadatum::Link(Address::hash(&[])),
-//                        Metadatum::Hints(ReducibilityHints::Regular(576554452)),
-//                        Metadatum::Link(Address::hash(&[]))
-//                    ]
-//                )]
-//            }),
-//            "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(
-//                    0u64.into(),
-//                    vec![Metadatum::Hints(ReducibilityHints::Opaque)]
-//                )]
-//            }),
-//            "0xE0A18100A10300"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(0u64.into(), vec![Metadatum::All(vec![])])]
-//            }),
-//            "0xE0A18100A104A0"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(0u64.into(), vec![Metadatum::MutCtx(vec![])])]
-//            }),
-//            "0xE0A18100A105A0"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![(
-//                    0u64.into(),
-//                    vec![Metadatum::Hints(ReducibilityHints::Regular(42))]
-//                )]
-//            }),
-//            "0xe0a18100a103022a000000"
-//        ));
-//        assert!(test(
-//            Ixon::Meta(Metadata {
-//                map: vec![
-//                    (
-//                        0u64.into(),
-//                        vec![
-//                            Metadatum::Name(Name {
-//                                parts: vec![NamePart::Str("d".to_string())]
-//                            }),
-//                            Metadatum::Link(Address::hash(&[])),
-//                            Metadatum::Hints(ReducibilityHints::Regular(576554452)),
-//                            Metadatum::Link(Address::hash(&[]))
-//                        ]
-//                    ),
-//                    (
-//                        1u64.into(),
-//                        vec![
-//                            Metadatum::Info(BinderInfo::InstImplicit),
-//                            Metadatum::Info(BinderInfo::InstImplicit),
-//                            Metadatum::Info(BinderInfo::StrictImplicit),
-//                        ]
-//                    ),
-//                    (
-//                        2u64.into(),
-//                        vec![
-//                            Metadatum::All(vec![Name {
-//                                parts: vec![NamePart::Num(165851424810452359u64.into())]
-//                            }]),
-//                            Metadatum::Info(BinderInfo::Default)
-//                        ]
-//                    ),
-//                    (3u64.into(), vec![]),
-//                    (4u64.into(), vec![]),
-//                    (
-//                        5u64.into(),
-//                        vec![Metadatum::Hints(ReducibilityHints::Opaque)]
-//                    ),
-//                    (
-//                        6u64.into(),
-//                        vec![Metadatum::Name(Name {
-//                            parts: vec![NamePart::Num(871843802607008850u64.into())]
-//                        })]
-//                    )
-//                ]
-//            }),
-//            "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
-//        ));
-//    }
-//}
+impl Serialize for MetaAddress {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.data.put(buf);
+    self.meta.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let data = Address::get(buf)?;
+    let meta = Address::get(buf)?;
+    Ok(MetaAddress { data, meta })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Quotient {
+  pub kind: QuotKind,
+  pub lvls: Nat,
+  pub typ: Address,
+}
+
+impl Serialize for Quotient {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.kind.put(buf);
+    self.lvls.put(buf);
+    self.typ.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let kind = QuotKind::get(buf)?;
+    let lvls = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    Ok(Quotient { kind, lvls, typ })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Axiom {
+  pub is_unsafe: bool,
+  pub lvls: Nat,
+  pub typ: Address,
+}
+
+impl Serialize for Axiom {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.is_unsafe.put(buf);
+    self.lvls.put(buf);
+    self.typ.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let is_unsafe = bool::get(buf)?;
+    let lvls = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    Ok(Axiom { lvls, typ, is_unsafe })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Definition {
+  pub kind: DefKind,
+  pub safety: DefSafety,
+  pub lvls: Nat,
+  pub typ: Address,
+  pub value: Address,
+}
+
+impl Serialize for Definition {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.kind.put(buf);
+    self.safety.put(buf);
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.value.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let kind = DefKind::get(buf)?;
+    let safety = DefSafety::get(buf)?;
+    let lvls = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    let value = Address::get(buf)?;
+    Ok(Definition { kind, safety, lvls, typ, value })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Constructor {
+  pub is_unsafe: bool,
+  pub lvls: Nat,
+  pub cidx: Nat,
+  pub params: Nat,
+  pub fields: Nat,
+  pub typ: Address,
+}
+
+impl Serialize for Constructor {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.is_unsafe.put(buf);
+    self.lvls.put(buf);
+    self.cidx.put(buf);
+    self.params.put(buf);
+    self.fields.put(buf);
+    self.typ.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let is_unsafe = bool::get(buf)?;
+    let lvls = Nat::get(buf)?;
+    let cidx = Nat::get(buf)?;
+    let params = Nat::get(buf)?;
+    let fields = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    Ok(Constructor { lvls, typ, cidx, params, fields, is_unsafe })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RecursorRule {
+  pub fields: Nat,
+  pub rhs: Address,
+}
+
+impl Serialize for RecursorRule {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.fields.put(buf);
+    self.rhs.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let fields = Nat::get(buf)?;
+    let rhs = Address::get(buf)?;
+    Ok(RecursorRule { fields, rhs })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Recursor {
+  pub k: bool,
+  pub is_unsafe: bool,
+  pub lvls: Nat,
+  pub params: Nat,
+  pub indices: Nat,
+  pub motives: Nat,
+  pub minors: Nat,
+  pub typ: Address,
+  pub rules: Vec<RecursorRule>,
+}
+
+impl Serialize for Recursor {
+  fn put(&self, buf: &mut Vec<u8>) {
+    pack_bools(vec![self.k, self.is_unsafe]).put(buf);
+    self.lvls.put(buf);
+    self.params.put(buf);
+    self.indices.put(buf);
+    self.motives.put(buf);
+    self.minors.put(buf);
+    self.typ.put(buf);
+    self.rules.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let bools = unpack_bools(2, u8::get(buf)?);
+    let lvls = Nat::get(buf)?;
+    let params = Nat::get(buf)?;
+    let indices = Nat::get(buf)?;
+    let motives = Nat::get(buf)?;
+    let minors = Nat::get(buf)?;
+    let typ = Serialize::get(buf)?;
+    let rules = Serialize::get(buf)?;
+    Ok(Recursor {
+      lvls,
+      typ,
+      params,
+      indices,
+      motives,
+      minors,
+      rules,
+      k: bools[0],
+      is_unsafe: bools[1],
+    })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Inductive {
+  pub recr: bool,
+  pub refl: bool,
+  pub is_unsafe: bool,
+  pub lvls: Nat,
+  pub params: Nat,
+  pub indices: Nat,
+  pub nested: Nat,
+  pub typ: Address,
+  pub ctors: Vec<Constructor>,
+}
+
+impl Serialize for Inductive {
+  fn put(&self, buf: &mut Vec<u8>) {
+    pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
+    self.lvls.put(buf);
+    self.params.put(buf);
+    self.indices.put(buf);
+    self.nested.put(buf);
+    self.typ.put(buf);
+    Serialize::put(&self.ctors, buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let bools = unpack_bools(3, u8::get(buf)?);
+    let lvls = Nat::get(buf)?;
+    let params = Nat::get(buf)?;
+    let indices = Nat::get(buf)?;
+    let nested = Nat::get(buf)?;
+    let typ = Address::get(buf)?;
+    let ctors = Serialize::get(buf)?;
+    Ok(Inductive {
+      recr: bools[0],
+      refl: bools[1],
+      is_unsafe: bools[2],
+      lvls,
+      params,
+      indices,
+      nested,
+      typ,
+      ctors,
+    })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InductiveProj {
+  pub idx: Nat,
+  pub block: Address,
+}
+
+impl Serialize for InductiveProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.idx.put(buf);
+    self.block.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let idx = Nat::get(buf)?;
+    let block = Address::get(buf)?;
+    Ok(InductiveProj { idx, block })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConstructorProj {
+  pub idx: Nat,
+  pub cidx: Nat,
+  pub block: Address,
+}
+
+impl Serialize for ConstructorProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.idx.put(buf);
+    self.cidx.put(buf);
+    self.block.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let idx = Nat::get(buf)?;
+    let cidx = Nat::get(buf)?;
+    let block = Address::get(buf)?;
+    Ok(ConstructorProj { idx, cidx, block })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RecursorProj {
+  pub idx: Nat,
+  pub ridx: Nat,
+  pub block: Address,
+}
+
+impl Serialize for RecursorProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.idx.put(buf);
+    self.ridx.put(buf);
+    self.block.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let idx = Nat::get(buf)?;
+    let ridx = Nat::get(buf)?;
+    let block = Address::get(buf)?;
+    Ok(RecursorProj { idx, ridx, block })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DefinitionProj {
+  pub idx: Nat,
+  pub block: Address,
+}
+
+impl Serialize for DefinitionProj {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.idx.put(buf);
+    self.block.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let idx = Nat::get(buf)?;
+    let block = Address::get(buf)?;
+    Ok(DefinitionProj { idx, block })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Comm {
+  pub secret: Address,
+  pub payload: Address,
+}
+
+impl Serialize for Comm {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.secret.put(buf);
+    self.payload.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let secret = Address::get(buf)?;
+    let payload = Address::get(buf)?;
+    Ok(Comm { secret, payload })
+  }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EvalClaim {
+  pub lvls: Address,
+  pub typ: Address,
+  pub input: Address,
+  pub output: Address,
+}
+
+impl Serialize for EvalClaim {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.input.put(buf);
+    self.output.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Address::get(buf)?;
+    let typ = Address::get(buf)?;
+    let input = Address::get(buf)?;
+    let output = Address::get(buf)?;
+    Ok(Self { lvls, typ, input, output })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CheckClaim {
+  pub lvls: Address,
+  pub typ: Address,
+  pub value: Address,
+}
+
+impl Serialize for CheckClaim {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.lvls.put(buf);
+    self.typ.put(buf);
+    self.value.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let lvls = Address::get(buf)?;
+    let typ = Address::get(buf)?;
+    let value = Address::get(buf)?;
+    Ok(Self { lvls, typ, value })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Claim {
+  Checks(CheckClaim),
+  Evals(EvalClaim),
+}
+
+impl Serialize for Claim {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Evals(x) => {
+        u8::put(&0xE2, buf);
+        x.put(buf)
+      },
+      Self::Checks(x) => {
+        u8::put(&0xE3, buf);
+        x.put(buf)
+      },
+    }
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0xE2 => {
+            let x = EvalClaim::get(buf)?;
+            Ok(Self::Evals(x))
+          },
+          0xE3 => {
+            let x = CheckClaim::get(buf)?;
+            Ok(Self::Checks(x))
+          },
+          x => Err(format!("get Claim invalid {x}")),
+        }
+      },
+      None => Err("get Claim EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Proof {
+  pub claim: Claim,
+  pub proof: Vec<u8>,
+}
+
+impl Serialize for Proof {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.claim.put(buf);
+    self.proof.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let claim = Claim::get(buf)?;
+    let proof = Serialize::get(buf)?;
+    Ok(Proof { claim, proof })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Env {
+  pub env: Vec<MetaAddress>,
+}
+
+impl Serialize for Env {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.env.put(buf)
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    Ok(Env { env: Serialize::get(buf)? })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Substring {
+  pub str: Address,
+  pub start_pos: Nat,
+  pub stop_pos: Nat,
+}
+
+impl Serialize for Substring {
+  fn put(&self, buf: &mut Vec<u8>) {
+    self.str.put(buf);
+    self.start_pos.put(buf);
+    self.stop_pos.put(buf);
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let str = Address::get(buf)?;
+    let start_pos = Nat::get(buf)?;
+    let stop_pos = Nat::get(buf)?;
+    Ok(Substring { str, start_pos, stop_pos })
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SourceInfo {
+  Original(Substring, Nat, Substring, Nat),
+  Synthetic(Nat, Nat, bool),
+  None,
+}
+
+impl Serialize for SourceInfo {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Original(l, p, t, e) => {
+        buf.push(0);
+        l.put(buf);
+        p.put(buf);
+        t.put(buf);
+        e.put(buf);
+      },
+      Self::Synthetic(p, e, c) => {
+        buf.push(1);
+        p.put(buf);
+        e.put(buf);
+        c.put(buf);
+      },
+      Self::None => {
+        buf.push(2);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Original(
+            Substring::get(buf)?,
+            Nat::get(buf)?,
+            Substring::get(buf)?,
+            Nat::get(buf)?,
+          )),
+          1 => {
+            Ok(Self::Synthetic(Nat::get(buf)?, Nat::get(buf)?, bool::get(buf)?))
+          },
+          2 => Ok(Self::None),
+          x => Err(format!("get SourcInfo invalid {x}")),
+        }
+      },
+      None => Err("get SourceInfo EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Preresolved {
+  Namespace(Address),
+  Decl(Address, Vec<Address>),
+}
+
+impl Serialize for Preresolved {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Namespace(ns) => {
+        buf.push(0);
+        ns.put(buf);
+      },
+      Self::Decl(n, fields) => {
+        buf.push(1);
+        n.put(buf);
+        fields.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Namespace(Address::get(buf)?)),
+          1 => Ok(Self::Decl(Address::get(buf)?, Vec::<Address>::get(buf)?)),
+          x => Err(format!("get Preresolved invalid {x}")),
+        }
+      },
+      None => Err("get Preresolved EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Syntax {
+  Missing,
+  Node(SourceInfo, Address, Vec<Address>),
+  Atom(SourceInfo, Address),
+  Ident(SourceInfo, Substring, Address, Vec<Preresolved>),
+}
+
+impl Serialize for Syntax {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Missing => {
+        buf.push(0);
+      },
+      Self::Node(i, k, xs) => {
+        buf.push(1);
+        i.put(buf);
+        k.put(buf);
+        xs.put(buf);
+      },
+      Self::Atom(i, v) => {
+        buf.push(2);
+        i.put(buf);
+        v.put(buf);
+      },
+      Self::Ident(i, r, v, ps) => {
+        buf.push(3);
+        i.put(buf);
+        r.put(buf);
+        v.put(buf);
+        ps.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Missing),
+          1 => Ok(Self::Node(
+            SourceInfo::get(buf)?,
+            Address::get(buf)?,
+            Vec::<Address>::get(buf)?,
+          )),
+          2 => Ok(Self::Atom(SourceInfo::get(buf)?, Address::get(buf)?)),
+          3 => Ok(Self::Ident(
+            SourceInfo::get(buf)?,
+            Substring::get(buf)?,
+            Address::get(buf)?,
+            Vec::<Preresolved>::get(buf)?,
+          )),
+          x => Err(format!("get Syntax invalid {x}")),
+        }
+      },
+      None => Err("get Syntax EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MutConst {
+  Defn(Definition),
+  Indc(Inductive),
+  Recr(Recursor),
+}
+
+impl Serialize for MutConst {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Defn(x) => {
+        buf.push(0);
+        x.put(buf);
+      },
+      Self::Indc(x) => {
+        buf.push(1);
+        x.put(buf);
+      },
+      Self::Recr(x) => {
+        buf.push(2);
+        x.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Defn(Definition::get(buf)?)),
+          1 => Ok(Self::Indc(Inductive::get(buf)?)),
+          2 => Ok(Self::Recr(Recursor::get(buf)?)),
+          x => Err(format!("get MutConst invalid {x}")),
+        }
+      },
+      None => Err("get MutConst EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BuiltIn {
+  Obj,
+  Neutral,
+  Unreachable,
+}
+
+impl Serialize for BuiltIn {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Obj => buf.push(0),
+      Self::Neutral => buf.push(1),
+      Self::Unreachable => buf.push(2),
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Obj),
+          1 => Ok(Self::Neutral),
+          2 => Ok(Self::Unreachable),
+          x => Err(format!("get BuiltIn invalid {x}")),
+        }
+      },
+      None => Err("get BuiltIn EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DataValue {
+  OfString(Address),
+  OfBool(bool),
+  OfName(Address),
+  OfNat(Address),
+  OfInt(Address),
+  OfSyntax(Address),
+}
+
+impl Serialize for DataValue {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::OfString(x) => {
+        buf.push(0);
+        x.put(buf);
+      },
+      Self::OfBool(x) => {
+        buf.push(1);
+        x.put(buf);
+      },
+      Self::OfName(x) => {
+        buf.push(2);
+        x.put(buf);
+      },
+      Self::OfNat(x) => {
+        buf.push(3);
+        x.put(buf);
+      },
+      Self::OfInt(x) => {
+        buf.push(4);
+        x.put(buf);
+      },
+      Self::OfSyntax(x) => {
+        buf.push(5);
+        x.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::OfString(Address::get(buf)?)),
+          1 => Ok(Self::OfBool(bool::get(buf)?)),
+          2 => Ok(Self::OfName(Address::get(buf)?)),
+          3 => Ok(Self::OfNat(Address::get(buf)?)),
+          4 => Ok(Self::OfInt(Address::get(buf)?)),
+          5 => Ok(Self::OfSyntax(Address::get(buf)?)),
+          x => Err(format!("get DataValue invalid {x}")),
+        }
+      },
+      None => Err("get DataValue EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Metadatum {
+  Link(Address),
+  Info(BinderInfo),
+  Hints(ReducibilityHints),
+  Links(Vec<Address>),
+  Map(Vec<(Address, Address)>),
+  KVMap(Vec<(Address, DataValue)>),
+  Muts(Vec<Vec<Address>>),
+}
+
+impl Serialize for Metadatum {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::Link(x) => {
+        buf.push(0);
+        x.put(buf);
+      },
+      Self::Info(x) => {
+        buf.push(1);
+        x.put(buf);
+      },
+      Self::Hints(x) => {
+        buf.push(2);
+        x.put(buf);
+      },
+      Self::Links(x) => {
+        buf.push(3);
+        x.put(buf);
+      },
+      Self::Map(x) => {
+        buf.push(4);
+        x.put(buf);
+      },
+      Self::KVMap(x) => {
+        buf.push(5);
+        x.put(buf);
+      },
+      Self::Muts(x) => {
+        buf.push(6);
+        x.put(buf);
+      },
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    match buf.split_at_checked(1) {
+      Some((head, rest)) => {
+        *buf = rest;
+        match head[0] {
+          0 => Ok(Self::Link(Address::get(buf)?)),
+          1 => Ok(Self::Info(BinderInfo::get(buf)?)),
+          2 => Ok(Self::Hints(ReducibilityHints::get(buf)?)),
+          3 => Ok(Self::Links(Vec::<Address>::get(buf)?)),
+          4 => Ok(Self::Map(Vec::<(Address, Address)>::get(buf)?)),
+          5 => Ok(Self::KVMap(Vec::<(Address, DataValue)>::get(buf)?)),
+          6 => Ok(Self::Muts(Vec::<Vec<Address>>::get(buf)?)),
+          x => Err(format!("get Metadatum invalid {x}")),
+        }
+      },
+      None => Err("get Metadatum EOF".to_string()),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Metadata {
+  pub nodes: Vec<Metadatum>,
+}
+
+impl Serialize for Metadata {
+  fn put(&self, buf: &mut Vec<u8>) {
+    Tag4 { flag: 0x4, size: self.nodes.len() as u64 }.put(buf);
+    for n in self.nodes.iter() {
+      n.put(buf)
+    }
+  }
+
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let tag = Tag4::get(buf)?;
+    match tag {
+      Tag4 { flag: 0xF, size } => {
+        let mut nodes = vec![];
+        for _ in 0..size {
+          nodes.push(Metadatum::get(buf)?)
+        }
+        Ok(Metadata { nodes })
+      },
+      x => Err(format!("get Metadata invalid {x:?}")),
+    }
+  }
+}
+
+// TODO: Update Ixon
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Ixon {
+  NAnon,                                 // 0x00, anonymous name
+  NStr(Address, Address),                // 0x01, string name
+  NNum(Address, Address),                // 0x02, number name
+  UZero,                                 // 0x03, universe zero
+  USucc(Address),                        // 0x04, universe successor
+  UMax(Address, Address),                // 0x05, universe max
+  UIMax(Address, Address),               // 0x06, universe impredicative max
+  UVar(Nat),                             // 0x1X, universe variable
+  EVar(Nat),                             // 0x2X, expression variable
+  ERef(Address, Vec<Address>),           // 0x3X, expression reference
+  ERec(Nat, Vec<Address>),               // 0x4X, expression recursion
+  EPrj(Address, Nat, Address),           // 0x5X, expression projection
+  ESort(Address),                        // 0x80, expression sort
+  EStr(Address),                         // 0x81, expression string
+  ENat(Address),                         // 0x82, expression natural
+  EApp(Address, Address),                // 0x83, expression application
+  ELam(Address, Address),                // 0x84, expression lambda
+  EAll(Address, Address),                // 0x85, expression forall
+  ELet(bool, Address, Address, Address), // 0x86, 0x87, expression let
+  Blob(Vec<u8>),                         // 0x9X, tagged bytes
+  Defn(Definition),                      // 0xA0, definition constant
+  Recr(Recursor),                        // 0xA1, recursor constant
+  Axio(Axiom),                           // 0xA2, axiom constant
+  Quot(Quotient),                        // 0xA3, quotient constant
+  CPrj(ConstructorProj),                 // 0xA4, constructor projection
+  RPrj(RecursorProj),                    // 0xA5, recursor projection
+  IPrj(InductiveProj),                   // 0xA6, inductive projection
+  DPrj(DefinitionProj),                  // 0xA7, definition projection
+  Muts(Vec<MutConst>),                   // 0xBX, mutual constants
+  Prof(Proof),                           // 0xE0, zero-knowledge proof
+  Eval(EvalClaim),                       // 0xE1, evaluation claim
+  Chck(CheckClaim),                      // 0xE2, typechecking claim
+  Comm(Comm),                            // 0xE3, cryptographic commitment
+  Envn(Env),                             // 0xE4, multi-claim environment
+  Prim(BuiltIn),                         // 0xE5, compiler built-ins
+  Meta(Metadata),                        // 0xFX, metadata
+}
+
+impl Default for Ixon {
+  fn default() -> Self {
+    Self::NAnon
+  }
+}
+
+impl Ixon {
+  pub fn put_tag(flag: u8, size: u64, buf: &mut Vec<u8>) {
+    Tag4 { flag, size }.put(buf);
+  }
+
+  pub fn puts<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
+    for x in xs {
+      x.put(buf)
+    }
+  }
+
+  pub fn gets<S: Serialize>(
+    len: u64,
+    buf: &mut &[u8],
+  ) -> Result<Vec<S>, String> {
+    let mut vec = vec![];
+    for _ in 0..len {
+      let s = S::get(buf)?;
+      vec.push(s);
+    }
+    Ok(vec)
+  }
+}
+
+impl Serialize for Ixon {
+  fn put(&self, buf: &mut Vec<u8>) {
+    match self {
+      Self::NAnon => Self::put_tag(0x0, 0, buf),
+      Self::NStr(n, s) => {
+        Self::put_tag(0x0, 1, buf);
+        Serialize::put(n, buf);
+        Serialize::put(s, buf);
+      },
+      Self::NNum(n, s) => {
+        Self::put_tag(0x0, 2, buf);
+        Serialize::put(n, buf);
+        Serialize::put(s, buf);
+      },
+      Self::UZero => Self::put_tag(0x0, 3, buf),
+      Self::USucc(x) => {
+        Self::put_tag(0x0, 4, buf);
+        Serialize::put(x, buf);
+      },
+      Self::UMax(x, y) => {
+        Self::put_tag(0x0, 5, buf);
+        Serialize::put(x, buf);
+        Serialize::put(y, buf);
+      },
+      Self::UIMax(x, y) => {
+        Self::put_tag(0x0, 6, buf);
+        Serialize::put(x, buf);
+        Serialize::put(y, buf);
+      },
+      Self::UVar(x) => {
+        let bytes = x.0.to_bytes_le();
+        Self::put_tag(0x1, bytes.len() as u64, buf);
+        Self::puts(&bytes, buf)
+      },
+      Self::EVar(x) => {
+        let bytes = x.0.to_bytes_le();
+        Self::put_tag(0x2, bytes.len() as u64, buf);
+        Self::puts(&bytes, buf)
+      },
+      Self::ERef(a, ls) => {
+        Self::put_tag(0x3, ls.len() as u64, buf);
+        a.put(buf);
+        Self::puts(ls, buf)
+      },
+      Self::ERec(i, ls) => {
+        Self::put_tag(0x4, ls.len() as u64, buf);
+        i.put(buf);
+        Self::puts(ls, buf)
+      },
+      Self::EPrj(t, n, x) => {
+        let bytes = n.0.to_bytes_le();
+        Self::put_tag(0x5, bytes.len() as u64, buf);
+        t.put(buf);
+        Self::puts(&bytes, buf);
+        x.put(buf);
+      },
+      Self::ESort(u) => {
+        Self::put_tag(0x8, 0, buf);
+        u.put(buf);
+      },
+      Self::EStr(s) => {
+        Self::put_tag(0x8, 1, buf);
+        s.put(buf);
+      },
+      Self::ENat(n) => {
+        Self::put_tag(0x8, 2, buf);
+        n.put(buf);
+      },
+      Self::EApp(f, a) => {
+        Self::put_tag(0x8, 3, buf);
+        f.put(buf);
+        a.put(buf);
+      },
+      Self::ELam(t, b) => {
+        Self::put_tag(0x8, 4, buf);
+        t.put(buf);
+        b.put(buf);
+      },
+      Self::EAll(t, b) => {
+        Self::put_tag(0x8, 5, buf);
+        t.put(buf);
+        b.put(buf);
+      },
+      Self::ELet(nd, t, d, b) => {
+        if *nd {
+          Self::put_tag(0x8, 6, buf);
+        } else {
+          Self::put_tag(0x8, 7, buf);
+        }
+        t.put(buf);
+        d.put(buf);
+        b.put(buf);
+      },
+      Self::Blob(xs) => {
+        Self::put_tag(0x9, xs.len() as u64, buf);
+        Self::puts(xs, buf);
+      },
+      Self::Defn(x) => {
+        Self::put_tag(0xA, 0, buf);
+        x.put(buf);
+      },
+      Self::Recr(x) => {
+        Self::put_tag(0xA, 1, buf);
+        x.put(buf);
+      },
+      Self::Axio(x) => {
+        Self::put_tag(0xA, 2, buf);
+        x.put(buf);
+      },
+      Self::Quot(x) => {
+        Self::put_tag(0xA, 3, buf);
+        x.put(buf);
+      },
+      Self::CPrj(x) => {
+        Self::put_tag(0xA, 4, buf);
+        x.put(buf);
+      },
+      Self::RPrj(x) => {
+        Self::put_tag(0xA, 5, buf);
+        x.put(buf);
+      },
+      Self::IPrj(x) => {
+        Self::put_tag(0xA, 6, buf);
+        x.put(buf);
+      },
+      Self::DPrj(x) => {
+        Self::put_tag(0xA, 7, buf);
+        x.put(buf);
+      },
+      Self::Muts(xs) => {
+        Self::put_tag(0xB, xs.len() as u64, buf);
+        Self::puts(xs, buf);
+      },
+      Self::Prof(x) => {
+        Self::put_tag(0xE, 0, buf);
+        x.put(buf);
+      },
+      Self::Eval(x) => {
+        Self::put_tag(0xE, 1, buf);
+        x.put(buf);
+      },
+      Self::Chck(x) => {
+        Self::put_tag(0xE, 2, buf);
+        x.put(buf);
+      },
+      Self::Comm(x) => {
+        Self::put_tag(0xE, 3, buf);
+        x.put(buf);
+      },
+      Self::Envn(x) => {
+        Self::put_tag(0xE, 4, buf);
+        x.put(buf);
+      },
+      Self::Prim(x) => {
+        Self::put_tag(0xE, 5, buf);
+        x.put(buf);
+      },
+      Self::Meta(x) => {
+        Self::put_tag(0xE, 5, buf);
+        x.put(buf);
+      },
+    }
+  }
+  fn get(buf: &mut &[u8]) -> Result<Self, String> {
+    let tag = Tag4::get(buf)?;
+    match tag {
+      Tag4 { flag: 0x0, size: 0 } => Ok(Self::NAnon),
+      Tag4 { flag: 0x0, size: 1 } => {
+        Ok(Self::NStr(Address::get(buf)?, Address::get(buf)?))
+      },
+      Tag4 { flag: 0x0, size: 2 } => {
+        Ok(Self::NNum(Address::get(buf)?, Address::get(buf)?))
+      },
+      Tag4 { flag: 0x0, size: 3 } => Ok(Self::UZero),
+      Tag4 { flag: 0x0, size: 4 } => Ok(Self::USucc(Address::get(buf)?)),
+      Tag4 { flag: 0x0, size: 5 } => {
+        Ok(Self::UMax(Address::get(buf)?, Address::get(buf)?))
+      },
+      Tag4 { flag: 0x0, size: 6 } => {
+        Ok(Self::UIMax(Address::get(buf)?, Address::get(buf)?))
+      },
+      Tag4 { flag: 0x1, size } => {
+        let bytes: Vec<u8> = Self::gets(size, buf)?;
+        Ok(Self::UVar(Nat::from_le_bytes(&bytes)))
+      },
+      Tag4 { flag: 0x3, size } => {
+        let bytes: Vec<u8> = Self::gets(size, buf)?;
+        Ok(Self::EVar(Nat::from_le_bytes(&bytes)))
+      },
+      Tag4 { flag: 0x4, size } => {
+        Ok(Self::ERef(Address::get(buf)?, Self::gets(size, buf)?))
+      },
+      Tag4 { flag: 0x5, size } => {
+        Ok(Self::ERec(Nat::get(buf)?, Self::gets(size, buf)?))
+      },
+      Tag4 { flag: 0x8, size: 0 } => Ok(Self::ESort(Address::get(buf)?)),
+      Tag4 { flag: 0x8, size: 1 } => Ok(Self::EStr(Address::get(buf)?)),
+      Tag4 { flag: 0x8, size: 2 } => Ok(Self::ENat(Address::get(buf)?)),
+      Tag4 { flag: 0x8, size: 3 } => {
+        Ok(Self::EApp(Address::get(buf)?, Address::get(buf)?))
+      },
+      Tag4 { flag: 0x8, size: 4 } => {
+        Ok(Self::ELam(Address::get(buf)?, Address::get(buf)?))
+      },
+      Tag4 { flag: 0x8, size: 5 } => {
+        Ok(Self::EAll(Address::get(buf)?, Address::get(buf)?))
+      },
+      Tag4 { flag: 0x8, size: 6 } => Ok(Self::ELet(
+        true,
+        Address::get(buf)?,
+        Address::get(buf)?,
+        Address::get(buf)?,
+      )),
+      Tag4 { flag: 0x8, size: 7 } => Ok(Self::ELet(
+        false,
+        Address::get(buf)?,
+        Address::get(buf)?,
+        Address::get(buf)?,
+      )),
+      Tag4 { flag: 0x9, size } => {
+        let bytes: Vec<u8> = Self::gets(size, buf)?;
+        Ok(Self::Blob(bytes))
+      },
+      Tag4 { flag: 0xA, size: 0 } => Ok(Self::Defn(Serialize::get(buf)?)),
+      Tag4 { flag: 0xA, size: 1 } => Ok(Self::Recr(Serialize::get(buf)?)),
+      Tag4 { flag: 0xA, size: 2 } => Ok(Self::Axio(Serialize::get(buf)?)),
+      Tag4 { flag: 0xA, size: 3 } => Ok(Self::Quot(Serialize::get(buf)?)),
+      Tag4 { flag: 0xA, size: 4 } => Ok(Self::CPrj(Serialize::get(buf)?)),
+      Tag4 { flag: 0xA, size: 5 } => Ok(Self::RPrj(Serialize::get(buf)?)),
+      Tag4 { flag: 0xA, size: 6 } => Ok(Self::IPrj(Serialize::get(buf)?)),
+      Tag4 { flag: 0xA, size: 7 } => Ok(Self::DPrj(Serialize::get(buf)?)),
+      Tag4 { flag: 0xB, size } => {
+        let xs: Vec<MutConst> = Self::gets(size, buf)?;
+        Ok(Self::Muts(xs))
+      },
+      Tag4 { flag: 0xE, size: 0 } => Ok(Self::Prof(Serialize::get(buf)?)),
+      Tag4 { flag: 0xE, size: 1 } => Ok(Self::Eval(Serialize::get(buf)?)),
+      Tag4 { flag: 0xE, size: 2 } => Ok(Self::Chck(Serialize::get(buf)?)),
+      Tag4 { flag: 0xE, size: 3 } => Ok(Self::Comm(Serialize::get(buf)?)),
+      Tag4 { flag: 0xE, size: 4 } => Ok(Self::Envn(Serialize::get(buf)?)),
+      Tag4 { flag: 0xE, size: 5 } => Ok(Self::Prim(Serialize::get(buf)?)),
+      Tag4 { flag: 0xF, size } => {
+        let nodes: Vec<Metadatum> = Self::gets(size, buf)?;
+        Ok(Self::Meta(Metadata { nodes }))
+      },
+      x => Err(format!("get Ixon invalid {x:?}")),
+    }
+  }
+}
 //
+////impl Serialize for Ixon {
+////    fn put(&self, buf: &mut Vec<u8>) {
+////        match self {
+////            Self::Vari(x) => Self::put_tag(0x0, *x, buf),
+////            Self::Sort(x) => {
+////                u8::put(&0x90, buf);
+////                x.put(buf);
+////            }
+////            Self::Refr(addr, lvls) => {
+////                Self::put_tag(0x1, lvls.len() as u64, buf);
+////                addr.put(buf);
+////                for l in lvls {
+////                    l.put(buf);
+////                }
+////            }
+////            Self::Recr(x, lvls) => {
+////                Self::put_tag(0x2, *x, buf);
+////                Ixon::put_array(lvls, buf);
+////            }
+////            Self::Apps(f, a, args) => {
+////                Self::put_tag(0x3, args.len() as u64, buf);
+////                f.put(buf);
+////                a.put(buf);
+////                for x in args {
+////                    x.put(buf);
+////                }
+////            }
+////            Self::Lams(ts, b) => {
+////                Self::put_tag(0x4, ts.len() as u64, buf);
+////                for t in ts {
+////                    t.put(buf);
+////                }
+////                b.put(buf);
+////            }
+////            Self::Alls(ts, b) => {
+////                Self::put_tag(0x5, ts.len() as u64, buf);
+////                for t in ts {
+////                    t.put(buf);
+////                }
+////                b.put(buf);
+////            }
+////            Self::Proj(t, n, x) => {
+////                Self::put_tag(0x6, *n, buf);
+////                t.put(buf);
+////                x.put(buf);
+////            }
+////            Self::Strl(s) => {
+////                let bytes = s.as_bytes();
+////                Self::put_tag(0x7, bytes.len() as u64, buf);
+////                buf.extend_from_slice(bytes);
+////            }
+////            Self::Natl(n) => {
+////                let bytes = n.0.to_bytes_le();
+////                Self::put_tag(0x8, bytes.len() as u64, buf);
+////                buf.extend_from_slice(&bytes);
+////            }
+////            Self::LetE(nd, t, d, b) => {
+////                if *nd {
+////                    u8::put(&0x91, buf);
+////                } else {
+////                    u8::put(&0x92, buf);
+////                }
+////                t.put(buf);
+////                d.put(buf);
+////                b.put(buf);
+////            }
+////            Self::List(xs) => Ixon::put_array(xs, buf),
+////            Self::Defn(x) => {
+////                u8::put(&0xB0, buf);
+////                x.put(buf);
+////            }
+////            Self::Axio(x) => {
+////                u8::put(&0xB1, buf);
+////                x.put(buf);
+////            }
+////            Self::Quot(x) => {
+////                u8::put(&0xB2, buf);
+////                x.put(buf);
+////            }
+////            Self::CPrj(x) => {
+////                u8::put(&0xB3, buf);
+////                x.put(buf);
+////            }
+////            Self::RPrj(x) => {
+////                u8::put(&0xB4, buf);
+////                x.put(buf);
+////            }
+////            Self::IPrj(x) => {
+////                u8::put(&0xB5, buf);
+////                x.put(buf);
+////            }
+////            Self::DPrj(x) => {
+////                u8::put(&0xB6, buf);
+////                x.put(buf);
+////            }
+////            Self::Inds(xs) => {
+////                Self::put_tag(0xC, xs.len() as u64, buf);
+////                for x in xs {
+////                    x.put(buf);
+////                }
+////            }
+////            Self::Defs(xs) => {
+////                Self::put_tag(0xD, xs.len() as u64, buf);
+////                for x in xs {
+////                    x.put(buf);
+////                }
+////            }
+////            Self::Meta(x) => {
+////                u8::put(&0xE0, buf);
+////                x.put(buf);
+////            }
+////            Self::Prof(x) => {
+////                u8::put(&0xE1, buf);
+////                x.put(buf);
+////            }
+////            Self::Eval(x) => {
+////                u8::put(&0xE2, buf);
+////                x.put(buf);
+////            }
+////            Self::Chck(x) => {
+////                u8::put(&0xE3, buf);
+////                x.put(buf);
+////            }
+////            Self::Comm(x) => {
+////                u8::put(&0xE4, buf);
+////                x.put(buf);
+////            }
+////            Self::Envn(x) => {
+////                u8::put(&0xE5, buf);
+////                x.put(buf);
+////            }
+////        }
+////    }
+////
+////    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+////        let tag_byte = u8::get(buf)?;
+////        let small_size = tag_byte & 0b111;
+////        let is_large = tag_byte & 0b1000 != 0;
+////        match tag_byte {
+////            0x00..=0x0F => {
+////                let x = Ixon::get_size(is_large, small_size, buf)?;
+////                Ok(Self::Vari(x))
+////            }
+////            0x90 => {
+////                let u = Univ::get(buf)?;
+////                Ok(Self::Sort(Box::new(u)))
+////            }
+////            0x10..=0x1F => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                let a = Address::get(buf)?;
+////                let mut lvls = Vec::new();
+////                for _ in 0..n {
+////                    let l = Univ::get(buf)?;
+////                    lvls.push(l);
+////                }
+////                Ok(Self::Refr(a, lvls))
+////            }
+////            0x20..=0x2F => {
+////                let x = Ixon::get_size(is_large, small_size, buf)?;
+////                let lvls = Ixon::get_array(buf)?;
+////                Ok(Self::Recr(x, lvls))
+////            }
+////            0x30..=0x3F => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                let f = Ixon::get(buf)?;
+////                let a = Ixon::get(buf)?;
+////                let mut args = Vec::new();
+////                for _ in 0..n {
+////                    let x = Ixon::get(buf)?;
+////                    args.push(x);
+////                }
+////                Ok(Self::Apps(Box::new(f), Box::new(a), args))
+////            }
+////            0x40..=0x4F => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                let mut ts = Vec::new();
+////                for _ in 0..n {
+////                    let x = Ixon::get(buf)?;
+////                    ts.push(x);
+////                }
+////                let b = Ixon::get(buf)?;
+////                Ok(Self::Lams(ts, Box::new(b)))
+////            }
+////            0x50..=0x5F => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                let mut ts = Vec::new();
+////                for _ in 0..n {
+////                    let x = Ixon::get(buf)?;
+////                    ts.push(x);
+////                }
+////                let b = Ixon::get(buf)?;
+////                Ok(Self::Alls(ts, Box::new(b)))
+////            }
+////            0x60..=0x6F => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                let t = Address::get(buf)?;
+////                let x = Ixon::get(buf)?;
+////                Ok(Self::Proj(t, n, Box::new(x)))
+////            }
+////            0x70..=0x7F => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                match buf.split_at_checked(n as usize) {
+////                    Some((head, rest)) => {
+////                        *buf = rest;
+////                        match String::from_utf8(head.to_owned()) {
+////                            Ok(s) => Ok(Ixon::Strl(s)),
+////                            Err(e) => Err(format!("UTF8 Error: {e}")),
+////                        }
+////                    }
+////                    None => Err("get Ixon Strl EOF".to_string()),
+////                }
+////            }
+////            0x80..=0x8F => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                match buf.split_at_checked(n as usize) {
+////                    Some((head, rest)) => {
+////                        *buf = rest;
+////                        Ok(Ixon::Natl(Nat(BigUint::from_bytes_le(head))))
+////                    }
+////                    None => Err("get Expr Natl EOF".to_string()),
+////                }
+////            }
+////            0x91..=0x92 => {
+////                let nd = tag_byte == 0x91;
+////                let t = Ixon::get(buf)?;
+////                let d = Ixon::get(buf)?;
+////                let b = Ixon::get(buf)?;
+////                Ok(Self::LetE(nd, Box::new(t), Box::new(d), Box::new(b)))
+////            }
+////            0xA0..=0xAF => {
+////                let len = Self::get_size(is_large, small_size, buf)?;
+////                let mut vec = vec![];
+////                for _ in 0..len {
+////                    let s = Ixon::get(buf)?;
+////                    vec.push(s);
+////                }
+////                Ok(Self::List(vec))
+////            }
+////            0xB0 => Ok(Self::Defn(Definition::get(buf)?)),
+////            0xB1 => Ok(Self::Axio(Axiom::get(buf)?)),
+////            0xB2 => Ok(Self::Quot(Quotient::get(buf)?)),
+////            0xB3 => Ok(Self::CPrj(ConstructorProj::get(buf)?)),
+////            0xB4 => Ok(Self::RPrj(RecursorProj::get(buf)?)),
+////            0xB5 => Ok(Self::IPrj(InductiveProj::get(buf)?)),
+////            0xB6 => Ok(Self::DPrj(DefinitionProj::get(buf)?)),
+////            0xC0..=0xCF => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                let mut inds = Vec::new();
+////                for _ in 0..n {
+////                    let x = Inductive::get(buf)?;
+////                    inds.push(x);
+////                }
+////                Ok(Self::Inds(inds))
+////            }
+////            0xD0..=0xDF => {
+////                let n = Ixon::get_size(is_large, small_size, buf)?;
+////                let mut defs = Vec::new();
+////                for _ in 0..n {
+////                    let x = Definition::get(buf)?;
+////                    defs.push(x);
+////                }
+////                Ok(Self::Defs(defs))
+////            }
+////            0xE0 => Ok(Self::Meta(Metadata::get(buf)?)),
+////            0xE1 => Ok(Self::Prof(Proof::get(buf)?)),
+////            0xE2 => Ok(Self::Eval(EvalClaim::get(buf)?)),
+////            0xE3 => Ok(Self::Chck(CheckClaim::get(buf)?)),
+////            0xE4 => Ok(Self::Comm(Comm::get(buf)?)),
+////            0xE5 => Ok(Self::Envn(Env::get(buf)?)),
+////            x => Err(format!("get Ixon invalid tag {x}")),
+////        }
+////    }
+////}
+////
+////#[cfg(test)]
+////pub mod tests {
+////    use super::*;
+////    use crate::ixon::nat::tests::arbitrary_nat;
+////    use crate::ixon::univ::tests::arbitrary_univ;
+////    use quickcheck::{Arbitrary, Gen};
+////    use std::fmt::Write;
+////    use std::ops::Range;
+////    use std::ptr;
+////
+////    pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
+////        let res: usize = Arbitrary::arbitrary(g);
+////        if range.is_empty() {
+////            0
+////        } else {
+////            (res % (range.end - range.start)) + range.start
+////        }
+////    }
+////
+////    pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
+////    where
+////        F: FnMut(&mut Gen) -> A,
+////    {
+////        let len = gen_range(g, 0..size);
+////        let mut vec = Vec::with_capacity(len);
+////        for _ in 0..len {
+////            vec.push(f(g));
+////        }
+////        vec
+////    }
+////
+////    pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
+////        let sum: usize = gens.iter().map(|x| x.0).sum();
+////        let mut weight: usize = gen_range(g, 1..sum);
+////        for (n, case) in gens {
+////            if *n == 0 {
+////                continue;
+////            } else {
+////                match weight.checked_sub(*n) {
+////                    None | Some(0) => {
+////                        return *case;
+////                    }
+////                    _ => {
+////                        weight -= *n;
+////                    }
+////                }
+////            }
+////        }
+////        unreachable!()
+////    }
+////
+////    #[test]
+////    fn unit_u64_trimmed() {
+////        fn test(input: u64, expected: Vec<u8>) -> bool {
+////            let mut tmp = Vec::new();
+////            let n = Ixon::u64_byte_count(input);
+////            Ixon::u64_put_trimmed_le(input, &mut tmp);
+////            if tmp != expected {
+////                return false;
+////            }
+////            match Ixon::u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
+////                Ok(out) => input == out,
+////                Err(e) => {
+////                    println!("err: {e}");
+////                    false
+////                }
+////            }
+////        }
+////        assert!(test(0x0, vec![]));
+////        assert!(test(0x01, vec![0x01]));
+////        assert!(test(0x0000000000000100, vec![0x00, 0x01]));
+////        assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
+////        assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
+////        assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
+////        assert!(test(
+////            0x0000010000000000,
+////            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+////        ));
+////        assert!(test(
+////            0x0001000000000000,
+////            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+////        ));
+////        assert!(test(
+////            0x0100000000000000,
+////            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+////        ));
+////        assert!(test(
+////            0x0102030405060708,
+////            vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+////        ));
+////    }
+////
+////    #[quickcheck]
+////    fn prop_u64_trimmed_le_readback(x: u64) -> bool {
+////        let mut buf = Vec::new();
+////        let n = Ixon::u64_byte_count(x);
+////        Ixon::u64_put_trimmed_le(x, &mut buf);
+////        match Ixon::u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
+////            Ok(y) => x == y,
+////            Err(e) => {
+////                println!("err: {e}");
+////                false
+////            }
+////        }
+////    }
+////
+////    #[derive(Debug, Clone, Copy)]
+////    pub enum IxonCase {
+////        Vari,
+////        Sort,
+////        Refr,
+////        Recr,
+////        Apps,
+////        Lams,
+////        Alls,
+////        Proj,
+////        Strl,
+////        Natl,
+////        LetE,
+////        List,
+////        Defn,
+////        Axio,
+////        Quot,
+////        CPrj,
+////        RPrj,
+////        IPrj,
+////        DPrj,
+////        Defs,
+////        Inds,
+////        Meta,
+////        Prof,
+////        Eval,
+////        Chck,
+////        Comm,
+////        Envn,
+////    }
+////
+////    pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
+////        let mut s = String::new();
+////        for _ in 0..cs {
+////            s.push(char::arbitrary(g));
+////        }
+////        s
+////    }
+////
+////    // incremental tree generation without recursion stack overflows
+////    pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
+////        let mut root = Ixon::Vari(0);
+////        let mut stack = vec![&mut root as *mut Ixon];
+////
+////        while let Some(ptr) = stack.pop() {
+////            let gens: Vec<(usize, IxonCase)> = vec![
+////                (100, IxonCase::Vari),
+////                (100, IxonCase::Sort),
+////                (15, IxonCase::Refr),
+////                (15, IxonCase::Recr),
+////                (15, IxonCase::Apps),
+////                (15, IxonCase::Lams),
+////                (15, IxonCase::Alls),
+////                (20, IxonCase::LetE),
+////                (50, IxonCase::Proj),
+////                (100, IxonCase::Strl),
+////                (100, IxonCase::Natl),
+////                (10, IxonCase::List),
+////                (100, IxonCase::Defn),
+////                (100, IxonCase::Axio),
+////                (100, IxonCase::Quot),
+////                (100, IxonCase::CPrj),
+////                (100, IxonCase::RPrj),
+////                (100, IxonCase::IPrj),
+////                (100, IxonCase::DPrj),
+////                (15, IxonCase::Inds),
+////                (15, IxonCase::Defs),
+////                (100, IxonCase::Meta),
+////                (100, IxonCase::Prof),
+////                (100, IxonCase::Eval),
+////                (100, IxonCase::Chck),
+////                (100, IxonCase::Comm),
+////                (100, IxonCase::Envn),
+////            ];
+////
+////            match next_case(g, &gens) {
+////                IxonCase::Vari => {
+////                    let x: u64 = Arbitrary::arbitrary(g);
+////                    unsafe {
+////                        ptr::replace(ptr, Ixon::Vari(x));
+////                    }
+////                }
+////                IxonCase::Sort => {
+////                    let u = arbitrary_univ(g, ctx);
+////                    unsafe {
+////                        ptr::replace(ptr, Ixon::Sort(Box::new(u)));
+////                    }
+////                }
+////                IxonCase::Refr => {
+////                    let addr = Address::arbitrary(g);
+////                    let mut lvls = vec![];
+////                    for _ in 0..gen_range(g, 0..9) {
+////                        lvls.push(arbitrary_univ(g, ctx));
+////                    }
+////                    unsafe {
+////                        ptr::replace(ptr, Ixon::Refr(addr, lvls));
+////                    }
+////                }
+////                IxonCase::Recr => {
+////                    let n = u64::arbitrary(g);
+////                    let mut lvls = vec![];
+////                    for _ in 0..gen_range(g, 0..9) {
+////                        lvls.push(arbitrary_univ(g, ctx));
+////                    }
+////                    unsafe {
+////                        ptr::replace(ptr, Ixon::Recr(n, lvls));
+////                    }
+////                }
+////                IxonCase::Apps => {
+////                    let mut f_box = Box::new(Ixon::default());
+////                    let f_ptr: *mut Ixon = &mut *f_box;
+////                    stack.push(f_ptr);
+////
+////                    let mut a_box = Box::new(Ixon::default());
+////                    let a_ptr: *mut Ixon = &mut *a_box;
+////                    stack.push(a_ptr);
+////
+////                    let n = gen_range(g, 0..9);
+////                    let mut xs: Vec<Ixon> = Vec::with_capacity(n);
+////                    xs.resize(n, Ixon::Vari(0));
+////                    for i in 0..n {
+////                        let p = unsafe { xs.as_mut_ptr().add(i) };
+////                        stack.push(p);
+////                    }
+////                    unsafe {
+////                        std::ptr::replace(ptr, Ixon::Apps(f_box, a_box, xs));
+////                    }
+////                }
+////                IxonCase::Lams => {
+////                    let n = gen_range(g, 0..9);
+////                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+////                    ts.resize(n, Ixon::Vari(0));
+////                    for i in 0..n {
+////                        let p = unsafe { ts.as_mut_ptr().add(i) };
+////                        stack.push(p);
+////                    }
+////                    let mut b_box = Box::new(Ixon::default());
+////                    let b_ptr: *mut Ixon = &mut *b_box;
+////                    stack.push(b_ptr);
+////                    unsafe {
+////                        std::ptr::replace(ptr, Ixon::Lams(ts, b_box));
+////                    }
+////                }
+////                IxonCase::Alls => {
+////                    let n = gen_range(g, 0..9);
+////                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+////                    ts.resize(n, Ixon::Vari(0));
+////                    for i in 0..n {
+////                        let p = unsafe { ts.as_mut_ptr().add(i) };
+////                        stack.push(p);
+////                    }
+////                    let mut b_box = Box::new(Ixon::default());
+////                    let b_ptr: *mut Ixon = &mut *b_box;
+////                    stack.push(b_ptr);
+////                    unsafe {
+////                        std::ptr::replace(ptr, Ixon::Alls(ts, b_box));
+////                    }
+////                }
+////                IxonCase::LetE => {
+////                    let nd = bool::arbitrary(g);
+////                    let mut t_box = Box::new(Ixon::default());
+////                    let t_ptr: *mut Ixon = &mut *t_box;
+////                    stack.push(t_ptr);
+////                    let mut d_box = Box::new(Ixon::default());
+////                    let d_ptr: *mut Ixon = &mut *d_box;
+////                    stack.push(d_ptr);
+////                    let mut b_box = Box::new(Ixon::default());
+////                    let b_ptr: *mut Ixon = &mut *b_box;
+////                    stack.push(b_ptr);
+////                    unsafe {
+////                        ptr::replace(ptr, Ixon::LetE(nd, t_box, d_box, b_box));
+////                    }
+////                }
+////                IxonCase::Proj => {
+////                    let addr = Address::arbitrary(g);
+////                    let n = u64::arbitrary(g);
+////                    let mut t_box = Box::new(Ixon::default());
+////                    let t_ptr: *mut Ixon = &mut *t_box;
+////                    stack.push(t_ptr);
+////                    unsafe {
+////                        ptr::replace(ptr, Ixon::Proj(addr, n, t_box));
+////                    }
+////                }
+////                IxonCase::Strl => unsafe {
+////                    let size = gen_range(g, 0..9);
+////                    ptr::replace(ptr, Ixon::Strl(arbitrary_string(g, size)));
+////                },
+////                IxonCase::Natl => {
+////                    let size = gen_range(g, 0..9);
+////                    unsafe {
+////                        ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
+////                    }
+////                }
+////                IxonCase::List => {
+////                    let n = gen_range(g, 0..9);
+////                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
+////                    ts.resize(n, Ixon::Vari(0));
+////                    for i in 0..n {
+////                        let p = unsafe { ts.as_mut_ptr().add(i) };
+////                        stack.push(p);
+////                    }
+////                    unsafe {
+////                        std::ptr::replace(ptr, Ixon::List(ts));
+////                    }
+////                }
+////                IxonCase::Quot => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Quot(Quotient::arbitrary(g)));
+////                },
+////                IxonCase::Axio => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Axio(Axiom::arbitrary(g)));
+////                },
+////                IxonCase::Defn => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
+////                },
+////                IxonCase::CPrj => unsafe {
+////                    std::ptr::replace(ptr, Ixon::CPrj(ConstructorProj::arbitrary(g)));
+////                },
+////                IxonCase::RPrj => unsafe {
+////                    std::ptr::replace(ptr, Ixon::RPrj(RecursorProj::arbitrary(g)));
+////                },
+////                IxonCase::DPrj => unsafe {
+////                    std::ptr::replace(ptr, Ixon::DPrj(DefinitionProj::arbitrary(g)));
+////                },
+////                IxonCase::IPrj => unsafe {
+////                    std::ptr::replace(ptr, Ixon::IPrj(InductiveProj::arbitrary(g)));
+////                },
+////                IxonCase::Inds => unsafe {
+////                    let inds = gen_vec(g, 9, Inductive::arbitrary);
+////                    std::ptr::replace(ptr, Ixon::Inds(inds));
+////                },
+////                IxonCase::Defs => unsafe {
+////                    let defs = gen_vec(g, 9, Definition::arbitrary);
+////                    std::ptr::replace(ptr, Ixon::Defs(defs));
+////                },
+////                IxonCase::Meta => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
+////                },
+////                IxonCase::Prof => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Prof(Proof::arbitrary(g)));
+////                },
+////                IxonCase::Eval => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Eval(EvalClaim::arbitrary(g)));
+////                },
+////                IxonCase::Chck => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Chck(CheckClaim::arbitrary(g)));
+////                },
+////                IxonCase::Comm => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
+////                },
+////                IxonCase::Envn => unsafe {
+////                    std::ptr::replace(ptr, Ixon::Envn(Env::arbitrary(g)));
+////                },
+////            }
+////        }
+////        root
+////    }
+////
+////    impl Arbitrary for Ixon {
+////        fn arbitrary(g: &mut Gen) -> Self {
+////            let ctx: u64 = Arbitrary::arbitrary(g);
+////            arbitrary_ixon(g, ctx)
+////        }
+////    }
+////
+////    #[quickcheck]
+////    fn prop_ixon_readback(x: Ixon) -> bool {
+////        let mut buf = Vec::new();
+////        Ixon::put(&x, &mut buf);
+////        match Ixon::get(&mut buf.as_slice()) {
+////            Ok(y) => x == y,
+////            Err(e) => {
+////                println!("err: {e}");
+////                false
+////            }
+////        }
+////    }
+////
+////    /// Parse a hex string (optional `0x`/`0X` prefix, `_` separators OK) into bytes.
+////    pub fn parse_hex(s: &str) -> Result<Vec<u8>, String> {
+////        // Strip prefix, drop underscores, and require an even count of hex digits.
+////        let s = s.trim();
+////        let s = s
+////            .strip_prefix("0x")
+////            .or_else(|| s.strip_prefix("0X"))
+////            .unwrap_or(s);
+////        let clean: String = s.chars().filter(|&c| c != '_').collect();
+////
+////        if clean.len() % 2 != 0 {
+////            return Err("odd number of hex digits".into());
+////        }
+////
+////        // Parse each 2-char chunk as a byte.
+////        (0..clean.len())
+////            .step_by(2)
+////            .map(|i| {
+////                u8::from_str_radix(&clean[i..i + 2], 16)
+////                    .map_err(|_| format!("invalid hex at chars {}..{}", i, i + 2))
+////            })
+////            .collect()
+////    }
+////
+////    /// Format bytes as a lowercase hex string with a `0x` prefix.
+////    pub fn to_hex(bytes: &[u8]) -> String {
+////        let mut out = String::with_capacity(2 + bytes.len() * 2);
+////        out.push_str("0x");
+////        for b in bytes {
+////            // `{:02x}` = two lowercase hex digits, zero-padded.
+////            write!(&mut out, "{b:02x}").unwrap();
+////        }
+////        out
+////    }
+////
+////    #[test]
+////    fn unit_ixon() {
+////        fn test(input: Ixon, expected: &str) -> bool {
+////            let mut tmp = Vec::new();
+////            let expect = parse_hex(expected).unwrap();
+////            Serialize::put(&input, &mut tmp);
+////            if tmp != expect {
+////                println!(
+////                    "serialied {input:?} as:\n {}\n test expects:\n {}",
+////                    to_hex(&tmp),
+////                    to_hex(&expect),
+////                );
+////                return false;
+////            }
+////            match Serialize::get(&mut tmp.as_slice()) {
+////                Ok(output) => {
+////                    if input != output {
+////                        println!(
+////                            "deserialized {} as {output:?}, expected {input:?}",
+////                            to_hex(&tmp)
+////                        );
+////                        false
+////                    } else {
+////                        true
+////                    }
+////                }
+////                Err(e) => {
+////                    println!("err: {e}");
+////                    false
+////                }
+////            }
+////        }
+////        assert!(test(Ixon::Vari(0x0), "0x00"));
+////        assert!(test(Ixon::Vari(0x7), "0x07"));
+////        assert!(test(Ixon::Vari(0x8), "0x0808"));
+////        assert!(test(Ixon::Vari(0xff), "0x08FF"));
+////        assert!(test(Ixon::Vari(0x0100), "0x090001"));
+////        assert!(test(Ixon::Vari(0xFFFF), "0x09FFFF"));
+////        assert!(test(Ixon::Vari(0x010000), "0x0A000001"));
+////        assert!(test(Ixon::Vari(0xFFFFFF), "0x0AFFFFFF"));
+////        assert!(test(Ixon::Vari(0x01000000), "0x0B00000001"));
+////        assert!(test(Ixon::Vari(0xFFFFFFFF), "0x0BFFFFFFFF"));
+////        assert!(test(Ixon::Vari(0x0100000000), "0x0C0000000001"));
+////        assert!(test(Ixon::Vari(0xFFFFFFFFFF), "0x0CFFFFFFFFFF"));
+////        assert!(test(Ixon::Vari(0x010000000000), "0x0D000000000001"));
+////        assert!(test(Ixon::Vari(0xFFFFFFFFFFFF), "0x0DFFFFFFFFFFFF"));
+////        assert!(test(Ixon::Vari(0x01000000000000), "0x0E00000000000001"));
+////        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFF), "0x0EFFFFFFFFFFFFFF"));
+////        assert!(test(Ixon::Vari(0x0100000000000000), "0x0F0000000000000001"));
+////        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFFFF), "0x0FFFFFFFFFFFFFFFFF"));
+////        // universes use 2-bit sub-tags
+////        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x0))), "0x9000"));
+////        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x1F))), "0x901F"));
+////        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x20))), "0x902020"));
+////        assert!(test(Ixon::Sort(Box::new(Univ::Const(0xFF))), "0x9020FF"));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0x0100))),
+////            "0x90210001"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0xFFFF))),
+////            "0x9021FFFF"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0x010000))),
+////            "0x9022000001"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFF))),
+////            "0x9022FFFFFF"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0x01000000))),
+////            "0x902300000001"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFF))),
+////            "0x9023FFFFFFFF"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0x0100000000))),
+////            "0x90240000000001"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFF))),
+////            "0x9024FFFFFFFFFF"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0x010000000000))),
+////            "0x9025000000000001"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFF))),
+////            "0x9025FFFFFFFFFFFF"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0x01000000000000))),
+////            "0x902600000000000001"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFF))),
+////            "0x9026FFFFFFFFFFFFFF"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0x0100000000000000))),
+////            "0x90270000000000000001"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFFFF))),
+////            "0x9027FFFFFFFFFFFFFFFF"
+////        ));
+////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0))), "0x9040"));
+////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x1F))), "0x905F"));
+////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x20))), "0x906020"));
+////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0xFF))), "0x9060FF"));
+////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0100))), "0x90610001"));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Var(0xFFFFFFFFFFFFFFFF))),
+////            "0x9067FFFFFFFFFFFFFFFF"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Const(0x0))))),
+////            "0x908000"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Var(0x0))))),
+////            "0x908040"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Add(0x1F, Box::new(Univ::Var(0x0))))),
+////            "0x909F40"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Add(0x20, Box::new(Univ::Var(0x0))))),
+////            "0x90A02040"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Add(0xFF, Box::new(Univ::Var(0x0))))),
+////            "0x90A0FF40"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Add(
+////                0xFFFF_FFFF_FFFF_FFFF,
+////                Box::new(Univ::Var(0x0))
+////            ))),
+////            "0x90A7FFFFFFFFFFFFFFFF40"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Max(
+////                Box::new(Univ::Var(0x0)),
+////                Box::new(Univ::Var(0x0))
+////            ))),
+////            "0x90C04040"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Max(
+////                Box::new(Univ::Var(0x0)),
+////                Box::new(Univ::Var(0x1))
+////            ))),
+////            "0x90C04041"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Max(
+////                Box::new(Univ::Var(0x1)),
+////                Box::new(Univ::Var(0x0))
+////            ))),
+////            "0x90C04140"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::Max(
+////                Box::new(Univ::Var(0x1)),
+////                Box::new(Univ::Var(0x1))
+////            ))),
+////            "0x90C04141"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::IMax(
+////                Box::new(Univ::Var(0x0)),
+////                Box::new(Univ::Var(0x0))
+////            ))),
+////            "0x90C14040"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::IMax(
+////                Box::new(Univ::Var(0x0)),
+////                Box::new(Univ::Var(0x1))
+////            ))),
+////            "0x90C14041"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::IMax(
+////                Box::new(Univ::Var(0x1)),
+////                Box::new(Univ::Var(0x0))
+////            ))),
+////            "0x90C14140"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::IMax(
+////                Box::new(Univ::Var(0x1)),
+////                Box::new(Univ::Var(0x1))
+////            ))),
+////            "0x90C14141"
+////        ));
+////        assert!(test(
+////            Ixon::Sort(Box::new(Univ::IMax(
+////                Box::new(Univ::Var(0x1)),
+////                Box::new(Univ::Var(0x1))
+////            ))),
+////            "0x90C14141"
+////        ));
+////        assert!(test(
+////            Ixon::Refr(Address::hash(&[]), vec![]),
+////            "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::Refr(Address::hash(&[]), vec![Univ::Var(0x0)]),
+////            "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240"
+////        ));
+////        assert!(test(Ixon::Recr(0x0, vec![Univ::Var(0x0)]), "0x20A140"));
+////        assert!(test(
+////            Ixon::Recr(0x0, vec![Univ::Var(0x0), Univ::Var(0x1)]),
+////            "0x20A24041"
+////        ));
+////        assert!(test(
+////            Ixon::Recr(0x8, vec![Univ::Var(0x0), Univ::Var(0x1)]),
+////            "0x2808A24041"
+////        ));
+////        assert!(test(
+////            Ixon::Apps(Box::new(Ixon::Vari(0x0)), Box::new(Ixon::Vari(0x1)), vec![]),
+////            "0x300001"
+////        ));
+////        assert!(test(
+////            Ixon::Apps(
+////                Box::new(Ixon::Vari(0x0)),
+////                Box::new(Ixon::Vari(0x1)),
+////                vec![Ixon::Vari(0x2)]
+////            ),
+////            "0x31000102"
+////        ));
+////        assert!(test(
+////            Ixon::Apps(
+////                Box::new(Ixon::Vari(0x0)),
+////                Box::new(Ixon::Vari(0x1)),
+////                vec![
+////                    Ixon::Vari(0x2),
+////                    Ixon::Vari(0x3),
+////                    Ixon::Vari(0x4),
+////                    Ixon::Vari(0x5),
+////                    Ixon::Vari(0x6),
+////                    Ixon::Vari(0x7),
+////                    Ixon::Vari(0x8),
+////                    Ixon::Vari(0x9),
+////                ]
+////            ),
+////            "0x3808000102030405060708080809"
+////        ));
+////        assert!(test(
+////            Ixon::Lams(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
+////            "0x410001"
+////        ));
+////        assert!(test(
+////            Ixon::Lams(
+////                vec![
+////                    Ixon::Vari(0x0),
+////                    Ixon::Vari(0x1),
+////                    Ixon::Vari(0x2),
+////                    Ixon::Vari(0x3),
+////                    Ixon::Vari(0x4),
+////                    Ixon::Vari(0x5),
+////                    Ixon::Vari(0x6),
+////                    Ixon::Vari(0x7)
+////                ],
+////                Box::new(Ixon::Vari(0x8))
+////            ),
+////            "0x480800010203040506070808"
+////        ));
+////        assert!(test(
+////            Ixon::Alls(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
+////            "0x510001"
+////        ));
+////        assert!(test(
+////            Ixon::Alls(
+////                vec![
+////                    Ixon::Vari(0x0),
+////                    Ixon::Vari(0x1),
+////                    Ixon::Vari(0x2),
+////                    Ixon::Vari(0x3),
+////                    Ixon::Vari(0x4),
+////                    Ixon::Vari(0x5),
+////                    Ixon::Vari(0x6),
+////                    Ixon::Vari(0x7)
+////                ],
+////                Box::new(Ixon::Vari(0x8))
+////            ),
+////            "0x580800010203040506070808"
+////        ));
+////        assert!(test(
+////            Ixon::Proj(Address::hash(&[]), 0x0, Box::new(Ixon::Vari(0x0))),
+////            "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
+////        ));
+////        assert!(test(
+////            Ixon::Proj(Address::hash(&[]), 0x8, Box::new(Ixon::Vari(0x0))),
+////            "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
+////        ));
+////        assert!(test(Ixon::Strl("".to_string()), "0x70"));
+////        assert!(test(Ixon::Strl("foobar".to_string()), "0x76666f6f626172"));
+////        assert!(test(Ixon::Natl(Nat::new_le(&[])), "0x8100"));
+////        assert!(test(Ixon::Natl(Nat::new_le(&[0x0])), "0x8100"));
+////        assert!(test(Ixon::Natl(Nat::new_le(&[0xFF])), "0x81FF"));
+////        assert!(test(Ixon::Natl(Nat::new_le(&[0x00, 0x01])), "0x820001"));
+////        assert!(test(
+////            Ixon::LetE(
+////                true,
+////                Box::new(Ixon::Vari(0x0)),
+////                Box::new(Ixon::Vari(0x1)),
+////                Box::new(Ixon::Vari(0x2))
+////            ),
+////            "0x91000102"
+////        ));
+////        assert!(test(Ixon::List(vec![]), "0xA0"));
+////        assert!(test(
+////            Ixon::List(vec![Ixon::Vari(0x0), Ixon::Vari(0x1), Ixon::Vari(0x2)]),
+////            "0xA3000102"
+////        ));
+////        assert!(test(
+////            Ixon::Defn(Definition {
+////                kind: DefKind::Definition,
+////                safety: DefSafety::Unsafe,
+////                lvls: 0u64.into(),
+////                typ: Address::hash(&[]),
+////                value: Address::hash(&[]),
+////            }),
+////            "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::Defn(Definition {
+////                kind: DefKind::Opaque,
+////                safety: DefSafety::Safe,
+////                lvls: 1u64.into(),
+////                typ: Address::hash(&[]),
+////                value: Address::hash(&[]),
+////            }),
+////            "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::Axio(Axiom {
+////                is_unsafe: true,
+////                lvls: 0u64.into(),
+////                typ: Address::hash(&[]),
+////            }),
+////            "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::Quot(Quotient {
+////                kind: QuotKind::Type,
+////                lvls: 0u64.into(),
+////                typ: Address::hash(&[]),
+////            }),
+////            "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::CPrj(ConstructorProj {
+////                idx: 0u64.into(),
+////                cidx: 0u64.into(),
+////                block: Address::hash(&[]),
+////            }),
+////            "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::RPrj(RecursorProj {
+////                idx: 0u64.into(),
+////                ridx: 0u64.into(),
+////                block: Address::hash(&[]),
+////            }),
+////            "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::IPrj(InductiveProj {
+////                idx: 0u64.into(),
+////                block: Address::hash(&[]),
+////            }),
+////            "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::DPrj(DefinitionProj {
+////                idx: 0u64.into(),
+////                block: Address::hash(&[]),
+////            }),
+////            "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(Ixon::Inds(vec![]), "0xC0"));
+////        assert!(test(
+////            Ixon::Inds(vec![Inductive {
+////                recr: false,
+////                refl: false,
+////                is_unsafe: false,
+////                lvls: 0u64.into(),
+////                params: 0u64.into(),
+////                indices: 0u64.into(),
+////                nested: 0u64.into(),
+////                typ: Address::hash(&[]),
+////                ctors: vec![],
+////                recrs: vec![],
+////            }]),
+////            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
+////        ));
+////        assert!(test(
+////            Ixon::Inds(vec![Inductive {
+////                recr: false,
+////                refl: false,
+////                is_unsafe: false,
+////                lvls: 0u64.into(),
+////                params: 0u64.into(),
+////                indices: 0u64.into(),
+////                nested: 0u64.into(),
+////                typ: Address::hash(&[]),
+////                ctors: vec![],
+////                recrs: vec![],
+////            }]),
+////            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
+////        ));
+////        assert!(test(
+////            Ixon::Inds(vec![Inductive {
+////                recr: false,
+////                refl: false,
+////                is_unsafe: false,
+////                lvls: 0u64.into(),
+////                params: 0u64.into(),
+////                indices: 0u64.into(),
+////                nested: 0u64.into(),
+////                typ: Address::hash(&[]),
+////                ctors: vec![Constructor {
+////                    is_unsafe: false,
+////                    lvls: 0u64.into(),
+////                    cidx: 0u64.into(),
+////                    params: 0u64.into(),
+////                    fields: 0u64.into(),
+////                    typ: Address::hash(&[])
+////                }],
+////                recrs: vec![Recursor {
+////                    k: false,
+////                    is_unsafe: false,
+////                    lvls: 0u64.into(),
+////                    params: 0u64.into(),
+////                    indices: 0u64.into(),
+////                    motives: 0u64.into(),
+////                    minors: 0u64.into(),
+////                    typ: Address::hash(&[]),
+////                    rules: vec![RecursorRule {
+////                        fields: 0u64.into(),
+////                        rhs: Address::hash(&[])
+////                    }]
+////                }],
+////            }]),
+////            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(Ixon::Defs(vec![]), "0xD0"));
+////        assert!(test(
+////            Ixon::Defs(vec![Definition {
+////                kind: DefKind::Definition,
+////                safety: DefSafety::Unsafe,
+////                lvls: 0u64.into(),
+////                typ: Address::hash(&[]),
+////                value: Address::hash(&[]),
+////            }]),
+////            "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(Ixon::Meta(Metadata { map: vec![] }), "0xE0A0"));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(0u64.into(), vec![])]
+////            }),
+////            "0xE0A18100A0"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(0u64.into(), vec![Metadatum::Name(Name { parts: vec![] })])]
+////            }),
+////            "0xE0A18100A100A0"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(
+////                    0u64.into(),
+////                    vec![Metadatum::Name(Name {
+////                        parts: vec![NamePart::Str("a".to_string())]
+////                    })]
+////                )]
+////            }),
+////            "0xE0A18100A100A17161"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(
+////                    0u64.into(),
+////                    vec![Metadatum::Name(Name {
+////                        parts: vec![
+////                            NamePart::Str("a".to_string()),
+////                            NamePart::Str("b".to_string()),
+////                        ]
+////                    })]
+////                )]
+////            }),
+////            "0xE0A18100A100A271617162"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(
+////                    0u64.into(),
+////                    vec![Metadatum::Name(Name {
+////                        parts: vec![
+////                            NamePart::Str("a".to_string()),
+////                            NamePart::Str("b".to_string()),
+////                            NamePart::Str("c".to_string()),
+////                        ]
+////                    })]
+////                )]
+////            }),
+////            "0xE0A18100A100A3716171627163"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(
+////                    0u64.into(),
+////                    vec![Metadatum::Name(Name {
+////                        parts: vec![NamePart::Num(165851424810452359u64.into())]
+////                    })]
+////                )]
+////            }),
+////            "0xE0A18100A100A1880887C551FDFD384D02"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(0u64.into(), vec![Metadatum::Info(BinderInfo::Default)])]
+////            }),
+////            "0xE0A18100A10100"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(0u64.into(), vec![Metadatum::Link(Address::hash(&[]))])]
+////            }),
+////            "0xE0A18100A102af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(
+////                    0u64.into(),
+////                    vec![
+////                        Metadatum::Name(Name {
+////                            parts: vec![NamePart::Str("d".to_string())]
+////                        }),
+////                        Metadatum::Link(Address::hash(&[])),
+////                        Metadatum::Hints(ReducibilityHints::Regular(576554452)),
+////                        Metadatum::Link(Address::hash(&[]))
+////                    ]
+////                )]
+////            }),
+////            "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(
+////                    0u64.into(),
+////                    vec![Metadatum::Hints(ReducibilityHints::Opaque)]
+////                )]
+////            }),
+////            "0xE0A18100A10300"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(0u64.into(), vec![Metadatum::All(vec![])])]
+////            }),
+////            "0xE0A18100A104A0"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(0u64.into(), vec![Metadatum::MutCtx(vec![])])]
+////            }),
+////            "0xE0A18100A105A0"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![(
+////                    0u64.into(),
+////                    vec![Metadatum::Hints(ReducibilityHints::Regular(42))]
+////                )]
+////            }),
+////            "0xe0a18100a103022a000000"
+////        ));
+////        assert!(test(
+////            Ixon::Meta(Metadata {
+////                map: vec![
+////                    (
+////                        0u64.into(),
+////                        vec![
+////                            Metadatum::Name(Name {
+////                                parts: vec![NamePart::Str("d".to_string())]
+////                            }),
+////                            Metadatum::Link(Address::hash(&[])),
+////                            Metadatum::Hints(ReducibilityHints::Regular(576554452)),
+////                            Metadatum::Link(Address::hash(&[]))
+////                        ]
+////                    ),
+////                    (
+////                        1u64.into(),
+////                        vec![
+////                            Metadatum::Info(BinderInfo::InstImplicit),
+////                            Metadatum::Info(BinderInfo::InstImplicit),
+////                            Metadatum::Info(BinderInfo::StrictImplicit),
+////                        ]
+////                    ),
+////                    (
+////                        2u64.into(),
+////                        vec![
+////                            Metadatum::All(vec![Name {
+////                                parts: vec![NamePart::Num(165851424810452359u64.into())]
+////                            }]),
+////                            Metadatum::Info(BinderInfo::Default)
+////                        ]
+////                    ),
+////                    (3u64.into(), vec![]),
+////                    (4u64.into(), vec![]),
+////                    (
+////                        5u64.into(),
+////                        vec![Metadatum::Hints(ReducibilityHints::Opaque)]
+////                    ),
+////                    (
+////                        6u64.into(),
+////                        vec![Metadatum::Name(Name {
+////                            parts: vec![NamePart::Num(871843802607008850u64.into())]
+////                        })]
+////                    )
+////                ]
+////            }),
+////            "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
+////        ));
+////    }
 ////}
+////
+//////}
diff --git a/src/ixon/address.rs b/src/ixon/address.rs
index ca9d50fc..17f93f19 100644
--- a/src/ixon/address.rs
+++ b/src/ixon/address.rs
@@ -1,64 +1,47 @@
-use crate::ixon::serialize::Serialize;
 use blake3::Hash;
 use std::cmp::{Ordering, PartialOrd};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Address {
-    pub hash: Hash,
+  pub hash: Hash,
 }
 
 impl Address {
-    pub fn hash(input: &[u8]) -> Self {
-        Address {
-            hash: blake3::hash(input),
-        }
-    }
-}
-
-impl Serialize for Address {
-    fn put(&self, buf: &mut Vec<u8>) {
-        buf.extend_from_slice(self.hash.as_bytes())
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(32) {
-            Some((head, rest)) => {
-                *buf = rest;
-                Ok(Address {
-                    hash: Hash::from_slice(head).unwrap(),
-                })
-            }
-            None => Err("get Address out of input".to_string()),
-        }
-    }
+  pub fn hash(input: &[u8]) -> Self {
+    Address { hash: blake3::hash(input) }
+  }
 }
 
 impl Ord for Address {
-    fn cmp(&self, other: &Address) -> Ordering {
-        self.hash.as_bytes().cmp(other.hash.as_bytes())
-    }
+  fn cmp(&self, other: &Address) -> Ordering {
+    self.hash.as_bytes().cmp(other.hash.as_bytes())
+  }
 }
 
 impl PartialOrd for Address {
-    fn partial_cmp(&self, other: &Address) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
+  fn partial_cmp(&self, other: &Address) -> Option<Ordering> {
+    Some(self.cmp(other))
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MetaAddress {
+  pub data: Address,
+  pub meta: Address,
 }
 
 #[cfg(test)]
 pub mod tests {
-    use super::*;
-    use quickcheck::{Arbitrary, Gen};
-
-    impl Arbitrary for Address {
-        fn arbitrary(g: &mut Gen) -> Self {
-            let mut bytes = [0u8; 32];
-            for b in &mut bytes {
-                *b = u8::arbitrary(g);
-            }
-            Address {
-                hash: Hash::from_slice(&bytes).unwrap(),
-            }
-        }
+  use super::*;
+  use quickcheck::{Arbitrary, Gen};
+
+  impl Arbitrary for Address {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let mut bytes = [0u8; 32];
+      for b in &mut bytes {
+        *b = u8::arbitrary(g);
+      }
+      Address { hash: Hash::from_slice(&bytes).unwrap() }
     }
+  }
 }
diff --git a/src/ixon/nat.rs b/src/ixon/nat.rs
deleted file mode 100644
index a4f55e9a..00000000
--- a/src/ixon/nat.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//use crate::ixon::serialize::Serialize;
-//use crate::ixon::*;
-use num_bigint::BigUint;
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Nat(pub BigUint);
-
-impl Nat {
-    pub fn new_le(bytes: &[u8]) -> Self {
-        Nat(BigUint::from_bytes_le(bytes))
-    }
-}
-
-//impl Serialize for Nat {
-//    fn put(&self, buf: &mut Vec<u8>) {
-//        Ixon::Natl(self.clone()).put(buf)
-//    }
-//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-//        match Ixon::get(buf) {
-//            Ok(Ixon::Natl(x)) => Ok(x),
-//            Ok(x) => Err(format!("get Nat invalid {x:?}")),
-//            Err(e) => Err(e),
-//        }
-//    }
-//}
-//
-impl<T> From<T> for Nat
-where
-    T: Into<BigUint>,
-{
-    fn from(x: T) -> Self {
-        Nat(x.into())
-    }
-}
-//
-//#[cfg(test)]
-//pub mod tests {
-//    use super::*;
-//    use crate::ixon::tests::gen_range;
-//    use quickcheck::{Arbitrary, Gen};
-//
-//    pub fn arbitrary_nat(g: &mut Gen, size: usize) -> Nat {
-//        let mut bytes = vec![];
-//
-//        let b = u8::arbitrary(g);
-//
-//        if b == 0 {
-//            bytes.push(b + 1);
-//        } else {
-//            bytes.push(b);
-//        }
-//
-//        for _ in 0..size {
-//            bytes.push(u8::arbitrary(g));
-//        }
-//
-//        Nat(BigUint::from_bytes_be(&bytes))
-//    }
-//
-//    impl Arbitrary for Nat {
-//        fn arbitrary(g: &mut Gen) -> Self {
-//            let size = gen_range(g, 0..4);
-//            arbitrary_nat(g, size)
-//        }
-//    }
-//}
diff --git a/src/ixon/serialize.rs b/src/ixon/serialize.rs
deleted file mode 100644
index 835cf7df..00000000
--- a/src/ixon/serialize.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-//use crate::ixon::*;
-
-pub trait Serialize: Sized {
-    fn put(&self, buf: &mut Vec<u8>);
-    fn get(buf: &mut &[u8]) -> Result<Self, String>;
-}
-
-impl Serialize for u8 {
-    fn put(&self, buf: &mut Vec<u8>) {
-        buf.push(*self)
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_first() {
-            Some((&x, rest)) => {
-                *buf = rest;
-                Ok(x)
-            }
-            None => Err("get u8 EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for u16 {
-    fn put(&self, buf: &mut Vec<u8>) {
-        buf.extend_from_slice(&self.to_le_bytes());
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(2) {
-            Some((head, rest)) => {
-                *buf = rest;
-                Ok(u16::from_le_bytes([head[0], head[1]]))
-            }
-            None => Err("get u16 EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for u32 {
-    fn put(&self, buf: &mut Vec<u8>) {
-        buf.extend_from_slice(&self.to_le_bytes());
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(4) {
-            Some((head, rest)) => {
-                *buf = rest;
-                Ok(u32::from_le_bytes([head[0], head[1], head[2], head[3]]))
-            }
-            None => Err("get u32 EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for u64 {
-    fn put(&self, buf: &mut Vec<u8>) {
-        buf.extend_from_slice(&self.to_le_bytes());
-    }
-
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(8) {
-            Some((head, rest)) => {
-                *buf = rest;
-                Ok(u64::from_le_bytes([
-                    head[0], head[1], head[2], head[3], head[4], head[5], head[6], head[7],
-                ]))
-            }
-            None => Err("get u64 EOF".to_string()),
-        }
-    }
-}
-
-impl Serialize for bool {
-    fn put(&self, buf: &mut Vec<u8>) {
-        match self {
-            false => buf.push(0),
-            true => buf.push(1),
-        }
-    }
-    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-        match buf.split_at_checked(1) {
-            Some((head, rest)) => {
-                *buf = rest;
-                match head[0] {
-                    0 => Ok(false),
-                    1 => Ok(true),
-                    x => Err(format!("get bool invalid {x}")),
-                }
-            }
-            None => Err("get bool EOF".to_string()),
-        }
-    }
-}
-
-//impl<S: Serialize> Serialize for Vec<S> {
-//    fn put(&self, buf: &mut Vec<u8>) {
-//        Ixon::put_array(self, buf)
-//    }
-//
-//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-//        Ixon::get_array(buf)
-//    }
-//}
-//
-//impl<X: Serialize, Y: Serialize> Serialize for (X, Y) {
-//    fn put(&self, buf: &mut Vec<u8>) {
-//        Serialize::put(&self.0, buf);
-//        Serialize::put(&self.1, buf);
-//    }
-//
-//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-//        let x = Serialize::get(buf)?;
-//        let y = Serialize::get(buf)?;
-//        Ok((x, y))
-//    }
-//}
diff --git a/src/ixon/tag.rs b/src/ixon/tag.rs
deleted file mode 100644
index 37731901..00000000
--- a/src/ixon/tag.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-use crate::ixon::serialize::Serialize;
-
-pub fn u64_byte_count(x: u64) -> u8 {
-  match x {
-    0 => 0,
-    x if x < 0x0000000000000100 => 1,
-    x if x < 0x0000000000010000 => 2,
-    x if x < 0x0000000001000000 => 3,
-    x if x < 0x0000000100000000 => 4,
-    x if x < 0x0000010000000000 => 5,
-    x if x < 0x0001000000000000 => 6,
-    x if x < 0x0100000000000000 => 7,
-    _ => 8,
-  }
-}
-
-pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
-  let n = u64_byte_count(x) as usize;
-  buf.extend_from_slice(&x.to_le_bytes()[..n])
-}
-
-pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
-  let mut res = [0u8; 8];
-  if len > 8 {
-    return Err("get trimmed_le_64 len > 8".to_string());
-  }
-  match buf.split_at_checked(len) {
-    Some((head, rest)) => {
-      *buf = rest;
-      res[..len].copy_from_slice(head);
-      Ok(u64::from_le_bytes(res))
-    },
-    None => Err("get trimmed_le_u64 EOF".to_string()),
-  }
-}
-
-//  F := flag, L := large-bit, X := small-field, A := large_field
-// 0xFFLX_XXXX {AAAA_AAAA, ...}
-#[derive(Clone, Debug)]
-pub struct Tag2 {
-  flag: u8,
-  size: u64,
-}
-
-impl Tag2 {
-  pub fn encode_head(&self) -> u8 {
-    if self.size < 32 {
-      (self.flag << 6) + (self.size as u8)
-    } else {
-      (self.flag << 6) + 0b10_0000 + u64_byte_count(self.size) - 1
-    }
-  }
-  pub fn decode_head(head: u8) -> (u8, bool, u8) {
-    (head >> 6, head & 0b10_0000 == 0, head % 0b10_0000)
-  }
-}
-
-impl Serialize for Tag2 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.encode_head().put(buf);
-    if self.size >= 32 {
-      u64_put_trimmed_le(self.size, buf)
-    }
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let head = u8::get(buf)?;
-    let (flag, large, small) = Tag2::decode_head(head);
-    let size = if large {
-      u64_get_trimmed_le((small + 1) as usize, buf)?
-    } else {
-      small as u64
-    };
-    Ok(Tag2 { flag, size })
-  }
-}
-
-//  F := flag, L := large-bit, X := small-field, A := large_field
-// 0xFFFF_LXXX {AAAA_AAAA, ...}
-// "Tag" means the whole thing
-// "Head" means the first byte of the tag
-// "Flag" means the first nibble of the head
-#[derive(Clone, Debug)]
-pub struct Tag4 {
-  flag: u8,
-  size: u64,
-}
-
-impl Tag4 {
-  pub fn encode_head(&self) -> u8 {
-    if self.size < 8 {
-      (self.flag << 4) + (self.size as u8)
-    } else {
-      (self.flag << 4) + 0b1000 + u64_byte_count(self.size) - 1
-    }
-  }
-  pub fn decode_head(head: u8) -> (u8, bool, u8) {
-    (head >> 4, head & 0b1000 == 0, head % 0b1000)
-  }
-}
-
-impl Serialize for Tag4 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.encode_head().put(buf);
-    if self.size >= 8 {
-      u64_put_trimmed_le(self.size, buf)
-    }
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let head = u8::get(buf)?;
-    let (flag, large, small) = Tag4::decode_head(head);
-    let size = if large {
-      u64_get_trimmed_le((small + 1) as usize, buf)?
-    } else {
-      small as u64
-    };
-    Ok(Tag4 { flag, size })
-  }
-}
diff --git a/src/lean/nat.rs b/src/lean/nat.rs
index a8900a7f..87067b61 100644
--- a/src/lean/nat.rs
+++ b/src/lean/nat.rs
@@ -3,34 +3,40 @@ use std::ffi::c_void;
 use num_bigint::BigUint;
 
 use crate::{
-    lean::{as_ref_unsafe, lean_is_scalar, object::LeanObject},
-    lean_unbox,
+  lean::{as_ref_unsafe, lean_is_scalar, object::LeanObject},
+  lean_unbox,
 };
 
 #[derive(Hash, PartialEq, Eq, Debug, Clone, PartialOrd, Ord)]
-pub struct Nat(BigUint);
+pub struct Nat(pub BigUint);
 
 impl Nat {
-    pub fn from_ptr(ptr: *const c_void) -> Nat {
-        if lean_is_scalar(ptr) {
-            let u = lean_unbox!(usize, ptr);
-            Nat(BigUint::from_bytes_le(&u.to_le_bytes()))
-        } else {
-            // Heap-allocated big integer (mpz_object)
-            let obj: &MpzObject = as_ref_unsafe(ptr.cast());
-            Nat(obj.m_value.to_biguint())
-        }
+  pub fn from_ptr(ptr: *const c_void) -> Nat {
+    if lean_is_scalar(ptr) {
+      let u = lean_unbox!(usize, ptr);
+      Nat(BigUint::from_bytes_le(&u.to_le_bytes()))
+    } else {
+      // Heap-allocated big integer (mpz_object)
+      let obj: &MpzObject = as_ref_unsafe(ptr.cast());
+      Nat(obj.m_value.to_biguint())
     }
+  }
 
-    #[inline]
-    pub fn from_le_bytes(bytes: &[u8]) -> Nat {
-        Nat(BigUint::from_bytes_le(bytes))
-    }
+  #[inline]
+  pub fn from_le_bytes(bytes: &[u8]) -> Nat {
+    Nat(BigUint::from_bytes_le(bytes))
+  }
 
-    #[inline]
-    pub fn to_le_bytes(&self) -> Vec<u8> {
-        self.0.to_bytes_le()
-    }
+  #[inline]
+  pub fn to_le_bytes(&self) -> Vec<u8> {
+    self.0.to_bytes_le()
+  }
+}
+
+#[derive(Hash, PartialEq, Eq, Debug, Clone, PartialOrd, Ord)]
+pub enum Int {
+  OfNat(Nat),
+  NegSucc(Nat),
 }
 
 /// From https://github.com/leanprover/lean4/blob/master/src/runtime/object.h:
@@ -44,25 +50,26 @@ impl Nat {
 /// ```
 #[repr(C)]
 struct MpzObject {
-    m_header: LeanObject,
-    m_value: Mpz,
+  m_header: LeanObject,
+  m_value: Mpz,
 }
 
 #[repr(C)]
 struct Mpz {
-    alloc: i32,
-    size: i32,
-    d: *const u64,
+  alloc: i32,
+  size: i32,
+  d: *const u64,
 }
 
 impl Mpz {
-    fn to_biguint(&self) -> BigUint {
-        let nlimbs = self.size.unsigned_abs() as usize;
-        let limbs = unsafe { std::slice::from_raw_parts(self.d, nlimbs) };
+  fn to_biguint(&self) -> BigUint {
+    let nlimbs = self.size.unsigned_abs() as usize;
+    let limbs = unsafe { std::slice::from_raw_parts(self.d, nlimbs) };
 
-        // Convert limbs (little-endian by limb)
-        let bytes: Vec<_> = limbs.iter().flat_map(|&limb| limb.to_le_bytes()).collect();
+    // Convert limbs (little-endian by limb)
+    let bytes: Vec<_> =
+      limbs.iter().flat_map(|&limb| limb.to_le_bytes()).collect();
 
-        BigUint::from_bytes_le(&bytes)
-    }
+    BigUint::from_bytes_le(&bytes)
+  }
 }

From ef21680984f07d58050471eaf5a4c02278657016 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 28 Oct 2025 18:15:51 -0400
Subject: [PATCH 69/74] ixon serialization testing

---
 src/ixon.rs         | 2139 ++++++++++++++++---------------------------
 src/ixon/address.rs |    5 +
 src/lib.rs          |   14 +-
 3 files changed, 803 insertions(+), 1355 deletions(-)

diff --git a/src/ixon.rs b/src/ixon.rs
index 10d3b151..8ded6ff6 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -130,7 +130,7 @@ pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
       res[..len].copy_from_slice(head);
       Ok(u64::from_le_bytes(res))
     },
-    None => Err("get trimmed_le_u64 EOF".to_string()),
+    None => Err(format!("get trimmed_le_u64 EOF {len} {buf:?}")),
   }
 }
 
@@ -139,7 +139,7 @@ pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
 // "Tag" means the whole thing
 // "Head" means the first byte of the tag
 // "Flag" means the first nibble of the head
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Tag4 {
   flag: u8,
   size: u64,
@@ -150,11 +150,11 @@ impl Tag4 {
     if self.size < 8 {
       (self.flag << 4) + (self.size as u8)
     } else {
-      (self.flag << 4) + 0b1000 + u64_byte_count(self.size) - 1
+      (self.flag << 4) + 0b1000 + (u64_byte_count(self.size) - 1)
     }
   }
   pub fn decode_head(head: u8) -> (u8, bool, u8) {
-    (head >> 4, head & 0b1000 == 0, head % 0b1000)
+    (head >> 4, head & 0b1000 != 0, head % 0b1000)
   }
 }
 
@@ -176,6 +176,8 @@ impl Serialize for Tag4 {
     Ok(Tag4 { flag, size })
   }
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ByteArray(pub Vec<u8>);
 
 impl Serialize for ByteArray {
@@ -371,7 +373,7 @@ impl Serialize for BinderInfo {
       Self::Implicit => buf.push(1),
       Self::StrictImplicit => buf.push(2),
       Self::InstImplicit => buf.push(3),
-      Self::AuxDecl => buf.push(3),
+      Self::AuxDecl => buf.push(4),
     }
   }
 
@@ -1315,7 +1317,7 @@ pub struct Metadata {
 
 impl Serialize for Metadata {
   fn put(&self, buf: &mut Vec<u8>) {
-    Tag4 { flag: 0x4, size: self.nodes.len() as u64 }.put(buf);
+    Tag4 { flag: 0xF, size: self.nodes.len() as u64 }.put(buf);
     for n in self.nodes.iter() {
       n.put(buf)
     }
@@ -1336,8 +1338,6 @@ impl Serialize for Metadata {
   }
 }
 
-// TODO: Update Ixon
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Ixon {
   NAnon,                                 // 0x00, anonymous name
@@ -1565,10 +1565,7 @@ impl Serialize for Ixon {
         Self::put_tag(0xE, 5, buf);
         x.put(buf);
       },
-      Self::Meta(x) => {
-        Self::put_tag(0xE, 5, buf);
-        x.put(buf);
-      },
+      Self::Meta(x) => x.put(buf),
     }
   }
   fn get(buf: &mut &[u8]) -> Result<Self, String> {
@@ -1593,16 +1590,21 @@ impl Serialize for Ixon {
         let bytes: Vec<u8> = Self::gets(size, buf)?;
         Ok(Self::UVar(Nat::from_le_bytes(&bytes)))
       },
-      Tag4 { flag: 0x3, size } => {
+      Tag4 { flag: 0x2, size } => {
         let bytes: Vec<u8> = Self::gets(size, buf)?;
         Ok(Self::EVar(Nat::from_le_bytes(&bytes)))
       },
-      Tag4 { flag: 0x4, size } => {
+      Tag4 { flag: 0x3, size } => {
         Ok(Self::ERef(Address::get(buf)?, Self::gets(size, buf)?))
       },
-      Tag4 { flag: 0x5, size } => {
+      Tag4 { flag: 0x4, size } => {
         Ok(Self::ERec(Nat::get(buf)?, Self::gets(size, buf)?))
       },
+      Tag4 { flag: 0x5, size } => Ok(Self::EPrj(
+        Address::get(buf)?,
+        Nat::from_le_bytes(&Self::gets(size, buf)?),
+        Address::get(buf)?,
+      )),
       Tag4 { flag: 0x8, size: 0 } => Ok(Self::ESort(Address::get(buf)?)),
       Tag4 { flag: 0x8, size: 1 } => Ok(Self::EStr(Address::get(buf)?)),
       Tag4 { flag: 0x8, size: 2 } => Ok(Self::ENat(Address::get(buf)?)),
@@ -1657,1336 +1659,777 @@ impl Serialize for Ixon {
     }
   }
 }
-//
-////impl Serialize for Ixon {
-////    fn put(&self, buf: &mut Vec<u8>) {
-////        match self {
-////            Self::Vari(x) => Self::put_tag(0x0, *x, buf),
-////            Self::Sort(x) => {
-////                u8::put(&0x90, buf);
-////                x.put(buf);
-////            }
-////            Self::Refr(addr, lvls) => {
-////                Self::put_tag(0x1, lvls.len() as u64, buf);
-////                addr.put(buf);
-////                for l in lvls {
-////                    l.put(buf);
-////                }
-////            }
-////            Self::Recr(x, lvls) => {
-////                Self::put_tag(0x2, *x, buf);
-////                Ixon::put_array(lvls, buf);
-////            }
-////            Self::Apps(f, a, args) => {
-////                Self::put_tag(0x3, args.len() as u64, buf);
-////                f.put(buf);
-////                a.put(buf);
-////                for x in args {
-////                    x.put(buf);
-////                }
-////            }
-////            Self::Lams(ts, b) => {
-////                Self::put_tag(0x4, ts.len() as u64, buf);
-////                for t in ts {
-////                    t.put(buf);
-////                }
-////                b.put(buf);
-////            }
-////            Self::Alls(ts, b) => {
-////                Self::put_tag(0x5, ts.len() as u64, buf);
-////                for t in ts {
-////                    t.put(buf);
-////                }
-////                b.put(buf);
-////            }
-////            Self::Proj(t, n, x) => {
-////                Self::put_tag(0x6, *n, buf);
-////                t.put(buf);
-////                x.put(buf);
-////            }
-////            Self::Strl(s) => {
-////                let bytes = s.as_bytes();
-////                Self::put_tag(0x7, bytes.len() as u64, buf);
-////                buf.extend_from_slice(bytes);
-////            }
-////            Self::Natl(n) => {
-////                let bytes = n.0.to_bytes_le();
-////                Self::put_tag(0x8, bytes.len() as u64, buf);
-////                buf.extend_from_slice(&bytes);
-////            }
-////            Self::LetE(nd, t, d, b) => {
-////                if *nd {
-////                    u8::put(&0x91, buf);
-////                } else {
-////                    u8::put(&0x92, buf);
-////                }
-////                t.put(buf);
-////                d.put(buf);
-////                b.put(buf);
-////            }
-////            Self::List(xs) => Ixon::put_array(xs, buf),
-////            Self::Defn(x) => {
-////                u8::put(&0xB0, buf);
-////                x.put(buf);
-////            }
-////            Self::Axio(x) => {
-////                u8::put(&0xB1, buf);
-////                x.put(buf);
-////            }
-////            Self::Quot(x) => {
-////                u8::put(&0xB2, buf);
-////                x.put(buf);
-////            }
-////            Self::CPrj(x) => {
-////                u8::put(&0xB3, buf);
-////                x.put(buf);
-////            }
-////            Self::RPrj(x) => {
-////                u8::put(&0xB4, buf);
-////                x.put(buf);
-////            }
-////            Self::IPrj(x) => {
-////                u8::put(&0xB5, buf);
-////                x.put(buf);
-////            }
-////            Self::DPrj(x) => {
-////                u8::put(&0xB6, buf);
-////                x.put(buf);
-////            }
-////            Self::Inds(xs) => {
-////                Self::put_tag(0xC, xs.len() as u64, buf);
-////                for x in xs {
-////                    x.put(buf);
-////                }
-////            }
-////            Self::Defs(xs) => {
-////                Self::put_tag(0xD, xs.len() as u64, buf);
-////                for x in xs {
-////                    x.put(buf);
-////                }
-////            }
-////            Self::Meta(x) => {
-////                u8::put(&0xE0, buf);
-////                x.put(buf);
-////            }
-////            Self::Prof(x) => {
-////                u8::put(&0xE1, buf);
-////                x.put(buf);
-////            }
-////            Self::Eval(x) => {
-////                u8::put(&0xE2, buf);
-////                x.put(buf);
-////            }
-////            Self::Chck(x) => {
-////                u8::put(&0xE3, buf);
-////                x.put(buf);
-////            }
-////            Self::Comm(x) => {
-////                u8::put(&0xE4, buf);
-////                x.put(buf);
-////            }
-////            Self::Envn(x) => {
-////                u8::put(&0xE5, buf);
-////                x.put(buf);
-////            }
-////        }
-////    }
-////
-////    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-////        let tag_byte = u8::get(buf)?;
-////        let small_size = tag_byte & 0b111;
-////        let is_large = tag_byte & 0b1000 != 0;
-////        match tag_byte {
-////            0x00..=0x0F => {
-////                let x = Ixon::get_size(is_large, small_size, buf)?;
-////                Ok(Self::Vari(x))
-////            }
-////            0x90 => {
-////                let u = Univ::get(buf)?;
-////                Ok(Self::Sort(Box::new(u)))
-////            }
-////            0x10..=0x1F => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                let a = Address::get(buf)?;
-////                let mut lvls = Vec::new();
-////                for _ in 0..n {
-////                    let l = Univ::get(buf)?;
-////                    lvls.push(l);
-////                }
-////                Ok(Self::Refr(a, lvls))
-////            }
-////            0x20..=0x2F => {
-////                let x = Ixon::get_size(is_large, small_size, buf)?;
-////                let lvls = Ixon::get_array(buf)?;
-////                Ok(Self::Recr(x, lvls))
-////            }
-////            0x30..=0x3F => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                let f = Ixon::get(buf)?;
-////                let a = Ixon::get(buf)?;
-////                let mut args = Vec::new();
-////                for _ in 0..n {
-////                    let x = Ixon::get(buf)?;
-////                    args.push(x);
-////                }
-////                Ok(Self::Apps(Box::new(f), Box::new(a), args))
-////            }
-////            0x40..=0x4F => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                let mut ts = Vec::new();
-////                for _ in 0..n {
-////                    let x = Ixon::get(buf)?;
-////                    ts.push(x);
-////                }
-////                let b = Ixon::get(buf)?;
-////                Ok(Self::Lams(ts, Box::new(b)))
-////            }
-////            0x50..=0x5F => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                let mut ts = Vec::new();
-////                for _ in 0..n {
-////                    let x = Ixon::get(buf)?;
-////                    ts.push(x);
-////                }
-////                let b = Ixon::get(buf)?;
-////                Ok(Self::Alls(ts, Box::new(b)))
-////            }
-////            0x60..=0x6F => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                let t = Address::get(buf)?;
-////                let x = Ixon::get(buf)?;
-////                Ok(Self::Proj(t, n, Box::new(x)))
-////            }
-////            0x70..=0x7F => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                match buf.split_at_checked(n as usize) {
-////                    Some((head, rest)) => {
-////                        *buf = rest;
-////                        match String::from_utf8(head.to_owned()) {
-////                            Ok(s) => Ok(Ixon::Strl(s)),
-////                            Err(e) => Err(format!("UTF8 Error: {e}")),
-////                        }
-////                    }
-////                    None => Err("get Ixon Strl EOF".to_string()),
-////                }
-////            }
-////            0x80..=0x8F => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                match buf.split_at_checked(n as usize) {
-////                    Some((head, rest)) => {
-////                        *buf = rest;
-////                        Ok(Ixon::Natl(Nat(BigUint::from_bytes_le(head))))
-////                    }
-////                    None => Err("get Expr Natl EOF".to_string()),
-////                }
-////            }
-////            0x91..=0x92 => {
-////                let nd = tag_byte == 0x91;
-////                let t = Ixon::get(buf)?;
-////                let d = Ixon::get(buf)?;
-////                let b = Ixon::get(buf)?;
-////                Ok(Self::LetE(nd, Box::new(t), Box::new(d), Box::new(b)))
-////            }
-////            0xA0..=0xAF => {
-////                let len = Self::get_size(is_large, small_size, buf)?;
-////                let mut vec = vec![];
-////                for _ in 0..len {
-////                    let s = Ixon::get(buf)?;
-////                    vec.push(s);
-////                }
-////                Ok(Self::List(vec))
-////            }
-////            0xB0 => Ok(Self::Defn(Definition::get(buf)?)),
-////            0xB1 => Ok(Self::Axio(Axiom::get(buf)?)),
-////            0xB2 => Ok(Self::Quot(Quotient::get(buf)?)),
-////            0xB3 => Ok(Self::CPrj(ConstructorProj::get(buf)?)),
-////            0xB4 => Ok(Self::RPrj(RecursorProj::get(buf)?)),
-////            0xB5 => Ok(Self::IPrj(InductiveProj::get(buf)?)),
-////            0xB6 => Ok(Self::DPrj(DefinitionProj::get(buf)?)),
-////            0xC0..=0xCF => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                let mut inds = Vec::new();
-////                for _ in 0..n {
-////                    let x = Inductive::get(buf)?;
-////                    inds.push(x);
-////                }
-////                Ok(Self::Inds(inds))
-////            }
-////            0xD0..=0xDF => {
-////                let n = Ixon::get_size(is_large, small_size, buf)?;
-////                let mut defs = Vec::new();
-////                for _ in 0..n {
-////                    let x = Definition::get(buf)?;
-////                    defs.push(x);
-////                }
-////                Ok(Self::Defs(defs))
-////            }
-////            0xE0 => Ok(Self::Meta(Metadata::get(buf)?)),
-////            0xE1 => Ok(Self::Prof(Proof::get(buf)?)),
-////            0xE2 => Ok(Self::Eval(EvalClaim::get(buf)?)),
-////            0xE3 => Ok(Self::Chck(CheckClaim::get(buf)?)),
-////            0xE4 => Ok(Self::Comm(Comm::get(buf)?)),
-////            0xE5 => Ok(Self::Envn(Env::get(buf)?)),
-////            x => Err(format!("get Ixon invalid tag {x}")),
-////        }
-////    }
-////}
-////
-////#[cfg(test)]
-////pub mod tests {
-////    use super::*;
-////    use crate::ixon::nat::tests::arbitrary_nat;
-////    use crate::ixon::univ::tests::arbitrary_univ;
-////    use quickcheck::{Arbitrary, Gen};
-////    use std::fmt::Write;
-////    use std::ops::Range;
-////    use std::ptr;
-////
-////    pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
-////        let res: usize = Arbitrary::arbitrary(g);
-////        if range.is_empty() {
-////            0
-////        } else {
-////            (res % (range.end - range.start)) + range.start
-////        }
-////    }
-////
-////    pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
-////    where
-////        F: FnMut(&mut Gen) -> A,
-////    {
-////        let len = gen_range(g, 0..size);
-////        let mut vec = Vec::with_capacity(len);
-////        for _ in 0..len {
-////            vec.push(f(g));
-////        }
-////        vec
-////    }
-////
-////    pub fn next_case<A: Copy>(g: &mut Gen, gens: &Vec<(usize, A)>) -> A {
-////        let sum: usize = gens.iter().map(|x| x.0).sum();
-////        let mut weight: usize = gen_range(g, 1..sum);
-////        for (n, case) in gens {
-////            if *n == 0 {
-////                continue;
-////            } else {
-////                match weight.checked_sub(*n) {
-////                    None | Some(0) => {
-////                        return *case;
-////                    }
-////                    _ => {
-////                        weight -= *n;
-////                    }
-////                }
-////            }
-////        }
-////        unreachable!()
-////    }
-////
-////    #[test]
-////    fn unit_u64_trimmed() {
-////        fn test(input: u64, expected: Vec<u8>) -> bool {
-////            let mut tmp = Vec::new();
-////            let n = Ixon::u64_byte_count(input);
-////            Ixon::u64_put_trimmed_le(input, &mut tmp);
-////            if tmp != expected {
-////                return false;
-////            }
-////            match Ixon::u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
-////                Ok(out) => input == out,
-////                Err(e) => {
-////                    println!("err: {e}");
-////                    false
-////                }
-////            }
-////        }
-////        assert!(test(0x0, vec![]));
-////        assert!(test(0x01, vec![0x01]));
-////        assert!(test(0x0000000000000100, vec![0x00, 0x01]));
-////        assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
-////        assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
-////        assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
-////        assert!(test(
-////            0x0000010000000000,
-////            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-////        ));
-////        assert!(test(
-////            0x0001000000000000,
-////            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-////        ));
-////        assert!(test(
-////            0x0100000000000000,
-////            vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-////        ));
-////        assert!(test(
-////            0x0102030405060708,
-////            vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
-////        ));
-////    }
-////
-////    #[quickcheck]
-////    fn prop_u64_trimmed_le_readback(x: u64) -> bool {
-////        let mut buf = Vec::new();
-////        let n = Ixon::u64_byte_count(x);
-////        Ixon::u64_put_trimmed_le(x, &mut buf);
-////        match Ixon::u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
-////            Ok(y) => x == y,
-////            Err(e) => {
-////                println!("err: {e}");
-////                false
-////            }
-////        }
-////    }
-////
-////    #[derive(Debug, Clone, Copy)]
-////    pub enum IxonCase {
-////        Vari,
-////        Sort,
-////        Refr,
-////        Recr,
-////        Apps,
-////        Lams,
-////        Alls,
-////        Proj,
-////        Strl,
-////        Natl,
-////        LetE,
-////        List,
-////        Defn,
-////        Axio,
-////        Quot,
-////        CPrj,
-////        RPrj,
-////        IPrj,
-////        DPrj,
-////        Defs,
-////        Inds,
-////        Meta,
-////        Prof,
-////        Eval,
-////        Chck,
-////        Comm,
-////        Envn,
-////    }
-////
-////    pub fn arbitrary_string(g: &mut Gen, cs: usize) -> String {
-////        let mut s = String::new();
-////        for _ in 0..cs {
-////            s.push(char::arbitrary(g));
-////        }
-////        s
-////    }
-////
-////    // incremental tree generation without recursion stack overflows
-////    pub fn arbitrary_ixon(g: &mut Gen, ctx: u64) -> Ixon {
-////        let mut root = Ixon::Vari(0);
-////        let mut stack = vec![&mut root as *mut Ixon];
-////
-////        while let Some(ptr) = stack.pop() {
-////            let gens: Vec<(usize, IxonCase)> = vec![
-////                (100, IxonCase::Vari),
-////                (100, IxonCase::Sort),
-////                (15, IxonCase::Refr),
-////                (15, IxonCase::Recr),
-////                (15, IxonCase::Apps),
-////                (15, IxonCase::Lams),
-////                (15, IxonCase::Alls),
-////                (20, IxonCase::LetE),
-////                (50, IxonCase::Proj),
-////                (100, IxonCase::Strl),
-////                (100, IxonCase::Natl),
-////                (10, IxonCase::List),
-////                (100, IxonCase::Defn),
-////                (100, IxonCase::Axio),
-////                (100, IxonCase::Quot),
-////                (100, IxonCase::CPrj),
-////                (100, IxonCase::RPrj),
-////                (100, IxonCase::IPrj),
-////                (100, IxonCase::DPrj),
-////                (15, IxonCase::Inds),
-////                (15, IxonCase::Defs),
-////                (100, IxonCase::Meta),
-////                (100, IxonCase::Prof),
-////                (100, IxonCase::Eval),
-////                (100, IxonCase::Chck),
-////                (100, IxonCase::Comm),
-////                (100, IxonCase::Envn),
-////            ];
-////
-////            match next_case(g, &gens) {
-////                IxonCase::Vari => {
-////                    let x: u64 = Arbitrary::arbitrary(g);
-////                    unsafe {
-////                        ptr::replace(ptr, Ixon::Vari(x));
-////                    }
-////                }
-////                IxonCase::Sort => {
-////                    let u = arbitrary_univ(g, ctx);
-////                    unsafe {
-////                        ptr::replace(ptr, Ixon::Sort(Box::new(u)));
-////                    }
-////                }
-////                IxonCase::Refr => {
-////                    let addr = Address::arbitrary(g);
-////                    let mut lvls = vec![];
-////                    for _ in 0..gen_range(g, 0..9) {
-////                        lvls.push(arbitrary_univ(g, ctx));
-////                    }
-////                    unsafe {
-////                        ptr::replace(ptr, Ixon::Refr(addr, lvls));
-////                    }
-////                }
-////                IxonCase::Recr => {
-////                    let n = u64::arbitrary(g);
-////                    let mut lvls = vec![];
-////                    for _ in 0..gen_range(g, 0..9) {
-////                        lvls.push(arbitrary_univ(g, ctx));
-////                    }
-////                    unsafe {
-////                        ptr::replace(ptr, Ixon::Recr(n, lvls));
-////                    }
-////                }
-////                IxonCase::Apps => {
-////                    let mut f_box = Box::new(Ixon::default());
-////                    let f_ptr: *mut Ixon = &mut *f_box;
-////                    stack.push(f_ptr);
-////
-////                    let mut a_box = Box::new(Ixon::default());
-////                    let a_ptr: *mut Ixon = &mut *a_box;
-////                    stack.push(a_ptr);
-////
-////                    let n = gen_range(g, 0..9);
-////                    let mut xs: Vec<Ixon> = Vec::with_capacity(n);
-////                    xs.resize(n, Ixon::Vari(0));
-////                    for i in 0..n {
-////                        let p = unsafe { xs.as_mut_ptr().add(i) };
-////                        stack.push(p);
-////                    }
-////                    unsafe {
-////                        std::ptr::replace(ptr, Ixon::Apps(f_box, a_box, xs));
-////                    }
-////                }
-////                IxonCase::Lams => {
-////                    let n = gen_range(g, 0..9);
-////                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-////                    ts.resize(n, Ixon::Vari(0));
-////                    for i in 0..n {
-////                        let p = unsafe { ts.as_mut_ptr().add(i) };
-////                        stack.push(p);
-////                    }
-////                    let mut b_box = Box::new(Ixon::default());
-////                    let b_ptr: *mut Ixon = &mut *b_box;
-////                    stack.push(b_ptr);
-////                    unsafe {
-////                        std::ptr::replace(ptr, Ixon::Lams(ts, b_box));
-////                    }
-////                }
-////                IxonCase::Alls => {
-////                    let n = gen_range(g, 0..9);
-////                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-////                    ts.resize(n, Ixon::Vari(0));
-////                    for i in 0..n {
-////                        let p = unsafe { ts.as_mut_ptr().add(i) };
-////                        stack.push(p);
-////                    }
-////                    let mut b_box = Box::new(Ixon::default());
-////                    let b_ptr: *mut Ixon = &mut *b_box;
-////                    stack.push(b_ptr);
-////                    unsafe {
-////                        std::ptr::replace(ptr, Ixon::Alls(ts, b_box));
-////                    }
-////                }
-////                IxonCase::LetE => {
-////                    let nd = bool::arbitrary(g);
-////                    let mut t_box = Box::new(Ixon::default());
-////                    let t_ptr: *mut Ixon = &mut *t_box;
-////                    stack.push(t_ptr);
-////                    let mut d_box = Box::new(Ixon::default());
-////                    let d_ptr: *mut Ixon = &mut *d_box;
-////                    stack.push(d_ptr);
-////                    let mut b_box = Box::new(Ixon::default());
-////                    let b_ptr: *mut Ixon = &mut *b_box;
-////                    stack.push(b_ptr);
-////                    unsafe {
-////                        ptr::replace(ptr, Ixon::LetE(nd, t_box, d_box, b_box));
-////                    }
-////                }
-////                IxonCase::Proj => {
-////                    let addr = Address::arbitrary(g);
-////                    let n = u64::arbitrary(g);
-////                    let mut t_box = Box::new(Ixon::default());
-////                    let t_ptr: *mut Ixon = &mut *t_box;
-////                    stack.push(t_ptr);
-////                    unsafe {
-////                        ptr::replace(ptr, Ixon::Proj(addr, n, t_box));
-////                    }
-////                }
-////                IxonCase::Strl => unsafe {
-////                    let size = gen_range(g, 0..9);
-////                    ptr::replace(ptr, Ixon::Strl(arbitrary_string(g, size)));
-////                },
-////                IxonCase::Natl => {
-////                    let size = gen_range(g, 0..9);
-////                    unsafe {
-////                        ptr::replace(ptr, Ixon::Natl(arbitrary_nat(g, size)));
-////                    }
-////                }
-////                IxonCase::List => {
-////                    let n = gen_range(g, 0..9);
-////                    let mut ts: Vec<Ixon> = Vec::with_capacity(n);
-////                    ts.resize(n, Ixon::Vari(0));
-////                    for i in 0..n {
-////                        let p = unsafe { ts.as_mut_ptr().add(i) };
-////                        stack.push(p);
-////                    }
-////                    unsafe {
-////                        std::ptr::replace(ptr, Ixon::List(ts));
-////                    }
-////                }
-////                IxonCase::Quot => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Quot(Quotient::arbitrary(g)));
-////                },
-////                IxonCase::Axio => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Axio(Axiom::arbitrary(g)));
-////                },
-////                IxonCase::Defn => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Defn(Definition::arbitrary(g)));
-////                },
-////                IxonCase::CPrj => unsafe {
-////                    std::ptr::replace(ptr, Ixon::CPrj(ConstructorProj::arbitrary(g)));
-////                },
-////                IxonCase::RPrj => unsafe {
-////                    std::ptr::replace(ptr, Ixon::RPrj(RecursorProj::arbitrary(g)));
-////                },
-////                IxonCase::DPrj => unsafe {
-////                    std::ptr::replace(ptr, Ixon::DPrj(DefinitionProj::arbitrary(g)));
-////                },
-////                IxonCase::IPrj => unsafe {
-////                    std::ptr::replace(ptr, Ixon::IPrj(InductiveProj::arbitrary(g)));
-////                },
-////                IxonCase::Inds => unsafe {
-////                    let inds = gen_vec(g, 9, Inductive::arbitrary);
-////                    std::ptr::replace(ptr, Ixon::Inds(inds));
-////                },
-////                IxonCase::Defs => unsafe {
-////                    let defs = gen_vec(g, 9, Definition::arbitrary);
-////                    std::ptr::replace(ptr, Ixon::Defs(defs));
-////                },
-////                IxonCase::Meta => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Meta(Metadata::arbitrary(g)));
-////                },
-////                IxonCase::Prof => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Prof(Proof::arbitrary(g)));
-////                },
-////                IxonCase::Eval => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Eval(EvalClaim::arbitrary(g)));
-////                },
-////                IxonCase::Chck => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Chck(CheckClaim::arbitrary(g)));
-////                },
-////                IxonCase::Comm => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Comm(Comm::arbitrary(g)));
-////                },
-////                IxonCase::Envn => unsafe {
-////                    std::ptr::replace(ptr, Ixon::Envn(Env::arbitrary(g)));
-////                },
-////            }
-////        }
-////        root
-////    }
-////
-////    impl Arbitrary for Ixon {
-////        fn arbitrary(g: &mut Gen) -> Self {
-////            let ctx: u64 = Arbitrary::arbitrary(g);
-////            arbitrary_ixon(g, ctx)
-////        }
-////    }
-////
-////    #[quickcheck]
-////    fn prop_ixon_readback(x: Ixon) -> bool {
-////        let mut buf = Vec::new();
-////        Ixon::put(&x, &mut buf);
-////        match Ixon::get(&mut buf.as_slice()) {
-////            Ok(y) => x == y,
-////            Err(e) => {
-////                println!("err: {e}");
-////                false
-////            }
-////        }
-////    }
-////
-////    /// Parse a hex string (optional `0x`/`0X` prefix, `_` separators OK) into bytes.
-////    pub fn parse_hex(s: &str) -> Result<Vec<u8>, String> {
-////        // Strip prefix, drop underscores, and require an even count of hex digits.
-////        let s = s.trim();
-////        let s = s
-////            .strip_prefix("0x")
-////            .or_else(|| s.strip_prefix("0X"))
-////            .unwrap_or(s);
-////        let clean: String = s.chars().filter(|&c| c != '_').collect();
-////
-////        if clean.len() % 2 != 0 {
-////            return Err("odd number of hex digits".into());
-////        }
-////
-////        // Parse each 2-char chunk as a byte.
-////        (0..clean.len())
-////            .step_by(2)
-////            .map(|i| {
-////                u8::from_str_radix(&clean[i..i + 2], 16)
-////                    .map_err(|_| format!("invalid hex at chars {}..{}", i, i + 2))
-////            })
-////            .collect()
-////    }
-////
-////    /// Format bytes as a lowercase hex string with a `0x` prefix.
-////    pub fn to_hex(bytes: &[u8]) -> String {
-////        let mut out = String::with_capacity(2 + bytes.len() * 2);
-////        out.push_str("0x");
-////        for b in bytes {
-////            // `{:02x}` = two lowercase hex digits, zero-padded.
-////            write!(&mut out, "{b:02x}").unwrap();
-////        }
-////        out
-////    }
-////
-////    #[test]
-////    fn unit_ixon() {
-////        fn test(input: Ixon, expected: &str) -> bool {
-////            let mut tmp = Vec::new();
-////            let expect = parse_hex(expected).unwrap();
-////            Serialize::put(&input, &mut tmp);
-////            if tmp != expect {
-////                println!(
-////                    "serialied {input:?} as:\n {}\n test expects:\n {}",
-////                    to_hex(&tmp),
-////                    to_hex(&expect),
-////                );
-////                return false;
-////            }
-////            match Serialize::get(&mut tmp.as_slice()) {
-////                Ok(output) => {
-////                    if input != output {
-////                        println!(
-////                            "deserialized {} as {output:?}, expected {input:?}",
-////                            to_hex(&tmp)
-////                        );
-////                        false
-////                    } else {
-////                        true
-////                    }
-////                }
-////                Err(e) => {
-////                    println!("err: {e}");
-////                    false
-////                }
-////            }
-////        }
-////        assert!(test(Ixon::Vari(0x0), "0x00"));
-////        assert!(test(Ixon::Vari(0x7), "0x07"));
-////        assert!(test(Ixon::Vari(0x8), "0x0808"));
-////        assert!(test(Ixon::Vari(0xff), "0x08FF"));
-////        assert!(test(Ixon::Vari(0x0100), "0x090001"));
-////        assert!(test(Ixon::Vari(0xFFFF), "0x09FFFF"));
-////        assert!(test(Ixon::Vari(0x010000), "0x0A000001"));
-////        assert!(test(Ixon::Vari(0xFFFFFF), "0x0AFFFFFF"));
-////        assert!(test(Ixon::Vari(0x01000000), "0x0B00000001"));
-////        assert!(test(Ixon::Vari(0xFFFFFFFF), "0x0BFFFFFFFF"));
-////        assert!(test(Ixon::Vari(0x0100000000), "0x0C0000000001"));
-////        assert!(test(Ixon::Vari(0xFFFFFFFFFF), "0x0CFFFFFFFFFF"));
-////        assert!(test(Ixon::Vari(0x010000000000), "0x0D000000000001"));
-////        assert!(test(Ixon::Vari(0xFFFFFFFFFFFF), "0x0DFFFFFFFFFFFF"));
-////        assert!(test(Ixon::Vari(0x01000000000000), "0x0E00000000000001"));
-////        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFF), "0x0EFFFFFFFFFFFFFF"));
-////        assert!(test(Ixon::Vari(0x0100000000000000), "0x0F0000000000000001"));
-////        assert!(test(Ixon::Vari(0xFFFFFFFFFFFFFFFF), "0x0FFFFFFFFFFFFFFFFF"));
-////        // universes use 2-bit sub-tags
-////        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x0))), "0x9000"));
-////        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x1F))), "0x901F"));
-////        assert!(test(Ixon::Sort(Box::new(Univ::Const(0x20))), "0x902020"));
-////        assert!(test(Ixon::Sort(Box::new(Univ::Const(0xFF))), "0x9020FF"));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0x0100))),
-////            "0x90210001"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0xFFFF))),
-////            "0x9021FFFF"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0x010000))),
-////            "0x9022000001"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFF))),
-////            "0x9022FFFFFF"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0x01000000))),
-////            "0x902300000001"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFF))),
-////            "0x9023FFFFFFFF"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0x0100000000))),
-////            "0x90240000000001"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFF))),
-////            "0x9024FFFFFFFFFF"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0x010000000000))),
-////            "0x9025000000000001"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFF))),
-////            "0x9025FFFFFFFFFFFF"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0x01000000000000))),
-////            "0x902600000000000001"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFF))),
-////            "0x9026FFFFFFFFFFFFFF"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0x0100000000000000))),
-////            "0x90270000000000000001"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Const(0xFFFFFFFFFFFFFFFF))),
-////            "0x9027FFFFFFFFFFFFFFFF"
-////        ));
-////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0))), "0x9040"));
-////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x1F))), "0x905F"));
-////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x20))), "0x906020"));
-////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0xFF))), "0x9060FF"));
-////        assert!(test(Ixon::Sort(Box::new(Univ::Var(0x0100))), "0x90610001"));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Var(0xFFFFFFFFFFFFFFFF))),
-////            "0x9067FFFFFFFFFFFFFFFF"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Const(0x0))))),
-////            "0x908000"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Add(0x0, Box::new(Univ::Var(0x0))))),
-////            "0x908040"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Add(0x1F, Box::new(Univ::Var(0x0))))),
-////            "0x909F40"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Add(0x20, Box::new(Univ::Var(0x0))))),
-////            "0x90A02040"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Add(0xFF, Box::new(Univ::Var(0x0))))),
-////            "0x90A0FF40"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Add(
-////                0xFFFF_FFFF_FFFF_FFFF,
-////                Box::new(Univ::Var(0x0))
-////            ))),
-////            "0x90A7FFFFFFFFFFFFFFFF40"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Max(
-////                Box::new(Univ::Var(0x0)),
-////                Box::new(Univ::Var(0x0))
-////            ))),
-////            "0x90C04040"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Max(
-////                Box::new(Univ::Var(0x0)),
-////                Box::new(Univ::Var(0x1))
-////            ))),
-////            "0x90C04041"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Max(
-////                Box::new(Univ::Var(0x1)),
-////                Box::new(Univ::Var(0x0))
-////            ))),
-////            "0x90C04140"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::Max(
-////                Box::new(Univ::Var(0x1)),
-////                Box::new(Univ::Var(0x1))
-////            ))),
-////            "0x90C04141"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::IMax(
-////                Box::new(Univ::Var(0x0)),
-////                Box::new(Univ::Var(0x0))
-////            ))),
-////            "0x90C14040"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::IMax(
-////                Box::new(Univ::Var(0x0)),
-////                Box::new(Univ::Var(0x1))
-////            ))),
-////            "0x90C14041"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::IMax(
-////                Box::new(Univ::Var(0x1)),
-////                Box::new(Univ::Var(0x0))
-////            ))),
-////            "0x90C14140"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::IMax(
-////                Box::new(Univ::Var(0x1)),
-////                Box::new(Univ::Var(0x1))
-////            ))),
-////            "0x90C14141"
-////        ));
-////        assert!(test(
-////            Ixon::Sort(Box::new(Univ::IMax(
-////                Box::new(Univ::Var(0x1)),
-////                Box::new(Univ::Var(0x1))
-////            ))),
-////            "0x90C14141"
-////        ));
-////        assert!(test(
-////            Ixon::Refr(Address::hash(&[]), vec![]),
-////            "0x10af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::Refr(Address::hash(&[]), vec![Univ::Var(0x0)]),
-////            "0x11af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326240"
-////        ));
-////        assert!(test(Ixon::Recr(0x0, vec![Univ::Var(0x0)]), "0x20A140"));
-////        assert!(test(
-////            Ixon::Recr(0x0, vec![Univ::Var(0x0), Univ::Var(0x1)]),
-////            "0x20A24041"
-////        ));
-////        assert!(test(
-////            Ixon::Recr(0x8, vec![Univ::Var(0x0), Univ::Var(0x1)]),
-////            "0x2808A24041"
-////        ));
-////        assert!(test(
-////            Ixon::Apps(Box::new(Ixon::Vari(0x0)), Box::new(Ixon::Vari(0x1)), vec![]),
-////            "0x300001"
-////        ));
-////        assert!(test(
-////            Ixon::Apps(
-////                Box::new(Ixon::Vari(0x0)),
-////                Box::new(Ixon::Vari(0x1)),
-////                vec![Ixon::Vari(0x2)]
-////            ),
-////            "0x31000102"
-////        ));
-////        assert!(test(
-////            Ixon::Apps(
-////                Box::new(Ixon::Vari(0x0)),
-////                Box::new(Ixon::Vari(0x1)),
-////                vec![
-////                    Ixon::Vari(0x2),
-////                    Ixon::Vari(0x3),
-////                    Ixon::Vari(0x4),
-////                    Ixon::Vari(0x5),
-////                    Ixon::Vari(0x6),
-////                    Ixon::Vari(0x7),
-////                    Ixon::Vari(0x8),
-////                    Ixon::Vari(0x9),
-////                ]
-////            ),
-////            "0x3808000102030405060708080809"
-////        ));
-////        assert!(test(
-////            Ixon::Lams(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
-////            "0x410001"
-////        ));
-////        assert!(test(
-////            Ixon::Lams(
-////                vec![
-////                    Ixon::Vari(0x0),
-////                    Ixon::Vari(0x1),
-////                    Ixon::Vari(0x2),
-////                    Ixon::Vari(0x3),
-////                    Ixon::Vari(0x4),
-////                    Ixon::Vari(0x5),
-////                    Ixon::Vari(0x6),
-////                    Ixon::Vari(0x7)
-////                ],
-////                Box::new(Ixon::Vari(0x8))
-////            ),
-////            "0x480800010203040506070808"
-////        ));
-////        assert!(test(
-////            Ixon::Alls(vec![Ixon::Vari(0x0)], Box::new(Ixon::Vari(0x1))),
-////            "0x510001"
-////        ));
-////        assert!(test(
-////            Ixon::Alls(
-////                vec![
-////                    Ixon::Vari(0x0),
-////                    Ixon::Vari(0x1),
-////                    Ixon::Vari(0x2),
-////                    Ixon::Vari(0x3),
-////                    Ixon::Vari(0x4),
-////                    Ixon::Vari(0x5),
-////                    Ixon::Vari(0x6),
-////                    Ixon::Vari(0x7)
-////                ],
-////                Box::new(Ixon::Vari(0x8))
-////            ),
-////            "0x580800010203040506070808"
-////        ));
-////        assert!(test(
-////            Ixon::Proj(Address::hash(&[]), 0x0, Box::new(Ixon::Vari(0x0))),
-////            "0x60af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
-////        ));
-////        assert!(test(
-////            Ixon::Proj(Address::hash(&[]), 0x8, Box::new(Ixon::Vari(0x0))),
-////            "0x6808af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f326200"
-////        ));
-////        assert!(test(Ixon::Strl("".to_string()), "0x70"));
-////        assert!(test(Ixon::Strl("foobar".to_string()), "0x76666f6f626172"));
-////        assert!(test(Ixon::Natl(Nat::new_le(&[])), "0x8100"));
-////        assert!(test(Ixon::Natl(Nat::new_le(&[0x0])), "0x8100"));
-////        assert!(test(Ixon::Natl(Nat::new_le(&[0xFF])), "0x81FF"));
-////        assert!(test(Ixon::Natl(Nat::new_le(&[0x00, 0x01])), "0x820001"));
-////        assert!(test(
-////            Ixon::LetE(
-////                true,
-////                Box::new(Ixon::Vari(0x0)),
-////                Box::new(Ixon::Vari(0x1)),
-////                Box::new(Ixon::Vari(0x2))
-////            ),
-////            "0x91000102"
-////        ));
-////        assert!(test(Ixon::List(vec![]), "0xA0"));
-////        assert!(test(
-////            Ixon::List(vec![Ixon::Vari(0x0), Ixon::Vari(0x1), Ixon::Vari(0x2)]),
-////            "0xA3000102"
-////        ));
-////        assert!(test(
-////            Ixon::Defn(Definition {
-////                kind: DefKind::Definition,
-////                safety: DefSafety::Unsafe,
-////                lvls: 0u64.into(),
-////                typ: Address::hash(&[]),
-////                value: Address::hash(&[]),
-////            }),
-////            "0xB000008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::Defn(Definition {
-////                kind: DefKind::Opaque,
-////                safety: DefSafety::Safe,
-////                lvls: 1u64.into(),
-////                typ: Address::hash(&[]),
-////                value: Address::hash(&[]),
-////            }),
-////            "0xB001018101af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::Axio(Axiom {
-////                is_unsafe: true,
-////                lvls: 0u64.into(),
-////                typ: Address::hash(&[]),
-////            }),
-////            "0xB1018100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::Quot(Quotient {
-////                kind: QuotKind::Type,
-////                lvls: 0u64.into(),
-////                typ: Address::hash(&[]),
-////            }),
-////            "0xB2008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::CPrj(ConstructorProj {
-////                idx: 0u64.into(),
-////                cidx: 0u64.into(),
-////                block: Address::hash(&[]),
-////            }),
-////            "0xB381008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::RPrj(RecursorProj {
-////                idx: 0u64.into(),
-////                ridx: 0u64.into(),
-////                block: Address::hash(&[]),
-////            }),
-////            "0xB481008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::IPrj(InductiveProj {
-////                idx: 0u64.into(),
-////                block: Address::hash(&[]),
-////            }),
-////            "0xB58100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::DPrj(DefinitionProj {
-////                idx: 0u64.into(),
-////                block: Address::hash(&[]),
-////            }),
-////            "0xB68100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(Ixon::Inds(vec![]), "0xC0"));
-////        assert!(test(
-////            Ixon::Inds(vec![Inductive {
-////                recr: false,
-////                refl: false,
-////                is_unsafe: false,
-////                lvls: 0u64.into(),
-////                params: 0u64.into(),
-////                indices: 0u64.into(),
-////                nested: 0u64.into(),
-////                typ: Address::hash(&[]),
-////                ctors: vec![],
-////                recrs: vec![],
-////            }]),
-////            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
-////        ));
-////        assert!(test(
-////            Ixon::Inds(vec![Inductive {
-////                recr: false,
-////                refl: false,
-////                is_unsafe: false,
-////                lvls: 0u64.into(),
-////                params: 0u64.into(),
-////                indices: 0u64.into(),
-////                nested: 0u64.into(),
-////                typ: Address::hash(&[]),
-////                ctors: vec![],
-////                recrs: vec![],
-////            }]),
-////            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A0A0"
-////        ));
-////        assert!(test(
-////            Ixon::Inds(vec![Inductive {
-////                recr: false,
-////                refl: false,
-////                is_unsafe: false,
-////                lvls: 0u64.into(),
-////                params: 0u64.into(),
-////                indices: 0u64.into(),
-////                nested: 0u64.into(),
-////                typ: Address::hash(&[]),
-////                ctors: vec![Constructor {
-////                    is_unsafe: false,
-////                    lvls: 0u64.into(),
-////                    cidx: 0u64.into(),
-////                    params: 0u64.into(),
-////                    fields: 0u64.into(),
-////                    typ: Address::hash(&[])
-////                }],
-////                recrs: vec![Recursor {
-////                    k: false,
-////                    is_unsafe: false,
-////                    lvls: 0u64.into(),
-////                    params: 0u64.into(),
-////                    indices: 0u64.into(),
-////                    motives: 0u64.into(),
-////                    minors: 0u64.into(),
-////                    typ: Address::hash(&[]),
-////                    rules: vec![RecursorRule {
-////                        fields: 0u64.into(),
-////                        rhs: Address::hash(&[])
-////                    }]
-////                }],
-////            }]),
-////            "0xC1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A1008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A10081008100810081008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262A18100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(Ixon::Defs(vec![]), "0xD0"));
-////        assert!(test(
-////            Ixon::Defs(vec![Definition {
-////                kind: DefKind::Definition,
-////                safety: DefSafety::Unsafe,
-////                lvls: 0u64.into(),
-////                typ: Address::hash(&[]),
-////                value: Address::hash(&[]),
-////            }]),
-////            "0xD100008100af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(Ixon::Meta(Metadata { map: vec![] }), "0xE0A0"));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(0u64.into(), vec![])]
-////            }),
-////            "0xE0A18100A0"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(0u64.into(), vec![Metadatum::Name(Name { parts: vec![] })])]
-////            }),
-////            "0xE0A18100A100A0"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(
-////                    0u64.into(),
-////                    vec![Metadatum::Name(Name {
-////                        parts: vec![NamePart::Str("a".to_string())]
-////                    })]
-////                )]
-////            }),
-////            "0xE0A18100A100A17161"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(
-////                    0u64.into(),
-////                    vec![Metadatum::Name(Name {
-////                        parts: vec![
-////                            NamePart::Str("a".to_string()),
-////                            NamePart::Str("b".to_string()),
-////                        ]
-////                    })]
-////                )]
-////            }),
-////            "0xE0A18100A100A271617162"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(
-////                    0u64.into(),
-////                    vec![Metadatum::Name(Name {
-////                        parts: vec![
-////                            NamePart::Str("a".to_string()),
-////                            NamePart::Str("b".to_string()),
-////                            NamePart::Str("c".to_string()),
-////                        ]
-////                    })]
-////                )]
-////            }),
-////            "0xE0A18100A100A3716171627163"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(
-////                    0u64.into(),
-////                    vec![Metadatum::Name(Name {
-////                        parts: vec![NamePart::Num(165851424810452359u64.into())]
-////                    })]
-////                )]
-////            }),
-////            "0xE0A18100A100A1880887C551FDFD384D02"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(0u64.into(), vec![Metadatum::Info(BinderInfo::Default)])]
-////            }),
-////            "0xE0A18100A10100"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(0u64.into(), vec![Metadatum::Link(Address::hash(&[]))])]
-////            }),
-////            "0xE0A18100A102af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(
-////                    0u64.into(),
-////                    vec![
-////                        Metadatum::Name(Name {
-////                            parts: vec![NamePart::Str("d".to_string())]
-////                        }),
-////                        Metadatum::Link(Address::hash(&[])),
-////                        Metadatum::Hints(ReducibilityHints::Regular(576554452)),
-////                        Metadatum::Link(Address::hash(&[]))
-////                    ]
-////                )]
-////            }),
-////            "0xe0a18100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(
-////                    0u64.into(),
-////                    vec![Metadatum::Hints(ReducibilityHints::Opaque)]
-////                )]
-////            }),
-////            "0xE0A18100A10300"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(0u64.into(), vec![Metadatum::All(vec![])])]
-////            }),
-////            "0xE0A18100A104A0"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(0u64.into(), vec![Metadatum::MutCtx(vec![])])]
-////            }),
-////            "0xE0A18100A105A0"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![(
-////                    0u64.into(),
-////                    vec![Metadatum::Hints(ReducibilityHints::Regular(42))]
-////                )]
-////            }),
-////            "0xe0a18100a103022a000000"
-////        ));
-////        assert!(test(
-////            Ixon::Meta(Metadata {
-////                map: vec![
-////                    (
-////                        0u64.into(),
-////                        vec![
-////                            Metadatum::Name(Name {
-////                                parts: vec![NamePart::Str("d".to_string())]
-////                            }),
-////                            Metadatum::Link(Address::hash(&[])),
-////                            Metadatum::Hints(ReducibilityHints::Regular(576554452)),
-////                            Metadatum::Link(Address::hash(&[]))
-////                        ]
-////                    ),
-////                    (
-////                        1u64.into(),
-////                        vec![
-////                            Metadatum::Info(BinderInfo::InstImplicit),
-////                            Metadatum::Info(BinderInfo::InstImplicit),
-////                            Metadatum::Info(BinderInfo::StrictImplicit),
-////                        ]
-////                    ),
-////                    (
-////                        2u64.into(),
-////                        vec![
-////                            Metadatum::All(vec![Name {
-////                                parts: vec![NamePart::Num(165851424810452359u64.into())]
-////                            }]),
-////                            Metadatum::Info(BinderInfo::Default)
-////                        ]
-////                    ),
-////                    (3u64.into(), vec![]),
-////                    (4u64.into(), vec![]),
-////                    (
-////                        5u64.into(),
-////                        vec![Metadatum::Hints(ReducibilityHints::Opaque)]
-////                    ),
-////                    (
-////                        6u64.into(),
-////                        vec![Metadatum::Name(Name {
-////                            parts: vec![NamePart::Num(871843802607008850u64.into())]
-////                        })]
-////                    )
-////                ]
-////            }),
-////            "0xe0a78100a400a1716402af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32620302d4855d2202af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f32628101a30103010301028102a204a1a1880887c551fdfd384d0201008103a08104a08105a103008106a100a18808523c04ba5169190c"
-////        ));
-////    }
-////}
-////
-//////}
+#[cfg(test)]
+pub mod tests {
+  use super::*;
+  use quickcheck::{Arbitrary, Gen};
+  use std::fmt::Write;
+  use std::ops::Range;
+  use std::ptr;
+
+  pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
+    let res: usize = Arbitrary::arbitrary(g);
+    if range.is_empty() {
+      0
+    } else {
+      (res % (range.end - range.start)) + range.start
+    }
+  }
+
+  pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
+  where
+    F: FnMut(&mut Gen) -> A,
+  {
+    let len = gen_range(g, 0..size);
+    let mut vec = Vec::with_capacity(len);
+    for _ in 0..len {
+      vec.push(f(g));
+    }
+    vec
+  }
+  #[test]
+  fn unit_u64_trimmed() {
+    fn test(input: u64, expected: Vec<u8>) -> bool {
+      let mut tmp = Vec::new();
+      let n = u64_byte_count(input);
+      u64_put_trimmed_le(input, &mut tmp);
+      if tmp != expected {
+        return false;
+      }
+      match u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
+        Ok(out) => input == out,
+        Err(e) => {
+          println!("err: {e}");
+          false
+        },
+      }
+    }
+    assert!(test(0x0, vec![]));
+    assert!(test(0x01, vec![0x01]));
+    assert!(test(0x0000000000000100, vec![0x00, 0x01]));
+    assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
+    assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0000010000000000, vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(
+      0x0001000000000000,
+      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+    ));
+    assert!(test(
+      0x0100000000000000,
+      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+    ));
+    assert!(test(
+      0x0102030405060708,
+      vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+    ));
+    assert!(test(
+      0x57712D6CE2965701,
+      vec![0x01, 0x57, 0x96, 0xE2, 0x6C, 0x2D, 0x71, 0x57]
+    ));
+  }
+
+  #[quickcheck]
+  fn prop_u64_trimmed_le_readback(x: u64) -> bool {
+    let mut buf = Vec::new();
+    let n = u64_byte_count(x);
+    u64_put_trimmed_le(x, &mut buf);
+    match u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
+      Ok(y) => x == y,
+      Err(e) => {
+        println!("err: {e}");
+        false
+      },
+    }
+  }
+
+  fn serialize_readback<S: Serialize + Eq>(x: S) -> bool {
+    let mut buf = Vec::new();
+    Serialize::put(&x, &mut buf);
+    match Serialize::get(&mut buf.as_slice()) {
+      Ok(y) => x == y,
+      Err(e) => {
+        println!("err: {e}");
+        false
+      },
+    }
+  }
+
+  #[quickcheck]
+  fn prop_u8_readback(x: u8) -> bool {
+    serialize_readback(x)
+  }
+  #[quickcheck]
+  fn prop_u16_readback(x: u16) -> bool {
+    serialize_readback(x)
+  }
+  #[quickcheck]
+  fn prop_u32_readback(x: u32) -> bool {
+    serialize_readback(x)
+  }
+  #[quickcheck]
+  fn prop_u64_readback(x: u64) -> bool {
+    serialize_readback(x)
+  }
+  #[quickcheck]
+  fn prop_bool_readback(x: bool) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Tag4 {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let flag = u8::arbitrary(g) % 16;
+      Tag4 { flag, size: u64::arbitrary(g) }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_tag4_readback(x: Tag4) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for ByteArray {
+    fn arbitrary(g: &mut Gen) -> Self {
+      ByteArray(gen_vec(g, 12, u8::arbitrary))
+    }
+  }
+
+  #[quickcheck]
+  fn prop_bytearray_readback(x: ByteArray) -> bool {
+    serialize_readback(x)
+  }
+
+  #[quickcheck]
+  fn prop_string_readback(x: String) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Nat {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Nat::from_le_bytes(&gen_vec(g, 12, u8::arbitrary))
+    }
+  }
+
+  #[quickcheck]
+  fn prop_nat_readback(x: Nat) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Int {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 2 {
+        0 => Int::OfNat(Nat::arbitrary(g)),
+        1 => Int::NegSucc(Nat::arbitrary(g)),
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_int_readback(x: Int) -> bool {
+    serialize_readback(x)
+  }
+
+  #[quickcheck]
+  fn prop_vec_bool_readback(x: Vec<bool>) -> bool {
+    serialize_readback(x)
+  }
+
+  #[quickcheck]
+  fn prop_pack_bool_readback(x: Vec<bool>) -> bool {
+    let mut bools = x;
+    bools.truncate(8);
+    bools == unpack_bools(bools.len(), pack_bools(bools.clone()))
+  }
+
+  impl Arbitrary for QuotKind {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 4 {
+        0 => Self::Type,
+        1 => Self::Ctor,
+        2 => Self::Lift,
+        3 => Self::Ind,
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_quotkind_readback(x: QuotKind) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for DefKind {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 3 {
+        0 => Self::Definition,
+        1 => Self::Opaque,
+        2 => Self::Theorem,
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_defkind_readback(x: DefKind) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for BinderInfo {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 5 {
+        0 => Self::Default,
+        1 => Self::Implicit,
+        2 => Self::StrictImplicit,
+        3 => Self::InstImplicit,
+        4 => Self::AuxDecl,
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_binderinfo_readback(x: BinderInfo) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for ReducibilityHints {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 3 {
+        0 => Self::Opaque,
+        1 => Self::Abbrev,
+        2 => Self::Regular(u32::arbitrary(g)),
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_reducibilityhints_readback(x: ReducibilityHints) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for DefSafety {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 3 {
+        0 => Self::Unsafe,
+        1 => Self::Safe,
+        2 => Self::Partial,
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_defsafety_readback(x: DefSafety) -> bool {
+    serialize_readback(x)
+  }
+
+  #[quickcheck]
+  fn prop_address_readback(x: Address) -> bool {
+    serialize_readback(x)
+  }
+  #[quickcheck]
+  fn prop_metaaddress_readback(x: MetaAddress) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Quotient {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        kind: QuotKind::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_quotient_readback(x: Quotient) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Axiom {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        is_unsafe: bool::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_axiom_readback(x: Axiom) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Definition {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        kind: DefKind::arbitrary(g),
+        safety: DefSafety::arbitrary(g),
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        value: Address::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_definition_readback(x: Definition) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Constructor {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        cidx: Nat::arbitrary(g),
+        params: Nat::arbitrary(g),
+        fields: Nat::arbitrary(g),
+        is_unsafe: bool::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_constructor_readback(x: Constructor) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for RecursorRule {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self { fields: Nat::arbitrary(g), rhs: Address::arbitrary(g) }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_recursorrule_readback(x: RecursorRule) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Recursor {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..9);
+      let mut rules = vec![];
+      for _ in 0..x {
+        rules.push(RecursorRule::arbitrary(g));
+      }
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        params: Nat::arbitrary(g),
+        indices: Nat::arbitrary(g),
+        motives: Nat::arbitrary(g),
+        minors: Nat::arbitrary(g),
+        rules,
+        k: bool::arbitrary(g),
+        is_unsafe: bool::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_recursor_readback(x: Recursor) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Inductive {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..9);
+      let mut ctors = vec![];
+      for _ in 0..x {
+        ctors.push(Constructor::arbitrary(g));
+      }
+      Self {
+        lvls: Nat::arbitrary(g),
+        typ: Address::arbitrary(g),
+        params: Nat::arbitrary(g),
+        indices: Nat::arbitrary(g),
+        ctors,
+        nested: Nat::arbitrary(g),
+        recr: bool::arbitrary(g),
+        refl: bool::arbitrary(g),
+        is_unsafe: bool::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_inductive_readback(x: Inductive) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for InductiveProj {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self { block: Address::arbitrary(g), idx: Nat::arbitrary(g) }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_inductiveproj_readback(x: InductiveProj) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for ConstructorProj {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        block: Address::arbitrary(g),
+        idx: Nat::arbitrary(g),
+        cidx: Nat::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_constructorproj_readback(x: ConstructorProj) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for RecursorProj {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        block: Address::arbitrary(g),
+        idx: Nat::arbitrary(g),
+        ridx: Nat::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_recursorproj_readback(x: RecursorProj) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for DefinitionProj {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self { block: Address::arbitrary(g), idx: Nat::arbitrary(g) }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_definitionproj_readback(x: DefinitionProj) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Comm {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self { secret: Address::arbitrary(g), payload: Address::arbitrary(g) }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_comm_readback(x: Comm) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for EvalClaim {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Address::arbitrary(g),
+        typ: Address::arbitrary(g),
+        input: Address::arbitrary(g),
+        output: Address::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_evalclaim_readback(x: EvalClaim) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for CheckClaim {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Self {
+        lvls: Address::arbitrary(g),
+        typ: Address::arbitrary(g),
+        value: Address::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_checkclaim_readback(x: CheckClaim) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Claim {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..1);
+      match x {
+        0 => Self::Evals(EvalClaim::arbitrary(g)),
+        _ => Self::Checks(CheckClaim::arbitrary(g)),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_claim_readback(x: Claim) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Proof {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..32);
+      let mut bytes = vec![];
+      for _ in 0..x {
+        bytes.push(u8::arbitrary(g));
+      }
+      Proof { claim: Claim::arbitrary(g), proof: bytes }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_proof_readback(x: Proof) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Env {
+    fn arbitrary(g: &mut Gen) -> Self {
+      let x = gen_range(g, 0..32);
+      let mut env = vec![];
+      for _ in 0..x {
+        env.push(MetaAddress::arbitrary(g));
+      }
+      Env { env }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_env_readback(x: Env) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Substring {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Substring {
+        str: Address::arbitrary(g),
+        start_pos: Nat::arbitrary(g),
+        stop_pos: Nat::arbitrary(g),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_substring_readback(x: Substring) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for SourceInfo {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 3 {
+        0 => Self::Original(
+          Substring::arbitrary(g),
+          Nat::arbitrary(g),
+          Substring::arbitrary(g),
+          Nat::arbitrary(g),
+        ),
+        1 => Self::Synthetic(
+          Nat::arbitrary(g),
+          Nat::arbitrary(g),
+          bool::arbitrary(g),
+        ),
+        2 => Self::None,
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_sourceinfo_readback(x: SourceInfo) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Preresolved {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 2 {
+        0 => Self::Namespace(Address::arbitrary(g)),
+        1 => {
+          Self::Decl(Address::arbitrary(g), gen_vec(g, 12, Address::arbitrary))
+        },
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_preresolved_readback(x: Preresolved) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Syntax {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 4 {
+        0 => Self::Missing,
+        1 => Self::Node(
+          SourceInfo::arbitrary(g),
+          Address::arbitrary(g),
+          gen_vec(g, 12, Address::arbitrary),
+        ),
+        2 => Self::Atom(SourceInfo::arbitrary(g), Address::arbitrary(g)),
+        3 => Self::Ident(
+          SourceInfo::arbitrary(g),
+          Substring::arbitrary(g),
+          Address::arbitrary(g),
+          gen_vec(g, 12, Preresolved::arbitrary),
+        ),
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_syntax_readback(x: Syntax) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for MutConst {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 3 {
+        0 => Self::Defn(Definition::arbitrary(g)),
+        1 => Self::Indc(Inductive::arbitrary(g)),
+        2 => Self::Recr(Recursor::arbitrary(g)),
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_mutconst_readback(x: MutConst) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for BuiltIn {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 3 {
+        0 => Self::Obj,
+        1 => Self::Neutral,
+        2 => Self::Unreachable,
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_builtin_readback(x: BuiltIn) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for DataValue {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 6 {
+        0 => Self::OfString(Address::arbitrary(g)),
+        1 => Self::OfBool(bool::arbitrary(g)),
+        2 => Self::OfName(Address::arbitrary(g)),
+        3 => Self::OfNat(Address::arbitrary(g)),
+        4 => Self::OfInt(Address::arbitrary(g)),
+        5 => Self::OfSyntax(Address::arbitrary(g)),
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_datavalue_readback(x: DataValue) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Metadatum {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 7 {
+        0 => Self::Link(Address::arbitrary(g)),
+        1 => Self::Info(BinderInfo::arbitrary(g)),
+        2 => Self::Hints(ReducibilityHints::arbitrary(g)),
+        3 => Self::Links(gen_vec(g, 12, Address::arbitrary)),
+        4 => Self::Map(gen_vec(g, 12, |g| {
+          (Address::arbitrary(g), Address::arbitrary(g))
+        })),
+        5 => Self::KVMap(gen_vec(g, 12, |g| {
+          (Address::arbitrary(g), DataValue::arbitrary(g))
+        })),
+        6 => Self::Muts(gen_vec(g, 12, |g| gen_vec(g, 12, Address::arbitrary))),
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_metadatum_readback(x: Metadatum) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Metadata {
+    fn arbitrary(g: &mut Gen) -> Self {
+      Metadata { nodes: gen_vec(g, 12, Metadatum::arbitrary) }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_metadata_readback(x: Metadata) -> bool {
+    serialize_readback(x)
+  }
+
+  impl Arbitrary for Ixon {
+    fn arbitrary(g: &mut Gen) -> Self {
+      match u8::arbitrary(g) % 37 {
+        0 => Self::NAnon,
+        1 => Self::NStr(Address::arbitrary(g), Address::arbitrary(g)),
+        2 => Self::NNum(Address::arbitrary(g), Address::arbitrary(g)),
+        3 => Self::UZero,
+        4 => Self::USucc(Address::arbitrary(g)),
+        5 => Self::UMax(Address::arbitrary(g), Address::arbitrary(g)),
+        6 => Self::UMax(Address::arbitrary(g), Address::arbitrary(g)),
+        7 => Self::UIMax(Address::arbitrary(g), Address::arbitrary(g)),
+        8 => Self::UVar(Nat::arbitrary(g)),
+        9 => Self::EVar(Nat::arbitrary(g)),
+        10 => {
+          Self::ERef(Address::arbitrary(g), gen_vec(g, 12, Address::arbitrary))
+        },
+        11 => Self::ERec(Nat::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
+        12 => Self::EPrj(
+          Address::arbitrary(g),
+          Nat::arbitrary(g),
+          Address::arbitrary(g),
+        ),
+        13 => Self::ESort(Address::arbitrary(g)),
+        14 => Self::EStr(Address::arbitrary(g)),
+        15 => Self::ENat(Address::arbitrary(g)),
+        16 => Self::EApp(Address::arbitrary(g), Address::arbitrary(g)),
+        17 => Self::ELam(Address::arbitrary(g), Address::arbitrary(g)),
+        18 => Self::EAll(Address::arbitrary(g), Address::arbitrary(g)),
+        19 => Self::ELet(
+          bool::arbitrary(g),
+          Address::arbitrary(g),
+          Address::arbitrary(g),
+          Address::arbitrary(g),
+        ),
+        20 => Self::Blob(gen_vec(g, 12, u8::arbitrary)),
+        21 => Self::Defn(Definition::arbitrary(g)),
+        22 => Self::Recr(Recursor::arbitrary(g)),
+        23 => Self::Axio(Axiom::arbitrary(g)),
+        24 => Self::Quot(Quotient::arbitrary(g)),
+        25 => Self::CPrj(ConstructorProj::arbitrary(g)),
+        26 => Self::RPrj(RecursorProj::arbitrary(g)),
+        27 => Self::IPrj(InductiveProj::arbitrary(g)),
+        28 => Self::DPrj(DefinitionProj::arbitrary(g)),
+        29 => Self::Muts(gen_vec(g, 12, MutConst::arbitrary)),
+        30 => Self::Prof(Proof::arbitrary(g)),
+        31 => Self::Eval(EvalClaim::arbitrary(g)),
+        32 => Self::Chck(CheckClaim::arbitrary(g)),
+        33 => Self::Comm(Comm::arbitrary(g)),
+        34 => Self::Envn(Env::arbitrary(g)),
+        35 => Self::Prim(BuiltIn::arbitrary(g)),
+        36 => Self::Meta(Metadata::arbitrary(g)),
+        _ => unreachable!(),
+      }
+    }
+  }
+
+  #[quickcheck]
+  fn prop_ixon_readback(x: Ixon) -> bool {
+    serialize_readback(x)
+  }
+}
diff --git a/src/ixon/address.rs b/src/ixon/address.rs
index 17f93f19..2fc47c19 100644
--- a/src/ixon/address.rs
+++ b/src/ixon/address.rs
@@ -44,4 +44,9 @@ pub mod tests {
       Address { hash: Hash::from_slice(&bytes).unwrap() }
     }
   }
+  impl Arbitrary for MetaAddress {
+    fn arbitrary(g: &mut Gen) -> Self {
+      MetaAddress { data: Address::arbitrary(g), meta: Address::arbitrary(g) }
+    }
+  }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 7d662030..45c3cec3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,10 @@
-//#[cfg(test)]
-//extern crate quickcheck;
-//#[cfg(test)]
-//#[macro_use(quickcheck)]
-//extern crate quickcheck_macros;
-//#[cfg(test)]
-//extern crate rand;
+#[cfg(test)]
+extern crate quickcheck;
+#[cfg(test)]
+#[macro_use(quickcheck)]
+extern crate quickcheck_macros;
+#[cfg(test)]
+extern crate rand;
 
 use indexmap::{IndexMap, IndexSet};
 use rustc_hash::FxBuildHasher;

From 782bcdc3394b2cf0a5ff2cc297d79e3649c9c937 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 28 Oct 2025 18:28:57 -0400
Subject: [PATCH 70/74] clippy

---
 src/ixon.rs | 98 +++++++++++++++++++++++++++--------------------------
 src/lib.rs  |  3 ++
 2 files changed, 53 insertions(+), 48 deletions(-)

diff --git a/src/ixon.rs b/src/ixon.rs
index 8ded6ff6..c76133cf 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -146,6 +146,7 @@ pub struct Tag4 {
 }
 
 impl Tag4 {
+  #[allow(clippy::cast_possible_truncation)]
   pub fn encode_head(&self) -> u8 {
     if self.size < 8 {
       (self.flag << 4) + (self.size as u8)
@@ -1663,9 +1664,7 @@ impl Serialize for Ixon {
 pub mod tests {
   use super::*;
   use quickcheck::{Arbitrary, Gen};
-  use std::fmt::Write;
   use std::ops::Range;
-  use std::ptr;
 
   pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
     let res: usize = Arbitrary::arbitrary(g);
@@ -1689,11 +1688,11 @@ pub mod tests {
   }
   #[test]
   fn unit_u64_trimmed() {
-    fn test(input: u64, expected: Vec<u8>) -> bool {
+    fn test(input: u64, expected: &Vec<u8>) -> bool {
       let mut tmp = Vec::new();
       let n = u64_byte_count(input);
       u64_put_trimmed_le(input, &mut tmp);
-      if tmp != expected {
+      if tmp != *expected {
         return false;
       }
       match u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
@@ -1704,28 +1703,31 @@ pub mod tests {
         },
       }
     }
-    assert!(test(0x0, vec![]));
-    assert!(test(0x01, vec![0x01]));
-    assert!(test(0x0000000000000100, vec![0x00, 0x01]));
-    assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
-    assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000010000000000, vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0, &vec![]));
+    assert!(test(0x01, &vec![0x01]));
+    assert!(test(0x0000000000000100, &vec![0x00, 0x01]));
+    assert!(test(0x0000000000010000, &vec![0x00, 0x00, 0x01]));
+    assert!(test(0x0000000001000000, &vec![0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0000000100000000, &vec![0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(
+      0x0000010000000000,
+      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+    ));
     assert!(test(
       0x0001000000000000,
-      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
     ));
     assert!(test(
       0x0100000000000000,
-      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
     ));
     assert!(test(
       0x0102030405060708,
-      vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+      &vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
     ));
     assert!(test(
       0x57712D6CE2965701,
-      vec![0x01, 0x57, 0x96, 0xE2, 0x6C, 0x2D, 0x71, 0x57]
+      &vec![0x01, 0x57, 0x96, 0xE2, 0x6C, 0x2D, 0x71, 0x57]
     ));
   }
 
@@ -1743,10 +1745,11 @@ pub mod tests {
     }
   }
 
+  #[allow(clippy::needless_pass_by_value)]
   fn serialize_readback<S: Serialize + Eq>(x: S) -> bool {
     let mut buf = Vec::new();
     Serialize::put(&x, &mut buf);
-    match Serialize::get(&mut buf.as_slice()) {
+    match S::get(&mut buf.as_slice()) {
       Ok(y) => x == y,
       Err(e) => {
         println!("err: {e}");
@@ -2374,55 +2377,54 @@ pub mod tests {
 
   impl Arbitrary for Ixon {
     fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 37 {
+      match u8::arbitrary(g) % 36 {
         0 => Self::NAnon,
         1 => Self::NStr(Address::arbitrary(g), Address::arbitrary(g)),
         2 => Self::NNum(Address::arbitrary(g), Address::arbitrary(g)),
         3 => Self::UZero,
         4 => Self::USucc(Address::arbitrary(g)),
         5 => Self::UMax(Address::arbitrary(g), Address::arbitrary(g)),
-        6 => Self::UMax(Address::arbitrary(g), Address::arbitrary(g)),
-        7 => Self::UIMax(Address::arbitrary(g), Address::arbitrary(g)),
-        8 => Self::UVar(Nat::arbitrary(g)),
-        9 => Self::EVar(Nat::arbitrary(g)),
-        10 => {
+        6 => Self::UIMax(Address::arbitrary(g), Address::arbitrary(g)),
+        7 => Self::UVar(Nat::arbitrary(g)),
+        8 => Self::EVar(Nat::arbitrary(g)),
+        9 => {
           Self::ERef(Address::arbitrary(g), gen_vec(g, 12, Address::arbitrary))
         },
-        11 => Self::ERec(Nat::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
-        12 => Self::EPrj(
+        10 => Self::ERec(Nat::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
+        11 => Self::EPrj(
           Address::arbitrary(g),
           Nat::arbitrary(g),
           Address::arbitrary(g),
         ),
-        13 => Self::ESort(Address::arbitrary(g)),
-        14 => Self::EStr(Address::arbitrary(g)),
-        15 => Self::ENat(Address::arbitrary(g)),
-        16 => Self::EApp(Address::arbitrary(g), Address::arbitrary(g)),
-        17 => Self::ELam(Address::arbitrary(g), Address::arbitrary(g)),
-        18 => Self::EAll(Address::arbitrary(g), Address::arbitrary(g)),
-        19 => Self::ELet(
+        12 => Self::ESort(Address::arbitrary(g)),
+        13 => Self::EStr(Address::arbitrary(g)),
+        14 => Self::ENat(Address::arbitrary(g)),
+        15 => Self::EApp(Address::arbitrary(g), Address::arbitrary(g)),
+        16 => Self::ELam(Address::arbitrary(g), Address::arbitrary(g)),
+        17 => Self::EAll(Address::arbitrary(g), Address::arbitrary(g)),
+        18 => Self::ELet(
           bool::arbitrary(g),
           Address::arbitrary(g),
           Address::arbitrary(g),
           Address::arbitrary(g),
         ),
-        20 => Self::Blob(gen_vec(g, 12, u8::arbitrary)),
-        21 => Self::Defn(Definition::arbitrary(g)),
-        22 => Self::Recr(Recursor::arbitrary(g)),
-        23 => Self::Axio(Axiom::arbitrary(g)),
-        24 => Self::Quot(Quotient::arbitrary(g)),
-        25 => Self::CPrj(ConstructorProj::arbitrary(g)),
-        26 => Self::RPrj(RecursorProj::arbitrary(g)),
-        27 => Self::IPrj(InductiveProj::arbitrary(g)),
-        28 => Self::DPrj(DefinitionProj::arbitrary(g)),
-        29 => Self::Muts(gen_vec(g, 12, MutConst::arbitrary)),
-        30 => Self::Prof(Proof::arbitrary(g)),
-        31 => Self::Eval(EvalClaim::arbitrary(g)),
-        32 => Self::Chck(CheckClaim::arbitrary(g)),
-        33 => Self::Comm(Comm::arbitrary(g)),
-        34 => Self::Envn(Env::arbitrary(g)),
-        35 => Self::Prim(BuiltIn::arbitrary(g)),
-        36 => Self::Meta(Metadata::arbitrary(g)),
+        19 => Self::Blob(gen_vec(g, 12, u8::arbitrary)),
+        20 => Self::Defn(Definition::arbitrary(g)),
+        21 => Self::Recr(Recursor::arbitrary(g)),
+        22 => Self::Axio(Axiom::arbitrary(g)),
+        23 => Self::Quot(Quotient::arbitrary(g)),
+        24 => Self::CPrj(ConstructorProj::arbitrary(g)),
+        25 => Self::RPrj(RecursorProj::arbitrary(g)),
+        26 => Self::IPrj(InductiveProj::arbitrary(g)),
+        27 => Self::DPrj(DefinitionProj::arbitrary(g)),
+        28 => Self::Muts(gen_vec(g, 12, MutConst::arbitrary)),
+        29 => Self::Prof(Proof::arbitrary(g)),
+        30 => Self::Eval(EvalClaim::arbitrary(g)),
+        31 => Self::Chck(CheckClaim::arbitrary(g)),
+        32 => Self::Comm(Comm::arbitrary(g)),
+        33 => Self::Envn(Env::arbitrary(g)),
+        34 => Self::Prim(BuiltIn::arbitrary(g)),
+        35 => Self::Meta(Metadata::arbitrary(g)),
         _ => unreachable!(),
       }
     }
diff --git a/src/lib.rs b/src/lib.rs
index 45c3cec3..6eda285a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,8 +1,11 @@
+#[allow(unused_extern_crates)]
 #[cfg(test)]
 extern crate quickcheck;
+#[allow(unused_extern_crates)]
 #[cfg(test)]
 #[macro_use(quickcheck)]
 extern crate quickcheck_macros;
+#[allow(unused_extern_crates)]
 #[cfg(test)]
 extern crate rand;
 

From b9a08245519f04101da4b93122621b11f5afa1de Mon Sep 17 00:00:00 2001
From: Samuel Burnham <45365069+samuelburnham@users.noreply.github.com>
Date: Tue, 28 Oct 2025 13:39:54 -0400
Subject: [PATCH 71/74] chore: Update benchmarks and Nix build (#245)

* chore: Update benchmarks and Nix build

* Restore CLI tests without store or prove
---
 Benchmarks/Aiur.lean    | 255 ++++++++--------
 Ix/Benchmark/Bench.lean | 643 ++++++++++++++++++++--------------------
 Ix/Benchmark/Serde.lean | 176 ++++++-----
 Ix/Cli/ProveCmd.lean    | 202 ++++++-------
 Ix/Cli/StoreCmd.lean    | 190 ++++++------
 Main.lean               |   8 +-
 Tests/Cli.lean          |  38 +--
 Tests/Main.lean         |   3 +-
 flake.lock              |  18 +-
 flake.nix               |   2 +-
 ix.nix                  |   2 +-
 lake-manifest.json      |   8 +-
 lakefile.lean           |   4 +-
 13 files changed, 780 insertions(+), 769 deletions(-)

diff --git a/Benchmarks/Aiur.lean b/Benchmarks/Aiur.lean
index 2369431a..86a70e05 100644
--- a/Benchmarks/Aiur.lean
+++ b/Benchmarks/Aiur.lean
@@ -1,129 +1,128 @@
---import Ix.Aiur.Meta
---import Ix.Aiur.Simple
---import Ix.Aiur.Compile
---import Ix.Aiur.Protocol
---import Ix.Benchmark.Bench
---
---def toplevel := ⟦
---  enum Nat {
---    Zero,
---    Succ(&Nat)
---  }
---
---  fn g_to_nat(g: G) -> Nat {
---    match g {
---      0 => Nat.Zero,
---      _ => Nat.Succ(store(g_to_nat(g - 1))),
---    }
---  }
---
---  fn nat_to_g(n: Nat) -> G {
---    match n {
---      Nat.Zero => 0,
---      Nat.Succ(ptr) => nat_to_g(load(ptr)) + 1,
---    }
---  }
---
---  fn nat_add(a: Nat, b: Nat) -> Nat {
---    match b {
---      Nat.Zero => a,
---      Nat.Succ(b'ptr) => nat_add(Nat.Succ(store(a)), load(b'ptr)),
---    }
---  }
---
---  fn nat_fib(n: Nat) -> Nat {
---    match n {
---      Nat.Zero => Nat.Succ(store(Nat.Zero)),
---      Nat.Succ(n'ptr) =>
---        let n' = load(n'ptr);
---        match n' {
---          Nat.Zero => Nat.Succ(store(Nat.Zero)),
---          Nat.Succ(n''ptr) =>
---            let n'' = load(n''ptr);
---            nat_add(nat_fib(n'), nat_fib(n'')),
---        },
---    }
---  }
---
---  fn main(g: G) -> G {
---    nat_to_g(nat_fib(g_to_nat(g)))
---  }
---⟧
---
---def commitmentParameters : Aiur.CommitmentParameters := {
---  logBlowup := 1
---}
---
---def friParameters : Aiur.FriParameters := {
---  logFinalPolyLen := 0
---  numQueries := 100
---  proofOfWorkBits := 20
---}
---
---def proveE2E (name: Lean.Name) : IO UInt32 := do
---  match toplevel.checkAndSimplify with
---  | .error e => IO.eprintln e; return 1
---  | .ok decls =>
---    let bytecode := decls.compile
---    let system := Aiur.AiurSystem.build bytecode commitmentParameters
---    let funIdx := toplevel.getFuncIdx name |>.get!
---    let (claim, proof, _) := system.prove friParameters funIdx #[10] default
---    match system.verify friParameters claim proof with
---    | .ok _ => return 0
---    | .error e => IO.eprintln e; return 1
---
---
----- End-to-end proof generation and verification benchmark
---def proveE2EBench := bgroup "prove E2E" [
---  benchIO "fib 10" proveE2E `main
---] { samplingMode := .flat }
---
----- Individual benchmarks of each step from `proveE2E`
---
---def toplevelBench := bgroup "nat_fib" [
---  bench "simplify toplevel" Aiur.Toplevel.checkAndSimplify toplevel
---]
---
---def compileBench : IO Unit := do
---  match toplevel.checkAndSimplify with
---  | .error e => IO.eprintln e
---  | .ok decls =>
---    bgroup "nat_fib" [
---      bench "compile decls" Aiur.TypedDecls.compile decls
---    ]
---
---def buildAiurSystemBench : IO Unit := do
---  match toplevel.checkAndSimplify with
---  | .error e => IO.eprintln e
---  | .ok decls =>
---    let bytecode := decls.compile
---    bgroup "nat_fib" [
---      bench "build AiurSystem" (Aiur.AiurSystem.build bytecode) commitmentParameters
---    ]
---
---def proveBench : IO Unit := do
---  match toplevel.checkAndSimplify with
---  | .error e => IO.eprintln e
---  | .ok decls =>
---    let bytecode := decls.compile
---    let system := Aiur.AiurSystem.build bytecode commitmentParameters
---    let funIdx := toplevel.getFuncIdx `main |>.get!
---    bgroup "nat_fib" [
---      bench "prove fib 10" (Aiur.AiurSystem.prove system friParameters funIdx) #[10]
---    ]
---
---def verifyBench : IO Unit := do
---  match toplevel.checkAndSimplify with
---  | .error e => IO.eprintln e
---  | .ok decls =>
---    let bytecode := decls.compile
---    let system := Aiur.AiurSystem.build bytecode commitmentParameters
---    let funIdx := toplevel.getFuncIdx `main |>.get!
---    let (claim, proof, _) := system.prove friParameters funIdx #[10] default
---    bgroup "nat_fib" [
---      bench "verify fib 10" (Aiur.AiurSystem.verify system friParameters claim) proof
---    ]
---
+import Ix.Aiur.Meta
+import Ix.Aiur.Simple
+import Ix.Aiur.Compile
+import Ix.Aiur.Protocol
+import Ix.Benchmark.Bench
+
+def toplevel := ⟦
+  enum Nat {
+    Zero,
+    Succ(&Nat)
+  }
+
+  fn g_to_nat(g: G) -> Nat {
+    match g {
+      0 => Nat.Zero,
+      _ => Nat.Succ(store(g_to_nat(g - 1))),
+    }
+  }
+
+  fn nat_to_g(n: Nat) -> G {
+    match n {
+      Nat.Zero => 0,
+      Nat.Succ(ptr) => nat_to_g(load(ptr)) + 1,
+    }
+  }
+
+  fn nat_add(a: Nat, b: Nat) -> Nat {
+    match b {
+      Nat.Zero => a,
+      Nat.Succ(b'ptr) => nat_add(Nat.Succ(store(a)), load(b'ptr)),
+    }
+  }
+
+  fn nat_fib(n: Nat) -> Nat {
+    match n {
+      Nat.Zero => Nat.Succ(store(Nat.Zero)),
+      Nat.Succ(n'ptr) =>
+        let n' = load(n'ptr);
+        match n' {
+          Nat.Zero => Nat.Succ(store(Nat.Zero)),
+          Nat.Succ(n''ptr) =>
+            let n'' = load(n''ptr);
+            nat_add(nat_fib(n'), nat_fib(n'')),
+        },
+    }
+  }
+
+  fn main(g: G) -> G {
+    nat_to_g(nat_fib(g_to_nat(g)))
+  }
+⟧
+
+def commitmentParameters : Aiur.CommitmentParameters := {
+  logBlowup := 1
+}
+
+def friParameters : Aiur.FriParameters := {
+  logFinalPolyLen := 0
+  numQueries := 100
+  proofOfWorkBits := 20
+}
+
+def proveE2E (name: Lean.Name) : IO UInt32 := do
+  match toplevel.checkAndSimplify with
+  | .error e => IO.eprintln e; return 1
+  | .ok decls =>
+    let bytecode := decls.compile
+    let system := Aiur.AiurSystem.build bytecode commitmentParameters
+    let funIdx := toplevel.getFuncIdx name |>.get!
+    let (claim, proof, _) := system.prove friParameters funIdx #[10] default
+    match system.verify friParameters claim proof with
+    | .ok _ => return 0
+    | .error e => IO.eprintln e; return 1
+
+
+-- End-to-end proof generation and verification benchmark
+def proveE2EBench := bgroup "prove E2E" [
+  benchIO "fib 10" proveE2E `main
+] { samplingMode := .flat }
+
+-- Individual benchmarks of each step from `proveE2E`
+
+def toplevelBench := bgroup "nat_fib" [
+  bench "simplify toplevel" Aiur.Toplevel.checkAndSimplify toplevel
+]
+
+def compileBench : IO Unit := do
+  match toplevel.checkAndSimplify with
+  | .error e => IO.eprintln e
+  | .ok decls =>
+    bgroup "nat_fib" [
+      bench "compile decls" Aiur.TypedDecls.compile decls
+    ]
+
+def buildAiurSystemBench : IO Unit := do
+  match toplevel.checkAndSimplify with
+  | .error e => IO.eprintln e
+  | .ok decls =>
+    let bytecode := decls.compile
+    bgroup "nat_fib" [
+      bench "build AiurSystem" (Aiur.AiurSystem.build bytecode) commitmentParameters
+    ]
+
+def proveBench : IO Unit := do
+  match toplevel.checkAndSimplify with
+  | .error e => IO.eprintln e
+  | .ok decls =>
+    let bytecode := decls.compile
+    let system := Aiur.AiurSystem.build bytecode commitmentParameters
+    let funIdx := toplevel.getFuncIdx `main |>.get!
+    bgroup "nat_fib" [
+      bench "prove fib 10" (Aiur.AiurSystem.prove system friParameters funIdx) #[10]
+    ]
+
+def verifyBench : IO Unit := do
+  match toplevel.checkAndSimplify with
+  | .error e => IO.eprintln e
+  | .ok decls =>
+    let bytecode := decls.compile
+    let system := Aiur.AiurSystem.build bytecode commitmentParameters
+    let funIdx := toplevel.getFuncIdx `main |>.get!
+    let (claim, proof, _) := system.prove friParameters funIdx #[10] default
+    bgroup "nat_fib" [
+      bench "verify fib 10" (Aiur.AiurSystem.verify system friParameters claim) proof
+    ]
+
 def main (_args : List String) : IO Unit := do
-    return ()
---  let _result ← proveBench
+  let _result ← proveBench
diff --git a/Ix/Benchmark/Bench.lean b/Ix/Benchmark/Bench.lean
index ab170b86..e8270766 100644
--- a/Ix/Benchmark/Bench.lean
+++ b/Ix/Benchmark/Bench.lean
@@ -1,322 +1,321 @@
---import Ix.Ixon
---import Ix.Address
---import Ix.Meta
---import Ix.CompileM
---import Ix.Cronos
---import Ix.Address
---import Batteries
---
---import Ix.Benchmark.Serde
---import Ix.Benchmark.Tukey
---
---open Batteries (RBMap)
---
---/-!
---# Benchmarking library modeled after Criterion in Haskell and Rust
---
---## Limitations
---- Measures time in nanoseconds using `IO.monoNanosNow`, which is less precise than the picoseconds used in Criterion.rs
----/
---
---/--
---Computes the result and then wraps the return type in IO. This prevents Lean from optimizing away the function call due to an unused return value.
----/
---@[never_extract, noinline]
---def blackBoxIO (f : α → β) (a : α) : IO β := do
---  pure $ f a
---
---/--
---A benchmark group defines a collection of related benchmarks that share a configuration, such as number of samples and noise threshold
----/
---structure BenchGroup where
---  name : String
---  config : Config
---
---inductive BenchFn ( α β : Type) where
---| pure (fn : α → β)
---| io (fn : α → IO β)
---
---structure Benchmarkable (α β : Type) where
---  name : String
---  func : BenchFn α β
---  arg : α
---
---/--
---Creates a `Benchmarkable` instance. Use with pure functions, which will later be called with `blackBoxIO` to prevent compiler optimizations.
----/
---def bench (name : String) (fn : α → β) (arg : α) : Benchmarkable α β := { name, func := BenchFn.pure fn, arg }
---
---/--
---Creates a `Benchmarkable` instance. Use with functions that return IO, as they don't need to be black boxed.
----/
---def benchIO (name : String) (fn : α → IO β) (arg : α) : Benchmarkable α β :=  { name, func := BenchFn.io fn, arg }
---
---/-- If the function is pure, we need to wrap it in `blackBoxIO` so that Lean doesn't optimize away the result -/
---def Benchmarkable.getFn ( bench: Benchmarkable α β) : α → IO β :=
---  match bench.func with
---  | .pure f => blackBoxIO f
---  | .io f => f
---
----- TODO: According to Criterion.rs docs the warmup iterations should increase linearly until the warmup time is reached, rather than one iteration per time check
---def BenchGroup.warmup (bg : BenchGroup) (bench : Benchmarkable α β) : IO Float := do
---  IO.println s!"Warming up for {bg.config.warmupTime.floatPretty 2}s"
---  let mut count := 0
---  let warmupNanos := Cronos.secToNano bg.config.warmupTime
---  let mut elapsed := 0
---  let func := bench.getFn
---  let startTime ← IO.monoNanosNow
---  while elapsed < warmupNanos do
---    let _res ← func bench.arg
---    let now ← IO.monoNanosNow
---    count := count + 1
---    elapsed := now - startTime
---  let mean := Float.ofNat elapsed / Float.ofNat count
---  --IO.println s!"{bench.name} warmup avg: {mean}ns"
---  return mean
---
----- TODO: Combine with other sampling functions, DRY
----- TODO: Recommend sample count if expectedTime >>> bg.config.sampleTime (i.e. itersPerSample == 1)
---/--
---Runs the sample as a sequence of constant iterations per data point, where the iteration count attempts to fit into the configurable `sampleTime` but cannot be less than 1.
---
---Returns the iteration counts and elapsed time per data point.
----/
---def BenchGroup.sampleFlat (bg : BenchGroup) (bench : Benchmarkable α β)
---(warmupMean : Float) : IO (Array Nat × Array Nat) := do
---  let targetTime := bg.config.sampleTime.toNanos
---  let timePerSample := targetTime / (Float.ofNat bg.config.numSamples)
---  let itersPerSample := (timePerSample / warmupMean).ceil.toUInt64.toNat.max 1
---  let totalIters := itersPerSample * bg.config.numSamples
---  let expectedTime := warmupMean * Float.ofNat itersPerSample * bg.config.numSamples.toSeconds
---  if itersPerSample == 1
---  then
---    IO.eprintln s!"Warning: Unable to complete {bg.config.numSamples} samples in {bg.config.sampleTime.floatPretty 2}s. You may wish to increase target time to {expectedTime.floatPretty 2}s"
---  IO.println s!"Running {bg.config.numSamples} samples in {expectedTime.floatPretty 2}s ({totalIters.natPretty} iterations)\n"
---  --IO.println s!"Flat sample. Iters per sample: {itersPerSample}"
---  let func := bench.getFn
---  let mut timings : Array Nat := #[]
---  -- TODO: `mkArray` deprecated in favor of `replicate` in Lean v4.19
---  let sampleIters := Array.mkArray bg.config.numSamples itersPerSample
---  for iters in sampleIters do
---    let start ← IO.monoNanosNow
---    for _i in Array.range iters do
---      let _res ← func bench.arg
---    let finish ← IO.monoNanosNow
---    timings := timings.push (finish - start)
---  return (sampleIters, timings)
---
---/--
---Runs the sample as a sequence of linearly increasing iterations [d, 2d, 3d, ..., Nd] where `N` is the total number of samples and `d` is a factor derived from the warmup iteration time.
---
---The sum of this series should be roughly equivalent to the total `sampleTime`.
---
---Returns the iteration counts and elapsed time per sample.
----/
---def BenchGroup.sampleLinear (bg : BenchGroup) (bench : Benchmarkable α β) (warmupMean : Float) : IO (Array Nat × Array Nat) := do
---  let totalRuns := bg.config.numSamples * (bg.config.numSamples + 1) / 2
---  let targetTime := bg.config.sampleTime.toNanos
---  let d := (targetTime / warmupMean / (Float.ofNat totalRuns)).ceil.toUInt64.toNat.max 1
---  let expectedTime := (Float.ofNat totalRuns) * (Float.ofNat d) * warmupMean.toSeconds
---  let sampleIters := (Array.range bg.config.numSamples).map (fun x => (x + 1) * d)
---  -- `d` has a minimum value of 1 if the `warmupMean` is sufficiently large
---  -- If so, that likely means the benchmark takes too long and target time should be increased, as well as other config options like flat sampling mode
---  if d == 1
---  then
---    IO.eprintln s!"Warning: Unable to complete {bg.config.numSamples} samples in {bg.config.sampleTime.floatPretty 2}s. You may wish to increase target time to {expectedTime.floatPretty 2}s"
---  IO.println s!"Running {bg.config.numSamples} samples in {expectedTime.floatPretty 2}s ({sampleIters.sum.natPretty} iterations)\n"
---  --IO.println s!"Linear sample. Iters increase by a factor of {d} per sample"
---  let func := bench.getFn
---  let mut timings : Array Nat := #[]
---  for iters in sampleIters do
---    let start ← IO.monoNanosNow
---    for _i in Array.range iters do
---      let _res ← func bench.arg
---    let finish ← IO.monoNanosNow
---    timings := timings.push (finish - start)
---  return (sampleIters, timings)
---
---def BenchGroup.sample (bg : BenchGroup) (bench : Benchmarkable α β) (warmupMean : Float) : IO (Array Nat × Array Nat) := do
---  match bg.config.samplingMode with
---  | .flat => bg.sampleFlat bench warmupMean
---  | .linear => bg.sampleLinear bench warmupMean
---
----- TODO
---inductive Throughput where
---| Bytes (n : UInt64)
---| BytesDecimal (n : UInt64)
---| Elements (n : UInt64)
---| Bits (n : UInt64)
---
---structure MeasurementData where
---  data : Data
---  avgTimes : Distribution
---  absoluteEstimates : Estimates
---  distributions : Distributions
---  comparison : Option ComparisonData
---  throughput : Option Throughput
---
---/-- Compare performance against prior run -/
---def BenchGroup.compare (bg : BenchGroup) (baseSample : Data) (baseEstimates : Estimates) (avgTimes : Distribution) (gen : StdGen) : ComparisonData :=
---  -- Get `base` data for comparison
---  let baseAvgTimes : Distribution := { d := baseSample.d.map (fun (x,y) => Float.ofNat y / Float.ofNat x) }
---  -- Then perform statistical analysis
---  let (tValue, tDistribution) := tTest avgTimes baseAvgTimes bg.config gen
---  let (relativeEstimates, relativeDistributions) := changeEstimates avgTimes baseAvgTimes bg.config gen
---  let pValue := tDistribution.pValue tValue
---  {
---    pValue,
---    tDistribution,
---    tValue,
---    relativeEstimates,
---    relativeDistributions,
---    significanceThreshold := bg.config.significanceLevel,
---    noiseThreshold := bg.config.noiseThreshold,
---    baseSample,
---    baseAvgTimes,
---    baseEstimates
---  }
---
----- TODO: Don't compare if different sampling modes were used
---def BenchGroup.getComparison (bg : BenchGroup) (benchName : String) (avgTimes : Distribution) : IO (Option ComparisonData) := do
---  let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
---  let basePath := benchPath / "base"
---  if (← System.FilePath.pathExists basePath)
---  then do
---    let newPath := benchPath / "new"
---    -- If 2 or more prior runs, then the base data was stored in `new`
---    let basePath' := if (← System.FilePath.pathExists newPath)
---    then
---      newPath
---    else
---      basePath
---    let baseEstimateBytes ← IO.FS.readBinFile (basePath' / "estimates.ixon")
---    let baseEstimates ← match (Ixon.Serialize.get baseEstimateBytes : Except String Estimates) with
---    | .ok bd' => pure bd'
---    | e => throw $ IO.userError s!"expected `Estimates`, got {repr e}"
---    let baseSampleBytes ← IO.FS.readBinFile (basePath' / "sample.ixon")
---    let baseSample ← match (Ixon.Serialize.get baseSampleBytes : Except String Data) with
---    | .ok bd' => pure bd'
---    | e => throw $ IO.userError s!"expected `Data`, got {repr e}"
---    let gen ← IO.stdGenRef.get
---    return some $ bg.compare baseSample baseEstimates avgTimes gen
---  else
---    return none
---
---inductive ComparisonResult where
---| Improved
---| Regressed
---| NonSignificant
---
---def compareToThreshold (estimate : Estimate) (noiseThreshold : Float) : ComparisonResult :=
---  let ci := estimate.confidenceInterval
---  let (lb, ub) := (ci.lowerBound, ci.upperBound)
---  let noiseNeg := noiseThreshold.neg
---
---  if lb < noiseNeg && ub < noiseNeg
---  then
---    ComparisonResult.Improved
---  else if lb > noiseThreshold && ub > noiseThreshold
---  then
---    ComparisonResult.Regressed
---  else
---    ComparisonResult.NonSignificant
---
----- TODO: Print ~24 whitespace characters before time, change, regression
---def BenchGroup.printResults (bg : BenchGroup) (benchName : String) (m : MeasurementData) : IO Unit := do
---  let estimates := m.absoluteEstimates
---  let typicalEstimate := estimates.slope.getD estimates.mean
---  IO.println s!"{bg.name}/{benchName}"
---  let lb := typicalEstimate.confidenceInterval.lowerBound.formatNanos
---  let pointEst := typicalEstimate.pointEstimate.formatNanos
---  let ub := typicalEstimate.confidenceInterval.upperBound.formatNanos
---  IO.println s!"time:   [{lb} {pointEst} {ub}]"
---  if let some comp := m.comparison
---  then
---    let diffMean := comp.pValue < comp.significanceThreshold
---    let meanEst := comp.relativeEstimates.mean
---    let pointEst := (meanEst.pointEstimate * 100).floatPretty 4
---    let lb := (meanEst.confidenceInterval.lowerBound * 100).floatPretty 4
---    let ub := (meanEst.confidenceInterval.upperBound * 100).floatPretty 4
---    let symbol := if diffMean then "<" else ">"
---    IO.println s!"change: [{lb}% {pointEst}% {ub}%] (p = {comp.pValue.floatPretty 2} {symbol} {comp.significanceThreshold.floatPretty 2})"
---    let explanation := if diffMean
---    then
---      "No change in performance detected"
---    else
---      match compareToThreshold meanEst comp.noiseThreshold with
---      | ComparisonResult.Improved => "Performance has improved"
---      | ComparisonResult.Regressed => "Performance has regressed"
---      | ComparisonResult.NonSignificant => "Change within noise threshold"
---    IO.println explanation
---  IO.println ""
---  m.avgTimes.tukey
---
---def saveComparison! (benchName : String) (comparison : Option ComparisonData) : IO Unit := do
---  match comparison with
---  | some comp => do
---    let changeIxon := Ixon.Serialize.put comp.relativeEstimates
---    let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
---    let changePath := benchPath / "change"
---    let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", changePath.toString ] }
---    IO.FS.writeBinFile (changePath / "estimates.ixon") changeIxon
---  | none => IO.eprintln s!"Error: expected `comparisonData` to write but found none"
---
----- TODO: Write sampling mode in `sample.json` for comparison
---def saveResults (benchName : String) (m : MeasurementData) : IO Unit := do
---  let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
---  let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", benchPath.toString] }
---  let basePath := benchPath / "base"
---  let baseDir := basePath.toString
---  -- If prior results were saved to disk, don't overwrite them
---  let newPath ← if (← System.FilePath.pathExists basePath)
---    then do
---      let newPath := benchPath / "new"
---      let newDir := newPath.toString
---      -- If 2 or more prior runs, then the base data was stored in `new`
---      -- Move the base data to `base`
---      if (← System.FilePath.pathExists newPath)
---      then do
---        let _out ← IO.Process.run {cmd := "rm", args := #["-r", baseDir] }
---        let _out ← IO.Process.run {cmd := "mv", args := #[newDir, baseDir] }
---      let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", newPath.toString] }
---      saveComparison! benchName m.comparison
---      pure newPath
---  else do
---    let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", baseDir] }
---    pure basePath
---  let sampleIxon := Ixon.Serialize.put m.data
---  IO.FS.writeBinFile (newPath / "sample.ixon") sampleIxon
---  let estimateIxon := Ixon.Serialize.put m.absoluteEstimates
---  IO.FS.writeBinFile (newPath / "estimates.ixon") estimateIxon
---
----- TODO: Make sure compiler isn't caching partial evaluation result for future runs of the same function (measure first vs subsequent runs)
---/-- Runs each benchmark in a `BenchGroup` and analyzes the results -/
---def bgroup {α β : Type} (name: String) (benches : List (Benchmarkable α β)) (config : Config := {}) : IO Unit := do
---  let bg : BenchGroup := { name, config }
---  IO.println s!"Running bench group {name}\n"
---  for b in benches do
---    let warmupMean ← bg.warmup b
---    IO.println s!"Running {b.name}"
---    let (iters, times) ← bg.sample b warmupMean
---    let data := iters.zip times
---    let avgTimes : Distribution := { d := data.map (fun (x,y) => Float.ofNat y / Float.ofNat x) }
---    let gen ← IO.stdGenRef.get
---    let mut (distributions, estimates) := avgTimes.estimates bg.config gen
---    if bg.config.samplingMode == .linear
---    then
---      let data' : Data := { d := data }
---      let (distribution, slope) := data'.regression bg.config gen
---      estimates := { estimates with slope := .some slope }
---      distributions := { distributions with slope := .some distribution }
---    let comparisonData : Option ComparisonData ← bg.getComparison b.name avgTimes
---    let m :=  {
---      data := { d := data },
---      avgTimes,
---      absoluteEstimates := estimates,
---      distributions,
---      comparison := comparisonData
---      throughput := none
---    }
---    bg.printResults b.name m
---    IO.println ""
---    saveResults b.name m
+import Ix.Ixon
+import Ix.Address
+import Ix.Meta
+import Ix.CompileM
+import Ix.Cronos
+import Ix.Address
+import Batteries
+
+import Ix.Benchmark.Serde
+import Ix.Benchmark.Tukey
+
+open Batteries (RBMap)
+
+/-!
+# Benchmarking library modeled after Criterion in Haskell and Rust
+
+## Limitations
+- Measures time in nanoseconds using `IO.monoNanosNow`, which is less precise than the picoseconds used in Criterion.rs
+-/
+
+/--
+Computes the result and then wraps the return type in IO. This prevents Lean from optimizing away the function call due to an unused return value.
+-/
+@[never_extract, noinline]
+def blackBoxIO (f : α → β) (a : α) : IO β := do
+  pure $ f a
+
+/--
+A benchmark group defines a collection of related benchmarks that share a configuration, such as number of samples and noise threshold
+-/
+structure BenchGroup where
+  name : String
+  config : Config
+
+inductive BenchFn ( α β : Type) where
+| pure (fn : α → β)
+| io (fn : α → IO β)
+
+structure Benchmarkable (α β : Type) where
+  name : String
+  func : BenchFn α β
+  arg : α
+
+/--
+Creates a `Benchmarkable` instance. Use with pure functions, which will later be called with `blackBoxIO` to prevent compiler optimizations.
+-/
+def bench (name : String) (fn : α → β) (arg : α) : Benchmarkable α β := { name, func := BenchFn.pure fn, arg }
+
+/--
+Creates a `Benchmarkable` instance. Use with functions that return IO, as they don't need to be black boxed.
+-/
+def benchIO (name : String) (fn : α → IO β) (arg : α) : Benchmarkable α β :=  { name, func := BenchFn.io fn, arg }
+
+/-- If the function is pure, we need to wrap it in `blackBoxIO` so that Lean doesn't optimize away the result -/
+def Benchmarkable.getFn ( bench: Benchmarkable α β) : α → IO β :=
+  match bench.func with
+  | .pure f => blackBoxIO f
+  | .io f => f
+
+-- TODO: According to Criterion.rs docs the warmup iterations should increase linearly until the warmup time is reached, rather than one iteration per time check
+def BenchGroup.warmup (bg : BenchGroup) (bench : Benchmarkable α β) : IO Float := do
+  IO.println s!"Warming up for {bg.config.warmupTime.floatPretty 2}s"
+  let mut count := 0
+  let warmupNanos := Cronos.secToNano bg.config.warmupTime
+  let mut elapsed := 0
+  let func := bench.getFn
+  let startTime ← IO.monoNanosNow
+  while elapsed < warmupNanos do
+    let _res ← func bench.arg
+    let now ← IO.monoNanosNow
+    count := count + 1
+    elapsed := now - startTime
+  let mean := Float.ofNat elapsed / Float.ofNat count
+  --IO.println s!"{bench.name} warmup avg: {mean}ns"
+  return mean
+
+-- TODO: Combine with other sampling functions, DRY
+-- TODO: Recommend sample count if expectedTime >>> bg.config.sampleTime (i.e. itersPerSample == 1)
+/--
+Runs the sample as a sequence of constant iterations per data point, where the iteration count attempts to fit into the configurable `sampleTime` but cannot be less than 1.
+
+Returns the iteration counts and elapsed time per data point.
+-/
+def BenchGroup.sampleFlat (bg : BenchGroup) (bench : Benchmarkable α β)
+(warmupMean : Float) : IO (Array Nat × Array Nat) := do
+  let targetTime := bg.config.sampleTime.toNanos
+  let timePerSample := targetTime / (Float.ofNat bg.config.numSamples)
+  let itersPerSample := (timePerSample / warmupMean).ceil.toUInt64.toNat.max 1
+  let totalIters := itersPerSample * bg.config.numSamples
+  let expectedTime := warmupMean * Float.ofNat itersPerSample * bg.config.numSamples.toSeconds
+  if itersPerSample == 1
+  then
+    IO.eprintln s!"Warning: Unable to complete {bg.config.numSamples} samples in {bg.config.sampleTime.floatPretty 2}s. You may wish to increase target time to {expectedTime.floatPretty 2}s"
+  IO.println s!"Running {bg.config.numSamples} samples in {expectedTime.floatPretty 2}s ({totalIters.natPretty} iterations)\n"
+  --IO.println s!"Flat sample. Iters per sample: {itersPerSample}"
+  let func := bench.getFn
+  let mut timings : Array Nat := #[]
+  let sampleIters := Array.replicate bg.config.numSamples itersPerSample
+  for iters in sampleIters do
+    let start ← IO.monoNanosNow
+    for _i in Array.range iters do
+      let _res ← func bench.arg
+    let finish ← IO.monoNanosNow
+    timings := timings.push (finish - start)
+  return (sampleIters, timings)
+
+/--
+Runs the sample as a sequence of linearly increasing iterations [d, 2d, 3d, ..., Nd] where `N` is the total number of samples and `d` is a factor derived from the warmup iteration time.
+
+The sum of this series should be roughly equivalent to the total `sampleTime`.
+
+Returns the iteration counts and elapsed time per sample.
+-/
+def BenchGroup.sampleLinear (bg : BenchGroup) (bench : Benchmarkable α β) (warmupMean : Float) : IO (Array Nat × Array Nat) := do
+  let totalRuns := bg.config.numSamples * (bg.config.numSamples + 1) / 2
+  let targetTime := bg.config.sampleTime.toNanos
+  let d := (targetTime / warmupMean / (Float.ofNat totalRuns)).ceil.toUInt64.toNat.max 1
+  let expectedTime := (Float.ofNat totalRuns) * (Float.ofNat d) * warmupMean.toSeconds
+  let sampleIters := (Array.range bg.config.numSamples).map (fun x => (x + 1) * d)
+  -- `d` has a minimum value of 1 if the `warmupMean` is sufficiently large
+  -- If so, that likely means the benchmark takes too long and target time should be increased, as well as other config options like flat sampling mode
+  if d == 1
+  then
+    IO.eprintln s!"Warning: Unable to complete {bg.config.numSamples} samples in {bg.config.sampleTime.floatPretty 2}s. You may wish to increase target time to {expectedTime.floatPretty 2}s"
+  IO.println s!"Running {bg.config.numSamples} samples in {expectedTime.floatPretty 2}s ({sampleIters.sum.natPretty} iterations)\n"
+  --IO.println s!"Linear sample. Iters increase by a factor of {d} per sample"
+  let func := bench.getFn
+  let mut timings : Array Nat := #[]
+  for iters in sampleIters do
+    let start ← IO.monoNanosNow
+    for _i in Array.range iters do
+      let _res ← func bench.arg
+    let finish ← IO.monoNanosNow
+    timings := timings.push (finish - start)
+  return (sampleIters, timings)
+
+def BenchGroup.sample (bg : BenchGroup) (bench : Benchmarkable α β) (warmupMean : Float) : IO (Array Nat × Array Nat) := do
+  match bg.config.samplingMode with
+  | .flat => bg.sampleFlat bench warmupMean
+  | .linear => bg.sampleLinear bench warmupMean
+
+-- TODO
+inductive Throughput where
+| Bytes (n : UInt64)
+| BytesDecimal (n : UInt64)
+| Elements (n : UInt64)
+| Bits (n : UInt64)
+
+structure MeasurementData where
+  data : Data
+  avgTimes : Distribution
+  absoluteEstimates : Estimates
+  distributions : Distributions
+  comparison : Option ComparisonData
+  throughput : Option Throughput
+
+/-- Compare performance against prior run -/
+def BenchGroup.compare (bg : BenchGroup) (baseSample : Data) (baseEstimates : Estimates) (avgTimes : Distribution) (gen : StdGen) : ComparisonData :=
+  -- Get `base` data for comparison
+  let baseAvgTimes : Distribution := { d := baseSample.d.map (fun (x,y) => Float.ofNat y / Float.ofNat x) }
+  -- Then perform statistical analysis
+  let (tValue, tDistribution) := tTest avgTimes baseAvgTimes bg.config gen
+  let (relativeEstimates, relativeDistributions) := changeEstimates avgTimes baseAvgTimes bg.config gen
+  let pValue := tDistribution.pValue tValue
+  {
+    pValue,
+    tDistribution,
+    tValue,
+    relativeEstimates,
+    relativeDistributions,
+    significanceThreshold := bg.config.significanceLevel,
+    noiseThreshold := bg.config.noiseThreshold,
+    baseSample,
+    baseAvgTimes,
+    baseEstimates
+  }
+
+-- TODO: Don't compare if different sampling modes were used
+def BenchGroup.getComparison (bg : BenchGroup) (benchName : String) (avgTimes : Distribution) : IO (Option ComparisonData) := do
+  let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
+  let basePath := benchPath / "base"
+  if (← System.FilePath.pathExists basePath)
+  then do
+    let newPath := benchPath / "new"
+    -- If 2 or more prior runs, then the base data was stored in `new`
+    let basePath' := if (← System.FilePath.pathExists newPath)
+    then
+      newPath
+    else
+      basePath
+    let baseEstimateBytes ← IO.FS.readBinFile (basePath' / "estimates.ixon")
+    let baseEstimates ← match (Ixon.de baseEstimateBytes : Except String Estimates) with
+    | .ok bd' => pure bd'
+    | e => throw $ IO.userError s!"expected `Estimates`, got {repr e}"
+    let baseSampleBytes ← IO.FS.readBinFile (basePath' / "sample.ixon")
+    let baseSample ← match (Ixon.de baseSampleBytes : Except String Data) with
+    | .ok bd' => pure bd'
+    | e => throw $ IO.userError s!"expected `Data`, got {repr e}"
+    let gen ← IO.stdGenRef.get
+    return some $ bg.compare baseSample baseEstimates avgTimes gen
+  else
+    return none
+
+inductive ComparisonResult where
+| Improved
+| Regressed
+| NonSignificant
+
+def compareToThreshold (estimate : Estimate) (noiseThreshold : Float) : ComparisonResult :=
+  let ci := estimate.confidenceInterval
+  let (lb, ub) := (ci.lowerBound, ci.upperBound)
+  let noiseNeg := noiseThreshold.neg
+
+  if lb < noiseNeg && ub < noiseNeg
+  then
+    ComparisonResult.Improved
+  else if lb > noiseThreshold && ub > noiseThreshold
+  then
+    ComparisonResult.Regressed
+  else
+    ComparisonResult.NonSignificant
+
+-- TODO: Print ~24 whitespace characters before time, change, regression
+def BenchGroup.printResults (bg : BenchGroup) (benchName : String) (m : MeasurementData) : IO Unit := do
+  let estimates := m.absoluteEstimates
+  let typicalEstimate := estimates.slope.getD estimates.mean
+  IO.println s!"{bg.name}/{benchName}"
+  let lb := typicalEstimate.confidenceInterval.lowerBound.formatNanos
+  let pointEst := typicalEstimate.pointEstimate.formatNanos
+  let ub := typicalEstimate.confidenceInterval.upperBound.formatNanos
+  IO.println s!"time:   [{lb} {pointEst} {ub}]"
+  if let some comp := m.comparison
+  then
+    let diffMean := comp.pValue < comp.significanceThreshold
+    let meanEst := comp.relativeEstimates.mean
+    let pointEst := (meanEst.pointEstimate * 100).floatPretty 4
+    let lb := (meanEst.confidenceInterval.lowerBound * 100).floatPretty 4
+    let ub := (meanEst.confidenceInterval.upperBound * 100).floatPretty 4
+    let symbol := if diffMean then "<" else ">"
+    IO.println s!"change: [{lb}% {pointEst}% {ub}%] (p = {comp.pValue.floatPretty 2} {symbol} {comp.significanceThreshold.floatPretty 2})"
+    let explanation := if diffMean
+    then
+      "No change in performance detected"
+    else
+      match compareToThreshold meanEst comp.noiseThreshold with
+      | ComparisonResult.Improved => "Performance has improved"
+      | ComparisonResult.Regressed => "Performance has regressed"
+      | ComparisonResult.NonSignificant => "Change within noise threshold"
+    IO.println explanation
+  IO.println ""
+  m.avgTimes.tukey
+
+def saveComparison! (benchName : String) (comparison : Option ComparisonData) : IO Unit := do
+  match comparison with
+  | some comp => do
+    let changeIxon := Ixon.ser comp.relativeEstimates
+    let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
+    let changePath := benchPath / "change"
+    let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", changePath.toString ] }
+    IO.FS.writeBinFile (changePath / "estimates.ixon") changeIxon
+  | none => IO.eprintln s!"Error: expected `comparisonData` to write but found none"
+
+-- TODO: Write sampling mode in `sample.json` for comparison
+def saveResults (benchName : String) (m : MeasurementData) : IO Unit := do
+  let benchPath := System.mkFilePath [".", ".lake", "benches", benchName]
+  let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", benchPath.toString] }
+  let basePath := benchPath / "base"
+  let baseDir := basePath.toString
+  -- If prior results were saved to disk, don't overwrite them
+  let newPath ← if (← System.FilePath.pathExists basePath)
+    then do
+      let newPath := benchPath / "new"
+      let newDir := newPath.toString
+      -- If 2 or more prior runs, then the base data was stored in `new`
+      -- Move the base data to `base`
+      if (← System.FilePath.pathExists newPath)
+      then do
+        let _out ← IO.Process.run {cmd := "rm", args := #["-r", baseDir] }
+        let _out ← IO.Process.run {cmd := "mv", args := #[newDir, baseDir] }
+      let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", newPath.toString] }
+      saveComparison! benchName m.comparison
+      pure newPath
+  else do
+    let _out ← IO.Process.run {cmd := "mkdir", args := #["-p", baseDir] }
+    pure basePath
+  let sampleIxon := Ixon.ser m.data
+  IO.FS.writeBinFile (newPath / "sample.ixon") sampleIxon
+  let estimateIxon := Ixon.ser m.absoluteEstimates
+  IO.FS.writeBinFile (newPath / "estimates.ixon") estimateIxon
+
+-- TODO: Make sure compiler isn't caching partial evaluation result for future runs of the same function (measure first vs subsequent runs)
+/-- Runs each benchmark in a `BenchGroup` and analyzes the results -/
+def bgroup {α β : Type} (name: String) (benches : List (Benchmarkable α β)) (config : Config := {}) : IO Unit := do
+  let bg : BenchGroup := { name, config }
+  IO.println s!"Running bench group {name}\n"
+  for b in benches do
+    let warmupMean ← bg.warmup b
+    IO.println s!"Running {b.name}"
+    let (iters, times) ← bg.sample b warmupMean
+    let data := iters.zip times
+    let avgTimes : Distribution := { d := data.map (fun (x,y) => Float.ofNat y / Float.ofNat x) }
+    let gen ← IO.stdGenRef.get
+    let mut (distributions, estimates) := avgTimes.estimates bg.config gen
+    if bg.config.samplingMode == .linear
+    then
+      let data' : Data := { d := data }
+      let (distribution, slope) := data'.regression bg.config gen
+      estimates := { estimates with slope := .some slope }
+      distributions := { distributions with slope := .some distribution }
+    let comparisonData : Option ComparisonData ← bg.getComparison b.name avgTimes
+    let m :=  {
+      data := { d := data },
+      avgTimes,
+      absoluteEstimates := estimates,
+      distributions,
+      comparison := comparisonData
+      throughput := none
+    }
+    bg.printResults b.name m
+    IO.println ""
+    saveResults b.name m
diff --git a/Ix/Benchmark/Serde.lean b/Ix/Benchmark/Serde.lean
index 75056d11..3a8a3830 100644
--- a/Ix/Benchmark/Serde.lean
+++ b/Ix/Benchmark/Serde.lean
@@ -1,82 +1,94 @@
---import Ix.Ixon.Expr
---import Ix.Benchmark.Change
---
---@[inline] def putFloat (x : Float): Ixon.PutM := Ixon.putUInt64LE x.toBits
---@[inline] def getFloat : Ixon.GetM Float := Ixon.getUInt64LE.map Float.ofBits
---
---instance : Ixon.Serialize Float where
---  put := Ixon.runPut ∘ putFloat
---  get := Ixon.runGet getFloat
---
---def putTupleNat (xy : Nat × Nat) : Ixon.PutM := do
---  Ixon.putNatl xy.fst
---  Ixon.putNatl xy.snd
---
---def putData (data : Data) : Ixon.PutM := do
---  Ixon.putArray putTupleNat data.d.toList
---
---def getTupleNat : Ixon.GetM (Nat × Nat) := do
---  return (← Ixon.getNatl, ← Ixon.getNatl)
---
---def getData : Ixon.GetM Data := do
---  let data ← Ixon.getArray getTupleNat
---  return { d := data.toArray }
---
---instance : Ixon.Serialize Data where
---  put := Ixon.runPut ∘ putData
---  get := Ixon.runGet getData
---
---def putConfidenceInterval (ci : ConfidenceInterval) : Ixon.PutM := do
---  putFloat ci.confidenceLevel
---  putFloat ci.lowerBound
---  putFloat ci.upperBound
---
---def getConfidenceInterval : Ixon.GetM ConfidenceInterval := do
---  return { confidenceLevel := (← getFloat), lowerBound := (← getFloat), upperBound := (← getFloat)}
---
---def putEstimate (est : Estimate) : Ixon.PutM := do
---  putConfidenceInterval est.confidenceInterval
---  putFloat est.pointEstimate
---  putFloat est.stdErr
---
---def getEstimate : Ixon.GetM Estimate := do
---  return { confidenceInterval := (← getConfidenceInterval), pointEstimate := (← getFloat), stdErr := (← getFloat)}
---
---def putEstimates (est : Estimates) : Ixon.PutM := do
---  putEstimate est.mean
---  putEstimate est.median
---  putEstimate est.medianAbsDev
---  if let .some x := est.slope
---  then
---    Ixon.putUInt8 1
---    putEstimate x
---  else
---    Ixon.putUInt8 0
---  putEstimate est.stdDev
---
---def getEstimates : Ixon.GetM Estimates := do
---  let mean ← getEstimate
---  let median ← getEstimate
---  let medianAbsDev ← getEstimate
---  let slope ← match (← Ixon.getUInt8) with
---    | 1 => pure $ some (← getEstimate)
---    | _ => pure none
---  let stdDev ← getEstimate
---  return { mean, median, medianAbsDev, slope, stdDev }
---
---instance : Ixon.Serialize Estimates where
---  put := Ixon.runPut ∘ putEstimates
---  get := Ixon.runGet getEstimates
---
---def putChangeEstimates (changeEst : ChangeEstimates) : Ixon.PutM := do
---  putEstimate changeEst.mean
---  putEstimate changeEst.median
---
---def getChangeEstimates : Ixon.GetM ChangeEstimates := do
---  let mean ← getEstimate
---  let median ← getEstimate
---  return { mean, median }
---
---instance : Ixon.Serialize ChangeEstimates where
---  put := Ixon.runPut ∘ putChangeEstimates
---  get := Ixon.runGet getChangeEstimates
+import Ix.Ixon
+import Ix.Benchmark.Change
+
+@[inline] def putFloat (x : Float) : Ixon.PutM Unit := Ixon.putUInt64LE x.toBits
+@[inline] def getFloat : Ixon.GetM Float := Ixon.getUInt64LE.map Float.ofBits
+
+instance : Ixon.Serialize Float where
+  put := putFloat
+  get := getFloat
+
+def putTupleNat (xy : Nat × Nat) : Ixon.PutM Unit := do
+  Ixon.putNat Ixon.putBytesTagged xy.fst
+  Ixon.putNat Ixon.putBytesTagged xy.snd
+
+def getTupleNat : Ixon.GetM (Nat × Nat) := do
+  return (← Ixon.Serialize.get, ← Ixon.Serialize.get)
+
+instance : Ixon.Serialize (Nat × Nat) where
+  put := putTupleNat
+  get := getTupleNat 
+
+def putData (data : Data) : Ixon.PutM Unit := do
+  Ixon.Serialize.put data.d.toList
+
+def getData : Ixon.GetM Data := do
+  let data : List (Nat × Nat) ← Ixon.Serialize.get
+  return { d := data.toArray } 
+
+instance : Ixon.Serialize Data where
+  put := putData 
+  get := getData
+
+def putConfidenceInterval (ci : ConfidenceInterval) : Ixon.PutM Unit := do
+  putFloat ci.confidenceLevel
+  putFloat ci.lowerBound
+  putFloat ci.upperBound
+
+def getConfidenceInterval : Ixon.GetM ConfidenceInterval := do
+  return { confidenceLevel := (← getFloat), lowerBound := (← getFloat), upperBound := (← getFloat)}
+
+instance : Ixon.Serialize ConfidenceInterval where
+  put := putConfidenceInterval 
+  get := getConfidenceInterval 
+
+def putEstimate (est : Estimate) : Ixon.PutM Unit := do
+  putConfidenceInterval est.confidenceInterval
+  putFloat est.pointEstimate
+  putFloat est.stdErr
+
+def getEstimate : Ixon.GetM Estimate := do
+  return { confidenceInterval := (← getConfidenceInterval), pointEstimate := (← getFloat), stdErr := (← getFloat)}
+
+instance : Ixon.Serialize Estimate where
+  put := putEstimate
+  get := getEstimate
+
+def putEstimates (est : Estimates) : Ixon.PutM Unit := do
+  putEstimate est.mean
+  putEstimate est.median
+  putEstimate est.medianAbsDev
+  if let .some x := est.slope
+  then
+    Ixon.putUInt8 1
+    putEstimate x
+  else
+    Ixon.putUInt8 0
+  putEstimate est.stdDev
+
+def getEstimates : Ixon.GetM Estimates := do
+  let mean ← getEstimate
+  let median ← getEstimate
+  let medianAbsDev ← getEstimate
+  let slope ← match (← Ixon.getUInt8) with
+    | 1 => pure $ some (← getEstimate)
+    | _ => pure none
+  let stdDev ← getEstimate
+  return { mean, median, medianAbsDev, slope, stdDev }
+
+instance : Ixon.Serialize Estimates where
+  put := putEstimates
+  get := getEstimates
+
+def putChangeEstimates (changeEst : ChangeEstimates) : Ixon.PutM Unit := do
+  putEstimate changeEst.mean
+  putEstimate changeEst.median
+
+def getChangeEstimates : Ixon.GetM ChangeEstimates := do
+  let mean ← getEstimate
+  let median ← getEstimate
+  return { mean, median }
+
+instance : Ixon.Serialize ChangeEstimates where
+  put := putChangeEstimates
+  get := getChangeEstimates
diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean
index 6d7ca722..82801509 100644
--- a/Ix/Cli/ProveCmd.lean
+++ b/Ix/Cli/ProveCmd.lean
@@ -1,101 +1,101 @@
-import Cli
-import Ix.Cronos
-import Ix.Common
-import Ix.CompileM
-import Ix.Store
-import Ix.Address
-import Ix.Meta
-import Lean
-
-open Ix.Compile
-
---❯ ix prove IxTest.lean "id'"
---typechecking:
---id' (A : Type) (x : A) : A
---claim: #bbd740022aa44acd553c52e156807a5571428220a926377fe3c57d63b06a99f4 : #ba33b735b743386477f7a0e6802c67d388c165cab0e34b04880b50270205f265 @ #0000000000000000000000000000000000000000000000000000000000000000
-def runProveCheck
-  (env: Lean.Environment)
-  (constInfo: Lean.ConstantInfo)
-  (commit: Bool)
-  : IO UInt32
-  := do
-  let constSort <- runMeta (Lean.Meta.inferType constInfo.type) env
-  let signature <- runMeta (Lean.PrettyPrinter.ppSignature constInfo.name) env
-  IO.println "typechecking:"
-  IO.println signature.fmt.pretty
-  let ((claim, _, _), _stt) <-
-    (checkClaim constInfo.name constInfo.type constSort constInfo.levelParams commit).runIO env
-  IO.println $ s!"claim: {claim}"
-  -- TODO: prove
-  return 0
-
-def mkConst' (constName : Lean.Name) : Lean.MetaM Lean.Expr := do
-  return Lean.mkConst constName (← (← Lean.getConstInfo constName).levelParams.mapM fun _ => Lean.Meta.mkFreshLevelMVar)
-
---ix prove IxTest.lean "id'" --eval=Nat,one
---evaluating:
---id' (A : Type) (x : A) : A
---id' Nat one
---  ~> 1
---  : Nat
---  @ []
---claim: #88ba2a7b099ce94a030eef202dc26ee3d9eb088057830049b926c7e88044bba1 ~> #d5ea7e6e7a3ee02780ba254a0becfe1fe712436a5a30832095ab71f7c64e25cd : #41ba41a9691e8167a387046f736a82ce0ec1601e7fb996c58d5930887c4b7764 @ #0000000000000000000000000000000000000000000000000000000000000000
-def runProveEval
-  (env: Lean.Environment)
-  (constInfo: Lean.ConstantInfo)
-  (args: Array String)
-  (commit: Bool)
-  : IO UInt32
-  := do
-  let signature <- runMeta (Lean.PrettyPrinter.ppSignature constInfo.name) env
-  let args : Array Lean.Expr <- args.mapM $ fun a => do
-    let argInfo <- match env.constants.find? a.toName with
-      | some c => runMeta (mkConst' c.name) env
-      | none => throw $ IO.userError s!"unknown constant {a.toName}"
-  let (lvls, input, output, type, sort) <-
-    runMeta (metaMakeEvalClaim constInfo.name (args.toList)) env
-  IO.println "evaluating:"
-  IO.println signature.fmt.pretty
-  let inputPretty <- runMeta (Lean.Meta.ppExpr input) env
-  let outputPretty <- runMeta (Lean.Meta.ppExpr output) env
-  let typePretty <- runMeta (Lean.Meta.ppExpr type) env
-  IO.println s!"{inputPretty}"
-  IO.println s!"  ~> {outputPretty}"
-  IO.println s!"  : {typePretty}"
-  IO.println s!"  @ {repr lvls}"
-  let ((claim, _, _), _stt) <- (evalClaim lvls input output type sort commit).runIO env
-  IO.println $ s!"claim: {claim}"
-  -- TODO: prove
-  return 0
-
-
-
-def runProve (p: Cli.Parsed): IO UInt32 := do
-  let input : String       := p.positionalArg! "input" |>.as! String
-  let const : String       := p.positionalArg! "const" |>.as! String
-  StoreIO.toIO Store.ensureStoreDir
-  let path := ⟨input⟩
-  Lean.setLibsPaths input
-  let env ← Lean.runFrontend (← IO.FS.readFile path) path
-  let constInfo <- match env.constants.find? const.toName with
-    | some c => pure c
-    | none => throw $ IO.userError s!"unknown constant {const.toName}"
-  let commit := p.hasFlag "commit"
-  if let some evalArgs := p.flag? "eval"
-  then runProveEval env constInfo (evalArgs.as! (Array String)) commit
-  else runProveCheck env constInfo commit
-  return 0
-
-
-def proveCmd : Cli.Cmd := `[Cli|
-  prove VIA runProve;
-  "Generates a ZK proof of a given Lean constant"
-
-  FLAGS:
-    cron, "cronos"   : String; "enable Cronos timings"
-    eval, "eval"     : Array String; "prove evaluation with arguments"
-
-  ARGS:
-   input  : String; "Source file input"
-   const  : String; "constant name"
-]
+--import Cli
+--import Ix.Cronos
+--import Ix.Common
+--import Ix.CompileM
+--import Ix.Store
+--import Ix.Address
+--import Ix.Meta
+--import Lean
+--
+--open Ix.Compile
+--
+----❯ ix prove IxTest.lean "id'"
+----typechecking:
+----id' (A : Type) (x : A) : A
+----claim: #bbd740022aa44acd553c52e156807a5571428220a926377fe3c57d63b06a99f4 : #ba33b735b743386477f7a0e6802c67d388c165cab0e34b04880b50270205f265 @ #0000000000000000000000000000000000000000000000000000000000000000
+--def runProveCheck
+--  (env: Lean.Environment)
+--  (constInfo: Lean.ConstantInfo)
+--  (commit: Bool)
+--  : IO UInt32
+--  := do
+--  let constSort <- runMeta (Lean.Meta.inferType constInfo.type) env
+--  let signature <- runMeta (Lean.PrettyPrinter.ppSignature constInfo.name) env
+--  IO.println "typechecking:"
+--  IO.println signature.fmt.pretty
+--  let ((claim, _, _), _stt) <-
+--    (checkClaim constInfo.name constInfo.type constSort constInfo.levelParams commit).runIO env
+--  IO.println $ s!"claim: {claim}"
+--  -- TODO: prove
+--  return 0
+--
+--def mkConst' (constName : Lean.Name) : Lean.MetaM Lean.Expr := do
+--  return Lean.mkConst constName (← (← Lean.getConstInfo constName).levelParams.mapM fun _ => Lean.Meta.mkFreshLevelMVar)
+--
+----ix prove IxTest.lean "id'" --eval=Nat,one
+----evaluating:
+----id' (A : Type) (x : A) : A
+----id' Nat one
+----  ~> 1
+----  : Nat
+----  @ []
+----claim: #88ba2a7b099ce94a030eef202dc26ee3d9eb088057830049b926c7e88044bba1 ~> #d5ea7e6e7a3ee02780ba254a0becfe1fe712436a5a30832095ab71f7c64e25cd : #41ba41a9691e8167a387046f736a82ce0ec1601e7fb996c58d5930887c4b7764 @ #0000000000000000000000000000000000000000000000000000000000000000
+--def runProveEval
+--  (env: Lean.Environment)
+--  (constInfo: Lean.ConstantInfo)
+--  (args: Array String)
+--  (commit: Bool)
+--  : IO UInt32
+--  := do
+--  let signature <- runMeta (Lean.PrettyPrinter.ppSignature constInfo.name) env
+--  let args : Array Lean.Expr <- args.mapM $ fun a => do
+--    let argInfo <- match env.constants.find? a.toName with
+--      | some c => runMeta (mkConst' c.name) env
+--      | none => throw $ IO.userError s!"unknown constant {a.toName}"
+--  let (lvls, input, output, type, sort) <-
+--    runMeta (metaMakeEvalClaim constInfo.name (args.toList)) env
+--  IO.println "evaluating:"
+--  IO.println signature.fmt.pretty
+--  let inputPretty <- runMeta (Lean.Meta.ppExpr input) env
+--  let outputPretty <- runMeta (Lean.Meta.ppExpr output) env
+--  let typePretty <- runMeta (Lean.Meta.ppExpr type) env
+--  IO.println s!"{inputPretty}"
+--  IO.println s!"  ~> {outputPretty}"
+--  IO.println s!"  : {typePretty}"
+--  IO.println s!"  @ {repr lvls}"
+--  let ((claim, _, _), _stt) <- (evalClaim lvls input output type sort commit).runIO env
+--  IO.println $ s!"claim: {claim}"
+--  -- TODO: prove
+--  return 0
+--
+--
+--
+--def runProve (p: Cli.Parsed): IO UInt32 := do
+--  let input : String       := p.positionalArg! "input" |>.as! String
+--  let const : String       := p.positionalArg! "const" |>.as! String
+--  StoreIO.toIO Store.ensureStoreDir
+--  let path := ⟨input⟩
+--  Lean.setLibsPaths input
+--  let env ← Lean.runFrontend (← IO.FS.readFile path) path
+--  let constInfo <- match env.constants.find? const.toName with
+--    | some c => pure c
+--    | none => throw $ IO.userError s!"unknown constant {const.toName}"
+--  let commit := p.hasFlag "commit"
+--  if let some evalArgs := p.flag? "eval"
+--  then runProveEval env constInfo (evalArgs.as! (Array String)) commit
+--  else runProveCheck env constInfo commit
+--  return 0
+--
+--
+--def proveCmd : Cli.Cmd := `[Cli|
+--  prove VIA runProve;
+--  "Generates a ZK proof of a given Lean constant"
+--
+--  FLAGS:
+--    cron, "cronos"   : String; "enable Cronos timings"
+--    eval, "eval"     : Array String; "prove evaluation with arguments"
+--
+--  ARGS:
+--   input  : String; "Source file input"
+--   const  : String; "constant name"
+--]
diff --git a/Ix/Cli/StoreCmd.lean b/Ix/Cli/StoreCmd.lean
index 9f3e984d..174e36f1 100644
--- a/Ix/Cli/StoreCmd.lean
+++ b/Ix/Cli/StoreCmd.lean
@@ -1,95 +1,95 @@
-import Cli
-import Ix.Cronos
-import Ix.Common
-import Ix.CompileM
-import Ix.TransportM
-import Ix.Store
-import Ix.Address
-import Lean
-
--- ix store <lean file>
--- ix store get <address>
--- ix store remat <address> <address>
-def runStore (p : Cli.Parsed) : IO UInt32 := do
-  let source : String       := p.positionalArg! "source" |>.as! String
-  let mut cronos ← Cronos.new.clock "Lean-frontend"
-  Lean.setLibsPaths source
-  StoreIO.toIO Store.ensureStoreDir
-  let path := ⟨source⟩
-  let leanEnv ← Lean.runFrontend (← IO.FS.readFile path) path
-  cronos ← cronos.clock "Lean-frontend"
-  -- Start content-addressing
-  cronos ← cronos.clock "content-address"
-  let stt ← Ix.Compile.compileEnvIO leanEnv
-  stt.names.forM fun name (const, «meta») => do
-     IO.println <| s!"{name}:"
-     IO.println <| s!"  #{const}"
-     --IO.println <| s!"  {repr <| stt.store.find! const}"
-     --IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! const))}"
-     IO.println <| s!"  #{«meta»}"
-     --IO.println <| s!"  {repr <| stt.store.find! meta}"
-     --IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! meta))}"
-  --stt.store.forM fun adr const => do
-  --   IO.println <| s!"adr' {adr}"
-  --   IO.println <| s!"const {repr const}"
-  --   let adr' <- StoreIO.toIO (writeConst const)
-  --   IO.println <| s!"adr' {adr}"
-  --   let const' <- StoreIO.toIO (readConst adr')
-  --   IO.println <| s!"const' {repr const'}"
-  cronos ← cronos.clock "content-address"
-  IO.println cronos.summary
-  return 0
-
-def runGet (p : Cli.Parsed) : IO UInt32 := do
-  let input : String       := p.positionalArg! "address" |>.as! String
-  let address : Address <- IO.ofExcept $
-    match Address.fromString input with
-    | .some a => .ok a
-    | .none => .error "bad address"
-  let const <- StoreIO.toIO (Store.readConst address)
-  IO.println <| s!"{repr const}"
-  return 0
-
-def runRemat (p : Cli.Parsed) : IO UInt32 := do
-  let cont : String       := p.positionalArg! "constantAddress" |>.as! String
-  let «meta» : String       := p.positionalArg! "metadataAddress" |>.as! String
-  let (c, m) <- IO.ofExcept $
-    match Address.fromString cont, Address.fromString «meta» with
-    | .some c, .some m => .ok (c, m)
-    | .none, _ => .error "bad address {cont}"
-    | _, .none => .error "bad address {meta}"
-  let cont <- StoreIO.toIO (Store.readConst c)
-  let «meta» <- StoreIO.toIO (Store.readConst m)
-  let ix := Ix.TransportM.rematerialize cont «meta»
-  IO.println <| s!"{repr ix}"
-  return 0
-
-def storeGetCmd : Cli.Cmd := `[Cli|
-  get VIA runGet;
-  "print a store entry"
-  ARGS:
-    address  : String; "Ix address"
-]
-
-def storeRematCmd : Cli.Cmd := `[Cli|
-  remat VIA runRemat;
-  "print a store entry"
-  ARGS:
-    constantAddress  : String; "Ix constant address"
-    metadataAddress  : String; "Ix metadata address"
-]
-
-def storeCmd : Cli.Cmd := `[Cli|
-  store VIA runStore;
-  "Interact with the Ix store"
-
-  FLAGS:
-    cron, "cronos"   : String; "enable Cronos timings"
-
-  ARGS:
-    source : String; "Source file input"
-
-  SUBCOMMANDS:
-    storeGetCmd;
-    storeRematCmd
-]
+--import Cli
+--import Ix.Cronos
+--import Ix.Common
+--import Ix.CompileM
+--import Ix.TransportM
+--import Ix.Store
+--import Ix.Address
+--import Lean
+--
+---- ix store <lean file>
+---- ix store get <address>
+---- ix store remat <address> <address>
+--def runStore (p : Cli.Parsed) : IO UInt32 := do
+--  let source : String       := p.positionalArg! "source" |>.as! String
+--  let mut cronos ← Cronos.new.clock "Lean-frontend"
+--  Lean.setLibsPaths source
+--  StoreIO.toIO Store.ensureStoreDir
+--  let path := ⟨source⟩
+--  let leanEnv ← Lean.runFrontend (← IO.FS.readFile path) path
+--  cronos ← cronos.clock "Lean-frontend"
+--  -- Start content-addressing
+--  cronos ← cronos.clock "content-address"
+--  let stt ← Ix.Compile.compileEnvIO leanEnv
+--  stt.names.forM fun name (const, «meta») => do
+--     IO.println <| s!"{name}:"
+--     IO.println <| s!"  #{const}"
+--     --IO.println <| s!"  {repr <| stt.store.find! const}"
+--     --IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! const))}"
+--     IO.println <| s!"  #{«meta»}"
+--     --IO.println <| s!"  {repr <| stt.store.find! meta}"
+--     --IO.println <| s!"  {hexOfBytes (Ixon.Serialize.put (stt.store.find! meta))}"
+--  --stt.store.forM fun adr const => do
+--  --   IO.println <| s!"adr' {adr}"
+--  --   IO.println <| s!"const {repr const}"
+--  --   let adr' <- StoreIO.toIO (writeConst const)
+--  --   IO.println <| s!"adr' {adr}"
+--  --   let const' <- StoreIO.toIO (readConst adr')
+--  --   IO.println <| s!"const' {repr const'}"
+--  cronos ← cronos.clock "content-address"
+--  IO.println cronos.summary
+--  return 0
+--
+--def runGet (p : Cli.Parsed) : IO UInt32 := do
+--  let input : String       := p.positionalArg! "address" |>.as! String
+--  let address : Address <- IO.ofExcept $
+--    match Address.fromString input with
+--    | .some a => .ok a
+--    | .none => .error "bad address"
+--  let const <- StoreIO.toIO (Store.readConst address)
+--  IO.println <| s!"{repr const}"
+--  return 0
+--
+--def runRemat (p : Cli.Parsed) : IO UInt32 := do
+--  let cont : String       := p.positionalArg! "constantAddress" |>.as! String
+--  let «meta» : String       := p.positionalArg! "metadataAddress" |>.as! String
+--  let (c, m) <- IO.ofExcept $
+--    match Address.fromString cont, Address.fromString «meta» with
+--    | .some c, .some m => .ok (c, m)
+--    | .none, _ => .error "bad address {cont}"
+--    | _, .none => .error "bad address {meta}"
+--  let cont <- StoreIO.toIO (Store.readConst c)
+--  let «meta» <- StoreIO.toIO (Store.readConst m)
+--  let ix := Ix.TransportM.rematerialize cont «meta»
+--  IO.println <| s!"{repr ix}"
+--  return 0
+--
+--def storeGetCmd : Cli.Cmd := `[Cli|
+--  get VIA runGet;
+--  "print a store entry"
+--  ARGS:
+--    address  : String; "Ix address"
+--]
+--
+--def storeRematCmd : Cli.Cmd := `[Cli|
+--  remat VIA runRemat;
+--  "print a store entry"
+--  ARGS:
+--    constantAddress  : String; "Ix constant address"
+--    metadataAddress  : String; "Ix metadata address"
+--]
+--
+--def storeCmd : Cli.Cmd := `[Cli|
+--  store VIA runStore;
+--  "Interact with the Ix store"
+--
+--  FLAGS:
+--    cron, "cronos"   : String; "enable Cronos timings"
+--
+--  ARGS:
+--    source : String; "Source file input"
+--
+--  SUBCOMMANDS:
+--    storeGetCmd;
+--    storeRematCmd
+--]
diff --git a/Main.lean b/Main.lean
index c14460b6..825d5d80 100644
--- a/Main.lean
+++ b/Main.lean
@@ -1,5 +1,5 @@
-import Ix.Cli.ProveCmd
-import Ix.Cli.StoreCmd
+--import Ix.Cli.ProveCmd
+--import Ix.Cli.StoreCmd
 import Ix.Cli.ServeCmd
 import Ix.Cli.ConnectCmd
 import Ix
@@ -12,8 +12,8 @@ def ixCmd : Cli.Cmd := `[Cli|
   "A tool for generating content-addressed ZK proofs of Lean 4 code"
 
   SUBCOMMANDS:
-    proveCmd;
-    storeCmd;
+    --proveCmd;
+    --storeCmd;
     serveCmd;
     connectCmd
 ]
diff --git a/Tests/Cli.lean b/Tests/Cli.lean
index 5064a94e..021eb21c 100644
--- a/Tests/Cli.lean
+++ b/Tests/Cli.lean
@@ -1,21 +1,21 @@
 /-! Integration tests for the Ix CLI -/
 
---def Tests.Cli.run (buildCmd: String) (buildArgs : Array String) (buildDir : Option System.FilePath) : IO Unit := do
---  let proc : IO.Process.SpawnArgs :=
---    match buildDir with
---    | some bd => { cmd := buildCmd, args := buildArgs, cwd := bd }
---    | none => { cmd := buildCmd, args := buildArgs }
---  let out ← IO.Process.output proc
---  if out.exitCode ≠ 0 then
---    IO.eprintln out.stderr
---    throw $ IO.userError out.stderr
---  else
---    IO.println out.stdout
---
---def Tests.Cli.suite : IO UInt32 := do
---  Tests.Cli.run "lake" (#["run", "install"]) none
---  let ixTestDir := (← IO.currentDir) / "ix_test"
---  Tests.Cli.run "lake" (#["build"]) (some ixTestDir)
---  Tests.Cli.run "ix" (#["store", "ix_test/IxTest.lean"]) none
---  Tests.Cli.run "ix" (#["prove", "ix_test/IxTest.lean", "one"]) none
---  return 0
+def Tests.Cli.run (buildCmd: String) (buildArgs : Array String) (buildDir : Option System.FilePath) : IO Unit := do
+  let proc : IO.Process.SpawnArgs :=
+    match buildDir with
+    | some bd => { cmd := buildCmd, args := buildArgs, cwd := bd }
+    | none => { cmd := buildCmd, args := buildArgs }
+  let out ← IO.Process.output proc
+  if out.exitCode ≠ 0 then
+    IO.eprintln out.stderr
+    throw $ IO.userError out.stderr
+  else
+    IO.println out.stdout
+
+def Tests.Cli.suite : IO UInt32 := do
+  Tests.Cli.run "lake" (#["run", "install"]) none
+  let ixTestDir := (← IO.currentDir) / "ix_test"
+  Tests.Cli.run "lake" (#["build"]) (some ixTestDir)
+  --Tests.Cli.run "ix" (#["store", "ix_test/IxTest.lean"]) none
+  --Tests.Cli.run "ix" (#["prove", "ix_test/IxTest.lean", "one"]) none
+  return 0
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 014c79c4..341028ce 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -10,7 +10,8 @@ import Tests.Cli
 
 def main (args: List String) : IO UInt32 := do
   if args.contains "compile" then LSpec.lspecEachIO Tests.Ix.Compile.suiteIO id
-  else if args.contains "cli" then return 0 -- Tests.Cli.suite
+  else if args.contains "cli" then
+    Tests.Cli.suite
   else
     LSpec.lspecIO (.ofList [
        ("aiur", Tests.Aiur.suite),
diff --git a/flake.lock b/flake.lock
index b82a4452..8020b178 100644
--- a/flake.lock
+++ b/flake.lock
@@ -28,11 +28,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1758123462,
-        "narHash": "sha256-kh/xy8M5uqKOUeHNi+HyklrLVA+Ixd4cQCMXsMzswP4=",
+        "lastModified": 1761671743,
+        "narHash": "sha256-Zon0ul+lR4gNXxg9GQOMOZDP8QSwBnbNR5HRYOmA1T8=",
         "owner": "argumentcomputer",
         "repo": "Blake3.lean",
-        "rev": "a5ed3f0bceda9506271a8f95c365e9bd0040288d",
+        "rev": "a64c3f568b6538374e437681b770b0f092a89d2e",
         "type": "github"
       },
       "original": {
@@ -156,11 +156,11 @@
         "nixpkgs": "nixpkgs"
       },
       "locked": {
-        "lastModified": 1758037834,
-        "narHash": "sha256-P2rBelR9lgFJPE8kEV1wwX1LHK6xWlVcQqEez84ss6E=",
+        "lastModified": 1761368467,
+        "narHash": "sha256-eEs2YpE84+d6a8VKXCACNJy5czcu8GQCaeSZwR/mFMk=",
         "owner": "lenianiva",
         "repo": "lean4-nix",
-        "rev": "d87ff09bad00ca4addd471a68a968f2aa29c7c36",
+        "rev": "3550873ed1a87d666d633d34921e79abaa4671c1",
         "type": "github"
       },
       "original": {
@@ -175,11 +175,11 @@
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1760753731,
-        "narHash": "sha256-RJCrWSH1Iz8WPVL2hB2U/kBXuct4+tKo/aiPCaOYPzM=",
+        "lastModified": 1761368467,
+        "narHash": "sha256-eEs2YpE84+d6a8VKXCACNJy5czcu8GQCaeSZwR/mFMk=",
         "owner": "lenianiva",
         "repo": "lean4-nix",
-        "rev": "ae7abc9f97a26da2ecf5233b9edfe3ba0af1b9a9",
+        "rev": "3550873ed1a87d666d633d34921e79abaa4671c1",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index 881ce7f8..d3c4344b 100644
--- a/flake.nix
+++ b/flake.nix
@@ -115,7 +115,7 @@
             clang
             lib.rustToolchain
             rust-analyzer
-            lean.lean # Includes Lean compiler, lake, stdlib, etc.
+            lean.lean-all # Includes Lean compiler, lake, stdlib, etc.
           ];
         };
 
diff --git a/ix.nix b/ix.nix
index 42af5f25..996c4f87 100644
--- a/ix.nix
+++ b/ix.nix
@@ -63,7 +63,7 @@
       pname = "ix_c";
       version = "0.1.0";
       src = ./c;
-      buildInputs = [pkgs.gcc pkgs.lean.lean rustPkg];
+      buildInputs = [pkgs.gcc pkgs.lean.lean-all rustPkg];
       # Builds the C files
       buildPhase = builtins.concatStringsSep "\n" buildSteps;
       # Installs the library files
diff --git a/lake-manifest.json b/lake-manifest.json
index 18e9b0b5..359ea66d 100644
--- a/lake-manifest.json
+++ b/lake-manifest.json
@@ -25,20 +25,20 @@
    "type": "git",
    "subDir": null,
    "scope": "",
-   "rev": "a5ed3f0bceda9506271a8f95c365e9bd0040288d",
+   "rev": "a64c3f568b6538374e437681b770b0f092a89d2e",
    "name": "Blake3",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "a5ed3f0bceda9506271a8f95c365e9bd0040288d",
+   "inputRev": "a64c3f568b6538374e437681b770b0f092a89d2e",
    "inherited": false,
    "configFile": "lakefile.lean"},
   {"url": "https://github.com/argumentcomputer/LSpec",
    "type": "git",
    "subDir": null,
    "scope": "",
-   "rev": "1fc461a9b83eeb68da34df72cec2ef1994e906cb",
+   "rev": "d2bbbfa61a82ac199a5e852aa375acffd9a3b3f1",
    "name": "LSpec",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "1fc461a9b83eeb68da34df72cec2ef1994e906cb",
+   "inputRev": "d2bbbfa61a82ac199a5e852aa375acffd9a3b3f1",
    "inherited": false,
    "configFile": "lakefile.toml"}],
  "name": "ix",
diff --git a/lakefile.lean b/lakefile.lean
index 63a891b1..0079ca85 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -12,10 +12,10 @@ lean_exe ix where
   supportInterpreter := true
 
 require LSpec from git
-  "https://github.com/argumentcomputer/LSpec" @ "1fc461a9b83eeb68da34df72cec2ef1994e906cb"
+  "https://github.com/argumentcomputer/LSpec" @ "d2bbbfa61a82ac199a5e852aa375acffd9a3b3f1"
 
 require Blake3 from git
-  "https://github.com/argumentcomputer/Blake3.lean" @ "a5ed3f0bceda9506271a8f95c365e9bd0040288d"
+  "https://github.com/argumentcomputer/Blake3.lean" @ "a64c3f568b6538374e437681b770b0f092a89d2e"
 
 require Cli from git
   "https://github.com/leanprover/lean4-cli" @ "41c5d0b8814dec559e2e1441171db434fe2281cc"

From e93bb850a091eb3e2f7770d205013eda4f8e9b22 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 28 Oct 2025 18:28:57 -0400
Subject: [PATCH 72/74] clippy

---
 src/ixon.rs | 98 +++++++++++++++++++++++++++--------------------------
 src/lib.rs  |  3 ++
 2 files changed, 53 insertions(+), 48 deletions(-)

diff --git a/src/ixon.rs b/src/ixon.rs
index 8ded6ff6..c76133cf 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -146,6 +146,7 @@ pub struct Tag4 {
 }
 
 impl Tag4 {
+  #[allow(clippy::cast_possible_truncation)]
   pub fn encode_head(&self) -> u8 {
     if self.size < 8 {
       (self.flag << 4) + (self.size as u8)
@@ -1663,9 +1664,7 @@ impl Serialize for Ixon {
 pub mod tests {
   use super::*;
   use quickcheck::{Arbitrary, Gen};
-  use std::fmt::Write;
   use std::ops::Range;
-  use std::ptr;
 
   pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
     let res: usize = Arbitrary::arbitrary(g);
@@ -1689,11 +1688,11 @@ pub mod tests {
   }
   #[test]
   fn unit_u64_trimmed() {
-    fn test(input: u64, expected: Vec<u8>) -> bool {
+    fn test(input: u64, expected: &Vec<u8>) -> bool {
       let mut tmp = Vec::new();
       let n = u64_byte_count(input);
       u64_put_trimmed_le(input, &mut tmp);
-      if tmp != expected {
+      if tmp != *expected {
         return false;
       }
       match u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
@@ -1704,28 +1703,31 @@ pub mod tests {
         },
       }
     }
-    assert!(test(0x0, vec![]));
-    assert!(test(0x01, vec![0x01]));
-    assert!(test(0x0000000000000100, vec![0x00, 0x01]));
-    assert!(test(0x0000000000010000, vec![0x00, 0x00, 0x01]));
-    assert!(test(0x0000000001000000, vec![0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000000100000000, vec![0x00, 0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000010000000000, vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0, &vec![]));
+    assert!(test(0x01, &vec![0x01]));
+    assert!(test(0x0000000000000100, &vec![0x00, 0x01]));
+    assert!(test(0x0000000000010000, &vec![0x00, 0x00, 0x01]));
+    assert!(test(0x0000000001000000, &vec![0x00, 0x00, 0x00, 0x01]));
+    assert!(test(0x0000000100000000, &vec![0x00, 0x00, 0x00, 0x00, 0x01]));
+    assert!(test(
+      0x0000010000000000,
+      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+    ));
     assert!(test(
       0x0001000000000000,
-      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
     ));
     assert!(test(
       0x0100000000000000,
-      vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
     ));
     assert!(test(
       0x0102030405060708,
-      vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+      &vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
     ));
     assert!(test(
       0x57712D6CE2965701,
-      vec![0x01, 0x57, 0x96, 0xE2, 0x6C, 0x2D, 0x71, 0x57]
+      &vec![0x01, 0x57, 0x96, 0xE2, 0x6C, 0x2D, 0x71, 0x57]
     ));
   }
 
@@ -1743,10 +1745,11 @@ pub mod tests {
     }
   }
 
+  #[allow(clippy::needless_pass_by_value)]
   fn serialize_readback<S: Serialize + Eq>(x: S) -> bool {
     let mut buf = Vec::new();
     Serialize::put(&x, &mut buf);
-    match Serialize::get(&mut buf.as_slice()) {
+    match S::get(&mut buf.as_slice()) {
       Ok(y) => x == y,
       Err(e) => {
         println!("err: {e}");
@@ -2374,55 +2377,54 @@ pub mod tests {
 
   impl Arbitrary for Ixon {
     fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 37 {
+      match u8::arbitrary(g) % 36 {
         0 => Self::NAnon,
         1 => Self::NStr(Address::arbitrary(g), Address::arbitrary(g)),
         2 => Self::NNum(Address::arbitrary(g), Address::arbitrary(g)),
         3 => Self::UZero,
         4 => Self::USucc(Address::arbitrary(g)),
         5 => Self::UMax(Address::arbitrary(g), Address::arbitrary(g)),
-        6 => Self::UMax(Address::arbitrary(g), Address::arbitrary(g)),
-        7 => Self::UIMax(Address::arbitrary(g), Address::arbitrary(g)),
-        8 => Self::UVar(Nat::arbitrary(g)),
-        9 => Self::EVar(Nat::arbitrary(g)),
-        10 => {
+        6 => Self::UIMax(Address::arbitrary(g), Address::arbitrary(g)),
+        7 => Self::UVar(Nat::arbitrary(g)),
+        8 => Self::EVar(Nat::arbitrary(g)),
+        9 => {
           Self::ERef(Address::arbitrary(g), gen_vec(g, 12, Address::arbitrary))
         },
-        11 => Self::ERec(Nat::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
-        12 => Self::EPrj(
+        10 => Self::ERec(Nat::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
+        11 => Self::EPrj(
           Address::arbitrary(g),
           Nat::arbitrary(g),
           Address::arbitrary(g),
         ),
-        13 => Self::ESort(Address::arbitrary(g)),
-        14 => Self::EStr(Address::arbitrary(g)),
-        15 => Self::ENat(Address::arbitrary(g)),
-        16 => Self::EApp(Address::arbitrary(g), Address::arbitrary(g)),
-        17 => Self::ELam(Address::arbitrary(g), Address::arbitrary(g)),
-        18 => Self::EAll(Address::arbitrary(g), Address::arbitrary(g)),
-        19 => Self::ELet(
+        12 => Self::ESort(Address::arbitrary(g)),
+        13 => Self::EStr(Address::arbitrary(g)),
+        14 => Self::ENat(Address::arbitrary(g)),
+        15 => Self::EApp(Address::arbitrary(g), Address::arbitrary(g)),
+        16 => Self::ELam(Address::arbitrary(g), Address::arbitrary(g)),
+        17 => Self::EAll(Address::arbitrary(g), Address::arbitrary(g)),
+        18 => Self::ELet(
           bool::arbitrary(g),
           Address::arbitrary(g),
           Address::arbitrary(g),
           Address::arbitrary(g),
         ),
-        20 => Self::Blob(gen_vec(g, 12, u8::arbitrary)),
-        21 => Self::Defn(Definition::arbitrary(g)),
-        22 => Self::Recr(Recursor::arbitrary(g)),
-        23 => Self::Axio(Axiom::arbitrary(g)),
-        24 => Self::Quot(Quotient::arbitrary(g)),
-        25 => Self::CPrj(ConstructorProj::arbitrary(g)),
-        26 => Self::RPrj(RecursorProj::arbitrary(g)),
-        27 => Self::IPrj(InductiveProj::arbitrary(g)),
-        28 => Self::DPrj(DefinitionProj::arbitrary(g)),
-        29 => Self::Muts(gen_vec(g, 12, MutConst::arbitrary)),
-        30 => Self::Prof(Proof::arbitrary(g)),
-        31 => Self::Eval(EvalClaim::arbitrary(g)),
-        32 => Self::Chck(CheckClaim::arbitrary(g)),
-        33 => Self::Comm(Comm::arbitrary(g)),
-        34 => Self::Envn(Env::arbitrary(g)),
-        35 => Self::Prim(BuiltIn::arbitrary(g)),
-        36 => Self::Meta(Metadata::arbitrary(g)),
+        19 => Self::Blob(gen_vec(g, 12, u8::arbitrary)),
+        20 => Self::Defn(Definition::arbitrary(g)),
+        21 => Self::Recr(Recursor::arbitrary(g)),
+        22 => Self::Axio(Axiom::arbitrary(g)),
+        23 => Self::Quot(Quotient::arbitrary(g)),
+        24 => Self::CPrj(ConstructorProj::arbitrary(g)),
+        25 => Self::RPrj(RecursorProj::arbitrary(g)),
+        26 => Self::IPrj(InductiveProj::arbitrary(g)),
+        27 => Self::DPrj(DefinitionProj::arbitrary(g)),
+        28 => Self::Muts(gen_vec(g, 12, MutConst::arbitrary)),
+        29 => Self::Prof(Proof::arbitrary(g)),
+        30 => Self::Eval(EvalClaim::arbitrary(g)),
+        31 => Self::Chck(CheckClaim::arbitrary(g)),
+        32 => Self::Comm(Comm::arbitrary(g)),
+        33 => Self::Envn(Env::arbitrary(g)),
+        34 => Self::Prim(BuiltIn::arbitrary(g)),
+        35 => Self::Meta(Metadata::arbitrary(g)),
         _ => unreachable!(),
       }
     }
diff --git a/src/lib.rs b/src/lib.rs
index 45c3cec3..6eda285a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,8 +1,11 @@
+#[allow(unused_extern_crates)]
 #[cfg(test)]
 extern crate quickcheck;
+#[allow(unused_extern_crates)]
 #[cfg(test)]
 #[macro_use(quickcheck)]
 extern crate quickcheck_macros;
+#[allow(unused_extern_crates)]
 #[cfg(test)]
 extern crate rand;
 

From 435275b50227445894dfe081a77eabc924e7e340 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 28 Oct 2025 18:32:18 -0400
Subject: [PATCH 73/74] rustfmt

---
 src/ixon.rs         | 4172 ++++++++++++++++++++++---------------------
 src/ixon/address.rs |   59 +-
 src/lean/nat.rs     |   67 +-
 3 files changed, 2174 insertions(+), 2124 deletions(-)

diff --git a/src/ixon.rs b/src/ixon.rs
index c76133cf..5a8cc199 100644
--- a/src/ixon.rs
+++ b/src/ixon.rs
@@ -7,131 +7,130 @@ pub mod address;
 use address::*;
 
 pub trait Serialize: Sized {
-  fn put(&self, buf: &mut Vec<u8>);
-  fn get(buf: &mut &[u8]) -> Result<Self, String>;
+    fn put(&self, buf: &mut Vec<u8>);
+    fn get(buf: &mut &[u8]) -> Result<Self, String>;
 }
 
 impl Serialize for u8 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.push(*self)
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.push(*self)
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_first() {
-      Some((&x, rest)) => {
-        *buf = rest;
-        Ok(x)
-      },
-      None => Err("get u8 EOF".to_string()),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_first() {
+            Some((&x, rest)) => {
+                *buf = rest;
+                Ok(x)
+            }
+            None => Err("get u8 EOF".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for u16 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.extend_from_slice(&self.to_le_bytes());
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(&self.to_le_bytes());
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(2) {
-      Some((head, rest)) => {
-        *buf = rest;
-        Ok(u16::from_le_bytes([head[0], head[1]]))
-      },
-      None => Err("get u16 EOF".to_string()),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(2) {
+            Some((head, rest)) => {
+                *buf = rest;
+                Ok(u16::from_le_bytes([head[0], head[1]]))
+            }
+            None => Err("get u16 EOF".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for u32 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.extend_from_slice(&self.to_le_bytes());
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(&self.to_le_bytes());
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(4) {
-      Some((head, rest)) => {
-        *buf = rest;
-        Ok(u32::from_le_bytes([head[0], head[1], head[2], head[3]]))
-      },
-      None => Err("get u32 EOF".to_string()),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(4) {
+            Some((head, rest)) => {
+                *buf = rest;
+                Ok(u32::from_le_bytes([head[0], head[1], head[2], head[3]]))
+            }
+            None => Err("get u32 EOF".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for u64 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.extend_from_slice(&self.to_le_bytes());
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(8) {
-      Some((head, rest)) => {
-        *buf = rest;
-        Ok(u64::from_le_bytes([
-          head[0], head[1], head[2], head[3], head[4], head[5], head[6],
-          head[7],
-        ]))
-      },
-      None => Err("get u64 EOF".to_string()),
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(&self.to_le_bytes());
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(8) {
+            Some((head, rest)) => {
+                *buf = rest;
+                Ok(u64::from_le_bytes([
+                    head[0], head[1], head[2], head[3], head[4], head[5], head[6], head[7],
+                ]))
+            }
+            None => Err("get u64 EOF".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for bool {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      false => buf.push(0),
-      true => buf.push(1),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            false => buf.push(0),
+            true => buf.push(1),
+        }
     }
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(false),
-          1 => Ok(true),
-          x => Err(format!("get bool invalid {x}")),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(false),
+                    1 => Ok(true),
+                    x => Err(format!("get bool invalid {x}")),
+                }
+            }
+            None => Err("get bool EOF".to_string()),
         }
-      },
-      None => Err("get bool EOF".to_string()),
     }
-  }
 }
 
 pub fn u64_byte_count(x: u64) -> u8 {
-  match x {
-    0 => 0,
-    x if x < 0x0000000000000100 => 1,
-    x if x < 0x0000000000010000 => 2,
-    x if x < 0x0000000001000000 => 3,
-    x if x < 0x0000000100000000 => 4,
-    x if x < 0x0000010000000000 => 5,
-    x if x < 0x0001000000000000 => 6,
-    x if x < 0x0100000000000000 => 7,
-    _ => 8,
-  }
+    match x {
+        0 => 0,
+        x if x < 0x0000000000000100 => 1,
+        x if x < 0x0000000000010000 => 2,
+        x if x < 0x0000000001000000 => 3,
+        x if x < 0x0000000100000000 => 4,
+        x if x < 0x0000010000000000 => 5,
+        x if x < 0x0001000000000000 => 6,
+        x if x < 0x0100000000000000 => 7,
+        _ => 8,
+    }
 }
 
 pub fn u64_put_trimmed_le(x: u64, buf: &mut Vec<u8>) {
-  let n = u64_byte_count(x) as usize;
-  buf.extend_from_slice(&x.to_le_bytes()[..n])
+    let n = u64_byte_count(x) as usize;
+    buf.extend_from_slice(&x.to_le_bytes()[..n])
 }
 
 pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
-  let mut res = [0u8; 8];
-  if len > 8 {
-    return Err("get trimmed_le_64 len > 8".to_string());
-  }
-  match buf.split_at_checked(len) {
-    Some((head, rest)) => {
-      *buf = rest;
-      res[..len].copy_from_slice(head);
-      Ok(u64::from_le_bytes(res))
-    },
-    None => Err(format!("get trimmed_le_u64 EOF {len} {buf:?}")),
-  }
+    let mut res = [0u8; 8];
+    if len > 8 {
+        return Err("get trimmed_le_64 len > 8".to_string());
+    }
+    match buf.split_at_checked(len) {
+        Some((head, rest)) => {
+            *buf = rest;
+            res[..len].copy_from_slice(head);
+            Ok(u64::from_le_bytes(res))
+        }
+        None => Err(format!("get trimmed_le_u64 EOF {len} {buf:?}")),
+    }
 }
 
 //  F := flag, L := large-bit, X := small-field, A := large_field
@@ -141,2297 +140,2342 @@ pub fn u64_get_trimmed_le(len: usize, buf: &mut &[u8]) -> Result<u64, String> {
 // "Flag" means the first nibble of the head
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Tag4 {
-  flag: u8,
-  size: u64,
+    flag: u8,
+    size: u64,
 }
 
 impl Tag4 {
-  #[allow(clippy::cast_possible_truncation)]
-  pub fn encode_head(&self) -> u8 {
-    if self.size < 8 {
-      (self.flag << 4) + (self.size as u8)
-    } else {
-      (self.flag << 4) + 0b1000 + (u64_byte_count(self.size) - 1)
+    #[allow(clippy::cast_possible_truncation)]
+    pub fn encode_head(&self) -> u8 {
+        if self.size < 8 {
+            (self.flag << 4) + (self.size as u8)
+        } else {
+            (self.flag << 4) + 0b1000 + (u64_byte_count(self.size) - 1)
+        }
+    }
+    pub fn decode_head(head: u8) -> (u8, bool, u8) {
+        (head >> 4, head & 0b1000 != 0, head % 0b1000)
     }
-  }
-  pub fn decode_head(head: u8) -> (u8, bool, u8) {
-    (head >> 4, head & 0b1000 != 0, head % 0b1000)
-  }
 }
 
 impl Serialize for Tag4 {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.encode_head().put(buf);
-    if self.size >= 8 {
-      u64_put_trimmed_le(self.size, buf)
-    }
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let head = u8::get(buf)?;
-    let (flag, large, small) = Tag4::decode_head(head);
-    let size = if large {
-      u64_get_trimmed_le((small + 1) as usize, buf)?
-    } else {
-      small as u64
-    };
-    Ok(Tag4 { flag, size })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.encode_head().put(buf);
+        if self.size >= 8 {
+            u64_put_trimmed_le(self.size, buf)
+        }
+    }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let head = u8::get(buf)?;
+        let (flag, large, small) = Tag4::decode_head(head);
+        let size = if large {
+            u64_get_trimmed_le((small + 1) as usize, buf)?
+        } else {
+            small as u64
+        };
+        Ok(Tag4 { flag, size })
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ByteArray(pub Vec<u8>);
 
 impl Serialize for ByteArray {
-  fn put(&self, buf: &mut Vec<u8>) {
-    Tag4 { flag: 0x9, size: self.0.len() as u64 }.put(buf);
-    buf.extend_from_slice(&self.0);
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let tag = Tag4::get(buf)?;
-    match tag {
-      Tag4 { flag: 0x9, size } => {
-        let mut res = vec![];
-        for _ in 0..size {
-          res.push(u8::get(buf)?)
+    fn put(&self, buf: &mut Vec<u8>) {
+        Tag4 {
+            flag: 0x9,
+            size: self.0.len() as u64,
+        }
+        .put(buf);
+        buf.extend_from_slice(&self.0);
+    }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let tag = Tag4::get(buf)?;
+        match tag {
+            Tag4 { flag: 0x9, size } => {
+                let mut res = vec![];
+                for _ in 0..size {
+                    res.push(u8::get(buf)?)
+                }
+                Ok(ByteArray(res))
+            }
+            _ => Err("expected Tag4 0x9 for Vec<u8>".to_string()),
         }
-        Ok(ByteArray(res))
-      },
-      _ => Err("expected Tag4 0x9 for Vec<u8>".to_string()),
     }
-  }
 }
 
 impl Serialize for String {
-  fn put(&self, buf: &mut Vec<u8>) {
-    let bytes = self.as_bytes();
-    Tag4 { flag: 0x9, size: bytes.len() as u64 }.put(buf);
-    buf.extend_from_slice(bytes);
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let bytes = ByteArray::get(buf)?;
-    String::from_utf8(bytes.0).map_err(|e| format!("Invalid UTF-8: {e}"))
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        let bytes = self.as_bytes();
+        Tag4 {
+            flag: 0x9,
+            size: bytes.len() as u64,
+        }
+        .put(buf);
+        buf.extend_from_slice(bytes);
+    }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let bytes = ByteArray::get(buf)?;
+        String::from_utf8(bytes.0).map_err(|e| format!("Invalid UTF-8: {e}"))
+    }
 }
 
 impl Serialize for Nat {
-  fn put(&self, buf: &mut Vec<u8>) {
-    let bytes = self.to_le_bytes();
-    Tag4 { flag: 0x9, size: bytes.len() as u64 }.put(buf);
-    buf.extend_from_slice(&bytes);
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let bytes = ByteArray::get(buf)?;
-    Ok(Nat::from_le_bytes(&bytes.0))
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        let bytes = self.to_le_bytes();
+        Tag4 {
+            flag: 0x9,
+            size: bytes.len() as u64,
+        }
+        .put(buf);
+        buf.extend_from_slice(&bytes);
+    }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let bytes = ByteArray::get(buf)?;
+        Ok(Nat::from_le_bytes(&bytes.0))
+    }
 }
 
 impl Serialize for Int {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::OfNat(x) => {
-        buf.push(0);
-        x.put(buf);
-      },
-      Self::NegSucc(x) => {
-        buf.push(1);
-        x.put(buf);
-      },
-    }
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::OfNat(Nat::get(buf)?)),
-          1 => Ok(Self::NegSucc(Nat::get(buf)?)),
-          x => Err(format!("get Int invalid {x}")),
-        }
-      },
-      None => Err("get Int EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::OfNat(x) => {
+                buf.push(0);
+                x.put(buf);
+            }
+            Self::NegSucc(x) => {
+                buf.push(1);
+                x.put(buf);
+            }
+        }
+    }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::OfNat(Nat::get(buf)?)),
+                    1 => Ok(Self::NegSucc(Nat::get(buf)?)),
+                    x => Err(format!("get Int invalid {x}")),
+                }
+            }
+            None => Err("get Int EOF".to_string()),
+        }
+    }
 }
 
 impl<S: Serialize> Serialize for Vec<S> {
-  fn put(&self, buf: &mut Vec<u8>) {
-    Nat(BigUint::from(self.len())).put(buf);
-    for x in self {
-      x.put(buf)
+    fn put(&self, buf: &mut Vec<u8>) {
+        Nat(BigUint::from(self.len())).put(buf);
+        for x in self {
+            x.put(buf)
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let mut res = vec![];
-    let len = Nat::get(buf)?.0;
-    let mut i = BigUint::from(0u32);
-    while i < len {
-      res.push(S::get(buf)?);
-      i += 1u32;
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let mut res = vec![];
+        let len = Nat::get(buf)?.0;
+        let mut i = BigUint::from(0u32);
+        while i < len {
+            res.push(S::get(buf)?);
+            i += 1u32;
+        }
+        Ok(res)
     }
-    Ok(res)
-  }
 }
 
 #[allow(clippy::cast_possible_truncation)]
 pub fn pack_bools<I>(bools: I) -> u8
 where
-  I: IntoIterator<Item = bool>,
+    I: IntoIterator<Item = bool>,
 {
-  let mut acc: u8 = 0;
-  for (i, b) in bools.into_iter().take(8).enumerate() {
-    if b {
-      acc |= 1u8 << (i as u32);
+    let mut acc: u8 = 0;
+    for (i, b) in bools.into_iter().take(8).enumerate() {
+        if b {
+            acc |= 1u8 << (i as u32);
+        }
     }
-  }
-  acc
+    acc
 }
 
 pub fn unpack_bools(n: usize, b: u8) -> Vec<bool> {
-  (0..8).map(|i: u32| (b & (1u8 << i)) != 0).take(n.min(8)).collect()
+    (0..8)
+        .map(|i: u32| (b & (1u8 << i)) != 0)
+        .take(n.min(8))
+        .collect()
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum QuotKind {
-  Type,
-  Ctor,
-  Lift,
-  Ind,
+    Type,
+    Ctor,
+    Lift,
+    Ind,
 }
 
 impl Serialize for QuotKind {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Type => buf.push(0),
-      Self::Ctor => buf.push(1),
-      Self::Lift => buf.push(2),
-      Self::Ind => buf.push(3),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Type => buf.push(0),
+            Self::Ctor => buf.push(1),
+            Self::Lift => buf.push(2),
+            Self::Ind => buf.push(3),
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Type),
-          1 => Ok(Self::Ctor),
-          2 => Ok(Self::Lift),
-          3 => Ok(Self::Ind),
-          x => Err(format!("get QuotKind invalid {x}")),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Type),
+                    1 => Ok(Self::Ctor),
+                    2 => Ok(Self::Lift),
+                    3 => Ok(Self::Ind),
+                    x => Err(format!("get QuotKind invalid {x}")),
+                }
+            }
+            None => Err("get QuotKind EOF".to_string()),
         }
-      },
-      None => Err("get QuotKind EOF".to_string()),
     }
-  }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DefKind {
-  Definition,
-  Opaque,
-  Theorem,
+    Definition,
+    Opaque,
+    Theorem,
 }
 
 impl Serialize for DefKind {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Definition => buf.push(0),
-      Self::Opaque => buf.push(1),
-      Self::Theorem => buf.push(2),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Definition => buf.push(0),
+            Self::Opaque => buf.push(1),
+            Self::Theorem => buf.push(2),
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Definition),
-          1 => Ok(Self::Opaque),
-          2 => Ok(Self::Theorem),
-          x => Err(format!("get DefKind invalid {x}")),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Definition),
+                    1 => Ok(Self::Opaque),
+                    2 => Ok(Self::Theorem),
+                    x => Err(format!("get DefKind invalid {x}")),
+                }
+            }
+            None => Err("get DefKind EOF".to_string()),
         }
-      },
-      None => Err("get DefKind EOF".to_string()),
     }
-  }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BinderInfo {
-  Default,
-  Implicit,
-  StrictImplicit,
-  InstImplicit,
-  AuxDecl,
+    Default,
+    Implicit,
+    StrictImplicit,
+    InstImplicit,
+    AuxDecl,
 }
 
 impl Serialize for BinderInfo {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Default => buf.push(0),
-      Self::Implicit => buf.push(1),
-      Self::StrictImplicit => buf.push(2),
-      Self::InstImplicit => buf.push(3),
-      Self::AuxDecl => buf.push(4),
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Default),
-          1 => Ok(Self::Implicit),
-          2 => Ok(Self::StrictImplicit),
-          3 => Ok(Self::InstImplicit),
-          4 => Ok(Self::AuxDecl),
-          x => Err(format!("get BinderInfo invalid {x}")),
-        }
-      },
-      None => Err("get BinderInfo EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Default => buf.push(0),
+            Self::Implicit => buf.push(1),
+            Self::StrictImplicit => buf.push(2),
+            Self::InstImplicit => buf.push(3),
+            Self::AuxDecl => buf.push(4),
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Default),
+                    1 => Ok(Self::Implicit),
+                    2 => Ok(Self::StrictImplicit),
+                    3 => Ok(Self::InstImplicit),
+                    4 => Ok(Self::AuxDecl),
+                    x => Err(format!("get BinderInfo invalid {x}")),
+                }
+            }
+            None => Err("get BinderInfo EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ReducibilityHints {
-  Opaque,
-  Abbrev,
-  Regular(u32),
+    Opaque,
+    Abbrev,
+    Regular(u32),
 }
 
 impl Serialize for ReducibilityHints {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Opaque => buf.push(0),
-      Self::Abbrev => buf.push(1),
-      Self::Regular(x) => {
-        buf.push(2);
-        x.put(buf);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Opaque),
-          1 => Ok(Self::Abbrev),
-          2 => {
-            let x: u32 = Serialize::get(buf)?;
-            Ok(Self::Regular(x))
-          },
-          x => Err(format!("get ReducibilityHints invalid {x}")),
-        }
-      },
-      None => Err("get ReducibilityHints EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Opaque => buf.push(0),
+            Self::Abbrev => buf.push(1),
+            Self::Regular(x) => {
+                buf.push(2);
+                x.put(buf);
+            }
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Opaque),
+                    1 => Ok(Self::Abbrev),
+                    2 => {
+                        let x: u32 = Serialize::get(buf)?;
+                        Ok(Self::Regular(x))
+                    }
+                    x => Err(format!("get ReducibilityHints invalid {x}")),
+                }
+            }
+            None => Err("get ReducibilityHints EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DefSafety {
-  Unsafe,
-  Safe,
-  Partial,
+    Unsafe,
+    Safe,
+    Partial,
 }
 
 impl Serialize for DefSafety {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Unsafe => buf.push(0),
-      Self::Safe => buf.push(1),
-      Self::Partial => buf.push(2),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Unsafe => buf.push(0),
+            Self::Safe => buf.push(1),
+            Self::Partial => buf.push(2),
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Unsafe),
-          1 => Ok(Self::Safe),
-          2 => Ok(Self::Partial),
-          x => Err(format!("get DefSafety invalid {x}")),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Unsafe),
+                    1 => Ok(Self::Safe),
+                    2 => Ok(Self::Partial),
+                    x => Err(format!("get DefSafety invalid {x}")),
+                }
+            }
+            None => Err("get DefSafety EOF".to_string()),
         }
-      },
-      None => Err("get DefSafety EOF".to_string()),
     }
-  }
 }
 
 impl<A: Serialize, B: Serialize> Serialize for (A, B) {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.0.put(buf);
-    self.1.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.0.put(buf);
+        self.1.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    Ok((A::get(buf)?, B::get(buf)?))
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        Ok((A::get(buf)?, B::get(buf)?))
+    }
 }
 
 impl Serialize for Address {
-  fn put(&self, buf: &mut Vec<u8>) {
-    buf.extend_from_slice(self.hash.as_bytes())
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(32) {
-      Some((head, rest)) => {
-        *buf = rest;
-        Ok(Address { hash: Hash::from_slice(head).unwrap() })
-      },
-      None => Err("get Address out of input".to_string()),
+    fn put(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(self.hash.as_bytes())
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(32) {
+            Some((head, rest)) => {
+                *buf = rest;
+                Ok(Address {
+                    hash: Hash::from_slice(head).unwrap(),
+                })
+            }
+            None => Err("get Address out of input".to_string()),
+        }
     }
-  }
 }
 
 impl Serialize for MetaAddress {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.data.put(buf);
-    self.meta.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.data.put(buf);
+        self.meta.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let data = Address::get(buf)?;
-    let meta = Address::get(buf)?;
-    Ok(MetaAddress { data, meta })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let data = Address::get(buf)?;
+        let meta = Address::get(buf)?;
+        Ok(MetaAddress { data, meta })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Quotient {
-  pub kind: QuotKind,
-  pub lvls: Nat,
-  pub typ: Address,
+    pub kind: QuotKind,
+    pub lvls: Nat,
+    pub typ: Address,
 }
 
 impl Serialize for Quotient {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.kind.put(buf);
-    self.lvls.put(buf);
-    self.typ.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.kind.put(buf);
+        self.lvls.put(buf);
+        self.typ.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let kind = QuotKind::get(buf)?;
-    let lvls = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    Ok(Quotient { kind, lvls, typ })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let kind = QuotKind::get(buf)?;
+        let lvls = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        Ok(Quotient { kind, lvls, typ })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Axiom {
-  pub is_unsafe: bool,
-  pub lvls: Nat,
-  pub typ: Address,
+    pub is_unsafe: bool,
+    pub lvls: Nat,
+    pub typ: Address,
 }
 
 impl Serialize for Axiom {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.is_unsafe.put(buf);
-    self.lvls.put(buf);
-    self.typ.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.is_unsafe.put(buf);
+        self.lvls.put(buf);
+        self.typ.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let is_unsafe = bool::get(buf)?;
-    let lvls = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    Ok(Axiom { lvls, typ, is_unsafe })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let is_unsafe = bool::get(buf)?;
+        let lvls = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        Ok(Axiom {
+            lvls,
+            typ,
+            is_unsafe,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Definition {
-  pub kind: DefKind,
-  pub safety: DefSafety,
-  pub lvls: Nat,
-  pub typ: Address,
-  pub value: Address,
+    pub kind: DefKind,
+    pub safety: DefSafety,
+    pub lvls: Nat,
+    pub typ: Address,
+    pub value: Address,
 }
 
 impl Serialize for Definition {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.kind.put(buf);
-    self.safety.put(buf);
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.value.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let kind = DefKind::get(buf)?;
-    let safety = DefSafety::get(buf)?;
-    let lvls = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    let value = Address::get(buf)?;
-    Ok(Definition { kind, safety, lvls, typ, value })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.kind.put(buf);
+        self.safety.put(buf);
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.value.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let kind = DefKind::get(buf)?;
+        let safety = DefSafety::get(buf)?;
+        let lvls = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        let value = Address::get(buf)?;
+        Ok(Definition {
+            kind,
+            safety,
+            lvls,
+            typ,
+            value,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Constructor {
-  pub is_unsafe: bool,
-  pub lvls: Nat,
-  pub cidx: Nat,
-  pub params: Nat,
-  pub fields: Nat,
-  pub typ: Address,
+    pub is_unsafe: bool,
+    pub lvls: Nat,
+    pub cidx: Nat,
+    pub params: Nat,
+    pub fields: Nat,
+    pub typ: Address,
 }
 
 impl Serialize for Constructor {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.is_unsafe.put(buf);
-    self.lvls.put(buf);
-    self.cidx.put(buf);
-    self.params.put(buf);
-    self.fields.put(buf);
-    self.typ.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let is_unsafe = bool::get(buf)?;
-    let lvls = Nat::get(buf)?;
-    let cidx = Nat::get(buf)?;
-    let params = Nat::get(buf)?;
-    let fields = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    Ok(Constructor { lvls, typ, cidx, params, fields, is_unsafe })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.is_unsafe.put(buf);
+        self.lvls.put(buf);
+        self.cidx.put(buf);
+        self.params.put(buf);
+        self.fields.put(buf);
+        self.typ.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let is_unsafe = bool::get(buf)?;
+        let lvls = Nat::get(buf)?;
+        let cidx = Nat::get(buf)?;
+        let params = Nat::get(buf)?;
+        let fields = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        Ok(Constructor {
+            lvls,
+            typ,
+            cidx,
+            params,
+            fields,
+            is_unsafe,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RecursorRule {
-  pub fields: Nat,
-  pub rhs: Address,
+    pub fields: Nat,
+    pub rhs: Address,
 }
 
 impl Serialize for RecursorRule {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.fields.put(buf);
-    self.rhs.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.fields.put(buf);
+        self.rhs.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let fields = Nat::get(buf)?;
-    let rhs = Address::get(buf)?;
-    Ok(RecursorRule { fields, rhs })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let fields = Nat::get(buf)?;
+        let rhs = Address::get(buf)?;
+        Ok(RecursorRule { fields, rhs })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Recursor {
-  pub k: bool,
-  pub is_unsafe: bool,
-  pub lvls: Nat,
-  pub params: Nat,
-  pub indices: Nat,
-  pub motives: Nat,
-  pub minors: Nat,
-  pub typ: Address,
-  pub rules: Vec<RecursorRule>,
+    pub k: bool,
+    pub is_unsafe: bool,
+    pub lvls: Nat,
+    pub params: Nat,
+    pub indices: Nat,
+    pub motives: Nat,
+    pub minors: Nat,
+    pub typ: Address,
+    pub rules: Vec<RecursorRule>,
 }
 
 impl Serialize for Recursor {
-  fn put(&self, buf: &mut Vec<u8>) {
-    pack_bools(vec![self.k, self.is_unsafe]).put(buf);
-    self.lvls.put(buf);
-    self.params.put(buf);
-    self.indices.put(buf);
-    self.motives.put(buf);
-    self.minors.put(buf);
-    self.typ.put(buf);
-    self.rules.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let bools = unpack_bools(2, u8::get(buf)?);
-    let lvls = Nat::get(buf)?;
-    let params = Nat::get(buf)?;
-    let indices = Nat::get(buf)?;
-    let motives = Nat::get(buf)?;
-    let minors = Nat::get(buf)?;
-    let typ = Serialize::get(buf)?;
-    let rules = Serialize::get(buf)?;
-    Ok(Recursor {
-      lvls,
-      typ,
-      params,
-      indices,
-      motives,
-      minors,
-      rules,
-      k: bools[0],
-      is_unsafe: bools[1],
-    })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        pack_bools(vec![self.k, self.is_unsafe]).put(buf);
+        self.lvls.put(buf);
+        self.params.put(buf);
+        self.indices.put(buf);
+        self.motives.put(buf);
+        self.minors.put(buf);
+        self.typ.put(buf);
+        self.rules.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let bools = unpack_bools(2, u8::get(buf)?);
+        let lvls = Nat::get(buf)?;
+        let params = Nat::get(buf)?;
+        let indices = Nat::get(buf)?;
+        let motives = Nat::get(buf)?;
+        let minors = Nat::get(buf)?;
+        let typ = Serialize::get(buf)?;
+        let rules = Serialize::get(buf)?;
+        Ok(Recursor {
+            lvls,
+            typ,
+            params,
+            indices,
+            motives,
+            minors,
+            rules,
+            k: bools[0],
+            is_unsafe: bools[1],
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Inductive {
-  pub recr: bool,
-  pub refl: bool,
-  pub is_unsafe: bool,
-  pub lvls: Nat,
-  pub params: Nat,
-  pub indices: Nat,
-  pub nested: Nat,
-  pub typ: Address,
-  pub ctors: Vec<Constructor>,
+    pub recr: bool,
+    pub refl: bool,
+    pub is_unsafe: bool,
+    pub lvls: Nat,
+    pub params: Nat,
+    pub indices: Nat,
+    pub nested: Nat,
+    pub typ: Address,
+    pub ctors: Vec<Constructor>,
 }
 
 impl Serialize for Inductive {
-  fn put(&self, buf: &mut Vec<u8>) {
-    pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
-    self.lvls.put(buf);
-    self.params.put(buf);
-    self.indices.put(buf);
-    self.nested.put(buf);
-    self.typ.put(buf);
-    Serialize::put(&self.ctors, buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let bools = unpack_bools(3, u8::get(buf)?);
-    let lvls = Nat::get(buf)?;
-    let params = Nat::get(buf)?;
-    let indices = Nat::get(buf)?;
-    let nested = Nat::get(buf)?;
-    let typ = Address::get(buf)?;
-    let ctors = Serialize::get(buf)?;
-    Ok(Inductive {
-      recr: bools[0],
-      refl: bools[1],
-      is_unsafe: bools[2],
-      lvls,
-      params,
-      indices,
-      nested,
-      typ,
-      ctors,
-    })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        pack_bools(vec![self.recr, self.refl, self.is_unsafe]).put(buf);
+        self.lvls.put(buf);
+        self.params.put(buf);
+        self.indices.put(buf);
+        self.nested.put(buf);
+        self.typ.put(buf);
+        Serialize::put(&self.ctors, buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let bools = unpack_bools(3, u8::get(buf)?);
+        let lvls = Nat::get(buf)?;
+        let params = Nat::get(buf)?;
+        let indices = Nat::get(buf)?;
+        let nested = Nat::get(buf)?;
+        let typ = Address::get(buf)?;
+        let ctors = Serialize::get(buf)?;
+        Ok(Inductive {
+            recr: bools[0],
+            refl: bools[1],
+            is_unsafe: bools[2],
+            lvls,
+            params,
+            indices,
+            nested,
+            typ,
+            ctors,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct InductiveProj {
-  pub idx: Nat,
-  pub block: Address,
+    pub idx: Nat,
+    pub block: Address,
 }
 
 impl Serialize for InductiveProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.idx.put(buf);
-    self.block.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.idx.put(buf);
+        self.block.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let idx = Nat::get(buf)?;
-    let block = Address::get(buf)?;
-    Ok(InductiveProj { idx, block })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let idx = Nat::get(buf)?;
+        let block = Address::get(buf)?;
+        Ok(InductiveProj { idx, block })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ConstructorProj {
-  pub idx: Nat,
-  pub cidx: Nat,
-  pub block: Address,
+    pub idx: Nat,
+    pub cidx: Nat,
+    pub block: Address,
 }
 
 impl Serialize for ConstructorProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.idx.put(buf);
-    self.cidx.put(buf);
-    self.block.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.idx.put(buf);
+        self.cidx.put(buf);
+        self.block.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let idx = Nat::get(buf)?;
-    let cidx = Nat::get(buf)?;
-    let block = Address::get(buf)?;
-    Ok(ConstructorProj { idx, cidx, block })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let idx = Nat::get(buf)?;
+        let cidx = Nat::get(buf)?;
+        let block = Address::get(buf)?;
+        Ok(ConstructorProj { idx, cidx, block })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RecursorProj {
-  pub idx: Nat,
-  pub ridx: Nat,
-  pub block: Address,
+    pub idx: Nat,
+    pub ridx: Nat,
+    pub block: Address,
 }
 
 impl Serialize for RecursorProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.idx.put(buf);
-    self.ridx.put(buf);
-    self.block.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.idx.put(buf);
+        self.ridx.put(buf);
+        self.block.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let idx = Nat::get(buf)?;
-    let ridx = Nat::get(buf)?;
-    let block = Address::get(buf)?;
-    Ok(RecursorProj { idx, ridx, block })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let idx = Nat::get(buf)?;
+        let ridx = Nat::get(buf)?;
+        let block = Address::get(buf)?;
+        Ok(RecursorProj { idx, ridx, block })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DefinitionProj {
-  pub idx: Nat,
-  pub block: Address,
+    pub idx: Nat,
+    pub block: Address,
 }
 
 impl Serialize for DefinitionProj {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.idx.put(buf);
-    self.block.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.idx.put(buf);
+        self.block.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let idx = Nat::get(buf)?;
-    let block = Address::get(buf)?;
-    Ok(DefinitionProj { idx, block })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let idx = Nat::get(buf)?;
+        let block = Address::get(buf)?;
+        Ok(DefinitionProj { idx, block })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Comm {
-  pub secret: Address,
-  pub payload: Address,
+    pub secret: Address,
+    pub payload: Address,
 }
 
 impl Serialize for Comm {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.secret.put(buf);
-    self.payload.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.secret.put(buf);
+        self.payload.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let secret = Address::get(buf)?;
-    let payload = Address::get(buf)?;
-    Ok(Comm { secret, payload })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let secret = Address::get(buf)?;
+        let payload = Address::get(buf)?;
+        Ok(Comm { secret, payload })
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EvalClaim {
-  pub lvls: Address,
-  pub typ: Address,
-  pub input: Address,
-  pub output: Address,
+    pub lvls: Address,
+    pub typ: Address,
+    pub input: Address,
+    pub output: Address,
 }
 
 impl Serialize for EvalClaim {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.input.put(buf);
-    self.output.put(buf);
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Address::get(buf)?;
-    let typ = Address::get(buf)?;
-    let input = Address::get(buf)?;
-    let output = Address::get(buf)?;
-    Ok(Self { lvls, typ, input, output })
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.input.put(buf);
+        self.output.put(buf);
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Address::get(buf)?;
+        let typ = Address::get(buf)?;
+        let input = Address::get(buf)?;
+        let output = Address::get(buf)?;
+        Ok(Self {
+            lvls,
+            typ,
+            input,
+            output,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CheckClaim {
-  pub lvls: Address,
-  pub typ: Address,
-  pub value: Address,
+    pub lvls: Address,
+    pub typ: Address,
+    pub value: Address,
 }
 
 impl Serialize for CheckClaim {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.lvls.put(buf);
-    self.typ.put(buf);
-    self.value.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.lvls.put(buf);
+        self.typ.put(buf);
+        self.value.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let lvls = Address::get(buf)?;
-    let typ = Address::get(buf)?;
-    let value = Address::get(buf)?;
-    Ok(Self { lvls, typ, value })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let lvls = Address::get(buf)?;
+        let typ = Address::get(buf)?;
+        let value = Address::get(buf)?;
+        Ok(Self { lvls, typ, value })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Claim {
-  Checks(CheckClaim),
-  Evals(EvalClaim),
+    Checks(CheckClaim),
+    Evals(EvalClaim),
 }
 
 impl Serialize for Claim {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Evals(x) => {
-        u8::put(&0xE2, buf);
-        x.put(buf)
-      },
-      Self::Checks(x) => {
-        u8::put(&0xE3, buf);
-        x.put(buf)
-      },
-    }
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0xE2 => {
-            let x = EvalClaim::get(buf)?;
-            Ok(Self::Evals(x))
-          },
-          0xE3 => {
-            let x = CheckClaim::get(buf)?;
-            Ok(Self::Checks(x))
-          },
-          x => Err(format!("get Claim invalid {x}")),
-        }
-      },
-      None => Err("get Claim EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Evals(x) => {
+                u8::put(&0xE2, buf);
+                x.put(buf)
+            }
+            Self::Checks(x) => {
+                u8::put(&0xE3, buf);
+                x.put(buf)
+            }
+        }
+    }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0xE2 => {
+                        let x = EvalClaim::get(buf)?;
+                        Ok(Self::Evals(x))
+                    }
+                    0xE3 => {
+                        let x = CheckClaim::get(buf)?;
+                        Ok(Self::Checks(x))
+                    }
+                    x => Err(format!("get Claim invalid {x}")),
+                }
+            }
+            None => Err("get Claim EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Proof {
-  pub claim: Claim,
-  pub proof: Vec<u8>,
+    pub claim: Claim,
+    pub proof: Vec<u8>,
 }
 
 impl Serialize for Proof {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.claim.put(buf);
-    self.proof.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.claim.put(buf);
+        self.proof.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let claim = Claim::get(buf)?;
-    let proof = Serialize::get(buf)?;
-    Ok(Proof { claim, proof })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let claim = Claim::get(buf)?;
+        let proof = Serialize::get(buf)?;
+        Ok(Proof { claim, proof })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Env {
-  pub env: Vec<MetaAddress>,
+    pub env: Vec<MetaAddress>,
 }
 
 impl Serialize for Env {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.env.put(buf)
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.env.put(buf)
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    Ok(Env { env: Serialize::get(buf)? })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        Ok(Env {
+            env: Serialize::get(buf)?,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Substring {
-  pub str: Address,
-  pub start_pos: Nat,
-  pub stop_pos: Nat,
+    pub str: Address,
+    pub start_pos: Nat,
+    pub stop_pos: Nat,
 }
 
 impl Serialize for Substring {
-  fn put(&self, buf: &mut Vec<u8>) {
-    self.str.put(buf);
-    self.start_pos.put(buf);
-    self.stop_pos.put(buf);
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        self.str.put(buf);
+        self.start_pos.put(buf);
+        self.stop_pos.put(buf);
+    }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let str = Address::get(buf)?;
-    let start_pos = Nat::get(buf)?;
-    let stop_pos = Nat::get(buf)?;
-    Ok(Substring { str, start_pos, stop_pos })
-  }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let str = Address::get(buf)?;
+        let start_pos = Nat::get(buf)?;
+        let stop_pos = Nat::get(buf)?;
+        Ok(Substring {
+            str,
+            start_pos,
+            stop_pos,
+        })
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum SourceInfo {
-  Original(Substring, Nat, Substring, Nat),
-  Synthetic(Nat, Nat, bool),
-  None,
+    Original(Substring, Nat, Substring, Nat),
+    Synthetic(Nat, Nat, bool),
+    None,
 }
 
 impl Serialize for SourceInfo {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Original(l, p, t, e) => {
-        buf.push(0);
-        l.put(buf);
-        p.put(buf);
-        t.put(buf);
-        e.put(buf);
-      },
-      Self::Synthetic(p, e, c) => {
-        buf.push(1);
-        p.put(buf);
-        e.put(buf);
-        c.put(buf);
-      },
-      Self::None => {
-        buf.push(2);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Original(
-            Substring::get(buf)?,
-            Nat::get(buf)?,
-            Substring::get(buf)?,
-            Nat::get(buf)?,
-          )),
-          1 => {
-            Ok(Self::Synthetic(Nat::get(buf)?, Nat::get(buf)?, bool::get(buf)?))
-          },
-          2 => Ok(Self::None),
-          x => Err(format!("get SourcInfo invalid {x}")),
-        }
-      },
-      None => Err("get SourceInfo EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Original(l, p, t, e) => {
+                buf.push(0);
+                l.put(buf);
+                p.put(buf);
+                t.put(buf);
+                e.put(buf);
+            }
+            Self::Synthetic(p, e, c) => {
+                buf.push(1);
+                p.put(buf);
+                e.put(buf);
+                c.put(buf);
+            }
+            Self::None => {
+                buf.push(2);
+            }
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Original(
+                        Substring::get(buf)?,
+                        Nat::get(buf)?,
+                        Substring::get(buf)?,
+                        Nat::get(buf)?,
+                    )),
+                    1 => Ok(Self::Synthetic(
+                        Nat::get(buf)?,
+                        Nat::get(buf)?,
+                        bool::get(buf)?,
+                    )),
+                    2 => Ok(Self::None),
+                    x => Err(format!("get SourcInfo invalid {x}")),
+                }
+            }
+            None => Err("get SourceInfo EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Preresolved {
-  Namespace(Address),
-  Decl(Address, Vec<Address>),
+    Namespace(Address),
+    Decl(Address, Vec<Address>),
 }
 
 impl Serialize for Preresolved {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Namespace(ns) => {
-        buf.push(0);
-        ns.put(buf);
-      },
-      Self::Decl(n, fields) => {
-        buf.push(1);
-        n.put(buf);
-        fields.put(buf);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Namespace(Address::get(buf)?)),
-          1 => Ok(Self::Decl(Address::get(buf)?, Vec::<Address>::get(buf)?)),
-          x => Err(format!("get Preresolved invalid {x}")),
-        }
-      },
-      None => Err("get Preresolved EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Namespace(ns) => {
+                buf.push(0);
+                ns.put(buf);
+            }
+            Self::Decl(n, fields) => {
+                buf.push(1);
+                n.put(buf);
+                fields.put(buf);
+            }
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Namespace(Address::get(buf)?)),
+                    1 => Ok(Self::Decl(Address::get(buf)?, Vec::<Address>::get(buf)?)),
+                    x => Err(format!("get Preresolved invalid {x}")),
+                }
+            }
+            None => Err("get Preresolved EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Syntax {
-  Missing,
-  Node(SourceInfo, Address, Vec<Address>),
-  Atom(SourceInfo, Address),
-  Ident(SourceInfo, Substring, Address, Vec<Preresolved>),
+    Missing,
+    Node(SourceInfo, Address, Vec<Address>),
+    Atom(SourceInfo, Address),
+    Ident(SourceInfo, Substring, Address, Vec<Preresolved>),
 }
 
 impl Serialize for Syntax {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Missing => {
-        buf.push(0);
-      },
-      Self::Node(i, k, xs) => {
-        buf.push(1);
-        i.put(buf);
-        k.put(buf);
-        xs.put(buf);
-      },
-      Self::Atom(i, v) => {
-        buf.push(2);
-        i.put(buf);
-        v.put(buf);
-      },
-      Self::Ident(i, r, v, ps) => {
-        buf.push(3);
-        i.put(buf);
-        r.put(buf);
-        v.put(buf);
-        ps.put(buf);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Missing),
-          1 => Ok(Self::Node(
-            SourceInfo::get(buf)?,
-            Address::get(buf)?,
-            Vec::<Address>::get(buf)?,
-          )),
-          2 => Ok(Self::Atom(SourceInfo::get(buf)?, Address::get(buf)?)),
-          3 => Ok(Self::Ident(
-            SourceInfo::get(buf)?,
-            Substring::get(buf)?,
-            Address::get(buf)?,
-            Vec::<Preresolved>::get(buf)?,
-          )),
-          x => Err(format!("get Syntax invalid {x}")),
-        }
-      },
-      None => Err("get Syntax EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Missing => {
+                buf.push(0);
+            }
+            Self::Node(i, k, xs) => {
+                buf.push(1);
+                i.put(buf);
+                k.put(buf);
+                xs.put(buf);
+            }
+            Self::Atom(i, v) => {
+                buf.push(2);
+                i.put(buf);
+                v.put(buf);
+            }
+            Self::Ident(i, r, v, ps) => {
+                buf.push(3);
+                i.put(buf);
+                r.put(buf);
+                v.put(buf);
+                ps.put(buf);
+            }
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Missing),
+                    1 => Ok(Self::Node(
+                        SourceInfo::get(buf)?,
+                        Address::get(buf)?,
+                        Vec::<Address>::get(buf)?,
+                    )),
+                    2 => Ok(Self::Atom(SourceInfo::get(buf)?, Address::get(buf)?)),
+                    3 => Ok(Self::Ident(
+                        SourceInfo::get(buf)?,
+                        Substring::get(buf)?,
+                        Address::get(buf)?,
+                        Vec::<Preresolved>::get(buf)?,
+                    )),
+                    x => Err(format!("get Syntax invalid {x}")),
+                }
+            }
+            None => Err("get Syntax EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum MutConst {
-  Defn(Definition),
-  Indc(Inductive),
-  Recr(Recursor),
+    Defn(Definition),
+    Indc(Inductive),
+    Recr(Recursor),
 }
 
 impl Serialize for MutConst {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Defn(x) => {
-        buf.push(0);
-        x.put(buf);
-      },
-      Self::Indc(x) => {
-        buf.push(1);
-        x.put(buf);
-      },
-      Self::Recr(x) => {
-        buf.push(2);
-        x.put(buf);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Defn(Definition::get(buf)?)),
-          1 => Ok(Self::Indc(Inductive::get(buf)?)),
-          2 => Ok(Self::Recr(Recursor::get(buf)?)),
-          x => Err(format!("get MutConst invalid {x}")),
-        }
-      },
-      None => Err("get MutConst EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Defn(x) => {
+                buf.push(0);
+                x.put(buf);
+            }
+            Self::Indc(x) => {
+                buf.push(1);
+                x.put(buf);
+            }
+            Self::Recr(x) => {
+                buf.push(2);
+                x.put(buf);
+            }
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Defn(Definition::get(buf)?)),
+                    1 => Ok(Self::Indc(Inductive::get(buf)?)),
+                    2 => Ok(Self::Recr(Recursor::get(buf)?)),
+                    x => Err(format!("get MutConst invalid {x}")),
+                }
+            }
+            None => Err("get MutConst EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BuiltIn {
-  Obj,
-  Neutral,
-  Unreachable,
+    Obj,
+    Neutral,
+    Unreachable,
 }
 
 impl Serialize for BuiltIn {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Obj => buf.push(0),
-      Self::Neutral => buf.push(1),
-      Self::Unreachable => buf.push(2),
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Obj => buf.push(0),
+            Self::Neutral => buf.push(1),
+            Self::Unreachable => buf.push(2),
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Obj),
-          1 => Ok(Self::Neutral),
-          2 => Ok(Self::Unreachable),
-          x => Err(format!("get BuiltIn invalid {x}")),
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Obj),
+                    1 => Ok(Self::Neutral),
+                    2 => Ok(Self::Unreachable),
+                    x => Err(format!("get BuiltIn invalid {x}")),
+                }
+            }
+            None => Err("get BuiltIn EOF".to_string()),
         }
-      },
-      None => Err("get BuiltIn EOF".to_string()),
     }
-  }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DataValue {
-  OfString(Address),
-  OfBool(bool),
-  OfName(Address),
-  OfNat(Address),
-  OfInt(Address),
-  OfSyntax(Address),
+    OfString(Address),
+    OfBool(bool),
+    OfName(Address),
+    OfNat(Address),
+    OfInt(Address),
+    OfSyntax(Address),
 }
 
 impl Serialize for DataValue {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::OfString(x) => {
-        buf.push(0);
-        x.put(buf);
-      },
-      Self::OfBool(x) => {
-        buf.push(1);
-        x.put(buf);
-      },
-      Self::OfName(x) => {
-        buf.push(2);
-        x.put(buf);
-      },
-      Self::OfNat(x) => {
-        buf.push(3);
-        x.put(buf);
-      },
-      Self::OfInt(x) => {
-        buf.push(4);
-        x.put(buf);
-      },
-      Self::OfSyntax(x) => {
-        buf.push(5);
-        x.put(buf);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::OfString(Address::get(buf)?)),
-          1 => Ok(Self::OfBool(bool::get(buf)?)),
-          2 => Ok(Self::OfName(Address::get(buf)?)),
-          3 => Ok(Self::OfNat(Address::get(buf)?)),
-          4 => Ok(Self::OfInt(Address::get(buf)?)),
-          5 => Ok(Self::OfSyntax(Address::get(buf)?)),
-          x => Err(format!("get DataValue invalid {x}")),
-        }
-      },
-      None => Err("get DataValue EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::OfString(x) => {
+                buf.push(0);
+                x.put(buf);
+            }
+            Self::OfBool(x) => {
+                buf.push(1);
+                x.put(buf);
+            }
+            Self::OfName(x) => {
+                buf.push(2);
+                x.put(buf);
+            }
+            Self::OfNat(x) => {
+                buf.push(3);
+                x.put(buf);
+            }
+            Self::OfInt(x) => {
+                buf.push(4);
+                x.put(buf);
+            }
+            Self::OfSyntax(x) => {
+                buf.push(5);
+                x.put(buf);
+            }
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::OfString(Address::get(buf)?)),
+                    1 => Ok(Self::OfBool(bool::get(buf)?)),
+                    2 => Ok(Self::OfName(Address::get(buf)?)),
+                    3 => Ok(Self::OfNat(Address::get(buf)?)),
+                    4 => Ok(Self::OfInt(Address::get(buf)?)),
+                    5 => Ok(Self::OfSyntax(Address::get(buf)?)),
+                    x => Err(format!("get DataValue invalid {x}")),
+                }
+            }
+            None => Err("get DataValue EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Metadatum {
-  Link(Address),
-  Info(BinderInfo),
-  Hints(ReducibilityHints),
-  Links(Vec<Address>),
-  Map(Vec<(Address, Address)>),
-  KVMap(Vec<(Address, DataValue)>),
-  Muts(Vec<Vec<Address>>),
+    Link(Address),
+    Info(BinderInfo),
+    Hints(ReducibilityHints),
+    Links(Vec<Address>),
+    Map(Vec<(Address, Address)>),
+    KVMap(Vec<(Address, DataValue)>),
+    Muts(Vec<Vec<Address>>),
 }
 
 impl Serialize for Metadatum {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::Link(x) => {
-        buf.push(0);
-        x.put(buf);
-      },
-      Self::Info(x) => {
-        buf.push(1);
-        x.put(buf);
-      },
-      Self::Hints(x) => {
-        buf.push(2);
-        x.put(buf);
-      },
-      Self::Links(x) => {
-        buf.push(3);
-        x.put(buf);
-      },
-      Self::Map(x) => {
-        buf.push(4);
-        x.put(buf);
-      },
-      Self::KVMap(x) => {
-        buf.push(5);
-        x.put(buf);
-      },
-      Self::Muts(x) => {
-        buf.push(6);
-        x.put(buf);
-      },
-    }
-  }
-
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    match buf.split_at_checked(1) {
-      Some((head, rest)) => {
-        *buf = rest;
-        match head[0] {
-          0 => Ok(Self::Link(Address::get(buf)?)),
-          1 => Ok(Self::Info(BinderInfo::get(buf)?)),
-          2 => Ok(Self::Hints(ReducibilityHints::get(buf)?)),
-          3 => Ok(Self::Links(Vec::<Address>::get(buf)?)),
-          4 => Ok(Self::Map(Vec::<(Address, Address)>::get(buf)?)),
-          5 => Ok(Self::KVMap(Vec::<(Address, DataValue)>::get(buf)?)),
-          6 => Ok(Self::Muts(Vec::<Vec<Address>>::get(buf)?)),
-          x => Err(format!("get Metadatum invalid {x}")),
-        }
-      },
-      None => Err("get Metadatum EOF".to_string()),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::Link(x) => {
+                buf.push(0);
+                x.put(buf);
+            }
+            Self::Info(x) => {
+                buf.push(1);
+                x.put(buf);
+            }
+            Self::Hints(x) => {
+                buf.push(2);
+                x.put(buf);
+            }
+            Self::Links(x) => {
+                buf.push(3);
+                x.put(buf);
+            }
+            Self::Map(x) => {
+                buf.push(4);
+                x.put(buf);
+            }
+            Self::KVMap(x) => {
+                buf.push(5);
+                x.put(buf);
+            }
+            Self::Muts(x) => {
+                buf.push(6);
+                x.put(buf);
+            }
+        }
+    }
+
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        match buf.split_at_checked(1) {
+            Some((head, rest)) => {
+                *buf = rest;
+                match head[0] {
+                    0 => Ok(Self::Link(Address::get(buf)?)),
+                    1 => Ok(Self::Info(BinderInfo::get(buf)?)),
+                    2 => Ok(Self::Hints(ReducibilityHints::get(buf)?)),
+                    3 => Ok(Self::Links(Vec::<Address>::get(buf)?)),
+                    4 => Ok(Self::Map(Vec::<(Address, Address)>::get(buf)?)),
+                    5 => Ok(Self::KVMap(Vec::<(Address, DataValue)>::get(buf)?)),
+                    6 => Ok(Self::Muts(Vec::<Vec<Address>>::get(buf)?)),
+                    x => Err(format!("get Metadatum invalid {x}")),
+                }
+            }
+            None => Err("get Metadatum EOF".to_string()),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Metadata {
-  pub nodes: Vec<Metadatum>,
+    pub nodes: Vec<Metadatum>,
 }
 
 impl Serialize for Metadata {
-  fn put(&self, buf: &mut Vec<u8>) {
-    Tag4 { flag: 0xF, size: self.nodes.len() as u64 }.put(buf);
-    for n in self.nodes.iter() {
-      n.put(buf)
+    fn put(&self, buf: &mut Vec<u8>) {
+        Tag4 {
+            flag: 0xF,
+            size: self.nodes.len() as u64,
+        }
+        .put(buf);
+        for n in self.nodes.iter() {
+            n.put(buf)
+        }
     }
-  }
 
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let tag = Tag4::get(buf)?;
-    match tag {
-      Tag4 { flag: 0xF, size } => {
-        let mut nodes = vec![];
-        for _ in 0..size {
-          nodes.push(Metadatum::get(buf)?)
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let tag = Tag4::get(buf)?;
+        match tag {
+            Tag4 { flag: 0xF, size } => {
+                let mut nodes = vec![];
+                for _ in 0..size {
+                    nodes.push(Metadatum::get(buf)?)
+                }
+                Ok(Metadata { nodes })
+            }
+            x => Err(format!("get Metadata invalid {x:?}")),
         }
-        Ok(Metadata { nodes })
-      },
-      x => Err(format!("get Metadata invalid {x:?}")),
     }
-  }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Ixon {
-  NAnon,                                 // 0x00, anonymous name
-  NStr(Address, Address),                // 0x01, string name
-  NNum(Address, Address),                // 0x02, number name
-  UZero,                                 // 0x03, universe zero
-  USucc(Address),                        // 0x04, universe successor
-  UMax(Address, Address),                // 0x05, universe max
-  UIMax(Address, Address),               // 0x06, universe impredicative max
-  UVar(Nat),                             // 0x1X, universe variable
-  EVar(Nat),                             // 0x2X, expression variable
-  ERef(Address, Vec<Address>),           // 0x3X, expression reference
-  ERec(Nat, Vec<Address>),               // 0x4X, expression recursion
-  EPrj(Address, Nat, Address),           // 0x5X, expression projection
-  ESort(Address),                        // 0x80, expression sort
-  EStr(Address),                         // 0x81, expression string
-  ENat(Address),                         // 0x82, expression natural
-  EApp(Address, Address),                // 0x83, expression application
-  ELam(Address, Address),                // 0x84, expression lambda
-  EAll(Address, Address),                // 0x85, expression forall
-  ELet(bool, Address, Address, Address), // 0x86, 0x87, expression let
-  Blob(Vec<u8>),                         // 0x9X, tagged bytes
-  Defn(Definition),                      // 0xA0, definition constant
-  Recr(Recursor),                        // 0xA1, recursor constant
-  Axio(Axiom),                           // 0xA2, axiom constant
-  Quot(Quotient),                        // 0xA3, quotient constant
-  CPrj(ConstructorProj),                 // 0xA4, constructor projection
-  RPrj(RecursorProj),                    // 0xA5, recursor projection
-  IPrj(InductiveProj),                   // 0xA6, inductive projection
-  DPrj(DefinitionProj),                  // 0xA7, definition projection
-  Muts(Vec<MutConst>),                   // 0xBX, mutual constants
-  Prof(Proof),                           // 0xE0, zero-knowledge proof
-  Eval(EvalClaim),                       // 0xE1, evaluation claim
-  Chck(CheckClaim),                      // 0xE2, typechecking claim
-  Comm(Comm),                            // 0xE3, cryptographic commitment
-  Envn(Env),                             // 0xE4, multi-claim environment
-  Prim(BuiltIn),                         // 0xE5, compiler built-ins
-  Meta(Metadata),                        // 0xFX, metadata
+    NAnon,                                 // 0x00, anonymous name
+    NStr(Address, Address),                // 0x01, string name
+    NNum(Address, Address),                // 0x02, number name
+    UZero,                                 // 0x03, universe zero
+    USucc(Address),                        // 0x04, universe successor
+    UMax(Address, Address),                // 0x05, universe max
+    UIMax(Address, Address),               // 0x06, universe impredicative max
+    UVar(Nat),                             // 0x1X, universe variable
+    EVar(Nat),                             // 0x2X, expression variable
+    ERef(Address, Vec<Address>),           // 0x3X, expression reference
+    ERec(Nat, Vec<Address>),               // 0x4X, expression recursion
+    EPrj(Address, Nat, Address),           // 0x5X, expression projection
+    ESort(Address),                        // 0x80, expression sort
+    EStr(Address),                         // 0x81, expression string
+    ENat(Address),                         // 0x82, expression natural
+    EApp(Address, Address),                // 0x83, expression application
+    ELam(Address, Address),                // 0x84, expression lambda
+    EAll(Address, Address),                // 0x85, expression forall
+    ELet(bool, Address, Address, Address), // 0x86, 0x87, expression let
+    Blob(Vec<u8>),                         // 0x9X, tagged bytes
+    Defn(Definition),                      // 0xA0, definition constant
+    Recr(Recursor),                        // 0xA1, recursor constant
+    Axio(Axiom),                           // 0xA2, axiom constant
+    Quot(Quotient),                        // 0xA3, quotient constant
+    CPrj(ConstructorProj),                 // 0xA4, constructor projection
+    RPrj(RecursorProj),                    // 0xA5, recursor projection
+    IPrj(InductiveProj),                   // 0xA6, inductive projection
+    DPrj(DefinitionProj),                  // 0xA7, definition projection
+    Muts(Vec<MutConst>),                   // 0xBX, mutual constants
+    Prof(Proof),                           // 0xE0, zero-knowledge proof
+    Eval(EvalClaim),                       // 0xE1, evaluation claim
+    Chck(CheckClaim),                      // 0xE2, typechecking claim
+    Comm(Comm),                            // 0xE3, cryptographic commitment
+    Envn(Env),                             // 0xE4, multi-claim environment
+    Prim(BuiltIn),                         // 0xE5, compiler built-ins
+    Meta(Metadata),                        // 0xFX, metadata
 }
 
 impl Default for Ixon {
-  fn default() -> Self {
-    Self::NAnon
-  }
+    fn default() -> Self {
+        Self::NAnon
+    }
 }
 
 impl Ixon {
-  pub fn put_tag(flag: u8, size: u64, buf: &mut Vec<u8>) {
-    Tag4 { flag, size }.put(buf);
-  }
+    pub fn put_tag(flag: u8, size: u64, buf: &mut Vec<u8>) {
+        Tag4 { flag, size }.put(buf);
+    }
 
-  pub fn puts<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
-    for x in xs {
-      x.put(buf)
+    pub fn puts<S: Serialize>(xs: &[S], buf: &mut Vec<u8>) {
+        for x in xs {
+            x.put(buf)
+        }
     }
-  }
 
-  pub fn gets<S: Serialize>(
-    len: u64,
-    buf: &mut &[u8],
-  ) -> Result<Vec<S>, String> {
-    let mut vec = vec![];
-    for _ in 0..len {
-      let s = S::get(buf)?;
-      vec.push(s);
+    pub fn gets<S: Serialize>(len: u64, buf: &mut &[u8]) -> Result<Vec<S>, String> {
+        let mut vec = vec![];
+        for _ in 0..len {
+            let s = S::get(buf)?;
+            vec.push(s);
+        }
+        Ok(vec)
     }
-    Ok(vec)
-  }
 }
 
 impl Serialize for Ixon {
-  fn put(&self, buf: &mut Vec<u8>) {
-    match self {
-      Self::NAnon => Self::put_tag(0x0, 0, buf),
-      Self::NStr(n, s) => {
-        Self::put_tag(0x0, 1, buf);
-        Serialize::put(n, buf);
-        Serialize::put(s, buf);
-      },
-      Self::NNum(n, s) => {
-        Self::put_tag(0x0, 2, buf);
-        Serialize::put(n, buf);
-        Serialize::put(s, buf);
-      },
-      Self::UZero => Self::put_tag(0x0, 3, buf),
-      Self::USucc(x) => {
-        Self::put_tag(0x0, 4, buf);
-        Serialize::put(x, buf);
-      },
-      Self::UMax(x, y) => {
-        Self::put_tag(0x0, 5, buf);
-        Serialize::put(x, buf);
-        Serialize::put(y, buf);
-      },
-      Self::UIMax(x, y) => {
-        Self::put_tag(0x0, 6, buf);
-        Serialize::put(x, buf);
-        Serialize::put(y, buf);
-      },
-      Self::UVar(x) => {
-        let bytes = x.0.to_bytes_le();
-        Self::put_tag(0x1, bytes.len() as u64, buf);
-        Self::puts(&bytes, buf)
-      },
-      Self::EVar(x) => {
-        let bytes = x.0.to_bytes_le();
-        Self::put_tag(0x2, bytes.len() as u64, buf);
-        Self::puts(&bytes, buf)
-      },
-      Self::ERef(a, ls) => {
-        Self::put_tag(0x3, ls.len() as u64, buf);
-        a.put(buf);
-        Self::puts(ls, buf)
-      },
-      Self::ERec(i, ls) => {
-        Self::put_tag(0x4, ls.len() as u64, buf);
-        i.put(buf);
-        Self::puts(ls, buf)
-      },
-      Self::EPrj(t, n, x) => {
-        let bytes = n.0.to_bytes_le();
-        Self::put_tag(0x5, bytes.len() as u64, buf);
-        t.put(buf);
-        Self::puts(&bytes, buf);
-        x.put(buf);
-      },
-      Self::ESort(u) => {
-        Self::put_tag(0x8, 0, buf);
-        u.put(buf);
-      },
-      Self::EStr(s) => {
-        Self::put_tag(0x8, 1, buf);
-        s.put(buf);
-      },
-      Self::ENat(n) => {
-        Self::put_tag(0x8, 2, buf);
-        n.put(buf);
-      },
-      Self::EApp(f, a) => {
-        Self::put_tag(0x8, 3, buf);
-        f.put(buf);
-        a.put(buf);
-      },
-      Self::ELam(t, b) => {
-        Self::put_tag(0x8, 4, buf);
-        t.put(buf);
-        b.put(buf);
-      },
-      Self::EAll(t, b) => {
-        Self::put_tag(0x8, 5, buf);
-        t.put(buf);
-        b.put(buf);
-      },
-      Self::ELet(nd, t, d, b) => {
-        if *nd {
-          Self::put_tag(0x8, 6, buf);
-        } else {
-          Self::put_tag(0x8, 7, buf);
-        }
-        t.put(buf);
-        d.put(buf);
-        b.put(buf);
-      },
-      Self::Blob(xs) => {
-        Self::put_tag(0x9, xs.len() as u64, buf);
-        Self::puts(xs, buf);
-      },
-      Self::Defn(x) => {
-        Self::put_tag(0xA, 0, buf);
-        x.put(buf);
-      },
-      Self::Recr(x) => {
-        Self::put_tag(0xA, 1, buf);
-        x.put(buf);
-      },
-      Self::Axio(x) => {
-        Self::put_tag(0xA, 2, buf);
-        x.put(buf);
-      },
-      Self::Quot(x) => {
-        Self::put_tag(0xA, 3, buf);
-        x.put(buf);
-      },
-      Self::CPrj(x) => {
-        Self::put_tag(0xA, 4, buf);
-        x.put(buf);
-      },
-      Self::RPrj(x) => {
-        Self::put_tag(0xA, 5, buf);
-        x.put(buf);
-      },
-      Self::IPrj(x) => {
-        Self::put_tag(0xA, 6, buf);
-        x.put(buf);
-      },
-      Self::DPrj(x) => {
-        Self::put_tag(0xA, 7, buf);
-        x.put(buf);
-      },
-      Self::Muts(xs) => {
-        Self::put_tag(0xB, xs.len() as u64, buf);
-        Self::puts(xs, buf);
-      },
-      Self::Prof(x) => {
-        Self::put_tag(0xE, 0, buf);
-        x.put(buf);
-      },
-      Self::Eval(x) => {
-        Self::put_tag(0xE, 1, buf);
-        x.put(buf);
-      },
-      Self::Chck(x) => {
-        Self::put_tag(0xE, 2, buf);
-        x.put(buf);
-      },
-      Self::Comm(x) => {
-        Self::put_tag(0xE, 3, buf);
-        x.put(buf);
-      },
-      Self::Envn(x) => {
-        Self::put_tag(0xE, 4, buf);
-        x.put(buf);
-      },
-      Self::Prim(x) => {
-        Self::put_tag(0xE, 5, buf);
-        x.put(buf);
-      },
-      Self::Meta(x) => x.put(buf),
-    }
-  }
-  fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let tag = Tag4::get(buf)?;
-    match tag {
-      Tag4 { flag: 0x0, size: 0 } => Ok(Self::NAnon),
-      Tag4 { flag: 0x0, size: 1 } => {
-        Ok(Self::NStr(Address::get(buf)?, Address::get(buf)?))
-      },
-      Tag4 { flag: 0x0, size: 2 } => {
-        Ok(Self::NNum(Address::get(buf)?, Address::get(buf)?))
-      },
-      Tag4 { flag: 0x0, size: 3 } => Ok(Self::UZero),
-      Tag4 { flag: 0x0, size: 4 } => Ok(Self::USucc(Address::get(buf)?)),
-      Tag4 { flag: 0x0, size: 5 } => {
-        Ok(Self::UMax(Address::get(buf)?, Address::get(buf)?))
-      },
-      Tag4 { flag: 0x0, size: 6 } => {
-        Ok(Self::UIMax(Address::get(buf)?, Address::get(buf)?))
-      },
-      Tag4 { flag: 0x1, size } => {
-        let bytes: Vec<u8> = Self::gets(size, buf)?;
-        Ok(Self::UVar(Nat::from_le_bytes(&bytes)))
-      },
-      Tag4 { flag: 0x2, size } => {
-        let bytes: Vec<u8> = Self::gets(size, buf)?;
-        Ok(Self::EVar(Nat::from_le_bytes(&bytes)))
-      },
-      Tag4 { flag: 0x3, size } => {
-        Ok(Self::ERef(Address::get(buf)?, Self::gets(size, buf)?))
-      },
-      Tag4 { flag: 0x4, size } => {
-        Ok(Self::ERec(Nat::get(buf)?, Self::gets(size, buf)?))
-      },
-      Tag4 { flag: 0x5, size } => Ok(Self::EPrj(
-        Address::get(buf)?,
-        Nat::from_le_bytes(&Self::gets(size, buf)?),
-        Address::get(buf)?,
-      )),
-      Tag4 { flag: 0x8, size: 0 } => Ok(Self::ESort(Address::get(buf)?)),
-      Tag4 { flag: 0x8, size: 1 } => Ok(Self::EStr(Address::get(buf)?)),
-      Tag4 { flag: 0x8, size: 2 } => Ok(Self::ENat(Address::get(buf)?)),
-      Tag4 { flag: 0x8, size: 3 } => {
-        Ok(Self::EApp(Address::get(buf)?, Address::get(buf)?))
-      },
-      Tag4 { flag: 0x8, size: 4 } => {
-        Ok(Self::ELam(Address::get(buf)?, Address::get(buf)?))
-      },
-      Tag4 { flag: 0x8, size: 5 } => {
-        Ok(Self::EAll(Address::get(buf)?, Address::get(buf)?))
-      },
-      Tag4 { flag: 0x8, size: 6 } => Ok(Self::ELet(
-        true,
-        Address::get(buf)?,
-        Address::get(buf)?,
-        Address::get(buf)?,
-      )),
-      Tag4 { flag: 0x8, size: 7 } => Ok(Self::ELet(
-        false,
-        Address::get(buf)?,
-        Address::get(buf)?,
-        Address::get(buf)?,
-      )),
-      Tag4 { flag: 0x9, size } => {
-        let bytes: Vec<u8> = Self::gets(size, buf)?;
-        Ok(Self::Blob(bytes))
-      },
-      Tag4 { flag: 0xA, size: 0 } => Ok(Self::Defn(Serialize::get(buf)?)),
-      Tag4 { flag: 0xA, size: 1 } => Ok(Self::Recr(Serialize::get(buf)?)),
-      Tag4 { flag: 0xA, size: 2 } => Ok(Self::Axio(Serialize::get(buf)?)),
-      Tag4 { flag: 0xA, size: 3 } => Ok(Self::Quot(Serialize::get(buf)?)),
-      Tag4 { flag: 0xA, size: 4 } => Ok(Self::CPrj(Serialize::get(buf)?)),
-      Tag4 { flag: 0xA, size: 5 } => Ok(Self::RPrj(Serialize::get(buf)?)),
-      Tag4 { flag: 0xA, size: 6 } => Ok(Self::IPrj(Serialize::get(buf)?)),
-      Tag4 { flag: 0xA, size: 7 } => Ok(Self::DPrj(Serialize::get(buf)?)),
-      Tag4 { flag: 0xB, size } => {
-        let xs: Vec<MutConst> = Self::gets(size, buf)?;
-        Ok(Self::Muts(xs))
-      },
-      Tag4 { flag: 0xE, size: 0 } => Ok(Self::Prof(Serialize::get(buf)?)),
-      Tag4 { flag: 0xE, size: 1 } => Ok(Self::Eval(Serialize::get(buf)?)),
-      Tag4 { flag: 0xE, size: 2 } => Ok(Self::Chck(Serialize::get(buf)?)),
-      Tag4 { flag: 0xE, size: 3 } => Ok(Self::Comm(Serialize::get(buf)?)),
-      Tag4 { flag: 0xE, size: 4 } => Ok(Self::Envn(Serialize::get(buf)?)),
-      Tag4 { flag: 0xE, size: 5 } => Ok(Self::Prim(Serialize::get(buf)?)),
-      Tag4 { flag: 0xF, size } => {
-        let nodes: Vec<Metadatum> = Self::gets(size, buf)?;
-        Ok(Self::Meta(Metadata { nodes }))
-      },
-      x => Err(format!("get Ixon invalid {x:?}")),
-    }
-  }
+    fn put(&self, buf: &mut Vec<u8>) {
+        match self {
+            Self::NAnon => Self::put_tag(0x0, 0, buf),
+            Self::NStr(n, s) => {
+                Self::put_tag(0x0, 1, buf);
+                Serialize::put(n, buf);
+                Serialize::put(s, buf);
+            }
+            Self::NNum(n, s) => {
+                Self::put_tag(0x0, 2, buf);
+                Serialize::put(n, buf);
+                Serialize::put(s, buf);
+            }
+            Self::UZero => Self::put_tag(0x0, 3, buf),
+            Self::USucc(x) => {
+                Self::put_tag(0x0, 4, buf);
+                Serialize::put(x, buf);
+            }
+            Self::UMax(x, y) => {
+                Self::put_tag(0x0, 5, buf);
+                Serialize::put(x, buf);
+                Serialize::put(y, buf);
+            }
+            Self::UIMax(x, y) => {
+                Self::put_tag(0x0, 6, buf);
+                Serialize::put(x, buf);
+                Serialize::put(y, buf);
+            }
+            Self::UVar(x) => {
+                let bytes = x.0.to_bytes_le();
+                Self::put_tag(0x1, bytes.len() as u64, buf);
+                Self::puts(&bytes, buf)
+            }
+            Self::EVar(x) => {
+                let bytes = x.0.to_bytes_le();
+                Self::put_tag(0x2, bytes.len() as u64, buf);
+                Self::puts(&bytes, buf)
+            }
+            Self::ERef(a, ls) => {
+                Self::put_tag(0x3, ls.len() as u64, buf);
+                a.put(buf);
+                Self::puts(ls, buf)
+            }
+            Self::ERec(i, ls) => {
+                Self::put_tag(0x4, ls.len() as u64, buf);
+                i.put(buf);
+                Self::puts(ls, buf)
+            }
+            Self::EPrj(t, n, x) => {
+                let bytes = n.0.to_bytes_le();
+                Self::put_tag(0x5, bytes.len() as u64, buf);
+                t.put(buf);
+                Self::puts(&bytes, buf);
+                x.put(buf);
+            }
+            Self::ESort(u) => {
+                Self::put_tag(0x8, 0, buf);
+                u.put(buf);
+            }
+            Self::EStr(s) => {
+                Self::put_tag(0x8, 1, buf);
+                s.put(buf);
+            }
+            Self::ENat(n) => {
+                Self::put_tag(0x8, 2, buf);
+                n.put(buf);
+            }
+            Self::EApp(f, a) => {
+                Self::put_tag(0x8, 3, buf);
+                f.put(buf);
+                a.put(buf);
+            }
+            Self::ELam(t, b) => {
+                Self::put_tag(0x8, 4, buf);
+                t.put(buf);
+                b.put(buf);
+            }
+            Self::EAll(t, b) => {
+                Self::put_tag(0x8, 5, buf);
+                t.put(buf);
+                b.put(buf);
+            }
+            Self::ELet(nd, t, d, b) => {
+                if *nd {
+                    Self::put_tag(0x8, 6, buf);
+                } else {
+                    Self::put_tag(0x8, 7, buf);
+                }
+                t.put(buf);
+                d.put(buf);
+                b.put(buf);
+            }
+            Self::Blob(xs) => {
+                Self::put_tag(0x9, xs.len() as u64, buf);
+                Self::puts(xs, buf);
+            }
+            Self::Defn(x) => {
+                Self::put_tag(0xA, 0, buf);
+                x.put(buf);
+            }
+            Self::Recr(x) => {
+                Self::put_tag(0xA, 1, buf);
+                x.put(buf);
+            }
+            Self::Axio(x) => {
+                Self::put_tag(0xA, 2, buf);
+                x.put(buf);
+            }
+            Self::Quot(x) => {
+                Self::put_tag(0xA, 3, buf);
+                x.put(buf);
+            }
+            Self::CPrj(x) => {
+                Self::put_tag(0xA, 4, buf);
+                x.put(buf);
+            }
+            Self::RPrj(x) => {
+                Self::put_tag(0xA, 5, buf);
+                x.put(buf);
+            }
+            Self::IPrj(x) => {
+                Self::put_tag(0xA, 6, buf);
+                x.put(buf);
+            }
+            Self::DPrj(x) => {
+                Self::put_tag(0xA, 7, buf);
+                x.put(buf);
+            }
+            Self::Muts(xs) => {
+                Self::put_tag(0xB, xs.len() as u64, buf);
+                Self::puts(xs, buf);
+            }
+            Self::Prof(x) => {
+                Self::put_tag(0xE, 0, buf);
+                x.put(buf);
+            }
+            Self::Eval(x) => {
+                Self::put_tag(0xE, 1, buf);
+                x.put(buf);
+            }
+            Self::Chck(x) => {
+                Self::put_tag(0xE, 2, buf);
+                x.put(buf);
+            }
+            Self::Comm(x) => {
+                Self::put_tag(0xE, 3, buf);
+                x.put(buf);
+            }
+            Self::Envn(x) => {
+                Self::put_tag(0xE, 4, buf);
+                x.put(buf);
+            }
+            Self::Prim(x) => {
+                Self::put_tag(0xE, 5, buf);
+                x.put(buf);
+            }
+            Self::Meta(x) => x.put(buf),
+        }
+    }
+    fn get(buf: &mut &[u8]) -> Result<Self, String> {
+        let tag = Tag4::get(buf)?;
+        match tag {
+            Tag4 { flag: 0x0, size: 0 } => Ok(Self::NAnon),
+            Tag4 { flag: 0x0, size: 1 } => Ok(Self::NStr(Address::get(buf)?, Address::get(buf)?)),
+            Tag4 { flag: 0x0, size: 2 } => Ok(Self::NNum(Address::get(buf)?, Address::get(buf)?)),
+            Tag4 { flag: 0x0, size: 3 } => Ok(Self::UZero),
+            Tag4 { flag: 0x0, size: 4 } => Ok(Self::USucc(Address::get(buf)?)),
+            Tag4 { flag: 0x0, size: 5 } => Ok(Self::UMax(Address::get(buf)?, Address::get(buf)?)),
+            Tag4 { flag: 0x0, size: 6 } => Ok(Self::UIMax(Address::get(buf)?, Address::get(buf)?)),
+            Tag4 { flag: 0x1, size } => {
+                let bytes: Vec<u8> = Self::gets(size, buf)?;
+                Ok(Self::UVar(Nat::from_le_bytes(&bytes)))
+            }
+            Tag4 { flag: 0x2, size } => {
+                let bytes: Vec<u8> = Self::gets(size, buf)?;
+                Ok(Self::EVar(Nat::from_le_bytes(&bytes)))
+            }
+            Tag4 { flag: 0x3, size } => Ok(Self::ERef(Address::get(buf)?, Self::gets(size, buf)?)),
+            Tag4 { flag: 0x4, size } => Ok(Self::ERec(Nat::get(buf)?, Self::gets(size, buf)?)),
+            Tag4 { flag: 0x5, size } => Ok(Self::EPrj(
+                Address::get(buf)?,
+                Nat::from_le_bytes(&Self::gets(size, buf)?),
+                Address::get(buf)?,
+            )),
+            Tag4 { flag: 0x8, size: 0 } => Ok(Self::ESort(Address::get(buf)?)),
+            Tag4 { flag: 0x8, size: 1 } => Ok(Self::EStr(Address::get(buf)?)),
+            Tag4 { flag: 0x8, size: 2 } => Ok(Self::ENat(Address::get(buf)?)),
+            Tag4 { flag: 0x8, size: 3 } => Ok(Self::EApp(Address::get(buf)?, Address::get(buf)?)),
+            Tag4 { flag: 0x8, size: 4 } => Ok(Self::ELam(Address::get(buf)?, Address::get(buf)?)),
+            Tag4 { flag: 0x8, size: 5 } => Ok(Self::EAll(Address::get(buf)?, Address::get(buf)?)),
+            Tag4 { flag: 0x8, size: 6 } => Ok(Self::ELet(
+                true,
+                Address::get(buf)?,
+                Address::get(buf)?,
+                Address::get(buf)?,
+            )),
+            Tag4 { flag: 0x8, size: 7 } => Ok(Self::ELet(
+                false,
+                Address::get(buf)?,
+                Address::get(buf)?,
+                Address::get(buf)?,
+            )),
+            Tag4 { flag: 0x9, size } => {
+                let bytes: Vec<u8> = Self::gets(size, buf)?;
+                Ok(Self::Blob(bytes))
+            }
+            Tag4 { flag: 0xA, size: 0 } => Ok(Self::Defn(Serialize::get(buf)?)),
+            Tag4 { flag: 0xA, size: 1 } => Ok(Self::Recr(Serialize::get(buf)?)),
+            Tag4 { flag: 0xA, size: 2 } => Ok(Self::Axio(Serialize::get(buf)?)),
+            Tag4 { flag: 0xA, size: 3 } => Ok(Self::Quot(Serialize::get(buf)?)),
+            Tag4 { flag: 0xA, size: 4 } => Ok(Self::CPrj(Serialize::get(buf)?)),
+            Tag4 { flag: 0xA, size: 5 } => Ok(Self::RPrj(Serialize::get(buf)?)),
+            Tag4 { flag: 0xA, size: 6 } => Ok(Self::IPrj(Serialize::get(buf)?)),
+            Tag4 { flag: 0xA, size: 7 } => Ok(Self::DPrj(Serialize::get(buf)?)),
+            Tag4 { flag: 0xB, size } => {
+                let xs: Vec<MutConst> = Self::gets(size, buf)?;
+                Ok(Self::Muts(xs))
+            }
+            Tag4 { flag: 0xE, size: 0 } => Ok(Self::Prof(Serialize::get(buf)?)),
+            Tag4 { flag: 0xE, size: 1 } => Ok(Self::Eval(Serialize::get(buf)?)),
+            Tag4 { flag: 0xE, size: 2 } => Ok(Self::Chck(Serialize::get(buf)?)),
+            Tag4 { flag: 0xE, size: 3 } => Ok(Self::Comm(Serialize::get(buf)?)),
+            Tag4 { flag: 0xE, size: 4 } => Ok(Self::Envn(Serialize::get(buf)?)),
+            Tag4 { flag: 0xE, size: 5 } => Ok(Self::Prim(Serialize::get(buf)?)),
+            Tag4 { flag: 0xF, size } => {
+                let nodes: Vec<Metadatum> = Self::gets(size, buf)?;
+                Ok(Self::Meta(Metadata { nodes }))
+            }
+            x => Err(format!("get Ixon invalid {x:?}")),
+        }
+    }
 }
 #[cfg(test)]
 pub mod tests {
-  use super::*;
-  use quickcheck::{Arbitrary, Gen};
-  use std::ops::Range;
-
-  pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
-    let res: usize = Arbitrary::arbitrary(g);
-    if range.is_empty() {
-      0
-    } else {
-      (res % (range.end - range.start)) + range.start
-    }
-  }
-
-  pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
-  where
-    F: FnMut(&mut Gen) -> A,
-  {
-    let len = gen_range(g, 0..size);
-    let mut vec = Vec::with_capacity(len);
-    for _ in 0..len {
-      vec.push(f(g));
-    }
-    vec
-  }
-  #[test]
-  fn unit_u64_trimmed() {
-    fn test(input: u64, expected: &Vec<u8>) -> bool {
-      let mut tmp = Vec::new();
-      let n = u64_byte_count(input);
-      u64_put_trimmed_le(input, &mut tmp);
-      if tmp != *expected {
-        return false;
-      }
-      match u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
-        Ok(out) => input == out,
-        Err(e) => {
-          println!("err: {e}");
-          false
-        },
-      }
-    }
-    assert!(test(0x0, &vec![]));
-    assert!(test(0x01, &vec![0x01]));
-    assert!(test(0x0000000000000100, &vec![0x00, 0x01]));
-    assert!(test(0x0000000000010000, &vec![0x00, 0x00, 0x01]));
-    assert!(test(0x0000000001000000, &vec![0x00, 0x00, 0x00, 0x01]));
-    assert!(test(0x0000000100000000, &vec![0x00, 0x00, 0x00, 0x00, 0x01]));
-    assert!(test(
-      0x0000010000000000,
-      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-    ));
-    assert!(test(
-      0x0001000000000000,
-      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-    ));
-    assert!(test(
-      0x0100000000000000,
-      &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
-    ));
-    assert!(test(
-      0x0102030405060708,
-      &vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
-    ));
-    assert!(test(
-      0x57712D6CE2965701,
-      &vec![0x01, 0x57, 0x96, 0xE2, 0x6C, 0x2D, 0x71, 0x57]
-    ));
-  }
-
-  #[quickcheck]
-  fn prop_u64_trimmed_le_readback(x: u64) -> bool {
-    let mut buf = Vec::new();
-    let n = u64_byte_count(x);
-    u64_put_trimmed_le(x, &mut buf);
-    match u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
-      Ok(y) => x == y,
-      Err(e) => {
-        println!("err: {e}");
-        false
-      },
-    }
-  }
-
-  #[allow(clippy::needless_pass_by_value)]
-  fn serialize_readback<S: Serialize + Eq>(x: S) -> bool {
-    let mut buf = Vec::new();
-    Serialize::put(&x, &mut buf);
-    match S::get(&mut buf.as_slice()) {
-      Ok(y) => x == y,
-      Err(e) => {
-        println!("err: {e}");
-        false
-      },
-    }
-  }
-
-  #[quickcheck]
-  fn prop_u8_readback(x: u8) -> bool {
-    serialize_readback(x)
-  }
-  #[quickcheck]
-  fn prop_u16_readback(x: u16) -> bool {
-    serialize_readback(x)
-  }
-  #[quickcheck]
-  fn prop_u32_readback(x: u32) -> bool {
-    serialize_readback(x)
-  }
-  #[quickcheck]
-  fn prop_u64_readback(x: u64) -> bool {
-    serialize_readback(x)
-  }
-  #[quickcheck]
-  fn prop_bool_readback(x: bool) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Tag4 {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let flag = u8::arbitrary(g) % 16;
-      Tag4 { flag, size: u64::arbitrary(g) }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_tag4_readback(x: Tag4) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for ByteArray {
-    fn arbitrary(g: &mut Gen) -> Self {
-      ByteArray(gen_vec(g, 12, u8::arbitrary))
-    }
-  }
-
-  #[quickcheck]
-  fn prop_bytearray_readback(x: ByteArray) -> bool {
-    serialize_readback(x)
-  }
-
-  #[quickcheck]
-  fn prop_string_readback(x: String) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Nat {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Nat::from_le_bytes(&gen_vec(g, 12, u8::arbitrary))
-    }
-  }
-
-  #[quickcheck]
-  fn prop_nat_readback(x: Nat) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Int {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 2 {
-        0 => Int::OfNat(Nat::arbitrary(g)),
-        1 => Int::NegSucc(Nat::arbitrary(g)),
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_int_readback(x: Int) -> bool {
-    serialize_readback(x)
-  }
-
-  #[quickcheck]
-  fn prop_vec_bool_readback(x: Vec<bool>) -> bool {
-    serialize_readback(x)
-  }
-
-  #[quickcheck]
-  fn prop_pack_bool_readback(x: Vec<bool>) -> bool {
-    let mut bools = x;
-    bools.truncate(8);
-    bools == unpack_bools(bools.len(), pack_bools(bools.clone()))
-  }
-
-  impl Arbitrary for QuotKind {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 4 {
-        0 => Self::Type,
-        1 => Self::Ctor,
-        2 => Self::Lift,
-        3 => Self::Ind,
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_quotkind_readback(x: QuotKind) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for DefKind {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 3 {
-        0 => Self::Definition,
-        1 => Self::Opaque,
-        2 => Self::Theorem,
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_defkind_readback(x: DefKind) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for BinderInfo {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 5 {
-        0 => Self::Default,
-        1 => Self::Implicit,
-        2 => Self::StrictImplicit,
-        3 => Self::InstImplicit,
-        4 => Self::AuxDecl,
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_binderinfo_readback(x: BinderInfo) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for ReducibilityHints {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 3 {
-        0 => Self::Opaque,
-        1 => Self::Abbrev,
-        2 => Self::Regular(u32::arbitrary(g)),
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_reducibilityhints_readback(x: ReducibilityHints) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for DefSafety {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 3 {
-        0 => Self::Unsafe,
-        1 => Self::Safe,
-        2 => Self::Partial,
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_defsafety_readback(x: DefSafety) -> bool {
-    serialize_readback(x)
-  }
-
-  #[quickcheck]
-  fn prop_address_readback(x: Address) -> bool {
-    serialize_readback(x)
-  }
-  #[quickcheck]
-  fn prop_metaaddress_readback(x: MetaAddress) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Quotient {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        kind: QuotKind::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_quotient_readback(x: Quotient) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Axiom {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        is_unsafe: bool::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_axiom_readback(x: Axiom) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Definition {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        kind: DefKind::arbitrary(g),
-        safety: DefSafety::arbitrary(g),
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        value: Address::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_definition_readback(x: Definition) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Constructor {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        cidx: Nat::arbitrary(g),
-        params: Nat::arbitrary(g),
-        fields: Nat::arbitrary(g),
-        is_unsafe: bool::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_constructor_readback(x: Constructor) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for RecursorRule {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self { fields: Nat::arbitrary(g), rhs: Address::arbitrary(g) }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_recursorrule_readback(x: RecursorRule) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Recursor {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..9);
-      let mut rules = vec![];
-      for _ in 0..x {
-        rules.push(RecursorRule::arbitrary(g));
-      }
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        params: Nat::arbitrary(g),
-        indices: Nat::arbitrary(g),
-        motives: Nat::arbitrary(g),
-        minors: Nat::arbitrary(g),
-        rules,
-        k: bool::arbitrary(g),
-        is_unsafe: bool::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_recursor_readback(x: Recursor) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Inductive {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..9);
-      let mut ctors = vec![];
-      for _ in 0..x {
-        ctors.push(Constructor::arbitrary(g));
-      }
-      Self {
-        lvls: Nat::arbitrary(g),
-        typ: Address::arbitrary(g),
-        params: Nat::arbitrary(g),
-        indices: Nat::arbitrary(g),
-        ctors,
-        nested: Nat::arbitrary(g),
-        recr: bool::arbitrary(g),
-        refl: bool::arbitrary(g),
-        is_unsafe: bool::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_inductive_readback(x: Inductive) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for InductiveProj {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self { block: Address::arbitrary(g), idx: Nat::arbitrary(g) }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_inductiveproj_readback(x: InductiveProj) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for ConstructorProj {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        block: Address::arbitrary(g),
-        idx: Nat::arbitrary(g),
-        cidx: Nat::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_constructorproj_readback(x: ConstructorProj) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for RecursorProj {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        block: Address::arbitrary(g),
-        idx: Nat::arbitrary(g),
-        ridx: Nat::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_recursorproj_readback(x: RecursorProj) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for DefinitionProj {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self { block: Address::arbitrary(g), idx: Nat::arbitrary(g) }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_definitionproj_readback(x: DefinitionProj) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Comm {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self { secret: Address::arbitrary(g), payload: Address::arbitrary(g) }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_comm_readback(x: Comm) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for EvalClaim {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Address::arbitrary(g),
-        typ: Address::arbitrary(g),
-        input: Address::arbitrary(g),
-        output: Address::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_evalclaim_readback(x: EvalClaim) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for CheckClaim {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Self {
-        lvls: Address::arbitrary(g),
-        typ: Address::arbitrary(g),
-        value: Address::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_checkclaim_readback(x: CheckClaim) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Claim {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..1);
-      match x {
-        0 => Self::Evals(EvalClaim::arbitrary(g)),
-        _ => Self::Checks(CheckClaim::arbitrary(g)),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_claim_readback(x: Claim) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Proof {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..32);
-      let mut bytes = vec![];
-      for _ in 0..x {
-        bytes.push(u8::arbitrary(g));
-      }
-      Proof { claim: Claim::arbitrary(g), proof: bytes }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_proof_readback(x: Proof) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Env {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let x = gen_range(g, 0..32);
-      let mut env = vec![];
-      for _ in 0..x {
-        env.push(MetaAddress::arbitrary(g));
-      }
-      Env { env }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_env_readback(x: Env) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Substring {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Substring {
-        str: Address::arbitrary(g),
-        start_pos: Nat::arbitrary(g),
-        stop_pos: Nat::arbitrary(g),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_substring_readback(x: Substring) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for SourceInfo {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 3 {
-        0 => Self::Original(
-          Substring::arbitrary(g),
-          Nat::arbitrary(g),
-          Substring::arbitrary(g),
-          Nat::arbitrary(g),
-        ),
-        1 => Self::Synthetic(
-          Nat::arbitrary(g),
-          Nat::arbitrary(g),
-          bool::arbitrary(g),
-        ),
-        2 => Self::None,
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_sourceinfo_readback(x: SourceInfo) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Preresolved {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 2 {
-        0 => Self::Namespace(Address::arbitrary(g)),
-        1 => {
-          Self::Decl(Address::arbitrary(g), gen_vec(g, 12, Address::arbitrary))
-        },
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_preresolved_readback(x: Preresolved) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Syntax {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 4 {
-        0 => Self::Missing,
-        1 => Self::Node(
-          SourceInfo::arbitrary(g),
-          Address::arbitrary(g),
-          gen_vec(g, 12, Address::arbitrary),
-        ),
-        2 => Self::Atom(SourceInfo::arbitrary(g), Address::arbitrary(g)),
-        3 => Self::Ident(
-          SourceInfo::arbitrary(g),
-          Substring::arbitrary(g),
-          Address::arbitrary(g),
-          gen_vec(g, 12, Preresolved::arbitrary),
-        ),
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_syntax_readback(x: Syntax) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for MutConst {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 3 {
-        0 => Self::Defn(Definition::arbitrary(g)),
-        1 => Self::Indc(Inductive::arbitrary(g)),
-        2 => Self::Recr(Recursor::arbitrary(g)),
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_mutconst_readback(x: MutConst) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for BuiltIn {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 3 {
-        0 => Self::Obj,
-        1 => Self::Neutral,
-        2 => Self::Unreachable,
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_builtin_readback(x: BuiltIn) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for DataValue {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 6 {
-        0 => Self::OfString(Address::arbitrary(g)),
-        1 => Self::OfBool(bool::arbitrary(g)),
-        2 => Self::OfName(Address::arbitrary(g)),
-        3 => Self::OfNat(Address::arbitrary(g)),
-        4 => Self::OfInt(Address::arbitrary(g)),
-        5 => Self::OfSyntax(Address::arbitrary(g)),
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_datavalue_readback(x: DataValue) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Metadatum {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 7 {
-        0 => Self::Link(Address::arbitrary(g)),
-        1 => Self::Info(BinderInfo::arbitrary(g)),
-        2 => Self::Hints(ReducibilityHints::arbitrary(g)),
-        3 => Self::Links(gen_vec(g, 12, Address::arbitrary)),
-        4 => Self::Map(gen_vec(g, 12, |g| {
-          (Address::arbitrary(g), Address::arbitrary(g))
-        })),
-        5 => Self::KVMap(gen_vec(g, 12, |g| {
-          (Address::arbitrary(g), DataValue::arbitrary(g))
-        })),
-        6 => Self::Muts(gen_vec(g, 12, |g| gen_vec(g, 12, Address::arbitrary))),
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_metadatum_readback(x: Metadatum) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Metadata {
-    fn arbitrary(g: &mut Gen) -> Self {
-      Metadata { nodes: gen_vec(g, 12, Metadatum::arbitrary) }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_metadata_readback(x: Metadata) -> bool {
-    serialize_readback(x)
-  }
-
-  impl Arbitrary for Ixon {
-    fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 36 {
-        0 => Self::NAnon,
-        1 => Self::NStr(Address::arbitrary(g), Address::arbitrary(g)),
-        2 => Self::NNum(Address::arbitrary(g), Address::arbitrary(g)),
-        3 => Self::UZero,
-        4 => Self::USucc(Address::arbitrary(g)),
-        5 => Self::UMax(Address::arbitrary(g), Address::arbitrary(g)),
-        6 => Self::UIMax(Address::arbitrary(g), Address::arbitrary(g)),
-        7 => Self::UVar(Nat::arbitrary(g)),
-        8 => Self::EVar(Nat::arbitrary(g)),
-        9 => {
-          Self::ERef(Address::arbitrary(g), gen_vec(g, 12, Address::arbitrary))
-        },
-        10 => Self::ERec(Nat::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
-        11 => Self::EPrj(
-          Address::arbitrary(g),
-          Nat::arbitrary(g),
-          Address::arbitrary(g),
-        ),
-        12 => Self::ESort(Address::arbitrary(g)),
-        13 => Self::EStr(Address::arbitrary(g)),
-        14 => Self::ENat(Address::arbitrary(g)),
-        15 => Self::EApp(Address::arbitrary(g), Address::arbitrary(g)),
-        16 => Self::ELam(Address::arbitrary(g), Address::arbitrary(g)),
-        17 => Self::EAll(Address::arbitrary(g), Address::arbitrary(g)),
-        18 => Self::ELet(
-          bool::arbitrary(g),
-          Address::arbitrary(g),
-          Address::arbitrary(g),
-          Address::arbitrary(g),
-        ),
-        19 => Self::Blob(gen_vec(g, 12, u8::arbitrary)),
-        20 => Self::Defn(Definition::arbitrary(g)),
-        21 => Self::Recr(Recursor::arbitrary(g)),
-        22 => Self::Axio(Axiom::arbitrary(g)),
-        23 => Self::Quot(Quotient::arbitrary(g)),
-        24 => Self::CPrj(ConstructorProj::arbitrary(g)),
-        25 => Self::RPrj(RecursorProj::arbitrary(g)),
-        26 => Self::IPrj(InductiveProj::arbitrary(g)),
-        27 => Self::DPrj(DefinitionProj::arbitrary(g)),
-        28 => Self::Muts(gen_vec(g, 12, MutConst::arbitrary)),
-        29 => Self::Prof(Proof::arbitrary(g)),
-        30 => Self::Eval(EvalClaim::arbitrary(g)),
-        31 => Self::Chck(CheckClaim::arbitrary(g)),
-        32 => Self::Comm(Comm::arbitrary(g)),
-        33 => Self::Envn(Env::arbitrary(g)),
-        34 => Self::Prim(BuiltIn::arbitrary(g)),
-        35 => Self::Meta(Metadata::arbitrary(g)),
-        _ => unreachable!(),
-      }
-    }
-  }
-
-  #[quickcheck]
-  fn prop_ixon_readback(x: Ixon) -> bool {
-    serialize_readback(x)
-  }
+    use super::*;
+    use quickcheck::{Arbitrary, Gen};
+    use std::ops::Range;
+
+    pub fn gen_range(g: &mut Gen, range: Range<usize>) -> usize {
+        let res: usize = Arbitrary::arbitrary(g);
+        if range.is_empty() {
+            0
+        } else {
+            (res % (range.end - range.start)) + range.start
+        }
+    }
+
+    pub fn gen_vec<A, F>(g: &mut Gen, size: usize, mut f: F) -> Vec<A>
+    where
+        F: FnMut(&mut Gen) -> A,
+    {
+        let len = gen_range(g, 0..size);
+        let mut vec = Vec::with_capacity(len);
+        for _ in 0..len {
+            vec.push(f(g));
+        }
+        vec
+    }
+    #[test]
+    fn unit_u64_trimmed() {
+        fn test(input: u64, expected: &Vec<u8>) -> bool {
+            let mut tmp = Vec::new();
+            let n = u64_byte_count(input);
+            u64_put_trimmed_le(input, &mut tmp);
+            if tmp != *expected {
+                return false;
+            }
+            match u64_get_trimmed_le(n as usize, &mut tmp.as_slice()) {
+                Ok(out) => input == out,
+                Err(e) => {
+                    println!("err: {e}");
+                    false
+                }
+            }
+        }
+        assert!(test(0x0, &vec![]));
+        assert!(test(0x01, &vec![0x01]));
+        assert!(test(0x0000000000000100, &vec![0x00, 0x01]));
+        assert!(test(0x0000000000010000, &vec![0x00, 0x00, 0x01]));
+        assert!(test(0x0000000001000000, &vec![0x00, 0x00, 0x00, 0x01]));
+        assert!(test(
+            0x0000000100000000,
+            &vec![0x00, 0x00, 0x00, 0x00, 0x01]
+        ));
+        assert!(test(
+            0x0000010000000000,
+            &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+        ));
+        assert!(test(
+            0x0001000000000000,
+            &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+        ));
+        assert!(test(
+            0x0100000000000000,
+            &vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
+        ));
+        assert!(test(
+            0x0102030405060708,
+            &vec![0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]
+        ));
+        assert!(test(
+            0x57712D6CE2965701,
+            &vec![0x01, 0x57, 0x96, 0xE2, 0x6C, 0x2D, 0x71, 0x57]
+        ));
+    }
+
+    #[quickcheck]
+    fn prop_u64_trimmed_le_readback(x: u64) -> bool {
+        let mut buf = Vec::new();
+        let n = u64_byte_count(x);
+        u64_put_trimmed_le(x, &mut buf);
+        match u64_get_trimmed_le(n as usize, &mut buf.as_slice()) {
+            Ok(y) => x == y,
+            Err(e) => {
+                println!("err: {e}");
+                false
+            }
+        }
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    fn serialize_readback<S: Serialize + Eq>(x: S) -> bool {
+        let mut buf = Vec::new();
+        Serialize::put(&x, &mut buf);
+        match S::get(&mut buf.as_slice()) {
+            Ok(y) => x == y,
+            Err(e) => {
+                println!("err: {e}");
+                false
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_u8_readback(x: u8) -> bool {
+        serialize_readback(x)
+    }
+    #[quickcheck]
+    fn prop_u16_readback(x: u16) -> bool {
+        serialize_readback(x)
+    }
+    #[quickcheck]
+    fn prop_u32_readback(x: u32) -> bool {
+        serialize_readback(x)
+    }
+    #[quickcheck]
+    fn prop_u64_readback(x: u64) -> bool {
+        serialize_readback(x)
+    }
+    #[quickcheck]
+    fn prop_bool_readback(x: bool) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Tag4 {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let flag = u8::arbitrary(g) % 16;
+            Tag4 {
+                flag,
+                size: u64::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_tag4_readback(x: Tag4) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for ByteArray {
+        fn arbitrary(g: &mut Gen) -> Self {
+            ByteArray(gen_vec(g, 12, u8::arbitrary))
+        }
+    }
+
+    #[quickcheck]
+    fn prop_bytearray_readback(x: ByteArray) -> bool {
+        serialize_readback(x)
+    }
+
+    #[quickcheck]
+    fn prop_string_readback(x: String) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Nat {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Nat::from_le_bytes(&gen_vec(g, 12, u8::arbitrary))
+        }
+    }
+
+    #[quickcheck]
+    fn prop_nat_readback(x: Nat) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Int {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 2 {
+                0 => Int::OfNat(Nat::arbitrary(g)),
+                1 => Int::NegSucc(Nat::arbitrary(g)),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_int_readback(x: Int) -> bool {
+        serialize_readback(x)
+    }
+
+    #[quickcheck]
+    fn prop_vec_bool_readback(x: Vec<bool>) -> bool {
+        serialize_readback(x)
+    }
+
+    #[quickcheck]
+    fn prop_pack_bool_readback(x: Vec<bool>) -> bool {
+        let mut bools = x;
+        bools.truncate(8);
+        bools == unpack_bools(bools.len(), pack_bools(bools.clone()))
+    }
+
+    impl Arbitrary for QuotKind {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 4 {
+                0 => Self::Type,
+                1 => Self::Ctor,
+                2 => Self::Lift,
+                3 => Self::Ind,
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_quotkind_readback(x: QuotKind) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for DefKind {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 3 {
+                0 => Self::Definition,
+                1 => Self::Opaque,
+                2 => Self::Theorem,
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_defkind_readback(x: DefKind) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for BinderInfo {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 5 {
+                0 => Self::Default,
+                1 => Self::Implicit,
+                2 => Self::StrictImplicit,
+                3 => Self::InstImplicit,
+                4 => Self::AuxDecl,
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_binderinfo_readback(x: BinderInfo) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for ReducibilityHints {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 3 {
+                0 => Self::Opaque,
+                1 => Self::Abbrev,
+                2 => Self::Regular(u32::arbitrary(g)),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_reducibilityhints_readback(x: ReducibilityHints) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for DefSafety {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 3 {
+                0 => Self::Unsafe,
+                1 => Self::Safe,
+                2 => Self::Partial,
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_defsafety_readback(x: DefSafety) -> bool {
+        serialize_readback(x)
+    }
+
+    #[quickcheck]
+    fn prop_address_readback(x: Address) -> bool {
+        serialize_readback(x)
+    }
+    #[quickcheck]
+    fn prop_metaaddress_readback(x: MetaAddress) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Quotient {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                kind: QuotKind::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_quotient_readback(x: Quotient) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Axiom {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                is_unsafe: bool::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_axiom_readback(x: Axiom) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Definition {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                kind: DefKind::arbitrary(g),
+                safety: DefSafety::arbitrary(g),
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                value: Address::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_definition_readback(x: Definition) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Constructor {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                cidx: Nat::arbitrary(g),
+                params: Nat::arbitrary(g),
+                fields: Nat::arbitrary(g),
+                is_unsafe: bool::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_constructor_readback(x: Constructor) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for RecursorRule {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                fields: Nat::arbitrary(g),
+                rhs: Address::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_recursorrule_readback(x: RecursorRule) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Recursor {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..9);
+            let mut rules = vec![];
+            for _ in 0..x {
+                rules.push(RecursorRule::arbitrary(g));
+            }
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                params: Nat::arbitrary(g),
+                indices: Nat::arbitrary(g),
+                motives: Nat::arbitrary(g),
+                minors: Nat::arbitrary(g),
+                rules,
+                k: bool::arbitrary(g),
+                is_unsafe: bool::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_recursor_readback(x: Recursor) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Inductive {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..9);
+            let mut ctors = vec![];
+            for _ in 0..x {
+                ctors.push(Constructor::arbitrary(g));
+            }
+            Self {
+                lvls: Nat::arbitrary(g),
+                typ: Address::arbitrary(g),
+                params: Nat::arbitrary(g),
+                indices: Nat::arbitrary(g),
+                ctors,
+                nested: Nat::arbitrary(g),
+                recr: bool::arbitrary(g),
+                refl: bool::arbitrary(g),
+                is_unsafe: bool::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_inductive_readback(x: Inductive) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for InductiveProj {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                block: Address::arbitrary(g),
+                idx: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_inductiveproj_readback(x: InductiveProj) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for ConstructorProj {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                block: Address::arbitrary(g),
+                idx: Nat::arbitrary(g),
+                cidx: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_constructorproj_readback(x: ConstructorProj) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for RecursorProj {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                block: Address::arbitrary(g),
+                idx: Nat::arbitrary(g),
+                ridx: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_recursorproj_readback(x: RecursorProj) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for DefinitionProj {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                block: Address::arbitrary(g),
+                idx: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_definitionproj_readback(x: DefinitionProj) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Comm {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                secret: Address::arbitrary(g),
+                payload: Address::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_comm_readback(x: Comm) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for EvalClaim {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Address::arbitrary(g),
+                typ: Address::arbitrary(g),
+                input: Address::arbitrary(g),
+                output: Address::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_evalclaim_readback(x: EvalClaim) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for CheckClaim {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self {
+                lvls: Address::arbitrary(g),
+                typ: Address::arbitrary(g),
+                value: Address::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_checkclaim_readback(x: CheckClaim) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Claim {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..1);
+            match x {
+                0 => Self::Evals(EvalClaim::arbitrary(g)),
+                _ => Self::Checks(CheckClaim::arbitrary(g)),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_claim_readback(x: Claim) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Proof {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..32);
+            let mut bytes = vec![];
+            for _ in 0..x {
+                bytes.push(u8::arbitrary(g));
+            }
+            Proof {
+                claim: Claim::arbitrary(g),
+                proof: bytes,
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_proof_readback(x: Proof) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Env {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let x = gen_range(g, 0..32);
+            let mut env = vec![];
+            for _ in 0..x {
+                env.push(MetaAddress::arbitrary(g));
+            }
+            Env { env }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_env_readback(x: Env) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Substring {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Substring {
+                str: Address::arbitrary(g),
+                start_pos: Nat::arbitrary(g),
+                stop_pos: Nat::arbitrary(g),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_substring_readback(x: Substring) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for SourceInfo {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 3 {
+                0 => Self::Original(
+                    Substring::arbitrary(g),
+                    Nat::arbitrary(g),
+                    Substring::arbitrary(g),
+                    Nat::arbitrary(g),
+                ),
+                1 => Self::Synthetic(Nat::arbitrary(g), Nat::arbitrary(g), bool::arbitrary(g)),
+                2 => Self::None,
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_sourceinfo_readback(x: SourceInfo) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Preresolved {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 2 {
+                0 => Self::Namespace(Address::arbitrary(g)),
+                1 => Self::Decl(Address::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_preresolved_readback(x: Preresolved) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Syntax {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 4 {
+                0 => Self::Missing,
+                1 => Self::Node(
+                    SourceInfo::arbitrary(g),
+                    Address::arbitrary(g),
+                    gen_vec(g, 12, Address::arbitrary),
+                ),
+                2 => Self::Atom(SourceInfo::arbitrary(g), Address::arbitrary(g)),
+                3 => Self::Ident(
+                    SourceInfo::arbitrary(g),
+                    Substring::arbitrary(g),
+                    Address::arbitrary(g),
+                    gen_vec(g, 12, Preresolved::arbitrary),
+                ),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_syntax_readback(x: Syntax) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for MutConst {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 3 {
+                0 => Self::Defn(Definition::arbitrary(g)),
+                1 => Self::Indc(Inductive::arbitrary(g)),
+                2 => Self::Recr(Recursor::arbitrary(g)),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_mutconst_readback(x: MutConst) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for BuiltIn {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 3 {
+                0 => Self::Obj,
+                1 => Self::Neutral,
+                2 => Self::Unreachable,
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_builtin_readback(x: BuiltIn) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for DataValue {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 6 {
+                0 => Self::OfString(Address::arbitrary(g)),
+                1 => Self::OfBool(bool::arbitrary(g)),
+                2 => Self::OfName(Address::arbitrary(g)),
+                3 => Self::OfNat(Address::arbitrary(g)),
+                4 => Self::OfInt(Address::arbitrary(g)),
+                5 => Self::OfSyntax(Address::arbitrary(g)),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_datavalue_readback(x: DataValue) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Metadatum {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 7 {
+                0 => Self::Link(Address::arbitrary(g)),
+                1 => Self::Info(BinderInfo::arbitrary(g)),
+                2 => Self::Hints(ReducibilityHints::arbitrary(g)),
+                3 => Self::Links(gen_vec(g, 12, Address::arbitrary)),
+                4 => Self::Map(gen_vec(g, 12, |g| {
+                    (Address::arbitrary(g), Address::arbitrary(g))
+                })),
+                5 => Self::KVMap(gen_vec(g, 12, |g| {
+                    (Address::arbitrary(g), DataValue::arbitrary(g))
+                })),
+                6 => Self::Muts(gen_vec(g, 12, |g| gen_vec(g, 12, Address::arbitrary))),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_metadatum_readback(x: Metadatum) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Metadata {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Metadata {
+                nodes: gen_vec(g, 12, Metadatum::arbitrary),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_metadata_readback(x: Metadata) -> bool {
+        serialize_readback(x)
+    }
+
+    impl Arbitrary for Ixon {
+        fn arbitrary(g: &mut Gen) -> Self {
+            match u8::arbitrary(g) % 36 {
+                0 => Self::NAnon,
+                1 => Self::NStr(Address::arbitrary(g), Address::arbitrary(g)),
+                2 => Self::NNum(Address::arbitrary(g), Address::arbitrary(g)),
+                3 => Self::UZero,
+                4 => Self::USucc(Address::arbitrary(g)),
+                5 => Self::UMax(Address::arbitrary(g), Address::arbitrary(g)),
+                6 => Self::UIMax(Address::arbitrary(g), Address::arbitrary(g)),
+                7 => Self::UVar(Nat::arbitrary(g)),
+                8 => Self::EVar(Nat::arbitrary(g)),
+                9 => Self::ERef(Address::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
+                10 => Self::ERec(Nat::arbitrary(g), gen_vec(g, 12, Address::arbitrary)),
+                11 => Self::EPrj(
+                    Address::arbitrary(g),
+                    Nat::arbitrary(g),
+                    Address::arbitrary(g),
+                ),
+                12 => Self::ESort(Address::arbitrary(g)),
+                13 => Self::EStr(Address::arbitrary(g)),
+                14 => Self::ENat(Address::arbitrary(g)),
+                15 => Self::EApp(Address::arbitrary(g), Address::arbitrary(g)),
+                16 => Self::ELam(Address::arbitrary(g), Address::arbitrary(g)),
+                17 => Self::EAll(Address::arbitrary(g), Address::arbitrary(g)),
+                18 => Self::ELet(
+                    bool::arbitrary(g),
+                    Address::arbitrary(g),
+                    Address::arbitrary(g),
+                    Address::arbitrary(g),
+                ),
+                19 => Self::Blob(gen_vec(g, 12, u8::arbitrary)),
+                20 => Self::Defn(Definition::arbitrary(g)),
+                21 => Self::Recr(Recursor::arbitrary(g)),
+                22 => Self::Axio(Axiom::arbitrary(g)),
+                23 => Self::Quot(Quotient::arbitrary(g)),
+                24 => Self::CPrj(ConstructorProj::arbitrary(g)),
+                25 => Self::RPrj(RecursorProj::arbitrary(g)),
+                26 => Self::IPrj(InductiveProj::arbitrary(g)),
+                27 => Self::DPrj(DefinitionProj::arbitrary(g)),
+                28 => Self::Muts(gen_vec(g, 12, MutConst::arbitrary)),
+                29 => Self::Prof(Proof::arbitrary(g)),
+                30 => Self::Eval(EvalClaim::arbitrary(g)),
+                31 => Self::Chck(CheckClaim::arbitrary(g)),
+                32 => Self::Comm(Comm::arbitrary(g)),
+                33 => Self::Envn(Env::arbitrary(g)),
+                34 => Self::Prim(BuiltIn::arbitrary(g)),
+                35 => Self::Meta(Metadata::arbitrary(g)),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[quickcheck]
+    fn prop_ixon_readback(x: Ixon) -> bool {
+        serialize_readback(x)
+    }
 }
diff --git a/src/ixon/address.rs b/src/ixon/address.rs
index 2fc47c19..efcc62f1 100644
--- a/src/ixon/address.rs
+++ b/src/ixon/address.rs
@@ -3,50 +3,57 @@ use std::cmp::{Ordering, PartialOrd};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Address {
-  pub hash: Hash,
+    pub hash: Hash,
 }
 
 impl Address {
-  pub fn hash(input: &[u8]) -> Self {
-    Address { hash: blake3::hash(input) }
-  }
+    pub fn hash(input: &[u8]) -> Self {
+        Address {
+            hash: blake3::hash(input),
+        }
+    }
 }
 
 impl Ord for Address {
-  fn cmp(&self, other: &Address) -> Ordering {
-    self.hash.as_bytes().cmp(other.hash.as_bytes())
-  }
+    fn cmp(&self, other: &Address) -> Ordering {
+        self.hash.as_bytes().cmp(other.hash.as_bytes())
+    }
 }
 
 impl PartialOrd for Address {
-  fn partial_cmp(&self, other: &Address) -> Option<Ordering> {
-    Some(self.cmp(other))
-  }
+    fn partial_cmp(&self, other: &Address) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MetaAddress {
-  pub data: Address,
-  pub meta: Address,
+    pub data: Address,
+    pub meta: Address,
 }
 
 #[cfg(test)]
 pub mod tests {
-  use super::*;
-  use quickcheck::{Arbitrary, Gen};
+    use super::*;
+    use quickcheck::{Arbitrary, Gen};
 
-  impl Arbitrary for Address {
-    fn arbitrary(g: &mut Gen) -> Self {
-      let mut bytes = [0u8; 32];
-      for b in &mut bytes {
-        *b = u8::arbitrary(g);
-      }
-      Address { hash: Hash::from_slice(&bytes).unwrap() }
+    impl Arbitrary for Address {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let mut bytes = [0u8; 32];
+            for b in &mut bytes {
+                *b = u8::arbitrary(g);
+            }
+            Address {
+                hash: Hash::from_slice(&bytes).unwrap(),
+            }
+        }
     }
-  }
-  impl Arbitrary for MetaAddress {
-    fn arbitrary(g: &mut Gen) -> Self {
-      MetaAddress { data: Address::arbitrary(g), meta: Address::arbitrary(g) }
+    impl Arbitrary for MetaAddress {
+        fn arbitrary(g: &mut Gen) -> Self {
+            MetaAddress {
+                data: Address::arbitrary(g),
+                meta: Address::arbitrary(g),
+            }
+        }
     }
-  }
 }
diff --git a/src/lean/nat.rs b/src/lean/nat.rs
index 87067b61..74f0d57b 100644
--- a/src/lean/nat.rs
+++ b/src/lean/nat.rs
@@ -3,40 +3,40 @@ use std::ffi::c_void;
 use num_bigint::BigUint;
 
 use crate::{
-  lean::{as_ref_unsafe, lean_is_scalar, object::LeanObject},
-  lean_unbox,
+    lean::{as_ref_unsafe, lean_is_scalar, object::LeanObject},
+    lean_unbox,
 };
 
 #[derive(Hash, PartialEq, Eq, Debug, Clone, PartialOrd, Ord)]
 pub struct Nat(pub BigUint);
 
 impl Nat {
-  pub fn from_ptr(ptr: *const c_void) -> Nat {
-    if lean_is_scalar(ptr) {
-      let u = lean_unbox!(usize, ptr);
-      Nat(BigUint::from_bytes_le(&u.to_le_bytes()))
-    } else {
-      // Heap-allocated big integer (mpz_object)
-      let obj: &MpzObject = as_ref_unsafe(ptr.cast());
-      Nat(obj.m_value.to_biguint())
+    pub fn from_ptr(ptr: *const c_void) -> Nat {
+        if lean_is_scalar(ptr) {
+            let u = lean_unbox!(usize, ptr);
+            Nat(BigUint::from_bytes_le(&u.to_le_bytes()))
+        } else {
+            // Heap-allocated big integer (mpz_object)
+            let obj: &MpzObject = as_ref_unsafe(ptr.cast());
+            Nat(obj.m_value.to_biguint())
+        }
     }
-  }
 
-  #[inline]
-  pub fn from_le_bytes(bytes: &[u8]) -> Nat {
-    Nat(BigUint::from_bytes_le(bytes))
-  }
+    #[inline]
+    pub fn from_le_bytes(bytes: &[u8]) -> Nat {
+        Nat(BigUint::from_bytes_le(bytes))
+    }
 
-  #[inline]
-  pub fn to_le_bytes(&self) -> Vec<u8> {
-    self.0.to_bytes_le()
-  }
+    #[inline]
+    pub fn to_le_bytes(&self) -> Vec<u8> {
+        self.0.to_bytes_le()
+    }
 }
 
 #[derive(Hash, PartialEq, Eq, Debug, Clone, PartialOrd, Ord)]
 pub enum Int {
-  OfNat(Nat),
-  NegSucc(Nat),
+    OfNat(Nat),
+    NegSucc(Nat),
 }
 
 /// From https://github.com/leanprover/lean4/blob/master/src/runtime/object.h:
@@ -50,26 +50,25 @@ pub enum Int {
 /// ```
 #[repr(C)]
 struct MpzObject {
-  m_header: LeanObject,
-  m_value: Mpz,
+    m_header: LeanObject,
+    m_value: Mpz,
 }
 
 #[repr(C)]
 struct Mpz {
-  alloc: i32,
-  size: i32,
-  d: *const u64,
+    alloc: i32,
+    size: i32,
+    d: *const u64,
 }
 
 impl Mpz {
-  fn to_biguint(&self) -> BigUint {
-    let nlimbs = self.size.unsigned_abs() as usize;
-    let limbs = unsafe { std::slice::from_raw_parts(self.d, nlimbs) };
+    fn to_biguint(&self) -> BigUint {
+        let nlimbs = self.size.unsigned_abs() as usize;
+        let limbs = unsafe { std::slice::from_raw_parts(self.d, nlimbs) };
 
-    // Convert limbs (little-endian by limb)
-    let bytes: Vec<_> =
-      limbs.iter().flat_map(|&limb| limb.to_le_bytes()).collect();
+        // Convert limbs (little-endian by limb)
+        let bytes: Vec<_> = limbs.iter().flat_map(|&limb| limb.to_le_bytes()).collect();
 
-    BigUint::from_bytes_le(&bytes)
-  }
+        BigUint::from_bytes_le(&bytes)
+    }
 }

From 98897055d4af809d30eaa02815abe09f150a8804 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 28 Oct 2025 19:03:23 -0400
Subject: [PATCH 74/74] remove meta.rs

---
 src/ixon/meta.rs | 276 -----------------------------------------------
 1 file changed, 276 deletions(-)
 delete mode 100644 src/ixon/meta.rs

diff --git a/src/ixon/meta.rs b/src/ixon/meta.rs
deleted file mode 100644
index 1dcf0e14..00000000
--- a/src/ixon/meta.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-use crate::ixon::address::Address;
-//use crate::ixon::name::Name;
-use crate::ixon::nat::Nat;
-//use crate::ixon::serialize::Serialize;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Substring {
-    pub str: Address,
-    pub start_pos: Nat,
-    pub stop_pos: Nat,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum SourceInfo {
-    Original(Substring, Nat, Substring, Nat),
-    Synthetic(Nat, Nat, bool),
-    None,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Preresolved {
-    Namespace(Address),
-    Decl(Address, Vec<Address>),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Syntax {
-    Missing,
-    Node(SourceInfo, Address, Vec<Address>),
-    Atom(SourceInfo, Address),
-    Ident(SourceInfo, Substring, Address, Vec<Preresolved>),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum DataValue {
-    OfString(Address),
-    OfBool(bool),
-    OfName(Address),
-    OfNat(Address),
-    OfInt(Address),
-    OfSyntax(Address),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum BinderInfo {
-    Default,
-    Implicit,
-    StrictImplicit,
-    InstImplicit,
-    AuxDecl,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ReducibilityHints {
-    Opaque,
-    Abbrev,
-    Regular(u32),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Metadatum {
-    Link(Address),
-    Info(BinderInfo),
-    Hints(ReducibilityHints),
-    Links(Vec<Address>),
-    Map(Vec<(Address, Address)>),
-    KVMap(Vec<(Address, DataValue)>),
-    Muts(Vec<Vec<Address>>),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Metadata {
-    pub nodes: Vec<Metadatum>,
-}
-
-//impl Serialize for BinderInfo {
-//    fn put(&self, buf: &mut Vec<u8>) {
-//        match self {
-//            Self::Default => buf.push(0),
-//            Self::Implicit => buf.push(1),
-//            Self::StrictImplicit => buf.push(2),
-//            Self::InstImplicit => buf.push(3),
-//            Self::AuxDecl => buf.push(3),
-//        }
-//    }
-//
-//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-//        match buf.split_at_checked(1) {
-//            Some((head, rest)) => {
-//                *buf = rest;
-//                match head[0] {
-//                    0 => Ok(Self::Default),
-//                    1 => Ok(Self::Implicit),
-//                    2 => Ok(Self::StrictImplicit),
-//                    3 => Ok(Self::InstImplicit),
-//                    4 => Ok(Self::AuxDecl),
-//                    x => Err(format!("get BinderInfo invalid {x}")),
-//                }
-//            }
-//            None => Err("get BinderInfo EOF".to_string()),
-//        }
-//    }
-//}
-//
-//impl Serialize for ReducibilityHints {
-//    fn put(&self, buf: &mut Vec<u8>) {
-//        match self {
-//            Self::Opaque => buf.push(0),
-//            Self::Abbrev => buf.push(1),
-//            Self::Regular(x) => {
-//                buf.push(2);
-//                x.put(buf);
-//            }
-//        }
-//    }
-//
-//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-//        match buf.split_at_checked(1) {
-//            Some((head, rest)) => {
-//                *buf = rest;
-//                match head[0] {
-//                    0 => Ok(Self::Opaque),
-//                    1 => Ok(Self::Abbrev),
-//                    2 => {
-//                        let x: u32 = Serialize::get(buf)?;
-//                        Ok(Self::Regular(x))
-//                    }
-//                    x => Err(format!("get ReducibilityHints invalid {x}")),
-//                }
-//            }
-//            None => Err("get ReducibilityHints EOF".to_string()),
-//        }
-//    }
-//}
-
-//impl Serialize for Metadatum {
-//    fn put(&self, buf: &mut Vec<u8>) {
-//        match self {
-//            Self::Name(x) => {
-//                buf.push(0);
-//                x.put(buf);
-//            }
-//            Self::Info(x) => {
-//                buf.push(1);
-//                x.put(buf);
-//            }
-//            Self::Link(x) => {
-//                buf.push(2);
-//                x.put(buf);
-//            }
-//            Self::Hints(x) => {
-//                buf.push(3);
-//                x.put(buf);
-//            }
-//            Self::All(x) => {
-//                buf.push(4);
-//                x.put(buf);
-//            }
-//            Self::MutCtx(x) => {
-//                buf.push(5);
-//                x.put(buf);
-//            }
-//        }
-//    }
-//
-//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-//        match buf.split_at_checked(1) {
-//            Some((head, rest)) => {
-//                *buf = rest;
-//                match head[0] {
-//                    0 => {
-//                        let x = Name::get(buf)?;
-//                        Ok(Self::Name(x))
-//                    }
-//                    1 => {
-//                        let x = BinderInfo::get(buf)?;
-//                        Ok(Self::Info(x))
-//                    }
-//                    2 => {
-//                        let x = Address::get(buf)?;
-//                        Ok(Self::Link(x))
-//                    }
-//                    3 => {
-//                        let x = ReducibilityHints::get(buf)?;
-//                        Ok(Self::Hints(x))
-//                    }
-//                    4 => {
-//                        let x = Serialize::get(buf)?;
-//                        Ok(Self::All(x))
-//                    }
-//                    5 => {
-//                        let x = Serialize::get(buf)?;
-//                        Ok(Self::MutCtx(x))
-//                    }
-//                    x => Err(format!("get Metadata invalid {x}")),
-//                }
-//            }
-//            None => Err("get Metadata EOF".to_string()),
-//        }
-//    }
-//}
-
-//impl Serialize for Metadata {
-//    fn put(&self, buf: &mut Vec<u8>) {
-//        Serialize::put(&self.map, buf)
-//    }
-//
-//    fn get(buf: &mut &[u8]) -> Result<Self, String> {
-//        Ok(Metadata {
-//            map: Serialize::get(buf)?,
-//        })
-//    }
-//}
-//
-//#[cfg(test)]
-//mod tests {
-//    use super::*;
-//    use crate::ixon::tests::{gen_range, gen_vec};
-//    use quickcheck::{Arbitrary, Gen};
-//
-//    impl Arbitrary for BinderInfo {
-//        fn arbitrary(g: &mut Gen) -> Self {
-//            let x = gen_range(g, 0..4);
-//            match x {
-//                0 => Self::Default,
-//                1 => Self::Implicit,
-//                2 => Self::StrictImplicit,
-//                3 => Self::InstImplicit,
-//                _ => Self::AuxDecl,
-//            }
-//        }
-//    }
-//
-//    impl Arbitrary for ReducibilityHints {
-//        fn arbitrary(g: &mut Gen) -> Self {
-//            let x = gen_range(g, 0..2);
-//            match x {
-//                0 => Self::Opaque,
-//                1 => Self::Abbrev,
-//                _ => Self::Regular(Arbitrary::arbitrary(g)),
-//            }
-//        }
-//    }
-//
-//    impl Arbitrary for Metadatum {
-//        fn arbitrary(g: &mut Gen) -> Self {
-//            let x = gen_range(g, 0..5);
-//            match x {
-//                0 => Self::Name(Name::arbitrary(g)),
-//                1 => Self::Info(BinderInfo::arbitrary(g)),
-//                2 => Self::Link(Address::arbitrary(g)),
-//                3 => Self::Hints(ReducibilityHints::arbitrary(g)),
-//                4 => Self::All(gen_vec(g, 9, Arbitrary::arbitrary)),
-//                _ => {
-//                    let x = gen_range(g, 0..9);
-//                    let mut res = vec![];
-//                    for _ in 0..x {
-//                        res.push(gen_vec(g, 9, Arbitrary::arbitrary))
-//                    }
-//                    Self::MutCtx(res)
-//                }
-//            }
-//        }
-//    }
-//
-//    impl Arbitrary for Metadata {
-//        fn arbitrary(g: &mut Gen) -> Self {
-//            let x = gen_range(g, 0..9);
-//            let mut map = Vec::new();
-//            for _ in 0..x {
-//                map.push((Nat::arbitrary(g), gen_vec(g, 9, Metadatum::arbitrary)));
-//            }
-//            Metadata { map }
-//        }
-//    }
-//}