Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
97 commits
Select commit Hold shift + click to select a range
c2bf1d5
formal/notes: the agreement-set knowledge extractor, phase 0
TomWambsgans Nov 17, 2026
55f4952
formal: doom certificates with an acceptance predicate
TomWambsgans Nov 17, 2026
cfa06b9
formal: the fold round's escape count, relativised to a predicate on …
TomWambsgans Nov 17, 2026
b390f3a
formal: the WHIR opening's invariant, relativised to a descent predicate
TomWambsgans Nov 17, 2026
3e55775
formal: the assembly, relativised to the bad stacks, with an acceptan…
TomWambsgans Nov 17, 2026
f37da26
formal: knowledge soundness through the descent of an accepting run
TomWambsgans Nov 17, 2026
9f888bd
formal/notes: the agreement-set extractor's status; tests follow the …
TomWambsgans Nov 17, 2026
729d225
formal: the descent as an algorithm, over any near-tuple decoder
TomWambsgans Nov 17, 2026
0bd8f73
formal: the descent's thresholds at the deployed parameters
TomWambsgans Nov 17, 2026
5f5ab89
formal/notes: the replay's cut and the availability bound, made precise
TomWambsgans Nov 17, 2026
416c6f6
formal: the ghost opening cut at the final polynomial
TomWambsgans Nov 17, 2026
2ab1397
formal: the ghost verifier cut at the final polynomial
TomWambsgans Nov 17, 2026
cdde833
formal: the cut verifier's extracted run
TomWambsgans Nov 17, 2026
512fbec
formal/notes: the replay's remaining steps
TomWambsgans Nov 17, 2026
abce9cb
formal: the replay of a verifier program under partial permutation an…
TomWambsgans Nov 17, 2026
f6b5eb5
formal: the replay of the cut returns the ghost verifier's value
TomWambsgans Nov 17, 2026
14a06f2
formal: the replay's chain of permutations
TomWambsgans Nov 17, 2026
b42852a
formal: after the cut, the final query's proof of work hits
TomWambsgans Nov 17, 2026
0503d3b
formal: the extractor's queries are available, or the final grind hit…
TomWambsgans Nov 17, 2026
0eed8b4
formal: the final proof of work's data as a function of the log
TomWambsgans Nov 17, 2026
8da83c6
formal: a fresh hit of the final proof of work has probability 2^-127
TomWambsgans Nov 17, 2026
7ccee68
formal: the levels' roots are rarely answered afresh
TomWambsgans Nov 17, 2026
c0ae26c
formal: the agreement-set extractor and its correctness
TomWambsgans Nov 17, 2026
9095f3d
formal: knowledge soundness for the agreement-set extractor, random-o…
TomWambsgans Nov 17, 2026
4ab19c7
formal: a near-tuple decoder by choice
TomWambsgans Nov 17, 2026
d78f666
formal/notes: the agreement-set extractor's status
TomWambsgans Nov 17, 2026
6c13d1d
formal: the transcript's forward answers hold the adversary's F answers
TomWambsgans Nov 17, 2026
4a213a4
formal: knowledge soundness for the agreement-set extractor, random-p…
TomWambsgans Nov 17, 2026
ace82a4
formal/notes: knowledge soundness holds for the agreement-set extractor
TomWambsgans Nov 17, 2026
4c1566c
formal: a near-tuple decoder from Gao's Reed-Solomon decoder
TomWambsgans Nov 17, 2026
86869a5
formal: a polynomial's low part from its values on U_kappa
TomWambsgans Nov 17, 2026
3e5a5e5
formal: the descent over values
TomWambsgans Nov 17, 2026
c587969
formal: the agreement-set extractor reads its words through computed …
TomWambsgans Nov 17, 2026
37bbe3f
formal: the computable agreement-set extractor
TomWambsgans Nov 17, 2026
97282c9
formal/notes: the computable agreement-set extractor
TomWambsgans Nov 17, 2026
5c8820c
formal: skeletons of verifier programs and their replay
TomWambsgans Nov 17, 2026
4919d7d
formal: skeletons with postconditions and the verifier's leaves
TomWambsgans Nov 17, 2026
8a70a44
formal: the bus phase's skeleton
TomWambsgans Nov 17, 2026
108be46
formal: the bus phase's skeleton keeps a form per table
TomWambsgans Nov 17, 2026
3356623
formal: the front phases' skeletons
TomWambsgans Nov 17, 2026
4cc5402
formal: the cut verifier's skeleton
TomWambsgans Nov 17, 2026
3068a1c
formal: decoders of verifier programs
TomWambsgans Nov 17, 2026
0328984
formal: the cut levels' trace read off their history
TomWambsgans Nov 17, 2026
75ac62d
formal: the cut verifier's value read off its history
TomWambsgans Nov 17, 2026
583bb52
formal: the extractor over the verifier's skeleton
TomWambsgans Nov 17, 2026
327d2b6
formal: the agreement-set extractor's cost plan
TomWambsgans Nov 17, 2026
d3d03fc
formal: the transcript's first forward answers, indexed, and Keccak-2…
TomWambsgans Nov 17, 2026
4b1f991
formal: the agreement-set extractor on the transcript's indices
TomWambsgans Nov 17, 2026
9ca6ee5
formal: Newton interpolation and one-error decoding
TomWambsgans Nov 17, 2026
d31ce39
formal: the one-error near-tuple decoder
TomWambsgans Nov 17, 2026
bfb6483
formal: the computed extractors over any decoder over values; one-err…
TomWambsgans Nov 17, 2026
fd3ee88
formal: the decoding window from the columns in order
TomWambsgans Nov 17, 2026
285037b
formal: the descent's folds, agreement sets and one-error decoding ov…
TomWambsgans Nov 17, 2026
2c26031
formal: the descent over arrays, within and across levels
TomWambsgans Nov 17, 2026
431040b
formal: the agreement-set extractor over arrays, and its knowledge so…
TomWambsgans Nov 17, 2026
2b7824a
formal: one-error Newton decoding with its nodes in K
TomWambsgans Nov 17, 2026
0aa507a
formal: the agreement-set extractor in its compiled form
TomWambsgans Nov 17, 2026
46e3bf9
formal: compile the agreement-set extractor's decoder, descent and re…
TomWambsgans Nov 17, 2026
e29ee91
formal: the agreement-set extractor on the lite layout
TomWambsgans Nov 17, 2026
b62c2a2
formal: the agreement-set extractor compiled on the cost machine
TomWambsgans Nov 17, 2026
91878e3
formal: notes on the compiled agreement-set extractor
TomWambsgans Nov 17, 2026
c537627
formal: share the operands of E arithmetic in the compiled extractor
TomWambsgans Nov 17, 2026
00b4959
formal: price bounds of one-error Newton decoding
TomWambsgans Nov 17, 2026
476928d
formal: price bounds of the descent's folds, agreement sets and one-e…
TomWambsgans Nov 17, 2026
769fe01
formal: price bound of the descent within a level
TomWambsgans Nov 17, 2026
e399867
formal: the agreement-set extractor's program and its size
TomWambsgans Nov 17, 2026
ee1e958
formal: price bounds of the levels' shapes
TomWambsgans Nov 17, 2026
a71607e
formal: the decoded WHIR trace's shape
TomWambsgans Nov 17, 2026
245c3db
formal: price bound of the agreement-set extractor's candidate run
TomWambsgans Nov 17, 2026
ca7a1b8
formal: the decoded announced sizes meet the runner's assumptions
TomWambsgans Nov 17, 2026
5de3d75
formal: price bounds of the step up a level, level 0's stack and the …
TomWambsgans Nov 17, 2026
d4f92d0
formal: drop the levels' bounds superseded by the step up's
TomWambsgans Nov 17, 2026
30dcd40
formal: price bound of the descent across the opening's levels
TomWambsgans Nov 17, 2026
1a724d6
formal: price bound of the agreement-set extractor's finish
TomWambsgans Nov 17, 2026
cd14b13
formal: the roots' widths sum to at most 224, heights within the stac…
TomWambsgans Nov 17, 2026
5b23e72
formal: the descent's worst price within 2^max(58, 2μ+9) at every shape
TomWambsgans Nov 17, 2026
9d1e549
formal: the words' price, a constant per root, the roots' indexes and…
TomWambsgans Nov 17, 2026
1e16c91
formal: the agreement-set extractor's glue and its announced stack size
TomWambsgans Nov 17, 2026
1ba6ae9
formal: a successful agreement-set extraction's roots and trace
TomWambsgans Nov 17, 2026
12770be
formal: price bounds of the agreement-set extractor's replay, seed, s…
TomWambsgans Nov 17, 2026
a1a468b
formal: price bound of the agreement-set extractor where it succeeds
TomWambsgans Nov 17, 2026
a138efb
formal: the agreement-set extractor's price within 2^max(58, 2μ+9) + …
TomWambsgans Nov 17, 2026
2999b4c
formal: the compiled agreement-set program computes transcriptExtract…
TomWambsgans Nov 17, 2026
1e5db11
formal: statement.tex and the note for the agreement-set extractor an…
TomWambsgans Nov 17, 2026
9d2092a
formal: no en dashes in the agreement-set note
TomWambsgans Nov 17, 2026
aa2503f
formal: remove the list decoder, switch the end theorems to the agree…
TomWambsgans Nov 17, 2026
a0fd07b
formal: statement.tex at the measured extractor and guest decoder sizes
TomWambsgans Nov 17, 2026
9c34acd
formal: the agreement-set note's status
TomWambsgans Nov 18, 2026
c91e7af
formal: the budget passes 2^128 at about 2^97.7 queries
TomWambsgans Nov 18, 2026
b3fe00f
formal: guest-diff names the prover the generic signer caches take
TomWambsgans Nov 18, 2026
9e6bb78
formal: simplify the agreement-set branch
TomWambsgans Nov 18, 2026
7776796
formal: the extractor's size bound at its simplified program, 25365
TomWambsgans Nov 18, 2026
8eb706a
formal: one transcript index for every root, one index of the first f…
TomWambsgans Nov 18, 2026
7af74ae
formal: the extractor's budget back to the list decoder's per-query t…
TomWambsgans Nov 18, 2026
650a994
formal: the agreement-set budget is the statement's
TomWambsgans Nov 18, 2026
04e23fe
formal: the soundness error's account for the agreement-set extractor…
TomWambsgans Nov 18, 2026
a0a9495
Merge origin/main into agreement-set-extractor
TomWambsgans Nov 18, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion formal/AGENTS.md
Original file line number Diff line number Diff line change
Expand Up @@ -76,7 +76,6 @@ python3 -I ../lake-build.py . LeanVM LeanVMTests --dev --keep-going # every
scripts/guest-export/target/release/guest-export . [--check] # the guest's data, after a change to the guest
cargo run --release --manifest-path scripts/whir-fold-table/Cargo.toml -- LeanVM/Protocol/ToArkLib/Whir/AffineCombinerDeployedTable.lean [--check] # the fold rounds' certificate, after a change to whir_config.rs
scripts/renumber-chain dump OUT; scripts/renumber-chain apply BEFORE AFTER # the cost bounds' names, after a change to the cost-compiled chain moves its indices
python3 -I scripts/extractor-cost/cost.py scripts/extractor-cost/params.csv # the knowledge extractor's cost model, per shape (not a proof)
LEANVM_GUEST_DIFF=/tmp/g cargo test --release --manifest-path scripts/guest-export/Cargo.toml --lib guest_diff -- --ignored && lake exe guest-diff /tmp/g/*.txt

# lean_sphincs: the crates' known answers on the compiled statement
Expand Down
28 changes: 14 additions & 14 deletions formal/Statement/CostMachine.lean
Original file line number Diff line number Diff line change
Expand Up @@ -414,20 +414,20 @@ def decodeExecution (program : Semantics.LeanIsaProgram) : MachineValue → Opti
/-- **The extractor's budget**, for a proof announcing a stack of `2^μ` elements
(`stackLog = μ`) and a transcript of `N = permutationQueryCount` permutation queries: the most the
extractor's run may cost, in the machine's price (the sum of its steps' prices, each at least `1`,
so also the most steps it may execute), `2^max(80, 2μ + 25) + (N + 2^30)·(D + 2)²·(2^15 + 2D)`,
so also the most steps it may execute), `2^max(58, 2μ + 9) + (N + 2^30)·(D + 2)²·(2^15 + 2D)`,
with `D = log₂(N + 2) + 1` the levels of the extractor's sorted tables of the transcript.
`lean_vm` proves the compiled extractor's price at most this at every shape the replay admits
(stack log-size `16` to `30`, rate exponent `1` to `4`, memory and program log-sizes at most `30`):
the first term bounds the list decoder (its `64` lanes' Guruswami-Sudan decoding at the stack's
worst rate, each lane interpolated by an approximant basis: about `2^78.96` at `μ = 27`, `2^80.93`
at `28`, `2^82.91` at `29` and `2^84.91` at `30`, so the term is `2^80` up to `μ = 27`, then
`2^81`, `2^83`, `2^85`) and the runs of the candidate executions; the second term bounds the
transcript's index (per query and level squared, a level's positions growing by a limb per `64`
levels) and the committed leaves (`2^30` at most). Past `2^128` from about `2^100` queries, where
the soundness bound is still about `2^-25` (`statement.tex`, *What is not proved*, says what the regime
`lean_vm` proves the compiled extractor's price at most this wherever it extracts, at every shape
the replay admits (stack log-size `16` to `30`, rate exponent `1` to `4`, memory and program
log-sizes at most `30`): the first term bounds the descent from the final polynomial to level 0's
stack (each fold round's lanes decoded with at most one error on the columns of their agreement
set, level 0's descent dominating), level 0's stack, the candidate run and every other price
independent of the transcript; the second bounds, per query, the transcript's two indexes (its first
forward answers, and one preimage index every committed root shares) and, per committed leaf
or hashed block (`2^30` at most), their lookups. It passes `2^128` at about `N = 2^99.7`, where the
soundness bound is still about `2^-25` (`statement.tex`, *What is not proved*, says what the regime
leaves out). A proof announcing no layout is given the budget of `μ = 0`. -/
def leanVmKnowledgeExtractorBudget (stackLog permutationQueryCount : ℕ) : ℕ :=
2 ^ max 80 (2 * stackLog + 25) +
2 ^ max 58 (2 * stackLog + 9) +
(permutationQueryCount + 2 ^ 30) * (Nat.log2 (permutationQueryCount + 2) + 3) ^ 2 *
(2 ^ 15 + 2 * (Nat.log2 (permutationQueryCount + 2) + 1))

Expand All @@ -450,12 +450,12 @@ open Common

@[expose] public section

/-- **The bound on the extractor program's size** (`MachineProgram.size`): `14159`, the compiled
extractor's size (`14039`: its `699` compiled bodies and the entry, at `712` indices, `12` of
/-- **The bound on the extractor program's size** (`MachineProgram.size`): `25380`, the compiled
extractor's size (`25260`: its `514` compiled bodies and the entry, at `545` indices, `30` of
them holes, a literal `0` each) and a slack of `120`, less than one leanXMSS signature's encoding
(`309`: two layers of `153`, each a randomizer, `58` chain values and a path of `16`, digests of
two limbs), so the compiled extractor could carry no useful table of witnesses beside its code. -/
def leanVmKnowledgeExtractorSizeBound : ℕ := 14159
def leanVmKnowledgeExtractorSizeBound : ℕ := 25380

/-- **The extractor a program computes**: the program, of size at most
`leanVmKnowledgeExtractorSizeBound`, run on the encoded statement, transcript and proof
Expand Down
9 changes: 5 additions & 4 deletions formal/Statement/LeanVm.lean
Original file line number Diff line number Diff line change
Expand Up @@ -169,10 +169,11 @@ adversary of at most `Q ≤ 2^128` queries to `π` and `π⁻¹` (its coins free
probability at most `(Q + 2^14) · 2^-125 + 5 (Q + 2^14)² · 2^-256`, `2^-125` the round-by-round
error every verifier message is held to after its proof of work. The `2^14` covers the verifier's
own Keccak-256 evaluations and duplex permutations, at most `13708` (the `Q + 13708` of `lean_vm`'s
`soundnessError`; as calls of `π` they are up to `13708 · 2^30`, the IV hashing a bytecode of up to
`2^30` instructions, which the transfer below pays), its `13708 · 2^-256` for a fresh hash answer
equal to a stack root the adversary announced without computing it, and the transfer from two
random oracles to one permutation. `Statement.Theorems`
`soundnessErrorAS`; as calls of `π` they are up to `13708 · 2^30`, the IV hashing a bytecode of up to
`2^30` instructions, which the transfer below pays), and three terms of at most `2^-125` each: a
fresh hash answer of the verifier equal to a Merkle root the extractor reads (at most `2^16` roots
per verifier query, `2^-256` each), a fresh permutation answer that passes the final query's proof
of work (`2^-127`, once), and the transfer from two random oracles to one permutation. `Statement.Theorems`
states it for the extractor a cost-machine program computes within its budget
(`LeanVM.extractorComputedBy`, `CostMachine.lean`). The extractor must output some valid execution
of the program on the input; nothing requires it to be the execution the proof commits to (its
Expand Down
6 changes: 3 additions & 3 deletions formal/Statement/LeanVmGuest.lean
Original file line number Diff line number Diff line change
Expand Up @@ -457,14 +457,14 @@ open LeanVM.Parameters LeanVM.Semantics
`statement.tex` (*Soundness*, the decoder's budget and size bound) has their measurements and
limits. -/

/-- **The bound on the guest decoder program's size** (`MachineProgram.size`): `569815`, the
compiled decoder's size (`569405`: `lean_vm`'s `Cost/DecoderSize.lean` proves it at most that) and a
/-- **The bound on the guest decoder program's size** (`MachineProgram.size`): `568917`, the
compiled decoder's size (`568507`: `lean_vm`'s `Cost/DecoderSize.lean` proves it at most that) and a
slack of `410`, room for one leanXMSS signature's encoding (`309`) but not two, so no useful table
of witnesses (hard-coded signatures, matrices or proofs that would mask a bug of the guest program
on finitely many statements) fits beside the compiled decoder's code. The size counts in full the
guest program's per-function tables, literals of the compiled decoder; a program written differently
could hold more. -/
def guestWitnessDecoderSizeBound : ℕ := 569815
def guestWitnessDecoderSizeBound : ℕ := 568917

/-- **The guest decoder's budget** on an execution of `program` of `steps` steps on a memory of
`2^κ` words: the most the decoder's run may cost, in the machine's price (so also the most steps it
Expand Down
2 changes: 1 addition & 1 deletion formal/Statement/Prover/Witness.lean
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ hash map), recording each state stepped from, its bytecode slot and the instruct
(`runSteps`); then the six opcode tables' rows in one pass over the steps, each read carrying its
cell's count so far, the counters stepping by `g` in place (`rowsOf`). The address indices and the
public boundary are the knowledge extractor's too (`lean_vm`,
`LeanVM/Protocol/Extraction/Extractor.lean`).
`LeanVM/Protocol/Extraction/Fast/Address.lean`, `candidateExecutionTable_eq`).
-/

@[expose] public section
Expand Down
2 changes: 1 addition & 1 deletion formal/Statement/Theorems.lean
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,7 @@ structure Theorems
`extractorComputedBy leanVmKnowledgeExtractor`: at most `(Q + 2^14) · 2^-125 +
5 (Q + 2^14)² · 2^-256` for `Q ≤ 2^128` queries (`LeanVm.lean`). The program extracts nothing if
its size or its run's price exceeds its bound or budget (`leanVmKnowledgeExtractorBudget μ N`, for
`N` permutation queries at a stack of `2^μ`: about `2^max(80, 2μ + 25)` up to `2^50` queries,
`N` permutation queries at a stack of `2^μ`: about `2^max(58, 2μ + 9) + 2^15·N·log²N`,
`O(N·log³N)`), and extracting nothing from an accepted proof is a break; so, but with that
probability, the program extracts a valid execution within its budget. That a price unit is a constant number of instructions of a 64-bit
CPU is trusted (`CostMachine.lean`). -/
Expand Down
52 changes: 18 additions & 34 deletions formal/lean_vm/LeanVM.lean
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,7 @@ import Statement.Theorems
import Statement.Corollaries
import LeanVM.Protocol.WithHash
import LeanVM.Guest.WithHash
import LeanVM.Cost.Efficient
import LeanVM.Cost.KnowledgeExtractor
import LeanVM.Guest.DecoderProgram
import LeanVM.Cost.DecoderSpec
import LeanVM.Cost.Bounds.Guest.Budget
Expand Down Expand Up @@ -47,14 +47,14 @@ Its fields are proved by `theorems_of_decoderSpec`, for any decoder program meet
whose decodings explain the input by `guest_knowledge`.

**The extractor.** `Statement.Theorems` takes the extractor as a cost-machine program
(`Statement/CostMachine.lean`): `compiledKnowledgeExtractor`, the knowledge extractor
`transcriptExtractor` (`LeanVM/Protocol/Extraction/Extractor.lean`) compiled
(`Cost/Extractor/Top.lean`) behind an entry (`Cost/ExtractorProgram.lean`). Its size is within
`leanVmKnowledgeExtractorSizeBound` (`Cost/ExtractorSize.lean`), and the extractor it computes
within its budget is
(`Statement/CostMachine.lean`): `compiledKnowledgeExtractor` (`Cost/KnowledgeExtractor.lean`), the
knowledge extractor `transcriptExtractor` (`LeanVM/Protocol/KnowledgeSoundness.lean`, the
agreement-set extractor of `LeanVM/Protocol/Extraction/AS/Lite.lean`) compiled (`Cost/AS/Top.lean`)
behind an entry (`Cost/AS/Program.lean`). Its size is within `leanVmKnowledgeExtractorSizeBound`
(`Cost/AS/ProgramSize.lean`), and the extractor it computes within its budget is
`transcriptExtractor` (`LeanVM.Cost.extractorOf_extractorProgram`), for which
`knowledgeSoundness_holds` is proved; its price is within `leanVmKnowledgeExtractorBudget`
(`Cost/Bounds/Top.lean`).
wherever it extracts (`LeanVM.Cost.AS.asPrice_within`, `Cost/AS/End.lean`).

Each theorem below proves a proposition of `Statement/` (`statement.tex`), in the
random-permutation model where an adversary is involved, except the memory-decoder forms
Expand Down Expand Up @@ -91,14 +91,14 @@ random-permutation model where an adversary is involved, except the memory-decod
the random-permutation model (from `batch_rpm`).

The other theorems pinned below are steps or corollaries: the bounds' numbers (the soundness and
completeness errors, and the compiled extractor's price, `LeanVM.Cost.Bounds.extractorC_cost`,
`extractorPrice_30_4`, `extractorPrice_30_4_2_128`), the guest's batching
completeness errors, and the compiled extractor's price, `LeanVM.Cost.Bounds.AS.extractL_cost`,
`LeanVM.Cost.Bounds.AS.asPrice_le`, `LeanVM.Cost.AS.asPrice_within`), the guest's batching
of its children's deferred claims (`LeanVM.Guest.Batch.children_sound`, and in the
random-permutation model `batch_rpm`, `batch_rpm_bits`), `decode_binds`, `guest_sound`,
`aggregate_knowledge`, and the guest's completeness within its deployed budget
(`LeanVM.Guest.Budget.guest_complete`, `guest_complete_numeric`).
The two-oracle random-oracle model the proofs pass through (`LeanVM/Protocol/Rom/Statement.lean`:
`LeanVM.knowledgeSoundnessRom_holds`, `LeanVM.completenessRom_holds`; the batching's
`LeanVM.knowledgeSoundnessRomAS`, `LeanVM.completenessRom_holds`; the batching's
`LeanVM.Guest.Batch.batch_rom`, `batch_rom_bits`) is a proof step: its theorems are not pinned here
(`tests/LeanVMTests/Protocol/` and `tests/LeanVMTests/Guest/Batch.lean` check their footprints).
The build fails if their axiom footprint ever grows beyond Lean's three standard axioms. -/
Expand All @@ -124,29 +124,21 @@ example : LeanVM.Guest.Batch.BatchingSound := LeanVM.Guest.Batch.batch_sound_hol
#guard_msgs in
#print axioms LeanVM.knowledgeSoundness_holds

/-- info: 'LeanVM.Cost.Bounds.extractorC_cost' depends on axioms: [propext, Classical.choice, Quot.sound] -/
/-- info: 'LeanVM.Cost.Bounds.AS.extractL_cost' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.Cost.Bounds.extractorC_cost
#print axioms LeanVM.Cost.Bounds.AS.extractL_cost

/-- info: 'LeanVM.Cost.Bounds.extractorPrice_30_4' depends on axioms: [propext, Classical.choice, Quot.sound] -/
/-- info: 'LeanVM.Cost.Bounds.AS.asPrice_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.Cost.Bounds.extractorPrice_30_4
#print axioms LeanVM.Cost.Bounds.AS.asPrice_le

/-- info: 'LeanVM.Cost.Bounds.extractorPrice_30_4_2_128' depends on axioms: [propext, Classical.choice, Quot.sound] -/
/-- info: 'LeanVM.Cost.AS.asPrice_within' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.Cost.Bounds.extractorPrice_30_4_2_128
#print axioms LeanVM.Cost.AS.asPrice_within

/-- info: 'LeanVM.candidates_ncard_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
/-- info: 'LeanVM.soundnessRpmAS_le_statement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.candidates_ncard_le

/-- info: 'LeanVM.soundnessError_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.soundnessError_le

/-- info: 'LeanVM.soundnessRpm_le_statement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.soundnessRpm_le_statement
#print axioms LeanVM.soundnessRpmAS_le_statement

/-- info: 'LeanVM.completenessError_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
Expand All @@ -156,14 +148,6 @@ example : LeanVM.Guest.Batch.BatchingSound := LeanVM.Guest.Batch.batch_sound_hol
#guard_msgs in
#print axioms LeanVM.completeness_holds

/-- info: 'LeanVM.soundnessRpm_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.soundnessRpm_le

/-- info: 'LeanVM.soundnessRpm_le_bits' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.soundnessRpm_le_bits

/-- info: 'LeanVM.Rpm.completenessRpm_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms LeanVM.Rpm.completenessRpm_le
Expand Down
Loading
Loading