Report #10 — integer-encoding 4.1.0: selected scalar encoding and fixed-width operations
Aeneas be86ab0f1989d04944292b345b24c435be3ad10a
80 verified claims · 5 findings
Overview
For the built-in u8, u16, u32, u64, usize and corresponding signed types, the selected contracts establish the canonical low-group-first base-128 encoding. Signed values first undergo ZigZag: 2*z for nonnegative z, and -2*z-1 for negative z. required_space returns the exact number of bytes, and encode_var_vec returns those bytes. When the destination has at least that many bytes, encode_var succeeds, returns the count, writes exactly those bytes and preserves the remaining suffix. For example, zero encodes as [0].
Fixed-width encoding returns the scalar's little-endian bytes, including the two's-complement representation of signed values. Slice encoding succeeds only when the destination length equals the scalar's byte width; on any other length it returns None without changing the destination. Slice decoding likewise accepts exactly that width and interprets the bytes as little-endian with the target's signedness. switch_endianness returns the value represented by the reversed fixed-width bytes. These guarantees cover the array and vector encoding variants as well. The usize and isize fixed-width claims require a 64-bit pointer width.
The October 27, 2026 macOS arm64 run checked 80 selected scalar API mappings against the release bodies. It also checked short-buffer assertion failures in the extracted debug-assertion profile; those do not establish the release failure tag or destination state after unwinding. Native tests and the findings below are separate observations.
Findings (5)
VarIntReader can leave a complete varint partially consumed
FixedInt overview and methods disagree about endianness
Complete out-of-range varint is reported as UnexpectedEof
Generic FixedInt I/O panics for a valid sixteen-byte implementation
APIs (80)
Trait implementations
impl integer_encoding::FixedInt for …
fn decode_fixed10 implementations
fn encode_fixed10 implementations
fn encode_fixed_light10 implementations
fn encode_fixed_vec10 implementations
fn switch_endianness10 implementations
impl integer_encoding::VarInt for …
fn encode_var10 implementations
fn encode_var_vec10 implementations
fn required_space10 implementations
Evidence
https://github.com/keiichiw/crate-proofs/tree/ed016e12463fdae695da11060d7e0d41b8b672b0
Reproduce
Run locally
git clone -- https://github.com/keiichiw/crate-proofs report-10-source-1
git -C report-10-source-1 checkout --detach ed016e12463fdae695da11060d7e0d41b8b672b0
git -C report-10-source-1 submodule update --init --recursive --checkout
cd report-10-source-1/integer-encoding/4.1.0/aeneas/aeneas/profiles/default/proofs
lake build +EncodeVar +FixedProofs +FixedVec +RequiredSpace +VarintVec
printf '%s' 'import Aeneas
import EncodeVar
import FixedProofs
import FixedVec
import RequiredSpace
import VarintVec
set_option pp.all true
set_option pp.universes true
set_option pp.explicit true
set_option pp.fullNames true
set_option pp.notation false
set_option pp.proofs true
set_option pp.deepTerms true
set_option pp.maxSteps 10000000
-- proofs.rs adapter for Lean 4.35.0 / Aeneas be86ab0f.
-- Uses Lean'\''s environment, Meta telescope and pretty-printer, never source parsing.
open Lean Meta Elab Command
namespace ProofsProbe
meta def moduleOf (env : Environment) (n : Name) : String :=
match env.getModuleIdxFor? n with
| some idx => env.header.moduleNames[idx.toNat]!.toString
| none => ""
meta def pretty (e : Expr) : MetaM String := do
let s := (← ppExpr e).pretty
if s.contains '\''⋯'\'' then
throwError "Lean display contains an omission marker (or literal ⋯); refusing an incomplete proposition"
if s.utf8ByteSize > 1000000 then throwError "Proposition exceeds 1,000,000-byte recording limit"
return s
-- The full statement stays explicit; the inspection view uses Lean notation.
meta def readable (e : Expr) : MetaM String :=
withOptions (fun o =>
let o := o.setBool `pp.all false
let o := o.setBool `pp.explicit false
let o := o.setBool `pp.universes false
o.setBool `pp.notation true) (pretty e)
-- Only a constant'\''s own tag grants a link; names in plain text are never guessed.
partial def segments (code : Widget.CodeWithInfos) (ref : Option Name := none) : Array Json :=
match code with
| .text text => #[Json.mkObj (([("text", toJson text)]) ++
(ref.toList.map fun n => ("ref", toJson n.toString)))]
| .append parts => parts.foldl (fun acc part => acc ++ segments part ref) #[]
| .tag info part =>
let ref := match info.info.val.info with
| .ofTermInfo ti => ti.expr.constName?
| _ => none
segments part ref
meta def readableFields (key : String) (e : Expr) : MetaM (List (String × Json)) := do
let text ← readable e
let base := [(key, toJson text)]
try
let code ← withOptions (fun o =>
let o := o.setBool `pp.all false
let o := o.setBool `pp.explicit false
let o := o.setBool `pp.universes false
let o := o.setBool `pp.notation true
o.setBool `pp.tagAppFns true) (Widget.ppExprTagged e)
let parts := segments code
let joined := String.join (parts.toList.map fun j =>
(j.getObjValAs? String "text").toOption.getD "")
if joined != text || parts.size > 10000 || joined.utf8ByteSize > 1000000 then
return base
return base ++ [(key ++ "_segments", toJson parts)]
catch _ => return base
meta def inspect (n : Name) (ty : Expr) (manual : Bool) : MetaM (Option Json) := do
let env ← getEnv
forallTelescope ty fun xs conclusion => do
let programExpr ← try
let normalized ← Aeneas.Utils.normalizeLetBindings conclusion
let (expr, _) ← Aeneas.Step.getStepSpecFunArgsExpr normalized
pure (some expr)
catch _ => pure none
if programExpr.isNone && !manual then return none
let full ← pretty ty
let program ← match programExpr with
| some expr => pure (toJson (← readable expr))
| none => pure Json.null
let head := toJson (programExpr.bind (·.getAppFn.constName?) |>.map Name.toString)
let mut binders := #[]
for x in xs do
let d ← x.fvarId!.getDecl
let prop ← isProp d.type
binders := binders.push (Json.mkObj ((← readableFields "type" d.type) ++ [
("name", toJson d.userName.toString),
("kind", toJson (if d.binderInfo.isInstImplicit then "instance" else if prop then "hypothesis" else "variable")),
("binder", toJson (if d.binderInfo.isInstImplicit then "instance" else if d.binderInfo.isExplicit then "explicit" else "implicit"))]))
if binders.size > 1000 then throwError "More than 1000 binders"
let some ranges ← findDeclarationRanges? n | throwError "Missing theorem source range: {n}"
let axioms ← Lean.collectAxioms n
let constants := ty.getUsedConstants
let mut definitions := #[]
for nm in constants.extract 0 100 do
let ranges ← findDeclarationRanges? nm
definitions := definitions.push (Json.mkObj [
("name", toJson nm.toString), ("module", toJson (moduleOf env nm)),
("source", match ranges with
| some r => Json.mkObj [("first_line", toJson r.range.pos.line), ("last_line", toJson r.range.endPos.line)]
| none => Json.null)])
return some (Json.mkObj ((← readableFields "conclusion" conclusion) ++ [
("version", toJson (1 : Nat)), ("theorem", toJson n.toString),
("module", toJson (moduleOf env n)), ("statement", toJson full),
("binders", toJson binders),
("program", program), ("program_head", head),
("axioms", toJson (axioms.map Name.toString)),
("first_line", toJson ranges.range.pos.line), ("last_line", toJson ranges.range.endPos.line),
("definitions", toJson definitions), ("definitions_truncated", toJson (decide (constants.size > 100))),
("translation_rerun", toJson false)]))
end ProofsProbe
run_cmd do
let manual : Array Name := #[`IntegerRequiredSpace.u8_required_space, `IntegerEncodingEncode.u8_total, `IntegerEncodingVec.u8_total, `IntegerFixedProofs.u8_light, `IntegerFixedProofs.u8_encode, `IntegerFixedProofs.u8_decode, `IntegerFixedProofs.u8_switch, `IntegerFixedVecProofs.u8_total, `IntegerRequiredSpace.u16_required_space, `IntegerEncodingEncode.u16_total, `IntegerEncodingVec.u16_total, `IntegerFixedProofs.u16_light, `IntegerFixedProofs.u16_encode, `IntegerFixedProofs.u16_decode, `IntegerFixedProofs.u16_switch, `IntegerFixedVecProofs.u16_total, `IntegerRequiredSpace.u32_required_space, `IntegerEncodingEncode.u32_total, `IntegerEncodingVec.u32_total, `IntegerFixedProofs.u32_light, `IntegerFixedProofs.u32_encode, `IntegerFixedProofs.u32_decode, `IntegerFixedProofs.u32_switch, `IntegerFixedVecProofs.u32_total, `IntegerRequiredSpace.u64_required_space, `IntegerEncodingEncode.u64_total, `IntegerEncodingVec.u64_total, `IntegerFixedProofs.u64_light, `IntegerFixedProofs.u64_encode, `IntegerFixedProofs.u64_decode, `IntegerFixedProofs.u64_switch, `IntegerFixedVecProofs.u64_total, `IntegerRequiredSpace.usize_required_space, `IntegerEncodingEncode.usize_total, `IntegerEncodingVec.usize_total, `IntegerFixedProofs.usize_light, `IntegerFixedProofs.usize_encode, `IntegerFixedProofs.usize_decode, `IntegerFixedProofs.usize_switch, `IntegerFixedVecProofs.usize_total, `IntegerRequiredSpace.i8_required_space, `IntegerEncodingEncode.i8_total, `IntegerEncodingVec.i8_total, `IntegerFixedProofs.i8_light, `IntegerFixedProofs.i8_encode, `IntegerFixedProofs.i8_decode_signed, `IntegerFixedProofs.i8_switch_signed, `IntegerFixedVecProofs.i8_total, `IntegerRequiredSpace.i16_required_space, `IntegerEncodingEncode.i16_total, `IntegerEncodingVec.i16_total, `IntegerFixedProofs.i16_light, `IntegerFixedProofs.i16_encode, `IntegerFixedProofs.i16_decode_signed, `IntegerFixedProofs.i16_switch_signed, `IntegerFixedVecProofs.i16_total, `IntegerRequiredSpace.i32_required_space, `IntegerEncodingEncode.i32_total, `IntegerEncodingVec.i32_total, `IntegerFixedProofs.i32_light, `IntegerFixedProofs.i32_encode, `IntegerFixedProofs.i32_decode_signed, `IntegerFixedProofs.i32_switch_signed, `IntegerFixedVecProofs.i32_total, `IntegerRequiredSpace.i64_required_space, `IntegerEncodingEncode.i64_total, `IntegerEncodingVec.i64_total, `IntegerFixedProofs.i64_light, `IntegerFixedProofs.i64_encode, `IntegerFixedProofs.i64_decode_signed, `IntegerFixedProofs.i64_switch_signed, `IntegerFixedVecProofs.i64_total, `IntegerRequiredSpace.isize_required_space, `IntegerEncodingEncode.isize_total, `IntegerEncodingVec.isize_total, `IntegerFixedProofs.isize_light, `IntegerFixedProofs.isize_encode, `IntegerFixedProofs.isize_decode_signed, `IntegerFixedProofs.isize_switch_signed, `IntegerFixedVecProofs.isize_total]
let localModules : Array String := #[]
let roots : Array Name := #[]
let env ← getEnv
let mut closure : Array Name := #[]
let mut pending := roots.toList
while !pending.isEmpty do
let m := pending.head!
pending := pending.tail!
if !closure.contains m then
closure := closure.push m
if let some idx := env.header.moduleNames.findIdx? (· == m) then
pending := (env.header.moduleData[idx]!.imports.toList.map (·.module)) ++ pending
let scope := closure.filter (fun m => localModules.contains m.toString)
for n in manual do
match env.find? n with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: {n}"
for (n, ci) in env.constants.toList do
let explicit := manual.contains n
if explicit || scope.contains (ProofsProbe.moduleOf env n).toName then
if let .thmInfo th := ci then
let result ← liftTermElabM <| ProofsProbe.inspect n th.type explicit
if let some value := result then
liftIO <| IO.println ("proofs.rs:formal:" ++ value.compress)
run_cmd do
let theorem_name := `IntegerFixedProofs.i16_decode_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i16_decode_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i16_decode_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i16_decode_signed"
run_cmd do
let theorem_name := `IntegerFixedProofs.i16_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i16_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i16_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i16_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.i16_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i16_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i16_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i16_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.i16_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.i16_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.i16_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.i16_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.i16_switch_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i16_switch_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i16_switch_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i16_switch_signed"
run_cmd do
let theorem_name := `IntegerEncodingEncode.i16_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.i16_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.i16_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.i16_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.i16_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.i16_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.i16_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.i16_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.i16_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.i16_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.i16_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.i16_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.i32_decode_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i32_decode_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i32_decode_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i32_decode_signed"
run_cmd do
let theorem_name := `IntegerFixedProofs.i32_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i32_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i32_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i32_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.i32_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i32_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i32_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i32_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.i32_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.i32_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.i32_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.i32_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.i32_switch_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i32_switch_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i32_switch_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i32_switch_signed"
run_cmd do
let theorem_name := `IntegerEncodingEncode.i32_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.i32_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.i32_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.i32_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.i32_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.i32_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.i32_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.i32_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.i32_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.i32_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.i32_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.i32_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.i64_decode_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i64_decode_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i64_decode_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i64_decode_signed"
run_cmd do
let theorem_name := `IntegerFixedProofs.i64_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i64_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i64_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i64_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.i64_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i64_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i64_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i64_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.i64_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.i64_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.i64_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.i64_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.i64_switch_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i64_switch_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i64_switch_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i64_switch_signed"
run_cmd do
let theorem_name := `IntegerEncodingEncode.i64_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.i64_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.i64_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.i64_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.i64_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.i64_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.i64_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.i64_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.i64_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.i64_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.i64_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.i64_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.i8_decode_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i8_decode_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i8_decode_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i8_decode_signed"
run_cmd do
let theorem_name := `IntegerFixedProofs.i8_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i8_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i8_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i8_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.i8_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i8_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i8_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i8_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.i8_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.i8_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.i8_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.i8_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.i8_switch_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.i8_switch_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.i8_switch_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.i8_switch_signed"
run_cmd do
let theorem_name := `IntegerEncodingEncode.i8_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.i8_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.i8_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.i8_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.i8_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.i8_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.i8_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.i8_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.i8_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.i8_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.i8_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.i8_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.isize_decode_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.isize_decode_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.isize_decode_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.isize_decode_signed"
run_cmd do
let theorem_name := `IntegerFixedProofs.isize_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.isize_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.isize_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.isize_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.isize_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.isize_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.isize_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.isize_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.isize_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.isize_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.isize_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.isize_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.isize_switch_signed
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.isize_switch_signed"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.isize_switch_signed: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.isize_switch_signed"
run_cmd do
let theorem_name := `IntegerEncodingEncode.isize_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.isize_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.isize_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.isize_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.isize_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.isize_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.isize_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.isize_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.isize_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.isize_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.isize_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.isize_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.u16_decode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u16_decode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u16_decode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u16_decode"
run_cmd do
let theorem_name := `IntegerFixedProofs.u16_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u16_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u16_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u16_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.u16_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u16_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u16_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u16_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.u16_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.u16_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.u16_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.u16_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.u16_switch
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u16_switch"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u16_switch: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u16_switch"
run_cmd do
let theorem_name := `IntegerEncodingEncode.u16_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.u16_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.u16_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.u16_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.u16_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.u16_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.u16_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.u16_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.u16_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.u16_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.u16_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.u16_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.u32_decode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u32_decode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u32_decode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u32_decode"
run_cmd do
let theorem_name := `IntegerFixedProofs.u32_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u32_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u32_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u32_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.u32_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u32_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u32_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u32_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.u32_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.u32_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.u32_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.u32_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.u32_switch
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u32_switch"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u32_switch: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u32_switch"
run_cmd do
let theorem_name := `IntegerEncodingEncode.u32_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.u32_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.u32_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.u32_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.u32_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.u32_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.u32_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.u32_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.u32_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.u32_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.u32_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.u32_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.u64_decode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u64_decode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u64_decode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u64_decode"
run_cmd do
let theorem_name := `IntegerFixedProofs.u64_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u64_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u64_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u64_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.u64_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u64_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u64_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u64_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.u64_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.u64_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.u64_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.u64_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.u64_switch
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u64_switch"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u64_switch: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u64_switch"
run_cmd do
let theorem_name := `IntegerEncodingEncode.u64_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.u64_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.u64_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.u64_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.u64_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.u64_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.u64_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.u64_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.u64_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.u64_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.u64_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.u64_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.u8_decode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u8_decode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u8_decode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u8_decode"
run_cmd do
let theorem_name := `IntegerFixedProofs.u8_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u8_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u8_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u8_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.u8_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u8_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u8_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u8_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.u8_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.u8_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.u8_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.u8_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.u8_switch
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.u8_switch"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.u8_switch: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.u8_switch"
run_cmd do
let theorem_name := `IntegerEncodingEncode.u8_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.u8_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.u8_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.u8_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.u8_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.u8_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.u8_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.u8_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.u8_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.u8_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.u8_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.u8_required_space"
run_cmd do
let theorem_name := `IntegerFixedProofs.usize_decode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.usize_decode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.usize_decode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.usize_decode"
run_cmd do
let theorem_name := `IntegerFixedProofs.usize_encode
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.usize_encode"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.usize_encode: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.usize_encode"
run_cmd do
let theorem_name := `IntegerFixedProofs.usize_light
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.usize_light"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.usize_light: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.usize_light"
run_cmd do
let theorem_name := `IntegerFixedVecProofs.usize_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedVecProofs.usize_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedVecProofs.usize_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedVecProofs.usize_total"
run_cmd do
let theorem_name := `IntegerFixedProofs.usize_switch
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerFixedProofs.usize_switch"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerFixedProofs.usize_switch: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerFixedProofs.usize_switch"
run_cmd do
let theorem_name := `IntegerEncodingEncode.usize_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingEncode.usize_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingEncode.usize_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingEncode.usize_total"
run_cmd do
let theorem_name := `IntegerEncodingVec.usize_total
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerEncodingVec.usize_total"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerEncodingVec.usize_total: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerEncodingVec.usize_total"
run_cmd do
let theorem_name := `IntegerRequiredSpace.usize_required_space
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: IntegerRequiredSpace.usize_required_space"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in IntegerRequiredSpace.usize_required_space: {ax}"
liftIO <| IO.println "proofs.rs:checked:IntegerRequiredSpace.usize_required_space"
' | lake env lean --stdinSource on GitHub · SARIF with logs (.json)
Recorded run
Completed · 80 checks passed · 0 failed
| Check | Result | Claim |
|---|---|---|
| Lean checked theorem IntegerFixedProofs.i16_decode_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #1 |
| Lean checked theorem IntegerFixedProofs.i16_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #2 |
| Lean checked theorem IntegerFixedProofs.i16_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #3 |
| Lean checked theorem IntegerFixedVecProofs.i16_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #4 |
| Lean checked theorem IntegerFixedProofs.i16_switch_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #5 |
| Lean checked theorem IntegerEncodingEncode.i16_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #6 |
| Lean checked theorem IntegerEncodingVec.i16_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #7 |
| Lean checked theorem IntegerRequiredSpace.i16_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #8 |
| Lean checked theorem IntegerFixedProofs.i32_decode_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #9 |
| Lean checked theorem IntegerFixedProofs.i32_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #10 |
| Lean checked theorem IntegerFixedProofs.i32_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #11 |
| Lean checked theorem IntegerFixedVecProofs.i32_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #12 |
| Lean checked theorem IntegerFixedProofs.i32_switch_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #13 |
| Lean checked theorem IntegerEncodingEncode.i32_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #14 |
| Lean checked theorem IntegerEncodingVec.i32_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #15 |
| Lean checked theorem IntegerRequiredSpace.i32_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #16 |
| Lean checked theorem IntegerFixedProofs.i64_decode_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #17 |
| Lean checked theorem IntegerFixedProofs.i64_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #18 |
| Lean checked theorem IntegerFixedProofs.i64_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #19 |
| Lean checked theorem IntegerFixedVecProofs.i64_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #20 |
| Lean checked theorem IntegerFixedProofs.i64_switch_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #21 |
| Lean checked theorem IntegerEncodingEncode.i64_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #22 |
| Lean checked theorem IntegerEncodingVec.i64_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #23 |
| Lean checked theorem IntegerRequiredSpace.i64_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #24 |
| Lean checked theorem IntegerFixedProofs.i8_decode_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #25 |
| Lean checked theorem IntegerFixedProofs.i8_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #26 |
| Lean checked theorem IntegerFixedProofs.i8_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #27 |
| Lean checked theorem IntegerFixedVecProofs.i8_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #28 |
| Lean checked theorem IntegerFixedProofs.i8_switch_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #29 |
| Lean checked theorem IntegerEncodingEncode.i8_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #30 |
| Lean checked theorem IntegerEncodingVec.i8_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #31 |
| Lean checked theorem IntegerRequiredSpace.i8_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #32 |
| Lean checked theorem IntegerFixedProofs.isize_decode_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #33 |
| Lean checked theorem IntegerFixedProofs.isize_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #34 |
| Lean checked theorem IntegerFixedProofs.isize_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #35 |
| Lean checked theorem IntegerFixedVecProofs.isize_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #36 |
| Lean checked theorem IntegerFixedProofs.isize_switch_signed; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #37 |
| Lean checked theorem IntegerEncodingEncode.isize_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #38 |
| Lean checked theorem IntegerEncodingVec.isize_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #39 |
| Lean checked theorem IntegerRequiredSpace.isize_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #40 |
| Lean checked theorem IntegerFixedProofs.u16_decode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #41 |
| Lean checked theorem IntegerFixedProofs.u16_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #42 |
| Lean checked theorem IntegerFixedProofs.u16_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #43 |
| Lean checked theorem IntegerFixedVecProofs.u16_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #44 |
| Lean checked theorem IntegerFixedProofs.u16_switch; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #45 |
| Lean checked theorem IntegerEncodingEncode.u16_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #46 |
| Lean checked theorem IntegerEncodingVec.u16_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #47 |
| Lean checked theorem IntegerRequiredSpace.u16_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #48 |
| Lean checked theorem IntegerFixedProofs.u32_decode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #49 |
| Lean checked theorem IntegerFixedProofs.u32_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #50 |
| Lean checked theorem IntegerFixedProofs.u32_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #51 |
| Lean checked theorem IntegerFixedVecProofs.u32_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #52 |
| Lean checked theorem IntegerFixedProofs.u32_switch; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #53 |
| Lean checked theorem IntegerEncodingEncode.u32_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #54 |
| Lean checked theorem IntegerEncodingVec.u32_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #55 |
| Lean checked theorem IntegerRequiredSpace.u32_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #56 |
| Lean checked theorem IntegerFixedProofs.u64_decode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #57 |
| Lean checked theorem IntegerFixedProofs.u64_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #58 |
| Lean checked theorem IntegerFixedProofs.u64_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #59 |
| Lean checked theorem IntegerFixedVecProofs.u64_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #60 |
| Lean checked theorem IntegerFixedProofs.u64_switch; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #61 |
| Lean checked theorem IntegerEncodingEncode.u64_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #62 |
| Lean checked theorem IntegerEncodingVec.u64_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #63 |
| Lean checked theorem IntegerRequiredSpace.u64_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #64 |
| Lean checked theorem IntegerFixedProofs.u8_decode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #65 |
| Lean checked theorem IntegerFixedProofs.u8_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #66 |
| Lean checked theorem IntegerFixedProofs.u8_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #67 |
| Lean checked theorem IntegerFixedVecProofs.u8_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #68 |
| Lean checked theorem IntegerFixedProofs.u8_switch; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #69 |
| Lean checked theorem IntegerEncodingEncode.u8_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #70 |
| Lean checked theorem IntegerEncodingVec.u8_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #71 |
| Lean checked theorem IntegerRequiredSpace.u8_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #72 |
| Lean checked theorem IntegerFixedProofs.usize_decode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #73 |
| Lean checked theorem IntegerFixedProofs.usize_encode; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #74 |
| Lean checked theorem IntegerFixedProofs.usize_light; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #75 |
| Lean checked theorem IntegerFixedVecProofs.usize_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #76 |
| Lean checked theorem IntegerFixedProofs.usize_switch; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #77 |
| Lean checked theorem IntegerEncodingEncode.usize_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #78 |
| Lean checked theorem IntegerEncodingVec.usize_total; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #79 |
| Lean checked theorem IntegerRequiredSpace.usize_required_space; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #80 |
Execution details
- Started
- 2026-10-28T12:32:38.913469+00:00
- Finished
- 2026-10-28T12:45:25.454408+00:00
- Platform
- macos aarch64
- Rust compiler
- rustc 1.91.1 (ed61e7d7e 2025-11-07) binary: rustc commit-hash: ed61e7d7e242494fb7057f2657300d9e77bb4fcb commit-date: 2025-11-07 host: aarch64-apple-darwin release: 1.91.1 LLVM version: 21.1.2
- Working directory
- integer-encoding/4.1.0/aeneas/aeneas/profiles/default/proofs
- Environment overrides
- None recorded
- Git repository
- https://github.com/keiichiw/crate-proofs
- Git commit
- ed016e12463fdae695da11060d7e0d41b8b672b0
Diagnostics & logs
=== stdout ===
⚠ [2/11] Ran aeneas:extraDep
warning: building from source; failed to fetch GitHub release (run with '-v' for details)
✔ [4/67] Built AeneasMeta.Simp.RegisterCommand (601ms)
✔ [5/67] Built Aeneas.Data.Coinductive.Effect (608ms)
✔ [6/67] Built Aeneas.Tactic.Solver.Grind.Attribute (598ms)
✔ [7/67] Built AeneasMeta.BvEnumToBitVec (982ms)
✔ [8/68] Built AeneasMeta.Simp.RegisterCommand:c.o (504ms)
✔ [11/74] Built AeneasMeta.Simp.RegisterCommand:dynlib (166ms)
✔ [12/74] Built AeneasMeta.BvEnumToBitVec:c.o (346ms)
✔ [13/78] Built AeneasMeta.BvEnumToBitVec:dynlib (144ms)
✔ [14/83] Built AeneasMeta.OptionConfig (1.6s)
✔ [15/83] Built Qq.ForLean.ToExpr (567ms)
✔ [16/83] Built Qq.ForLean.ReduceEval (700ms)
✔ [17/83] Built Qq.Typ (608ms)
✔ [18/83] Built Qq.ForLean.Do (639ms)
✔ [19/83] Built Qq.SortLocalDecls (548ms)
✔ [20/83] Built AeneasMeta.UtilsCore (2.3s)
✔ [21/87] Built Aeneas.Std.Global (2.4s)
✔ [24/92] Built AeneasMeta.UtilsCore:c.o (227ms)
✔ [25/92] Built AeneasMeta.UtilsCore:dynlib (253ms)
✔ [26/92] Built Aeneas.Tactic.Solver.Grind.Init (1.9s)
✔ [27/92] Built AeneasMeta.OptionConfig:c.o (1.1s)
✔ [28/92] Built AeneasMeta.OptionConfig:dynlib (120ms)
✔ [29/92] Built Batteries.Util.LibraryNote (666ms)
✔ [32/98] Built Batteries.CodeAction.Deprecated (851ms)
✔ [33/101] Built Batteries.Tactic.Lint.Basic (831ms)
✔ [34/101] Built Aeneas.Data.Coinductive.CoInd (3.2s)
✔ [35/102] Built ImportGraph.Lean.Syntax (512ms)
✔ [36/102] Built ImportGraph.Lean.MessageData (530ms)
✔ [37/105] Built ImportGraph.Lean.EnvExtension (522ms)
✔ [38/105] Built ImportGraph.Shake.Core (781ms)
✔ [39/105] Built Batteries.Tactic.Lint.Misc (1.1s)
✔ [40/106] Built ImportGraph.Shake.EnvExtension (1.1s)
✔ [41/114] Built Batteries.Tactic.HelpCmd (2.1s)
✔ [42/114] Built ImportGraph.Util.Modules (1.2s)
✔ [43/115] Built Aeneas.Data.Coinductive.ITree (1.8s)
✔ [44/116] Built ImportGraph.Lean.Json (1.7s)
✔ [45/117] Built Batteries.Tactic.Alias (2.5s)
✔ [46/119] Built ImportGraph.Imports.ImportGraph (976ms)
✔ [47/120] Built ImportGraph.Lean.Environment (986ms)
✔ [48/120] Built ImportGraph.Imports.Pretty (2.8s)
✔ [49/120] Built ImportGraph.Shake.Basic (2.0s)
✔ [50/120] Built ImportGraph.Graph.TransitiveClosure (991ms)
✔ [51/120] Built ImportGraph.WorkspaceModel.Base (1.4s)
✔ [52/120] Built Qq.Macro (5.0s)
✔ [53/122] Built ImportGraph.Widget.Collapsible (1.5s)
✔ [54/122] Built ImportGraph.Imports.RequiredModules (1.2s)
✔ [55/122] Built ImportGraph.Widget.Copy (1.5s)
✔ [56/122] Built ImportGraph.Tools.ImportDiff (1.5s)
✔ [57/131] Built ImportGraph.Shake.Algebra (1.6s)
✔ [58/131] Built ImportGraph.Widget.GoToModule (1.9s)
✔ [59/132] Built ImportGraph.WorkspaceModel.Summary.Core (1.3s)
✔ [60/134] Built ImportGraph.WorkspaceModel.Model (1.5s)
✔ [61/136] Built ImportGraph.Imports.Redundant (989ms)
✔ [62/140] Built Qq.Commands (1.6s)
✔ [63/141] Built Qq.Delab (1.6s)
✔ [64/141] Built ImportGraph.WorkspaceModel.Summary.Cache (765ms)
✔ [65/152] Built ImportGraph.Imports.FromSource (1.2s)
✔ [66/152] Built Batteries.Lean.Position (759ms)
✔ [67/154] Built ImportGraph.WorkspaceModel.Summary.Get (860ms)
✔ [68/155] Built ImportGraph.Tools.RedundantImports (1.5s)
✔ [69/155] Built Mathlib.Tactic.Linter.DirectoryDependency (2.2s)
✔ [70/162] Built ImportGraph.Tools.MinImports (1.5s)
✔ [71/171] Built Batteries.Tactic.Lint.TypeClass (1.3s)
✔ [72/172] Built Qq.MetaM (1.7s)
✔ [73/172] Built Batteries.Util.ProofWanted (6.0s)
✔ [74/172] Built ImportGraph.WorkspaceModel.Summary (962ms)
✔ [75/179] Built Batteries.Tactic.Lint.Simp (2.4s)
✔ [76/179] Built Batteries.Lean.Meta.Inaccessible (1.0s)
✔ [77/180] Built ImportGraph.Shake.DeclNeeds (5.5s)
✔ [78/180] Built Batteries.Tactic.Unreachable (1.4s)
✔ [79/180] Built Qq.MatchImpl (1.4s)
✔ [80/180] Built AeneasMeta.Utils (9.8s)
✔ [81/184] Built Qq.Simp (1.4s)
✔ [82/184] Built Qq.AssertInstancesCommute (1.9s)
✔ [83/187] Built Aeneas.Data.Coinductive.ITreeWP.EffectWP (879ms)
✔ [84/189] Built Mathlib.Tactic.Linter.Header (2.6s)
✔ [85/189] Built Batteries.Tactic.Lint.Frontend (2.8s)
✔ [86/190] Built ImportGraph.WorkspaceModel.Build (1.5s)
✔ [87/190] Built Batteries.Lean.NameMapAttribute (1.1s)
✔ [88/190] Built Batteries.Logic (1.4s)
✔ [89/190] Built Batteries.Tactic.Lint (1.3s)
✔ [90/190] Built Aeneas.Tactic.Step.Trace (2.5s)
✔ [91/190] Built Mathlib.Tactic.TypeStar (1.4s)
✔ [92/190] Built Mathlib.Util.CodeActions.BinderPlicity (1.7s)
✔ [93/190] Built ImportGraph.Shake.Environment (3.2s)
✔ [94/190] Built Mathlib.Util.ParseCommand (1.4s)
✔ [95/190] Built Mathlib.Lean.Elab.Tactic.Meta (1.3s)
✔ [96/190] Built Mathlib.Tactic.Linter.TacticDocumentation (1.4s)
✔ [97/190] Built Mathlib.Tactic.Linter.UnusedTacticExtension (1.5s)
✔ [98/190] Built Batteries.Tactic.Trans (3.4s)
✔ [99/190] Built Mathlib.Tactic.MinImports (2.1s)
✔ [100/190] Built Mathlib.Tactic.Linter.PrivateModule (1.5s)
✔ [101/190] Built Mathlib.Tactic.Linter.OldObtain (1.4s)
✔ [102/190] Built Mathlib.Tactic.Linter.Whitespace (2.5s)
✔ [103/190] Built Mathlib.Tactic.Linter.Multigoal (1.9s)
✔ [104/190] Built Mathlib.Tactic.Linter.InternalConstructor (1.5s)
✔ [105/190] Built Mathlib.Tactic.DeclarationNames (1.6s)
✔ [106/190] Built Mathlib.Tactic.Linter.HaveILetI (1.7s)
✔ [107/190] Built Mathlib.Tactic.Linter.HashCommandLinter (1.9s)
✔ [108/190] Built Mathlib.Tactic.Linter.EmptyLine (1.8s)
✔ [109/190] Built Qq.Match (6.2s)
✔ [110/190] Built Mathlib.Tactic.Linter.DocString (2.2s)
✔ [111/190] Built Mathlib.Lean.Environment (1.3s)
✔ [112/196] Built Mathlib.Lean.Expr.Basic (1.7s)
✔ [113/196] Built Mathlib.Tactic.Linter.DeprecatedSyntaxLinter (1.8s)
✔ [114/196] Built Mathlib.Tactic.Linter.AuxLemma (1.4s)
✔ [115/196] Built Mathlib.Tactic.Linter.DocPrime (2.6s)
✔ [116/196] Built Mathlib.Tactic.Lemma (1.5s)
✔ [117/196] Built Mathlib.Tactic.AdaptationNote (1.5s)
✔ [118/196] Built Mathlib.Tactic.Linter.FlexibleLinter (3.7s)
✔ [119/196] Built Mathlib.Lean.Linter (1.4s)
✔ [120/196] Built Mathlib.Util.CodeActions (1.2s)
✔ [121/219] Built ImportGraph.Tools.NormImports (1.5s)
✔ [122/221] Built Mathlib.Lean.ContextInfo (1.5s)
✔ [123/223] Built Qq (1.0s)
✔ [124/238] Built Mathlib.Tactic.Linter.UnusedTactic (1.7s)
✔ [125/251] Built Mathlib.Tactic.Linter.Lint (1.6s)
✔ [126/251] Built Mathlib.Tactic.ExtractGoal (1.7s)
✔ [127/255] Built ImportGraph.Shake.Workspace (2.7s)
✔ [128/255] Built Mathlib.Lean.Elab.InfoTree (1.4s)
✔ [129/260] Built Batteries.Lean.Syntax (729ms)
✔ [130/260] Built Batteries.Tactic.Init (1.9s)
✔ [131/260] Built Batteries.Util.ExtendedBinder (1.3s)
✔ [132/260] Built Batteries.Lean.Expr (1.2s)
✔ [133/264] Built Mathlib.Tactic.TacticAnalysis (1.9s)
✔ [136/272] Built Batteries.Linter.UnreachableTactic (1.5s)
✔ [137/272] Built Mathlib.Tactic.Linter.UnusedInstancesInType (1.8s)
✔ [138/273] Built Mathlib.Tactic.Linter.Style (3.5s)
✔ [139/273] Built Batteries.Control.Lemmas (931ms)
✔ [140/273] Built Aesop.Script.Tactic (1.1s)
✔ [141/281] Built Aesop.Script.GoalWithMVars (1.2s)
✔ [142/281] Built Aesop.Nanos (1.0s)
✔ [143/284] Built Aesop.Index.DiscrTreeConfig (719ms)
✔ [144/285] Built Batteries.Lean.MonadBacktrack (723ms)
✔ [145/286] Built ImportGraph.Tools.FindHome (3.1s)
✔ [146/286] Built Aesop.Check (968ms)
✔ [147/289] Built Batteries.Control.AlternativeMonad (1.4s)
✔ [148/296] Built Batteries.Data.Array.Merge (2.2s)
✔ [149/296] Built Batteries.Tactic.PermuteGoals (1.7s)
✔ [150/296] Built Aesop.Rule.Name (1.2s)
✔ [151/296] Built Aesop.Options.Public (1.0s)
✔ [152/296] Built Mathlib.Tactic.Linter.OverlappingInstances (2.6s)
✔ [153/296] Built Aesop.Forward.PremiseIndex (771ms)
✔ [154/303] Built ImportGraph.Tools (1.5s)
✔ [155/303] Built Batteries.Lean.Meta.Basic (1.1s)
✔ [156/303] Built Aesop.Forward.LevelIndex (1.1s)
✔ [157/303] Built Aesop.Util.UnorderedArraySet (1.3s)
✔ [158/303] Built Aesop.Script.OptimizeSyntax (1.6s)
✔ [159/303] Built Aesop.Percent (1.0s)
✔ [160/308] Built Aesop.Options.Internal (835ms)
✔ [161/316] Built Mathlib.Tactic.TacticAnalysis.Declarations (4.4s)
✔ [162/319] Built Aesop.Forward.SlotIndex (870ms)
✔ [163/322] Built Batteries.Lean.Meta.SavedState (1.0s)
✔ [164/325] Built Mathlib.Tactic.Linter.DeclType (1.4s)
✔ [165/325] Built Aesop.Util.UnionFind (1.0s)
✔ [166/329] Built Aesop.Script.TacticState (1.3s)
✔ [167/329] Built Batteries.Lean.TagAttribute (851ms)
✔ [168/332] Built Aesop.RuleTac.RuleTerm (947ms)
✔ [169/334] Built Batteries.Tactic.SeqFocus (1.4s)
✔ [170/338] Built Aesop.Util.Tactic (946ms)
✔ [171/343] Built Batteries.Lean.AttributeExtra (1.1s)
✔ [172/343] Built Aesop.ElabM (1.2s)
✔ [173/344] Built Aesop.Util.Unfold (1.2s)
✔ [174/344] Built Batteries.Lean.Meta.UnusedNames (1.0s)
✔ [175/344] Built Aesop.Constants (842ms)
✔ [176/346] Built Aesop.Util.OrderedHashSet (843ms)
✔ [177/347] Built Mathlib.Init (1.0s)
✔ [178/347] Built Batteries.Lean.Meta.Expr (967ms)
✔ [179/347] Built Batteries.Lean.PersistentHashMap (856ms)
✔ [180/347] Built Aesop.RuleTac.ElabRuleTerm (1.5s)
✔ [181/347] Built Aesop.Util.Basic (3.7s)
✔ [182/347] Built Batteries.Lean.Meta.InstantiateMVars (1.0s)
✔ [183/347] Built Batteries.Lean.PersistentHashSet (957ms)
✔ [184/347] Built Aesop.Util.Tactic.Unfold (1.4s)
✔ [185/347] Built Batteries.Linter.UnnecessarySeqFocus (2.1s)
✔ [186/347] Built Aesop.Util.EqualUpToIds (5.1s)
✔ [187/347] Built Mathlib.Util.WithWeakNamespace (1.8s)
✔ [188/347] Built Mathlib.Lean.Elab.Term (1.8s)
✔ [189/347] Built Mathlib.Tactic.Core (2.3s)
✔ [190/347] Built Mathlib.Tactic.Inhabit (1.8s)
✔ [191/347] Built AeneasMeta.Utils:c.o (20s)
✔ [192/347] Built Mathlib.Tactic.SimpRw (2.3s)
✔ [193/347] Built Mathlib.Tactic.ExtendDoc (2.2s)
✔ [194/347] Built Mathlib.Lean.PrettyPrinter.Delaborator (1.0s)
✔ [195/347] Built Mathlib.Tactic.Use (2.0s)
✔ [196/347] Built Mathlib.Basic.Nonempty (2.0s)
✔ [197/347] Built Mathlib.Basic.IsEmpty.Defs (1.0s)
✔ [198/347] Built Mathlib.Tactic.OfNat (1.9s)
✔ [199/347] Built Mathlib.Basic.ExistsUnique (2.4s)
✔ [200/347] Built Mathlib.Data.Int.Notation (1.9s)
✔ [201/347] Built Mathlib.Tactic.Attr.Register (2.6s)
✔ [202/347] Built Mathlib.Tactic.Simproc.ExistsAndEq (4.0s)
✔ [203/347] Built Mathlib.Data.Nat.Notation (1.9s)
✔ [204/347] Built Mathlib.Tactic.Push.Attr (2.4s)
✔ [205/347] Built Mathlib.Data.Nat.BinaryRec (2.2s)
✔ [206/347] Built Mathlib.Tactic.CrossRefAttribute (3.4s)
✔ [207/347] Built Mathlib.Lean.Meta (2.2s)
✔ [208/347] Built Mathlib.Tactic.Simps.NotationClass (2.4s)
✔ [209/347] Built AeneasMeta.Utils:dynlib (220ms)
✔ [210/347] Built Mathlib.Tactic.Eqns (2.0s)
✔ [211/347] Built Mathlib.Util.AddRelatedDecl (3.2s)
✔ [212/347] Built Mathlib.Tactic.Translate.Attributes (1.0s)
✔ [213/347] Built Mathlib.Data.String.Defs (2.1s)
✔ [214/347] Built Batteries.Lean.Meta.DiscrTree (1.0s)
✔ [215/347] Built Mathlib.Tactic.Translate.UnfoldBoundary (3.3s)
✔ [216/347] Built Mathlib.Lean.Name (2.3s)
✔ [217/347] Built Mathlib.Lean.Meta.Simp (2.2s)
✔ [218/349] Built Aesop.RuleTac.Forward.Basic (1.6s)
✔ [219/351] Built Aesop.Script.CtorNames (1.6s)
✔ [220/351] Built Aesop.EMap (1.9s)
✔ [221/351] Built Batteries.Linter (1.4s)
✔ [222/351] Built Aesop.Script.Util (1.5s)
✔ [223/351] Built Aesop.Tracing (2.1s)
✔ [224/351] Built Aesop.Forward.Substitution (2.3s)
✔ [225/351] Built Mathlib.Tactic.Translate.Reorder (5.0s)
✔ [226/351] Built Mathlib.Basic.Nontrivial.Defs (2.1s)
✔ [227/351] Built Mathlib.Logic.Function.Defs (2.6s)
✔ [228/354] Built Mathlib.Tactic.SplitIfs (2.0s)
✔ [229/354] Built AeneasMeta.Extensions (2.9s)
✔ [230/354] Built Aesop.RuleSet.Name (1.0s)
✔ [231/354] Built AeneasMeta.Async.Async (3.3s)
✔ [232/354] Built Mathlib.Tactic.ScopedNS (4.3s)
✔ [233/354] Built Mathlib.Tactic.Translate.GuessName (3.1s)
✔ [234/354] Built Batteries.Tactic.Basic (1.5s)
✔ [235/355] Built AeneasMeta.Simp.Simp (3.9s)
✔ [236/355] Built Aesop.Script.Step (2.1s)
✔ [237/355] Built AeneasMeta.Extensions:c.o (529ms)
✔ [238/355] Built Mathlib.Tactic.MkIffOfInductiveProp (3.0s)
✔ [239/355] Built Aesop.RulePattern.Cache (1.6s)
✔ [240/355] Built Aesop.Util.Tactic.Ext (1.0s)
✔ [241/355] Built Aesop.Index.Basic (1.6s)
✔ [242/355] Built Mathlib.Basic.Logic.Basic (4.1s)
✔ [243/357] Built AeneasMeta.Extensions:dynlib (175ms)
✔ [244/357] Built Mathlib.Logic.Relator (2.2s)
✔ [245/357] Built Aesop.Stats.Basic (2.6s)
✔ [246/358] Built Aesop.RuleSet.Filter (1.4s)
✔ [247/358] Built AeneasMeta.Async.Async:c.o (1.9s)
✔ [248/359] Built Batteries.Classes.Order (1.8s)
✔ [249/359] Built AeneasMeta.Async.Async:dynlib (190ms)
✔ [250/359] Built Aesop.Script.UScript (1.5s)
✔ [251/359] Built Aesop.BaseM (1.4s)
✔ [252/360] Built Aesop.Script.SScript (1.7s)
✔ [253/360] Built AeneasMeta.Simp.Simp:c.o (3.6s)
✔ [254/361] Built Mathlib.Tactic.SetNotationForOrder (3.4s)
✔ [255/361] Built Batteries.Lean.HashSet (993ms)
✔ [256/363] Built AeneasMeta.Simp.Simp:dynlib (173ms)
✔ [257/363] Built Aesop.Script.Check (1.7s)
✔ [258/363] Built Aesop.Script.ScriptM (1.5s)
✔ [259/365] Built Batteries.Data.UInt (2.2s)
✔ [260/367] Built Mathlib.Tactic.Simps.Basic (8.0s)
✔ [261/369] Built Mathlib.Tactic.Translate.Expr (5.2s)
✔ [262/369] Built Aesop.RuleTac.GoalDiff (2.4s)
✔ [263/370] Built Aesop.Script.UScriptToSScript (2.4s)
✔ [264/372] Built Aesop.RulePattern (3.1s)
✔ [265/372] Built Aesop.Search.Expansion.Simp (1.4s)
✔ [266/374] Built AeneasMeta.Saturate.Attribute (5.7s)
✔ [267/375] Built Aesop.RuleTac.Basic (1.9s)
✔ [268/375] Built Mathlib.Tactic.Simps (2.6s)
✔ [269/376] Built Aesop.Script.SpecificTactics (3.9s)
✔ [270/377] Built AeneasMeta.Simp.SimpAllAssumptions (4.2s)
✔ [271/377] Built Aesop.Script.StructureStatic (2.2s)
✔ [272/377] Built Aesop.Exception (1.1s)
✔ [273/377] Built Aesop.Index.RulePattern (1.6s)
✔ [274/377] Built Aesop.Search.Expansion.Basic (1.3s)
✔ [275/378] Built Aesop.Script.StructureDynamic (3.1s)
✔ [276/384] Built Aesop.RuleTac.Tactic (1.5s)
✔ [277/398] Built Aesop.RuleTac.Apply (1.4s)
✔ [278/400] Built Batteries.Data.Array.Basic (5.6s)
✔ [279/400] Built Aesop.RuleTac.Preprocess (1.2s)
✔ [280/401] Built Batteries.Control.ForInStep.Basic (786ms)
✔ [281/404] Built Aesop.RuleTac.Cases (1.7s)
✔ [282/421] Built Aesop.Script.Main (1.4s)
✔ [283/421] Built AeneasMeta.Simp.SimpAllAssumptions:c.o (2.8s)
✔ [284/421] Built Aesop.Stats.Extension (1.1s)
✔ [285/421] Built AeneasMeta.Simp.SimpAllAssumptions:dynlib (170ms)
✔ [286/434] Built Aesop.Stats.File (1.3s)
✔ [287/440] Built Aesop.Frontend.Basic (990ms)
✔ [288/443] Built Mathlib.Util.Notation3 (12s)
✔ [289/446] Built Aesop.Forward.RuleInfo (2.1s)
✔ [290/446] Built AeneasMeta.Saturate.Attribute:c.o (5.6s)
✔ [291/446] Built Aesop.Stats.Report (1.6s)
✔ [292/446] Built AeneasMeta.Saturate.Attribute:dynlib (165ms)
✔ [293/446] Built Mathlib.Tactic.Spread (2.3s)
✔ [294/449] Built Aesop.Rule.Forward (1.3s)
✔ [295/451] Built AeneasMeta.Simp (3.2s)
✔ [296/451] Built Mathlib.Tactic.Conv (2.7s)
✔ [297/451] Built Mathlib.Tactic.Attr.Core (2.1s)
✔ [298/454] Built AeneasMeta.Simp:c.o (205ms)
✔ [299/454] Built AeneasMeta.Simp:dynlib (159ms)
✔ [300/454] Built Mathlib.Tactic.Lift (2.5s)
✔ [301/458] Built Mathlib.Tactic.Subsingleton (2.3s)
✔ [302/459] Built Aesop.Forward.Match.Types (1.5s)
✔ [303/462] Built Mathlib.Util.AtLocation (1.0s)
✔ [304/462] Built Aesop.RuleTac.Descr (1.1s)
✔ [305/462] Built Mathlib.Tactic.DepRewrite (6.0s)
✔ [306/462] Built Mathlib.Tactic.Relation.Rfl (1.0s)
✔ [307/463] Built Mathlib.Util.CompileInductive (2.9s)
✔ [308/463] Built Aesop.Index.Forward (1.5s)
✔ [309/468] Built Mathlib.Lean.Meta.CongrTheorems (3.3s)
✔ [310/468] Built Mathlib.Control.Combinators (1.9s)
✔ [311/468] Built Mathlib.Tactic.Translate.Core (13s)
✔ [312/468] Built Aesop.Rule.Basic (1.3s)
✔ [313/468] Built Batteries.Data.BinomialHeap.Basic (8.3s)
✔ [314/468] Built Mathlib.Data.Option.Defs (1.9s)
✔ [315/468] Built AeneasMeta.Async.TestTactics (4.5s)
✔ [316/468] Built Mathlib.Tactic.Coe (2.1s)
✔ [317/471] Built Mathlib.Data.Int.Init (2.8s)
✔ [318/473] Built Aesop.Rule (1.6s)
✔ [319/473] Built Aesop.Index (2.3s)
✔ [320/473] Built AeneasMeta.Async.TestTactics:c.o (1.2s)
✔ [321/473] Built Mathlib.Tactic.Translate.ToAdditive (2.7s)
✔ [322/473] Built Mathlib.Tactic.Push (4.3s)
✔ [323/473] Built Mathlib.Tactic.Translate.TagUnfoldBoundary (2.9s)
✔ [324/473] Built AeneasMeta.Async.TestTactics:dynlib (248ms)
✔ [325/473] Built Mathlib.Data.Ordering.Basic (1.0s)
✔ [326/475] Built Aesop.Tree.UnsafeQueue (1.6s)
✔ [327/476] Built Aesop.RuleSet.Member (1.9s)
✔ [328/478] Built Mathlib.Tactic.CongrExclamation (5.3s)
✔ [329/478] Built Aesop.Forward.Match (2.9s)
✔ [330/478] Built Batteries.Data.Except (891ms)
✔ [331/478] Built Mathlib.Tactic.ToAdditive (2.2s)
✔ [332/478] Built Mathlib.Tactic.Contrapose (2.6s)
✔ [333/478] Built Mathlib.Tactic.TermCongr (5.8s)
✔ [334/478] Built AeneasMeta.Saturate.Tactic (10s)
✔ [335/480] Built Mathlib.Tactic.FastInstance (3.6s)
✔ [336/480] Built Batteries.Tactic.Exact (1.3s)
✔ [337/480] Built Aesop.Builder.Basic (1.5s)
✔ [338/480] Built Aesop.Tree.Data.ForwardRuleMatches (1.4s)
✔ [339/480] Built Mathlib.Tactic.Translate.ToDual (3.1s)
✔ [340/480] Built Mathlib.Tactic.GCongr.ForwardAttr (2.3s)
✔ [341/487] Built Batteries.Lean.Except (1.1s)
✔ [342/487] Built Aesop.Builder.Unfold (1.5s)
✔ [343/487] Built Aesop.RuleTac.Forward (3.2s)
✔ [344/487] Built Batteries.Data.MLList.Basic (1.9s)
✔ [345/487] Built Mathlib.Algebra.Regular.Defs (2.3s)
✔ [346/487] Built Mathlib.Algebra.Notation.Defs (2.7s)
✔ [347/487] Built Mathlib.Tactic.Convert (4.3s)
✔ [348/487] Built Aesop.Builder.Forward (2.7s)
✔ [349/487] Built Aesop.Builder.Apply (1.7s)
✔ [350/487] Built Aesop.Builder.Tactic (1.6s)
✔ [351/487] Built Aesop.Builder.Constructors (1.6s)
✔ [352/487] Built Aesop.Builder.NormSimp (1.8s)
✔ [353/487] Built Aesop.Builder.Cases (1.7s)
✔ [354/490] Built Aesop.RuleTac (1.5s)
✔ [355/490] Built Batteries.Control.Nondet.Basic (1.8s)
✔ [356/491] Built Mathlib.Tactic.PPWithUniv (2.7s)
✔ [357/493] Built Mathlib.Tactic.ToDual (2.0s)
✔ [358/493] Built Aesop.Builder.Default (1.6s)
✔ [359/493] Built Mathlib.Algebra.Notation.Pi.Defs (3.1s)
✔ [360/493] Built Mathlib.Logic.Function.ULift (1.0s)
✔ [361/493] Built Mathlib.Algebra.Group.Semigroup (4.2s)
✔ [362/493] Built Aesop.RuleSet (5.7s)
✔ [363/494] Built Mathlib.Tactic.ByCases (2.7s)
✔ [364/495] Built Aesop.Forward.State (9.8s)
✔ [365/495] Built Mathlib.Tactic.Basic (2.8s)
✔ [366/495] Built Mathlib.Order.Notation (3.6s)
✔ [367/495] Built Mathlib.Order.Defs.Prop (2.5s)
✔ [368/495] Built Aesop.Frontend.Extension.Init (1.4s)
✔ [369/495] Built Mathlib.Order.Defs.PartialOrder (3.7s)
✔ [370/495] Built Mathlib.Tactic.Basify.Attr (3.3s)
✔ [371/495] Built Mathlib.Data.Set.Defs (4.3s)
✔ [372/499] Built Aesop.Forward.State.Initial (1.7s)
✔ [373/499] Built Aesop.Forward.State.ApplyGoalDiff (1.9s)
✔ [374/505] Built Aesop.Frontend.Extension (2.6s)
✔ [375/505] Built Aesop.Frontend.RuleExpr (5.6s)
✔ [376/505] Built Mathlib.Tactic.Hint (3.6s)
✔ [377/505] Built Aesop.Tree.Data (4.2s)
✔ [378/508] Built Mathlib.Algebra.Group.Monoid (6.5s)
✔ [379/508] Built Mathlib.Order.Defs.LinearOrder (3.9s)
✔ [380/508] Built Batteries.Data.Nat.Basic (1.5s)
✔ [381/508] Built Mathlib.Order.Defs.Unbundled (3.6s)
✔ [382/508] Built Aesop.Frontend.Attribute (2.2s)
✔ [383/511] Built Aesop.Tree.Traversal (1.4s)
✔ [384/511] Built Aesop.Search.Queue.Class (1.6s)
✔ [385/511] Built Aesop.Tree.TreeM (2.2s)
✔ [386/511] Built Aesop.Tree.RunMetaM (1.8s)
✔ [387/511] Built Aesop.Frontend.Tactic (2.9s)
✔ [388/511] Built Aesop.Frontend.Command (3.4s)
✔ [389/511] Built Batteries.Data.Nat.Lemmas (1.5s)
✔ [390/511] Built Mathlib.Tactic.ToExpr (2.5s)
✔ [391/511] Built Mathlib.Data.Int.Order.Basic (2.6s)
✔ [392/511] Built Mathlib.Data.Bool.Basic (3.2s)
✔ [393/511] Built Mathlib.Algebra.Group.DivInvMonoid (4.3s)
✔ [394/511] Built Aesop.BuiltinRules.Subst (2.4s)
✔ [395/511] Built Aesop.BuiltinRules.Split (2.1s)
✔ [396/511] Built Aesop.Saturate (9.9s)
✔ [397/511] Built Aesop.BuiltinRules.Rfl (2.1s)
✔ [398/511] Built Mathlib.Logic.Relation (5.3s)
✔ [399/511] Built Aesop.BuiltinRules.Intros (2.1s)
✔ [400/513] Built Aesop.BuiltinRules.Ext (1.0s)
✔ [401/513] Built Mathlib.Logic.Function.Basic (5.0s)
✔ [402/513] Built Aesop.BuiltinRules.ApplyHyps (2.1s)
✔ [403/520] Built Aesop.Tree.State (1.7s)
✔ [404/520] Built Aesop.BuiltinRules.DestructProducts (2.6s)
✔ [405/520] Built Aesop.BuiltinRules.Assumption (2.7s)
✔ [406/520] Built Mathlib.Data.Set.CoeSort (2.6s)
✔ [407/520] Built Aesop.Search.Queue (1.9s)
✔ [408/520] Built Aesop.Search.SearchM (1.6s)
✔ [409/520] Built Aesop.Tree.Free (1.5s)
✔ [410/520] Built Aesop.Tree.Stats (1.7s)
✔ [411/520] Built Aesop.Tree.Tracing (2.6s)
✔ [412/520] Built Aesop.Forward.State.UpdateGoal (1.4s)
✔ [413/522] Built Mathlib.Tactic.GCongr.Core (9.6s)
✔ [414/522] Built Aesop.Tree.ExtractProof (2.2s)
✔ [415/522] Built Aesop.Tree.ExtractScript (2.6s)
✔ [416/522] Built Mathlib.Algebra.Group.Defs (3.2s)
✔ [417/522] Built AeneasMeta.Saturate.Tactic:c.o (30s)
✔ [418/522] Built Aesop.Tree.AddRapp (4.1s)
✔ [419/522] Built Aesop.Frontend.Saturate (3.3s)
✔ [420/522] Built Mathlib.Data.Nat.Init (4.1s)
✔ [421/522] Built Mathlib.Logic.Pairwise (2.9s)
✔ [422/522] Built Mathlib.Basic.IsEmpty.Basic (3.0s)
✔ [423/522] Built Mathlib.Tactic.FBinop (4.4s)
✔ [424/522] Built Mathlib.Algebra.Notation.Pi.Basic (3.1s)
✔ [426/522] Built Aesop.Tree.Check (1.9s)
✔ [427/522] Built Mathlib.Basic.Unique (2.4s)
✔ [428/522] Built Aesop.Search.RuleSelection (1.7s)
✔ [429/522] Built Aesop.BuiltinRules (2.0s)
✔ [430/522] Built AeneasMeta.Saturate.Tactic:dynlib (202ms)
✔ [431/522] Built Mathlib.Data.Subtype (2.8s)
✔ [433/522] Built Mathlib.Logic.Function.Conjugate (2.9s)
✔ [434/522] Built Mathlib.Data.Sigma.Basic (3.2s)
✔ [435/522] Built Mathlib.Data.Sum.Basic (3.3s)
✔ [436/522] Built Mathlib.Tactic.Choose (4.0s)
✔ [437/522] Built Mathlib.Tactic.GCongr (2.4s)
✔ [438/522] Built Aesop.Frontend (1.9s)
✔ [439/523] Built Mathlib.Algebra.Group.Semiconj.Defs (2.4s)
✔ [440/523] Built Mathlib.Basic.SProd (2.2s)
✔ [441/523] Built Mathlib.Basic.FunLike.Basic (2.7s)
✔ [442/524] Built Mathlib.Data.Quot (3.7s)
✔ [443/524] Built Mathlib.Logic.Function.Iterate (2.0s)
✔ [444/524] Built AeneasMeta.Saturate (4.0s)
✔ [445/524] Built Mathlib.Tactic.Finiteness.Attr (2.2s)
✔ [446/524] Built Mathlib.Data.Nat.Basic (2.9s)
✔ [447/525] Built AeneasMeta.Saturate:c.o (202ms)
✔ [448/525] Built Mathlib.Algebra.Group.InjSurj (6.6s)
✔ [449/527] Built Aesop.Search.Expansion.Norm (5.2s)
✔ [450/528] Built AeneasMeta.Saturate:dynlib (158ms)
✔ [451/528] Built Mathlib.Algebra.Group.Pi.Basic (4.8s)
✔ [452/528] Built Plausible.Random (1.5s)
✔ [453/531] Built Mathlib.Tactic.GRewrite.Core (8.4s)
✔ [454/531] Built Plausible.Shrinkable (1.3s)
✔ [455/533] Built Mathlib.Basic.FunLike.Embedding (2.4s)
✔ [456/533] Built Mathlib.Algebra.Group.Commute.Defs (3.4s)
✔ [457/536] Built Plausible.Attr (1.3s)
✔ [458/536] Built Mathlib.Data.Prod.Basic (2.8s)
✔ [459/537] Built Plausible.Gen (1.9s)
✔ [460/537] Built Mathlib.Order.Basic (7.3s)
✔ [461/537] Built Aesop.Search.Expansion (3.4s)
✔ [462/538] Built Mathlib.Basic.FunLike.Equiv (2.5s)
✔ [463/539] Built Plausible.Arbitrary (1.4s)
✔ [464/539] Built Batteries.Tactic.Case (2.9s)
✔ [465/540] Built Mathlib.Tactic.GRewrite.Elab (4.3s)
✔ [466/540] Built Mathlib.Algebra.Notation.Prod (3.2s)
✔ [467/540] Built Plausible.DeriveShrinkable (3.6s)
✔ [468/540] Built Plausible.ArbitraryFueled (904ms)
✔ [469/545] Built Mathlib.Order.ULift (2.6s)
✔ [470/545] Built Aesop.Search.ExpandSafePrefix (2.1s)
✔ [471/545] Built Batteries.CodeAction.Attr (1.9s)
✔ [472/545] Built Plausible.Sampleable (1.9s)
✔ [474/545] Built Mathlib.Algebra.Group.Units.Defs (6.4s)
✔ [475/545] Built Batteries.Tactic.GeneralizeProofs (5.6s)
✔ [477/545] Built Mathlib.Tactic.GRewrite (2.8s)
✔ [478/546] Built Mathlib.Algebra.Group.Hom.Defs (10s)
✔ [479/547] Built Plausible.Functions (1.0s)
✔ [480/553] Built Plausible.DeriveArbitrary (3.0s)
✔ [481/553] Built Batteries.CodeAction.Basic (2.7s)
✔ [482/554] Built LeanSearchClient.Basic (1.3s)
✔ [483/554] Built Aesop.Search.Main (5.4s)
✔ [484/555] Built Mathlib.Logic.Equiv.Defs (8.0s)
✔ [485/555] Built Mathlib.Tactic.ApplyCongr (3.2s)
✔ [486/555] Built Mathlib.Lean.Meta.Basic (2.0s)
✔ [487/556] Built Batteries.CodeAction.Misc (6.1s)
✔ [488/556] Built Plausible.Testable (4.6s)
✔ [489/556] Built Batteries.Data.List.Basic (6.9s)
✔ [490/556] Built Mathlib.Order.Defs.Lattice (4.7s)
✔ [491/556] Built Mathlib.Tactic.ApplyWith (3.1s)
✔ [492/557] Built Aesop.Main (2.4s)
✔ [493/557] Built LeanSearchClient.Syntax (3.6s)
✔ [494/557] Built Mathlib.Tactic.ByContra (2.9s)
✔ [495/557] Built Mathlib.Control.EquivFunctor (2.8s)
✔ [496/558] Built Mathlib.Order.OrderDual (3.9s)
✔ [497/558] Built Mathlib.Tactic.CasesM (3.2s)
✔ [498/558] Built Mathlib.Algebra.Opposites (4.3s)
✔ [499/558] Built Plausible.Tactic (2.0s)
✔ [500/559] Built Mathlib.Tactic.ApplyAt (3.1s)
✔ [501/559] Built Batteries.CodeAction.Match (2.0s)
✔ [502/559] Built Mathlib.Tactic.Check (3.3s)
✔ [503/559] Built Aesop (2.4s)
✔ [504/559] Built Mathlib.Logic.Equiv.Prod (5.9s)
✔ [505/559] Built Mathlib.Tactic.ClearExclamation (2.8s)
✔ [506/560] Built LeanSearchClient.LoogleSyntax (3.4s)
✔ [507/560] Built Mathlib.Algebra.Group.Equiv.Defs (8.4s)
✔ [508/560] Built Plausible (2.0s)
✔ [509/560] Built Mathlib.Data.Set.Operations (5.1s)
✔ [510/561] Built Mathlib.Order.Compare (3.5s)
✔ [511/561] Built Mathlib.Tactic.ClearExcept (2.9s)
✔ [512/561] Built Mathlib.Tactic.Clear_ (2.6s)
✔ [513/561] Built Mathlib.Order.Max (4.8s)
✔ [514/561] Built Batteries.CodeAction (2.4s)
✔ [515/562] Built Mathlib.Order.RelClasses (5.4s)
✔ [516/564] Built LeanSearchClient (1.9s)
✔ [517/567] Built Mathlib.Data.Option.Basic (3.9s)
✔ [518/576] Built Mathlib.Lean.GoalsLocation (3.0s)
✔ [523/579] Built Mathlib.Lean.Meta.KAbstractPositions (2.6s)
✔ [528/584] Built Mathlib.Lean.FoldEnvironment (3.1s)
✔ [529/594] Built Mathlib.Logic.Equiv.Sum (6.4s)
✔ [530/597] Built ProofWidgets.Compat (2.5s)
✔ [531/598] Built Mathlib.Lean.Meta.RefinedDiscrTree.Basic (4.9s)
✔ [532/599] Built Mathlib.Order.Monotone.Defs (6.6s)
✔ [533/599] Built ProofWidgets.Util (2.3s)
✔ [534/599] Built Mathlib.Tactic.NthRewrite (3.6s)
✔ [535/599] Built Mathlib.Order.BoundedOrder.Basic (7.4s)
✔ [536/599] Built Mathlib.Logic.Equiv.Option (6.1s)
✔ [537/602] Built ProofWidgets.Component.Basic (4.1s)
✔ [538/602] Built Mathlib.Tactic.CongrM (4.2s)
✔ [539/602] Built Mathlib.Tactic.Constructor (3.6s)
✔ [540/603] Built Mathlib.Control.Basic (4.8s)
✔ [541/603] Built Mathlib.Lean.Meta.RefinedDiscrTree.Encode (5.0s)
✔ [542/603] Built ProofWidgets.Cancellable (3.1s)
✔ [543/604] Built Mathlib.Lean.Meta.RefinedDiscrTree.Initialize (5.3s)
✔ [544/604] Built ProofWidgets.Component.Panel.Basic (2.9s)
✔ [545/605] Built Mathlib.Lean.MessageData.Trace (3.4s)
✔ [546/605] Built ProofWidgets.Component.MakeEditLink (2.9s)
✔ [547/606] Built Mathlib.Algebra.Group.Basic (15s)
✔ [548/606] Built Mathlib.Order.Monotone.Basic (6.8s)
✔ [549/607] Built Mathlib.Tactic.DeprecateTo (4.5s)
✔ [550/607] Built Mathlib.Tactic.DefEqTransformations (4.8s)
✔ [551/607] Built Mathlib.Tactic.DSimpPercent (2.8s)
✔ [552/607] Built Mathlib.Tactic.ExistsI (2.2s)
✔ [553/607] Built Mathlib.Lean.Meta.RefinedDiscrTree.Lookup (4.2s)
✔ [554/607] Built ProofWidgets.Data.Html (7.7s)
✔ [555/609] Built Mathlib.Tactic.DefEqAbuse (4.5s)
✔ [556/609] Built Mathlib.Tactic.ErwQuestion (3.8s)
✔ [557/609] Built Mathlib.Logic.Equiv.Basic (9.0s)
✔ [558/609] Built Mathlib.Algebra.Group.SelfInv (4.1s)
✔ [559/609] Built Mathlib.Algebra.Group.Semiconj.Basic (3.9s)
✔ [560/610] Built Mathlib.Lean.Meta.RefinedDiscrTree (2.7s)
✔ [561/610] Built ProofWidgets.Component.RefreshComponent (2.9s)
✔ [562/613] Built Mathlib.Tactic.FailIfNoProgress (3.4s)
✔ [563/613] Built Batteries.Util.Cache (1.3s)
✔ [564/613] Built Mathlib.Algebra.Group.Units.Basic (5.9s)
✔ [565/613] Built ProofWidgets.Component.OfRpcMethod (2.3s)
✔ [566/621] Built ProofWidgets.Component.FilterDetails (2.0s)
✔ [567/622] Built Mathlib.Algebra.Group.Hom.Basic (5.8s)
✔ [568/623] Built Mathlib.Tactic.FunProp.Decl (2.8s)
✔ [569/623] Built Mathlib.Tactic.FunProp.Mor (2.6s)
✔ [570/623] Built Mathlib.Tactic.Find (2.7s)
✔ [571/624] Built Mathlib.Algebra.Group.Commute.Basic (3.9s)
✔ [572/624] Built Mathlib.Tactic.InferParam (2.7s)
✔ [573/624] Built Mathlib.Tactic.GrindAttrs (2.5s)
✔ [574/626] Built Mathlib.Order.Lattice (8.2s)
✔ [575/626] Built Mathlib.Tactic.FunProp.ToBatteries (3.9s)
✔ [576/626] Built Mathlib.Tactic.GuardGoalNums (2.1s)
✔ [577/629] Built Mathlib.Tactic.ClickSuggestions.Util (5.6s)
✔ [578/629] Built Mathlib.Tactic.GuardHypNums (2.1s)
✔ [579/629] Built Mathlib.Tactic.HigherOrder (3.2s)
✔ [580/631] Built Mathlib.Util.TermReduce (2.9s)
✔ [581/631] Built Mathlib.Algebra.Group.Torsion (4.0s)
✔ [582/632] Built Mathlib.Algebra.Group.Units.Hom (4.0s)
✔ [583/632] Built Mathlib.Tactic.Linter.HaveLetLinter (2.6s)
✔ [584/633] Built Mathlib.Order.BoundedOrder.Lattice (4.0s)
✔ [585/633] Built Mathlib.Algebra.Group.Equiv.Basic (5.8s)
✔ [586/633] Built Mathlib.Tactic.Linter.MinImports (2.0s)
✔ [587/634] Built Mathlib.Tactic.FunProp.FunctionData (3.4s)
✔ [588/634] Built Mathlib.Tactic.Linter.PPRoundtrip (2.5s)
✔ [589/634] Built Mathlib.Tactic.ClickSuggestions.Unfold (2.9s)
✔ [590/635] Built Mathlib.Tactic.ClickSuggestions.SectionState (3.7s)
✔ [591/635] Built Mathlib.Tactic.Linter.UpstreamableDecl (2.8s)
✔ [592/635] Built Mathlib.Tactic.IrreducibleDef (4.1s)
✔ [593/635] Built Mathlib.Tactic.Observe (3.0s)
✔ [594/635] Built Mathlib.Tactic.RSuffices (2.2s)
✔ [595/635] Built Mathlib.Tactic.Recover (2.9s)
✔ [596/635] Built Mathlib.Algebra.Group.Opposite (5.5s)
✔ [597/635] Built Mathlib.Tactic.FunProp.Types (3.4s)
✔ [598/638] Built Mathlib.Algebra.Group.TypeTags.Basic (6.3s)
✔ [599/638] Built Mathlib.Order.Disjoint (6.1s)
✔ [600/638] Built Mathlib.Algebra.Group.Units.Equiv (5.0s)
✔ [601/638] Built Mathlib.Tactic.ClickSuggestions.ApplyAt (3.6s)
✔ [602/639] Built Mathlib.Tactic.ClickSuggestions.Apply (3.0s)
✔ [603/639] Built Mathlib.Tactic.Rename (2.3s)
✔ [604/642] Built Mathlib.Tactic.ClickSuggestions.GRewrite (4.5s)
✔ [605/642] Built Mathlib.Tactic.Linter (2.4s)
✔ [606/643] Built Mathlib.Util.Tactic (2.2s)
✔ [607/644] Built Mathlib.Tactic.Says (3.0s)
✔ [608/644] Built Mathlib.Tactic.FunProp.Theorems (3.9s)
✔ [609/645] Built Mathlib.Tactic.ClickSuggestions.Rewrite (5.0s)
✔ [610/645] Built Mathlib.Lean.Elab.Tactic.Basic (2.2s)
✔ [611/646] Built Mathlib.Tactic.Set (2.8s)
✔ [612/646] Built Mathlib.Order.PropInstances (3.5s)
✔ [613/646] Built Mathlib.Algebra.Group.TypeTags.Hom (4.5s)
✔ [614/646] Built Mathlib.Tactic.SimpIntro (3.2s)
✔ [615/647] Built Mathlib.Tactic.RenameBVar (2.6s)
✔ [616/647] Built Mathlib.Tactic.Substs (2.5s)
✔ [617/647] Built Mathlib.Tactic.SuccessIfFailWithMsg (2.7s)
✔ [618/648] Built Mathlib.Tactic.FunProp.Attr (3.0s)
✔ [619/649] Built Mathlib.Tactic.SudoSetOption (2.4s)
✔ [620/650] Built Mathlib.Tactic.ClickSuggestions.FindPremises (4.2s)
✔ [621/650] Built Mathlib.Tactic.SwapVar (3.1s)
✔ [622/650] Built Mathlib.Tactic.Setm (3.9s)
✔ [623/652] Built Mathlib.Tactic.ToFun (3.0s)
✔ [624/652] Built Mathlib.Algebra.Group.Prod (11s)
✔ [625/658] Built Mathlib.Algebra.Group.Equiv.TypeTags (5.3s)
✔ [626/658] Built Mathlib.Tactic.ToLevel (2.9s)
✔ [627/661] Built Mathlib.Tactic.Tauto (5.3s)
✔ [628/662] Built Mathlib.Tactic.Trace (3.1s)
✔ [629/665] Built Mathlib.Tactic.UnsetOption (2.5s)
✔ [630/665] Built Mathlib.Data.Set.Basic (8.0s)
✔ [631/665] Built Mathlib.Tactic.FunProp.Core (9.8s)
✔ [632/665] Built Mathlib.Tactic.Widget.SelectInsertParamsClass (2.6s)
✔ [633/665] Built Mathlib.Tactic.ClickSuggestions.TryPremises (6.3s)
✔ [634/668] Built Mathlib.Util.TransImports (3.1s)
✔ [635/670] Built Mathlib.Util.PrintSorries (3.8s)
✔ [636/671] Built Mathlib.Tactic.WLOG (4.6s)
✔ [637/680] Built Mathlib.Util.CountHeartbeats (5.6s)
✔ [638/682] Built Mathlib.Tactic.Variable (6.6s)
✔ [639/690] Built Mathlib.Util.WhatsNew (4.2s)
✔ [640/691] Built Mathlib.Tactic.Widget.SelectPanelUtils (4.3s)
✔ [641/691] Built Mathlib.Tactic.FunProp.Elab (4.5s)
✔ [642/691] Built Batteries.Tactic.Congr (2.6s)
✔ [643/691] Built Mathlib.Data.Set.Disjoint (3.4s)
✔ [644/691] Built Mathlib.Data.Set.Inclusion (2.8s)
✔ [645/691] Built Mathlib.Tactic.ClickSuggestions (3.9s)
✔ [646/691] Built Mathlib.Control.ULift (1.2s)
✔ [647/691] Built Mathlib.Data.Prod.PProd (1.2s)
✔ [648/691] Built Mathlib.Tactic.Monotonicity.Attr (1.2s)
✔ [649/694] Built Mathlib.Tactic.Widget.CongrM (1.1s)
✔ [650/694] Built Mathlib.Order.BoundedOrder.Monotone (1.6s)
✔ [651/698] Built Mathlib.Tactic.FunProp (1.3s)
✔ [652/698] Built Mathlib.Order.GaloisConnection.Defs (2.7s)
✔ [653/698] Built Mathlib.Data.ULift (1.3s)
✔ [654/703] Built Mathlib.Tactic.Widget.Calc (1.0s)
✔ [655/712] Built Mathlib.Tactic.Widget.Conv (2.4s)
✔ [656/719] Built Mathlib.Util.PPOptions (1.3s)
✔ [657/719] Built Mathlib.Tactic.Widget.LibraryRewrite (3.1s)
✔ [658/719] Built Mathlib.Data.Set.Insert (2.4s)
✔ [659/720] Built Mathlib.Algebra.Order.ZeroLEOne (1.6s)
✔ [660/720] Built Mathlib.Order.Interval.Set.Defs (1.4s)
✔ [661/721] Built Mathlib.Order.Bounds.Defs (1.3s)
✔ [662/721] Built Mathlib.Logic.Embedding.Basic (2.4s)
✔ [663/721] Built Mathlib.Basic.Nontrivial.Basic (1.5s)
✔ [664/721] Built Mathlib.Data.Option.NAry (1.4s)
✔ [665/722] Built Mathlib.Order.TypeTags (1.5s)
✔ [666/722] Built Mathlib.Tactic.Common (1.7s)
✔ [667/722] Built Mathlib.Data.Bool.Set (1.4s)
✔ [668/722] Built Mathlib.Control.Monad.Basic (1.4s)
✔ [669/724] Built Mathlib.Dynamics.FixedPoints.Defs (1.2s)
✔ [670/724] Built Mathlib.Data.Set.Subsingleton (1.9s)
✔ [671/726] Built Mathlib.Algebra.Order.IsBotOne (1.7s)
✔ [672/729] Built Mathlib.Util.Delaborators (3.0s)
✔ [673/731] Built Batteries.Control.ForInStep.Lemmas (600ms)
✔ [674/731] Built Mathlib.Order.Iterate (1.6s)
✔ [675/731] Built Mathlib.Tactic.SetLike (1.2s)
✔ [676/733] Built Mathlib.Order.Heyting.Basic (5.3s)
✔ [677/735] Built Batteries.Data.List.Pairwise (719ms)
✔ [678/735] Built Mathlib.Order.SetNotation (2.0s)
✔ [679/755] Built Mathlib.Data.Part (2.7s)
✔ [680/755] Built Mathlib.Data.List.TFAE (1.4s)
✔ [681/757] Built Mathlib.Order.RelIso.Basic (3.9s)
✔ [682/757] Built Mathlib.Lean.Expr.ExtraRecognizers (1.5s)
✔ [683/762] Built Mathlib.Basic.SetLike.Basic (2.3s)
✔ [684/762] Built Mathlib.Order.BooleanAlgebra.Defs (2.3s)
✔ [685/763] Built Mathlib.Algebra.Group.End (4.4s)
✔ [686/765] Built Aeneas.Tactic.Elab.TraitDefault.Init (1.7s)
✔ [687/766] Built Aeneas.Tactic.Step.Simp (1.9s)
✔ [688/774] Built Mathlib.Util.AtomM (1.4s)
✔ [689/776] Built Mathlib.Data.Set.Notation (1.8s)
✔ [690/776] Built Mathlib.Algebra.Group.Int.Defs (1.1s)
✔ [691/776] Built Batteries.Data.List.Lemmas (4.6s)
✔ [692/779] Built Mathlib.Util.AtomM.Recurse (1.3s)
✔ [693/782] Built Mathlib.Algebra.Order.Monoid.Unbundled.Defs (2.0s)
✔ [694/782] Built Mathlib.Logic.OpClass (1.2s)
✔ [695/783] Built Mathlib.Algebra.Group.Equiv.Opposite (2.4s)
✔ [696/785] Built Batteries.Classes.RatCast (528ms)
✔ [697/785] Built Mathlib.Data.Int.Basic (1.7s)
✔ [698/788] Built Mathlib.Order.BooleanAlgebra.Basic (3.3s)
✔ [699/788] Built Mathlib.Order.WithBot (8.2s)
✔ [700/788] Built Mathlib.Data.Nat.Cast.Defs (1.6s)
✔ [701/789] Built Mathlib.Data.List.Pairwise (2.4s)
✔ [702/789] Built Mathlib.Data.Rat.Init (1.3s)
✔ [703/789] Built Mathlib.Algebra.Group.IsCommutative (1.4s)
✔ [704/793] Built Mathlib.Order.MinMax (2.0s)
✔ [705/794] Built Mathlib.Algebra.GroupWithZero.Defs (1.5s)
✔ [706/794] Built Mathlib.Order.Hom.Basic (5.8s)
✔ [707/794] Built Mathlib.Algebra.Group.Even (2.4s)
✔ [708/794] Built Mathlib.Data.Int.Cast.Defs (1.2s)
✔ [709/794] Built Mathlib.Order.Lex (1.3s)
✔ [710/794] Built Mathlib.Algebra.Notation.Bracket (1.3s)
✔ [711/798] Built AeneasMeta.Async.Test (137s)
✔ [712/798] Built Mathlib.Data.Rat.Defs (2.2s)
✔ [713/798] Built AeneasMeta.Async.Test:c.o (386ms)
✔ [714/799] Built Mathlib.Order.BooleanAlgebra.Set (3.1s)
✔ [715/802] Built Mathlib.Order.SymmDiff (3.0s)
✔ [716/802] Built AeneasMeta.Async.Test:dynlib (227ms)
✔ [717/802] Built Mathlib.Order.Part (2.2s)
✔ [718/802] Built Mathlib.Data.Int.Cast.Basic (1.6s)
✔ [719/802] Built Mathlib.Algebra.CharZero.Defs (1.5s)
✔ [720/811] Built Mathlib.Order.Antisymmetrization (2.6s)
✔ [721/811] Built Mathlib.Algebra.NeZero (1.3s)
✔ [722/811] Built Mathlib.Algebra.Ring.Defs (3.1s)
✔ [723/817] Built Mathlib.Algebra.Order.Monoid.Unbundled.Basic (4.5s)
✔ [724/817] Built Mathlib.Data.Set.SymmDiff (1.9s)
✔ [725/817] Built Mathlib.Algebra.Group.Semiconj.Units (1.6s)
✔ [726/817] Built Mathlib.Algebra.Group.Invertible.Defs (1.5s)
✔ [727/817] Built Mathlib.Algebra.GroupWithZero.NeZero (1.4s)
✔ [728/817] Built Mathlib.Tactic.TFAE (2.6s)
✔ [729/817] Built AeneasMeta.Async (2.4s)
✔ [730/817] Built Mathlib.Algebra.Order.Group.Synonym (3.8s)
✔ [731/817] Built Mathlib.Algebra.Group.Hom.Instances (3.1s)
✔ [732/817] Built Mathlib.Algebra.Ring.Semiconj (1.2s)
✔ [733/817] Built Mathlib.Algebra.Ring.Int.Defs (1.6s)
✔ [734/817] Built Mathlib.Algebra.Ring.GrindInstances (1.9s)
✔ [735/817] Built AeneasMeta.Async:c.o (222ms)
✔ [736/817] Built Mathlib.Algebra.Field.Defs (1.6s)
✔ [737/818] Built Mathlib.Tactic.Nontriviality.Core (1.7s)
✔ [738/821] Built AeneasMeta.Async:dynlib (256ms)
✔ [739/821] Built Mathlib.Order.Interval.Set.Basic (4.5s)
✔ [740/821] Built Mathlib.Algebra.Order.Sub.Defs (2.1s)
✔ [741/821] Built Mathlib.Algebra.GroupWithZero.InjSurj (1.8s)
✔ [742/823] Built Mathlib.Algebra.Group.Commute.Units (2.3s)
✔ [743/823] Built Mathlib.Algebra.Order.Ring.Synonym (2.1s)
✔ [744/823] Built Mathlib.Algebra.GroupWithZero.Basic (2.6s)
✔ [745/823] Built Mathlib.Algebra.Ring.Basic (2.4s)
✔ [746/825] Built Mathlib.Tactic.Bound.Init (1.6s)
✔ [747/825] Built Mathlib.Tactic.Nontriviality (2.0s)
✔ [748/827] Built Mathlib.Algebra.Order.GroupWithZero.Defs (2.5s)
✔ [749/827] Built Mathlib.Data.Set.Image (4.8s)
✔ [750/829] Built Mathlib.Algebra.Order.Monoid.Unbundled.OrderDual (1.9s)
✔ [751/829] Built AeneasMeta (3.4s)
✔ [752/829] Built Mathlib.Algebra.Group.Invertible.Basic (1.8s)
✔ [753/829] Built Mathlib.Tactic.Bound.Attribute (1.8s)
✔ [754/829] Built Mathlib.Algebra.GroupWithZero.Hom (2.1s)
✔ [755/831] Built Mathlib.Algebra.Group.Nat.Defs (1.3s)
✔ [756/834] Built Mathlib.Algebra.Divisibility.Basic (2.5s)
✔ [757/834] Built AeneasMeta:c.o (268ms)
✔ [758/834] Built Mathlib.Algebra.Order.Group.Unbundled.Basic (4.3s)
✔ [759/837] Built Mathlib.Algebra.GroupWithZero.Units.Basic (2.5s)
✔ [760/837] Built Mathlib.Data.Set.Restrict (2.0s)
✔ [761/837] Built Mathlib.Data.Nat.Set (1.9s)
✔ [762/837] Built Mathlib.Algebra.Ring.InjSurj (4.9s)
✔ [763/837] Built AeneasMeta:shared (245ms)
✔ [764/837] Built Mathlib.Order.Directed (2.3s)
✔ [765/837] Built Mathlib.Data.Nat.Cast.Pi (1.4s)
✔ [766/837] Built Mathlib.Algebra.GroupWithZero.Nat (1.4s)
✔ [767/837] Built Mathlib.Algebra.Order.Monoid.Unbundled.Pow (2.7s)
✔ [768/837] Built Mathlib.Algebra.Group.Nat.Hom (1.9s)
✔ [769/837] Built Mathlib.Data.Nat.Cast.NeZero (1.4s)
✔ [770/840] Built Mathlib.Data.Set.Prod (3.9s)
✔ [771/840] Built Mathlib.Algebra.Divisibility.Hom (2.3s)
✔ [772/840] Built Mathlib.Algebra.GroupWithZero.Invertible (2.0s)
✔ [773/840] Built Mathlib.Algebra.Ring.Hom.Defs (3.4s)
✔ [774/840] Built Mathlib.Algebra.Order.Group.OrderIso (2.4s)
✔ [775/840] Built Aeneas.Std.Spec (2.1s)
✔ [776/840] Built Mathlib.Algebra.Ring.Rat (2.4s)
✔ [777/840] Built Mathlib.Algebra.Ring.Nat (1.5s)
✔ [778/842] Built Mathlib.Algebra.GroupWithZero.Semiconj (1.9s)
✔ [779/844] Built Aeneas.Tactic.Step.DspecInduction (3.6s)
✔ [780/850] Built Mathlib.Data.Set.NAry (2.6s)
✔ [781/853] Built Mathlib.Algebra.Ring.Invertible (2.3s)
✔ [782/857] Built Mathlib.Algebra.Ring.Units (2.3s)
✔ [783/857] Built Mathlib.Algebra.Order.Group.Lattice (2.4s)
✔ [784/857] Built Mathlib.Data.Nat.Cast.Basic (2.8s)
✔ [785/858] Built Mathlib.Data.PNat.Notation (1.3s)
✔ [786/859] Built Aeneas.Extract.Extract (5.0s)
✔ [787/859] Built Mathlib.Algebra.GroupWithZero.Commute (1.9s)
✔ [788/859] Built Mathlib.Data.Nat.Sqrt (1.7s)
✔ [789/859] Built Mathlib.Data.Set.Function (4.5s)
✔ [790/859] Built Mathlib.Data.Nat.Find (1.6s)
✔ [791/860] Built Mathlib.Order.Bounds.Basic (5.8s)
✔ [792/860] Built Mathlib.Algebra.Ring.Commute (2.1s)
✔ [793/860] Built Mathlib.Algebra.Divisibility.Units (2.5s)
✔ [794/860] Built Mathlib.Tactic.HaveI (1.3s)
✔ [795/860] Built Mathlib.Data.PNat.Defs (1.7s)
✔ [796/860] Built Mathlib.Algebra.Group.Nat.Even (1.0s)
✔ [797/860] Built Mathlib.Algebra.GroupWithZero.Units.Lemmas (1.7s)
✔ [798/860] Built Mathlib.Data.Int.Sqrt (2.2s)
✔ [799/860] Built Mathlib.Lean.Expr.Rat (1.2s)
✔ [800/860] Built Aeneas.Extract (1.6s)
✔ [801/860] Built Mathlib.Data.Nat.Cast.Order.Basic (2.7s)
✔ [802/860] Built Aeneas.Std.Core.Result (2.2s)
✔ [803/860] Built Mathlib.Algebra.Order.Group.Unbundled.Abs (3.3s)
✔ [804/864] Built Mathlib.Data.Set.Pairwise.Basic (2.1s)
✔ [805/864] Built Mathlib.Order.Nat (1.7s)
✔ [806/867] Built Mathlib.Order.WellFounded (2.2s)
✔ [807/867] Built Mathlib.Algebra.GroupWithZero.Divisibility (2.5s)
✔ [808/867] Built Mathlib.Data.Nat.Cast.Commute (2.0s)
✔ [809/869] Built Mathlib.Util.Qq (1.5s)
✔ [810/870] Built Mathlib.Order.CompleteLattice.Defs (2.0s)
✔ [811/870] Built Mathlib.Order.Bounds.Image (3.1s)
✔ [812/871] Built Mathlib.Logic.Equiv.Set (3.6s)
✔ [813/874] Built Mathlib.Data.Ineq (699ms)
✔ [814/874] Built Mathlib.Algebra.Order.GroupWithZero.Basic (4.0s)
✔ [815/874] Built Mathlib.Tactic.TryThis (1.2s)
✔ [816/874] Built Mathlib.Algebra.Group.Int.Even (2.7s)
✔ [817/877] Built Mathlib.Algebra.Order.Group.Unbundled.Int (2.0s)
✔ [818/877] Built Mathlib.Algebra.Field.Basic (3.7s)
✔ [819/877] Built Aeneas.Std.Primitives (2.9s)
✔ [820/879] Built Mathlib.Tactic.NormNum.Result (2.9s)
✔ [821/879] Built Mathlib.Order.ScottContinuity (2.4s)
✔ [822/879] Built Mathlib.Algebra.Order.Monoid.Unbundled.ExistsOfLE (1.8s)
✔ [823/879] Built Mathlib.Algebra.Order.Monoid.Defs (2.1s)
✔ [824/881] Built Mathlib.Algebra.GroupWithZero.Regular (1.3s)
✔ [825/883] Built Mathlib.Order.Hom.Set (3.6s)
✔ [826/883] Built Mathlib.Algebra.Group.WithOne.Defs (2.7s)
✔ [827/884] Built Mathlib.Algebra.Order.Nonneg.Basic (3.2s)
✔ [828/884] Built Mathlib.Algebra.Ring.Parity (3.1s)
✔ [829/884] Built Mathlib.Algebra.GroupWithZero.Equiv (1.8s)
✔ [830/884] Built Aeneas.Std.Core.Ops (2.4s)
✔ [831/884] Built Mathlib.Algebra.Order.Monoid.Canonical.Defs (2.0s)
✔ [832/885] Built Aeneas.Std.Delab (2.7s)
✔ [833/885] Built Mathlib.Algebra.Order.Ring.Unbundled.Rat (4.2s)
✔ [834/885] Built Mathlib.Tactic.NormNum.Core (2.8s)
✔ [835/885] Built Mathlib.Algebra.Regular.Basic (2.0s)
✔ [836/885] Built Mathlib.Algebra.Group.WithOne.Map (1.0s)
✔ [837/887] Built Mathlib.Order.Preorder.Chain (2.4s)
✔ [838/888] Built Mathlib.Algebra.Order.Group.Defs (1.9s)
✔ [839/888] Built Mathlib.Algebra.Order.Group.Nat (1.6s)
✔ [840/888] Built Mathlib.Algebra.Ring.Int.Parity (2.7s)
✔ [841/891] Built Mathlib.Algebra.Order.Group.Int (1.7s)
✔ [842/891] Built Mathlib.Data.Int.Cast.Lemmas (2.0s)
✔ [843/891] Built Mathlib.Algebra.Order.Monoid.Unbundled.WithTop (4.3s)
✔ [844/892] Built Mathlib.Algebra.Order.Monoid.Units (1.7s)
✔ [845/892] Built Mathlib.Order.CompleteLattice.Basic (5.0s)
✔ [846/896] Built Mathlib.Algebra.Order.Monoid.OrderDual (1.6s)
✔ [847/896] Built Mathlib.Algebra.GroupWithZero.WithZero (3.8s)
✔ [848/896] Built Mathlib.Data.NNRat.Defs (3.1s)
✔ [849/900] Built Mathlib.Algebra.Order.Monoid.WithTop (1.8s)
✔ [850/902] Built Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags (2.1s)
✔ [851/902] Built Mathlib.Data.Rat.Lemmas (2.5s)
✔ [852/902] Built Mathlib.Algebra.Order.Group.Units (1.7s)
✔ [853/902] Built Mathlib.Algebra.Order.Monoid.NatCast (1.9s)
✔ [854/907] Built Mathlib.Order.OmegaCompletePartialOrder (3.0s)
✔ [855/907] Built Mathlib.Algebra.Order.Monoid.Unbundled.MinMax (2.2s)
✔ [856/908] Built Mathlib.Order.CompleteLattice.Lemmas (2.5s)
✔ [857/912] Built Mathlib.Tactic.NormNum.Basic (5.3s)
✔ [858/912] Built Mathlib.Util.SynthesizeUsing (1.2s)
✔ [859/912] Built Mathlib.Algebra.Field.Rat (2.2s)
✔ [860/912] Built Mathlib.Algebra.Order.Sub.Unbundled.Basic (2.0s)
✔ [861/914] Built Mathlib.Algebra.Order.Monoid.TypeTags (1.9s)
✔ [862/916] Built Mathlib.Algebra.Order.AddGroupWithTop (2.3s)
✔ [863/916] Built Mathlib.Order.GaloisConnection.Basic (3.4s)
✔ [864/916] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes (1.4s)
✔ [865/916] Built Mathlib.Lean.Meta.Tactic.Rewrite (1.3s)
✔ [866/916] Built Mathlib.Data.Tree.Basic (1.3s)
✔ [867/916] Built Mathlib.Util.ElabWithoutMVars (1.3s)
✔ [868/919] Built Mathlib.Tactic.Zify (1.7s)
✔ [869/922] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Gauss (1.3s)
✔ [870/923] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.SimplexAlgorithm (1.6s)
✔ [871/923] Built Mathlib.Algebra.Order.Sub.Basic (2.2s)
✔ [872/923] Built Mathlib.Algebra.Order.Ring.Unbundled.Basic (3.4s)
✔ [873/924] Built Mathlib.Data.Rat.Cast.Defs (2.7s)
✔ [874/925] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.PositiveVector (1.1s)
✔ [875/929] Built Mathlib.Tactic.NormNum.Pow (3.6s)
✔ [876/932] Built Mathlib.Order.Hom.Order (2.1s)
✔ [877/932] Built Mathlib.Order.ConditionallyCompletePartialOrder.Defs (1.9s)
✔ [878/932] Built Mathlib.Order.ConditionallyCompleteLattice.Defs (2.1s)
✔ [879/937] Built Mathlib.Algebra.Order.Ring.Defs (1.9s)
✔ [880/937] Built Mathlib.Order.Antichain (2.3s)
✔ [881/939] Built Mathlib.Data.Set.Order (1.7s)
✔ [882/939] Built Mathlib.Data.Rat.Cast.CharZero (2.3s)
✔ [883/939] Built Mathlib.Order.ConditionallyCompletePartialOrder.Basic (2.0s)
✔ [884/939] Built Mathlib.Order.Interval.Set.Image (2.9s)
✔ [885/940] Built Mathlib.Algebra.Order.GroupWithZero.Canonical (5.0s)
✔ [886/940] Built Mathlib.Algebra.Order.Monoid.Basic (1.9s)
✔ [887/941] Built Mathlib.Order.LatticeIntervals (2.8s)
✔ [888/946] Built Mathlib.Order.CompleteBooleanAlgebra (6.1s)
✔ [889/947] Built Mathlib.Algebra.Order.Ring.Canonical (2.4s)
✔ [890/947] Built Mathlib.Algebra.Order.Positive.Ring (2.3s)
✔ [891/947] Built Mathlib.Order.Interval.Set.LinearOrder (3.0s)
✔ [892/953] Built Mathlib.Algebra.Order.Ring.Rat (1.0s)
✔ [893/954] Built Mathlib.Tactic.CancelDenoms.Core (3.4s)
✔ [894/954] Built Mathlib.Algebra.Order.Ring.InjSurj (1.8s)
✔ [895/955] Built Mathlib.Algebra.Order.Ring.Nat (2.1s)
✔ [896/956] Built Mathlib.Data.Set.BooleanAlgebra (1.7s)
✔ [897/958] Built Mathlib.Algebra.Notation (1.4s)
✔ [898/958] Built Mathlib.Tactic.NormNum.Inv (3.3s)
✔ [899/958] Built Mathlib.Algebra.Order.Field.Canonical (2.1s)
✔ [900/958] Built Mathlib.Algebra.Order.Group.Abs (2.8s)
✔ [901/964] Built Mathlib.Data.Int.GCD (2.7s)
✔ [902/964] Built Mathlib.Algebra.Order.Hom.Basic (1.8s)
✔ [903/965] Built Mathlib.Data.Nat.Cast.Order.Ring (2.2s)
✔ [904/965] Built Mathlib.Algebra.Order.Ring.Basic (2.4s)
✔ [905/965] Built Mathlib.Order.Interval.Set.UnorderedInterval (3.1s)
✔ [906/966] Built Mathlib.Data.Int.Cast.Pi (1.4s)
✔ [907/966] Built Mathlib.Algebra.Notation.Support (2.5s)
✔ [908/966] Built Mathlib.Data.Int.Cast.Field (1.8s)
✔ [909/966] Built Mathlib.Data.Set.Lattice.Indexed (2.8s)
✔ [910/966] Built Mathlib.Tactic.NormNum.Eq (2.7s)
✔ [911/966] Built Mathlib.Algebra.Order.Group.PosPart (3.3s)
✔ [912/969] Built Mathlib.Algebra.Order.Invertible (2.2s)
✔ [913/971] Built Mathlib.Tactic.NormNum.Abs (2.6s)
✔ [914/971] Built Aeneas.Tactic.Solver.ScalarTac.Init (2.3s)
✔ [915/971] Built Mathlib.Tactic.Linarith.Lemmas (2.5s)
✔ [916/971] Built Mathlib.Algebra.Order.Ring.Int (2.9s)
✔ [917/972] Built Mathlib.Data.Nat.Factorial.Basic (3.2s)
✔ [918/972] Built Aeneas.Tactic.Simp.SimpScalar.Init (1.6s)
✔ [919/972] Built Mathlib.Order.Interval.Set.OrderEmbedding (2.1s)
✔ [920/975] Built Mathlib.Data.Int.CharZero (2.0s)
✔ [921/975] Built Aeneas.Tactic.Simp.SimpBoolProp.Init (1.5s)
✔ [922/975] Built Aeneas.Tactic.Conv.Bvify.Init (1.5s)
✔ [923/975] Built Aeneas.Data.Nat (1.5s)
✔ [924/976] Built Aeneas.Data.Int (1.5s)
✔ [925/980] Built Mathlib.Data.Set.Lattice.Bounded (2.9s)
✔ [926/980] Built Mathlib.Tactic.Linarith.Datatypes (2.6s)
✔ [927/980] Built Mathlib.Algebra.Order.Ring.Cast (2.4s)
✔ [928/980] Built Aeneas.Tactic.Simp.SimpLists.Init (1.7s)
✔ [929/980] Built Mathlib.Algebra.Group.Nat.Units (1.3s)
✔ [930/980] Built Mathlib.Order.Interval.Set.OrdConnected (2.6s)
✔ [931/980] Built Mathlib.Order.ConditionallyCompleteLattice.Basic (4.5s)
✔ [932/980] Built Aeneas.Tactic.Simp.SimpBoolProp.SimpBoolProp (2.5s)
✔ [933/981] Built Mathlib.Algebra.Group.Irreducible.Defs (1.5s)
✔ [934/986] Built Aeneas.Std.Scalar.Elab (3.1s)
✔ [935/986] Built Mathlib.Order.BourbakiWitt (2.2s)
✔ [936/988] Built Mathlib.Tactic.Ring.Common (8.9s)
✔ [937/988] Built Batteries.Data.Fin.Basic (808ms)
✔ [938/988] Built Mathlib.Tactic.Linarith.Parsing (2.3s)
✔ [939/988] Built Mathlib.Tactic.Linarith.Preprocessing (3.2s)
✔ [940/991] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm (2.7s)
✔ [941/991] Built Mathlib.Data.Int.DivMod (1.3s)
✔ [942/991] Built Mathlib.Algebra.Prime.Defs (2.2s)
✔ [943/991] Built Mathlib.Algebra.GroupWithZero.Opposite (1.7s)
✔ [944/992] Built Mathlib.Order.CompleteLatticeIntervals (3.1s)
✔ [945/995] Built Mathlib.Tactic.NormNum.Ineq (3.4s)
✔ [946/995] Built Mathlib.Order.FixedPoints (2.7s)
✔ [947/995] Built Mathlib.Algebra.Group.ULift (1.0s)
✔ [948/997] Built Mathlib.Tactic.Positivity.Core (4.7s)
✔ [949/997] Built Mathlib.Tactic.Linarith.Verification (2.9s)
✔ [950/997] Built Mathlib.Data.Fin.Basic (2.7s)
✔ [951/997] Built Mathlib.Data.Nat.Prime.Defs (2.4s)
✔ [952/997] Built Mathlib.Algebra.Order.Nonneg.Lattice (2.3s)
✔ [953/998] Built Mathlib.Algebra.Group.ModEq (2.1s)
✔ [954/998] Built Mathlib.Tactic.Ring.Basic (5.1s)
✔ [955/998] Built Mathlib.Algebra.Ring.Equiv (4.4s)
✔ [956/1000] Built Mathlib.Tactic.NormNum.DivMod (2.6s)
✔ [957/1000] Built Mathlib.Algebra.Ring.Opposite (3.6s)
✔ [958/1000] Built Mathlib.Data.Nat.GCD.Basic (2.6s)
✔ [959/1000] Built Aeneas.Data.Coinductive.ITreeWP.FunctionalWP (2.2s)
✔ [960/1000] Built Mathlib.Data.Nat.Cast.Prod (1.6s)
✔ [961/1000] Built Mathlib.Algebra.CharP.Defs (2.4s)
✔ [962/1000] Built Mathlib.Algebra.GroupWithZero.Units.Equiv (1.8s)
✔ [963/1001] Built Mathlib.Algebra.Order.Nonneg.Ring (2.3s)
✔ [964/1001] Built Mathlib.Algebra.Group.Int.Units (1.7s)
✔ [965/1002] Built Mathlib.Data.Fin.SuccPred (3.7s)
✔ [966/1002] Built Mathlib.Tactic.Ring.RingNF (2.0s)
✔ [967/1005] Built Mathlib.Algebra.Ring.ULift (3.0s)
✔ [968/1005] Built Mathlib.Data.Nat.ModEq (3.1s)
✔ [969/1005] Built Aeneas.Data.Coinductive.ITreeWP.DWLP (2.2s)
✔ [970/1005] Built Aeneas.Data.Coinductive.ITreeWP.DWP (2.2s)
✔ [971/1015] Built Mathlib.Tactic.Linarith.Frontend (3.0s)
✔ [972/1019] Built Mathlib.Algebra.Ring.Int.Units (1.7s)
✔ [973/1019] Built Aeneas.Data.Coinductive.ITreeWP.Taxonomy (562ms)
✔ [974/1020] Built Mathlib.Algebra.Order.Nonneg.Field (2.8s)
✔ [975/1021] Built Mathlib.Data.ENat.Defs (1.2s)
✔ [976/1021] Built Mathlib.Data.Fin.Rev (1.9s)
✔ [977/1026] Built Mathlib.Algebra.Order.Sub.WithTop (1.7s)
✔ [978/1026] Built Aeneas.Data.Coinductive.ITreeWP.Tests (749ms)
✔ [979/1026] Built Mathlib.Data.List.Monad (1.2s)
✔ [980/1026] Built Mathlib.Control.Functor (1.4s)
✔ [981/1026] Built Mathlib.Order.Interval.Set.WithBotTop (2.1s)
✔ [982/1026] Built Mathlib.Data.Int.ModEq (2.5s)
✔ [983/1026] Built Batteries.Data.List.Perm (1.6s)
✔ [984/1027] Built Aeneas.Data.Coinductive.ITreeWP (537ms)
✔ [985/1027] Built Mathlib.Algebra.Order.Field.Rat (2.2s)
✔ [986/1027] Built Mathlib.Algebra.Order.Ring.WithTop (5.1s)
✔ [987/1036] Built Mathlib.Data.List.Forall2 (2.4s)
✔ [988/1037] Built Mathlib.Algebra.Group.Fin.Basic (2.2s)
✔ [989/1037] Built Mathlib.Data.List.InsertIdx (2.1s)
✔ [990/1039] Built Mathlib.Data.ENat.Basic (2.4s)
✔ [991/1039] Built Mathlib.Tactic.Positivity.Basic (10s)
✔ [992/1045] Built Mathlib.Data.List.Defs (2.2s)
✔ [993/1045] Built Mathlib.Data.Finset.Attr (1.2s)
✔ [994/1045] Built Mathlib.Data.List.Count (2.0s)
✔ [995/1052] Built Mathlib.Algebra.CharP.Basic (2.2s)
✔ [996/1061] Built Mathlib.Data.List.Perm.Basic (2.2s)
✔ [997/1068] Built Mathlib.Data.Set.List (1.7s)
✔ [998/1075] Built Mathlib.Data.ENat.Monoid (2.8s)
✔ [999/1075] Built Mathlib.Tactic.NormNum.OfScientific (2.6s)
✔ [1000/1084] Built Mathlib.Order.Cover (4.9s)
✔ [1001/1084] Built Mathlib.Data.Rat.Cast.Order (4.2s)
✔ [1002/1088] Built Batteries.Data.Fin.Lemmas (1.3s)
✔ [1003/1091] Built Mathlib.Data.List.TakeDrop (3.2s)
✔ [1004/1092] Built Mathlib.Basic.Finite.Defs (1.9s)
✔ [1005/1092] Built Aeneas.Std.WP (5.3s)
✔ [1006/1092] Built Mathlib.Data.List.Induction (2.2s)
✔ [1007/1092] Built Mathlib.Logic.Small.Defs (1.6s)
✔ [1008/1097] Built Mathlib.Data.List.Basic (4.4s)
✔ [1009/1097] Built Mathlib.Data.Fin.Embedding (2.7s)
✔ [1010/1097] Built Mathlib.Basic.Countable.Defs (1.5s)
✔ [1011/1097] Built Mathlib.Algebra.BigOperators.Group.List.Defs (1.7s)
✔ [1012/1097] Built Mathlib.Data.List.Flatten (1.7s)
✔ [1013/1097] Built Mathlib.Tactic.NormNum (2.5s)
✔ [1014/1097] Built Mathlib.Data.List.ProdSigma (1.0s)
✔ [1015/1097] Built Mathlib.Basic.UnivLE (1.4s)
✔ [1016/1097] Built Mathlib.Logic.Small.Basic (1.6s)
✔ [1017/1097] Built Mathlib.Data.List.Lex (2.1s)
✔ [1018/1100] Built Mathlib.Algebra.Order.Hom.Monoid (5.0s)
✔ [1019/1100] Built Aeneas.Tactic.Step.PrepareIntroOutputs (2.8s)
✔ [1020/1100] Built Mathlib.Data.List.Infix (2.4s)
✔ [1021/1100] Built Mathlib.Order.Fin.Basic (3.1s)
✔ [1022/1103] Built Mathlib.Order.SuccPred.Basic (5.4s)
✔ [1023/1103] Built Mathlib.Data.List.Lattice (2.7s)
✔ [1024/1103] Built Mathlib.Algebra.BigOperators.Group.List.Basic (3.9s)
✔ [1025/1103] Built Mathlib.Data.List.Perm.Subperm (2.3s)
✔ [1026/1109] Built Aeneas.Command.Decompose (5.1s)
✔ [1027/1109] Built Mathlib.Basic.Countable.Small (2.1s)
✔ [1028/1109] Built Mathlib.Data.List.Nodup (3.8s)
✔ [1029/1109] Built Mathlib.Tactic.Linarith (2.9s)
✔ [1030/1109] Built Aeneas.Tactic.Step.SpecInfo (2.9s)
✔ [1031/1109] Built Mathlib.Data.List.Chain (3.4s)
✔ [1032/1109] Built Mathlib.Order.SuccPred.WithBot (2.2s)
✔ [1033/1112] Built Mathlib.Algebra.Order.Hom.MonoidWithZero (3.6s)
✔ [1034/1112] Built Mathlib.Data.List.Enum (2.3s)
✔ [1035/1112] Built Mathlib.Data.Multiset.Defs (2.6s)
✔ [1036/1115] Built Mathlib.Order.SuccPred.Archimedean (3.4s)
✔ [1037/1115] Built Mathlib.Data.List.Dedup (2.5s)
✔ [1038/1115] Built Mathlib.Data.Nat.Choose.Basic (2.8s)
✔ [1039/1115] Built Mathlib.Data.Fin.Tuple.Basic (4.6s)
✔ [1040/1115] Built Mathlib.Data.List.Perm.Lattice (2.8s)
✔ [1041/1115] Built Mathlib.Data.List.Duplicate (2.5s)
✔ [1042/1115] Built Mathlib.Data.List.Rotate (3.1s)
✔ [1043/1115] Built Mathlib.Data.List.Range (2.2s)
✔ [1044/1116] Built Mathlib.Data.List.OffDiag (2.3s)
✔ [1045/1117] Built Aeneas.Tactic.Solver.ScalarTac.Core (3.7s)
✔ [1046/1120] Built Mathlib.Data.Set.Piecewise (1.9s)
✔ [1047/1121] Built Mathlib.Data.Finset.Defs (2.5s)
✔ [1048/1121] Built Mathlib.Algebra.Order.Hom.Ring (3.3s)
✔ [1049/1122] Built Mathlib.Data.Multiset.ZeroCons (3.2s)
✔ [1050/1126] Built Mathlib.Data.List.OfFn (2.4s)
✔ [1051/1126] Built Mathlib.Data.List.FinRange (2.4s)
✔ [1052/1127] Built Mathlib.Algebra.BigOperators.Group.List.Lemmas (2.5s)
✔ [1053/1127] Built Mathlib.Order.SuccPred.Limit (4.5s)
✔ [1054/1128] Built Mathlib.Data.Finset.Empty (2.1s)
✔ [1055/1129] Built Aeneas.Tactic.Step.Init (6.6s)
✔ [1056/1129] Built Mathlib.Data.Multiset.Count (2.3s)
✔ [1057/1131] Built Mathlib.Data.Multiset.Basic (2.2s)
✔ [1058/1131] Built Mathlib.Data.Set.Sigma (2.0s)
✔ [1059/1136] Built Mathlib.Order.Hom.Lattice (3.4s)
✔ [1060/1138] Built Mathlib.Order.Hom.Bounded (3.8s)
✔ [1061/1140] Built Aeneas.Tactic.Solver.ScalarTac.ScalarTac (6.0s)
✔ [1062/1142] Built Mathlib.Data.Set.Lattice.Image (3.8s)
✔ [1063/1143] Built Mathlib.Algebra.Order.SuccPred (3.4s)
✔ [1064/1147] Built Mathlib.Data.List.Sort (3.7s)
✔ [1065/1147] Built Mathlib.Logic.Function.DependsOn (2.5s)
✔ [1066/1147] Built Aeneas.Std.Core.Cmp (3.6s)
✔ [1067/1147] Built Mathlib.Data.Multiset.AddSub (3.3s)
✔ [1068/1147] Built Mathlib.Logic.Embedding.Set (3.2s)
✔ [1069/1148] Built Aeneas.Std.Core.Core (3.7s)
✔ [1070/1148] Built Mathlib.Control.Applicative (1.5s)
✔ [1071/1148] Built Mathlib.Control.Traversable.Basic (1.5s)
✔ [1072/1149] Built Mathlib.Order.Hom.BoundedLattice (4.3s)
✔ [1073/1151] Built Mathlib.Data.Vector.Defs (2.2s)
✔ [1074/1151] Built Mathlib.Order.SuccPred.Nat (2.3s)
✔ [1075/1155] Built Mathlib.Tactic.ApplyFun (2.1s)
✔ [1076/1155] Built Mathlib.Order.Setoid.Basic (2.5s)
✔ [1077/1155] Built Mathlib.Data.Multiset.Replicate (2.2s)
✔ [1078/1159] Built Mathlib.Data.List.NodupEquivFin (2.5s)
✔ [1079/1159] Built Aeneas.Std.Core.Convert (2.8s)
✔ [1080/1160] Built Aeneas.Std.Alloc.Alloc (2.8s)
✔ [1081/1161] Built Mathlib.Data.List.Zip (1.0s)
✔ [1082/1161] Built Mathlib.Data.List.Sublists (2.2s)
✔ [1083/1165] Built Mathlib.Data.Set.Lattice.Disjoint (1.9s)
✔ [1084/1165] Built Mathlib.Data.Nat.Bits (1.6s)
✔ [1085/1169] Built Mathlib.Order.SuccPred.ENat (2.4s)
✔ [1086/1169] Built Mathlib.Data.Multiset.MapFold (2.8s)
✔ [1087/1169] Built Mathlib.Data.Vector.Basic (3.3s)
✔ [1088/1169] Built Mathlib.Data.Nat.Pairing (2.2s)
✔ [1089/1169] Built Mathlib.Data.PNat.Equiv (1.7s)
✔ [1090/1169] Built Mathlib.Data.Nat.Order.Lemmas (2.0s)
✔ [1091/1171] Built Mathlib.Data.Set.Pairwise.Lattice (2.4s)
✔ [1092/1173] Built Aeneas.Std.Alloc.Boxed (3.4s)
✔ [1093/1175] Built Mathlib.Logic.Small.Set (1.9s)
✔ [1094/1179] Built Mathlib.Data.ENat.Pow (2.5s)
✔ [1095/1179] Built Mathlib.Data.List.MinMax (3.8s)
✔ [1096/1179] Built Mathlib.Logic.Equiv.Nat (1.8s)
✔ [1097/1179] Built Mathlib.Data.Finset.Attach (2.3s)
✔ [1098/1179] Built Mathlib.Data.Multiset.Filter (2.7s)
✔ [1099/1188] Built Mathlib.Order.Minimal (4.1s)
✔ [1100/1188] Built Mathlib.Order.RelIso.Set (1.9s)
✔ [1101/1188] Built Mathlib.Order.Prod.Lex.Basic (2.9s)
✔ [1102/1188] Built Aeneas.Std.Scalar.Core (9.3s)
✔ [1103/1188] Built Mathlib.SetTheory.Cardinal.Defs (2.1s)
✔ [1104/1189] Built Mathlib.Order.ConditionallyCompletePartialOrder.Indexed (2.6s)
✔ [1105/1190] Built Mathlib.Logic.Encodable.Basic (2.6s)
✔ [1106/1192] Built Mathlib.Basic.Countable.Basic (2.2s)
✔ [1107/1192] Built Mathlib.Algebra.BigOperators.Group.Multiset.Defs (2.3s)
✔ [1108/1192] Built Mathlib.Data.Finset.Filter (2.4s)
✔ [1109/1192] Built Mathlib.Order.Sum.Order (4.3s)
✔ [1110/1193] Built Mathlib.Data.Finset.Erase (2.2s)
✔ [1111/1193] Built Mathlib.Order.CompleteLattice.Chain (1.8s)
✔ [1112/1196] Built Mathlib.Order.UpperLower.Basic (4.3s)
✔ [1113/1199] Built Mathlib.Data.Multiset.UnionInter (2.5s)
✔ [1114/1199] Built Mathlib.Data.Int.Cast.Prod (1.6s)
✔ [1115/1200] Built Mathlib.Algebra.GroupWithZero.Prod (2.1s)
✔ [1116/1200] Built Mathlib.Algebra.Ring.CompTypeclasses (2.0s)
✔ [1117/1200] Built Mathlib.Order.Zorn (1.9s)
✔ [1118/1203] Built Mathlib.Data.Fintype.Defs (2.6s)
✔ [1119/1210] Built Mathlib.Data.Multiset.Dedup (2.1s)
✔ [1120/1210] Built Mathlib.Algebra.Group.Subsemigroup.Defs (2.4s)
✔ [1121/1210] Built Mathlib.Order.Hom.Lex (2.0s)
✔ [1122/1210] Built Mathlib.Order.ConditionallyCompleteLattice.Indexed (4.3s)
✔ [1123/1210] Built Mathlib.Data.Multiset.Range (2.2s)
✔ [1124/1210] Built Mathlib.Algebra.Group.Action.Defs (3.1s)
✔ [1125/1210] Built Mathlib.Algebra.Group.Conj (2.7s)
✔ [1126/1210] Built Mathlib.SetTheory.Cardinal.SchroederBernstein (2.3s)
✔ [1127/1215] Built Mathlib.Data.Finset.Dedup (1.0s)
✔ [1128/1215] Built Mathlib.Data.Multiset.Fold (1.0s)
✔ [1129/1215] Built Mathlib.Algebra.Ring.Prod (3.8s)
✔ [1130/1217] Built Mathlib.Algebra.Order.Group.Multiset (2.2s)
✔ [1131/1219] Built Mathlib.Data.Multiset.FinsetOps (2.4s)
✔ [1132/1219] Built Mathlib.Algebra.Group.Subsemigroup.Basic (2.4s)
✔ [1133/1219] Built Mathlib.Algebra.Group.Action.Faithful (1.6s)
✔ [1134/1219] Built Mathlib.Algebra.Group.Pi.Lemmas (4.0s)
✔ [1135/1219] Built Mathlib.Algebra.Group.Submonoid.Defs (3.2s)
✔ [1136/1219] Built Mathlib.Algebra.Group.Action.Opposite (2.1s)
✔ [1137/1219] Built Mathlib.Order.InitialSeg (3.5s)
✔ [1138/1219] Built Mathlib.Order.SuccPred.CompleteLinearOrder (2.9s)
✔ [1139/1219] Built Mathlib.Data.Multiset.Sum (2.1s)
✔ [1140/1221] Built Mathlib.Algebra.BigOperators.Group.Multiset.Basic (2.8s)
✔ [1141/1221] Built Mathlib.Data.Sym.Basic (3.1s)
✔ [1142/1222] Built Mathlib.Data.Multiset.Lattice (2.2s)
✔ [1143/1222] Built Mathlib.Data.Finset.Lattice.Basic (2.7s)
✔ [1144/1223] Built Mathlib.Algebra.Group.Submonoid.MulAction (2.2s)
✔ [1145/1223] Built Mathlib.Algebra.Group.Action.Units (2.4s)
✔ [1146/1223] Built Mathlib.Data.Finset.Insert (3.5s)
✔ [1147/1223] Built Mathlib.Algebra.Group.Pointwise.Set.Scalar (2.8s)
✔ [1148/1223] Built Mathlib.Logic.Function.CompTypeclasses (1.3s)
✔ [1149/1223] Built Mathlib.Algebra.Group.Center (5.4s)
✔ [1150/1226] Built Mathlib.Algebra.Group.Submonoid.Basic (3.1s)
✔ [1151/1226] Built Mathlib.Algebra.GroupWithZero.Action.Defs (2.7s)
✔ [1152/1226] Built Mathlib.Data.Multiset.Bind (2.5s)
✔ [1153/1231] Built Mathlib.Algebra.Regular.SMul (2.1s)
✔ [1154/1231] Built Mathlib.Algebra.Group.Action.Basic (2.1s)
✔ [1155/1231] Built Mathlib.Data.Finset.Range (2.4s)
✔ [1156/1231] Built Mathlib.Data.Finset.SDiff (2.6s)
✔ [1157/1231] Built Mathlib.Data.Finset.Lattice.Lemmas (2.5s)
✔ [1158/1231] Built Mathlib.Algebra.Group.Hom.CompTypeclasses (1.7s)
✔ [1159/1232] Built Mathlib.Data.Finset.Disjoint (2.5s)
✔ [1160/1234] Built Mathlib.GroupTheory.Subsemigroup.Center (1.8s)
✔ [1161/1234] Built Mathlib.Algebra.Group.Subgroup.Defs (5.1s)
✔ [1162/1234] Built Mathlib.Algebra.Group.Action.TypeTags (1.7s)
✔ [1163/1234] Built Mathlib.Algebra.Group.Submonoid.DistribMulAction (1.7s)
✔ [1164/1235] Built Mathlib.Algebra.Module.Defs (1.7s)
✔ [1165/1239] Built Mathlib.Algebra.GroupWithZero.Action.Units (1.8s)
✔ [1166/1245] Built Mathlib.Data.Multiset.Pi (2.0s)
✔ [1167/1248] Built Mathlib.Data.Multiset.Powerset (2.3s)
✔ [1168/1248] Built Mathlib.Algebra.Group.Action.Pretransitive (1.7s)
✔ [1169/1256] Built Mathlib.Algebra.Group.Support (2.1s)
✔ [1170/1258] Built Mathlib.Algebra.Group.Commute.Hom (1.8s)
✔ [1171/1263] Built Mathlib.Data.Finset.Basic (3.3s)
✔ [1172/1263] Built Mathlib.Algebra.Order.Group.Action (2.1s)
✔ [1173/1264] Built Mathlib.Data.Finset.Image (3.8s)
✔ [1174/1264] Built Mathlib.Algebra.Ring.Divisibility.Basic (2.5s)
✔ [1175/1264] Built Mathlib.GroupTheory.GroupAction.Defs (4.0s)
✔ [1176/1264] Built Mathlib.Algebra.Group.Action.Hom (2.1s)
✔ [1177/1264] Built Mathlib.Algebra.Group.Irreducible.Lemmas (1.8s)
✔ [1178/1266] Built Mathlib.Data.PNat.Basic (2.5s)
✔ [1179/1266] Built Mathlib.Data.List.Permutation (2.4s)
✔ [1180/1266] Built Mathlib.Dynamics.FixedPoints.Basic (2.2s)
✔ [1181/1267] Built Mathlib.Data.Finset.BooleanAlgebra (2.3s)
✔ [1182/1267] Built Mathlib.Algebra.Group.Submonoid.Operations (7.6s)
✔ [1183/1267] Built Mathlib.Data.Fintype.OfMap (2.2s)
✔ [1184/1267] Built Mathlib.Data.Finset.SymmDiff (2.2s)
✔ [1185/1267] Built Mathlib.Data.Finset.Fold (2.5s)
✔ [1186/1267] Built Mathlib.Algebra.GroupWithZero.Action.End (1.7s)
✔ [1187/1275] Built Mathlib.Algebra.Group.Embedding (1.6s)
✔ [1188/1275] Built Mathlib.Algebra.Prime.Lemmas (2.4s)
✔ [1189/1275] Built Mathlib.Data.Finset.Piecewise (2.5s)
✔ [1190/1277] Built Mathlib.Algebra.Group.Pointwise.Set.Basic (8.4s)
✔ [1191/1278] Built Mathlib.Algebra.Order.Ring.Abs (3.1s)
✔ [1192/1283] Built Mathlib.GroupTheory.Submonoid.Center (3.1s)
✔ [1193/1284] Built Mathlib.Data.Fintype.Sets (2.0s)
✔ [1194/1284] Built Mathlib.Algebra.Ring.Action.Basic (2.0s)
✔ [1195/1284] Built Mathlib.Data.Finset.Card (5.6s)
✔ [1196/1285] Built Mathlib.Data.Finset.Union (3.2s)
✔ [1197/1285] Built Mathlib.Algebra.Notation.Indicator (2.6s)
✔ [1198/1287] Built Mathlib.Algebra.Group.Pointwise.Set.Lattice (2.8s)
✔ [1199/1287] Built Mathlib.Algebra.Group.Subgroup.Lattice (5.4s)
✔ [1200/1287] Built Mathlib.Order.Hom.WithTopBot (3.7s)
✔ [1201/1287] Built Mathlib.Algebra.GroupWithZero.Associated (3.5s)
✔ [1202/1288] Built Mathlib.Algebra.Group.Subsemigroup.MulOpposite (2.5s)
✔ [1203/1288] Built Mathlib.Data.Fintype.Basic (2.8s)
✔ [1204/1288] Built Mathlib.Algebra.Group.Action.Pointwise.Set.Basic (3.3s)
✔ [1205/1288] Built Mathlib.Data.Finset.Sum (2.6s)
✔ [1206/1288] Built Mathlib.Algebra.Group.Idempotent (1.7s)
✔ [1207/1288] Built Mathlib.Data.Finset.Option (2.3s)
✔ [1208/1288] Built Mathlib.Data.Finset.Prod (3.1s)
✔ [1209/1288] Built Mathlib.Data.Finset.Pi (3.1s)
✔ [1210/1288] Built Mathlib.Algebra.BigOperators.Group.Finset.Defs (5.4s)
✔ [1211/1288] Built Mathlib.Algebra.FreeMonoid.Basic (3.9s)
✔ [1212/1289] Built Mathlib.Algebra.Ring.Associated (2.2s)
✔ [1213/1289] Built Mathlib.Algebra.Group.Submonoid.MulOpposite (2.2s)
✔ [1214/1289] Built Mathlib.Data.Nat.Prime.Basic (2.5s)
✔ [1215/1289] Built Mathlib.Algebra.Order.BigOperators.Group.List (2.8s)
✔ [1216/1289] Built Mathlib.Data.Fintype.Card (2.5s)
✔ [1217/1289] Built Mathlib.Algebra.Group.Submonoid.Finite (2.3s)
✔ [1218/1293] Built Mathlib.Algebra.Group.TransferInstance (2.3s)
✔ [1219/1293] Built Mathlib.Algebra.Group.Subgroup.Map (5.1s)
✔ [1220/1293] Built Mathlib.Order.Sigma.Lex (1.4s)
✔ [1221/1295] Built Mathlib.Algebra.CharP.Two (2.6s)
✔ [1222/1295] Built Mathlib.Order.CompleteLattice.Finset (2.0s)
✔ [1223/1300] Built Mathlib.Algebra.Group.Subgroup.MulOpposite (2.6s)
✔ [1224/1300] Built Mathlib.Data.Fintype.EquivFin (2.8s)
✔ [1225/1300] Built Mathlib.Algebra.Group.Commutator (1.5s)
✔ [1226/1300] Built Mathlib.Algebra.Group.Subgroup.ZPowers.Basic (2.9s)
✔ [1227/1300] Built Mathlib.Data.Finset.Lattice.Fold (5.3s)
✔ [1228/1300] Built Mathlib.GroupTheory.GroupAction.Hom (10s)
✔ [1229/1300] Built Mathlib.Algebra.Group.Action.End (2.8s)
✔ [1230/1300] Built Mathlib.GroupTheory.Subsemigroup.Centralizer (1.9s)
✔ [1231/1302] Built Mathlib.Algebra.GCDMonoid.Basic (5.8s)
✔ [1232/1306] Built Mathlib.Data.Fintype.Option (2.1s)
✔ [1233/1306] Built Mathlib.Data.Fintype.Prod (2.3s)
✔ [1234/1306] Built Mathlib.Algebra.BigOperators.Group.Finset.Basic (7.1s)
✔ [1235/1306] Built Mathlib.Data.Fintype.Sum (2.2s)
✔ [1236/1306] Built Mathlib.Basic.Denumerable (2.7s)
✔ [1237/1306] Built Mathlib.Algebra.Group.Subgroup.Ker (5.8s)
✔ [1238/1306] Built Mathlib.Data.ZMod.Defs (2.7s)
✔ [1239/1306] Built Mathlib.Algebra.Group.Submonoid.Membership (4.4s)
✔ [1240/1306] Built Mathlib.Data.Set.Finite.Basic (3.6s)
✔ [1241/1306] Built Mathlib.GroupTheory.Submonoid.Centralizer (1.0s)
✔ [1242/1306] Built Mathlib.Data.Finset.Lattice.Union (2.5s)
✔ [1243/1306] Built Mathlib.Data.Finset.Sigma (2.7s)
✔ [1244/1306] Built Mathlib.Algebra.GCDMonoid.Nat (2.3s)
✔ [1245/1306] Built Mathlib.Algebra.GCDMonoid.Multiset (2.3s)
✔ [1246/1306] Built Mathlib.Algebra.Group.Action.Prod (2.2s)
✔ [1247/1306] Built Mathlib.Algebra.GroupWithZero.Pointwise.Set.Basic (1.0s)
✔ [1248/1306] Built Mathlib.Data.Finset.Max (4.1s)
✔ [1249/1306] Built Mathlib.Algebra.BigOperators.GroupWithZero.Finset (2.2s)
✔ [1250/1306] Built Mathlib.Algebra.BigOperators.Option (2.2s)
✔ [1251/1306] Built Mathlib.SetTheory.Cardinal.Order (3.3s)
✔ [1252/1306] Built Mathlib.Logic.Equiv.List (2.4s)
✔ [1253/1306] Built Mathlib.Data.Finset.NoncommProd (3.4s)
✔ [1254/1310] Built Mathlib.Data.Set.Finite.Range (2.3s)
✔ [1255/1310] Built Mathlib.Data.Fintype.Pi (2.6s)
✔ [1256/1310] Built Mathlib.Algebra.BigOperators.Group.Finset.Piecewise (3.8s)
✔ [1257/1310] Built Mathlib.Order.Preorder.Finite (2.7s)
✔ [1258/1310] Built Mathlib.Algebra.BigOperators.Group.Finset.Sigma (2.4s)
✔ [1259/1310] Built Mathlib.Data.Finset.Powerset (3.0s)
✔ [1260/1310] Built Mathlib.Data.Finset.Preimage (2.6s)
✔ [1261/1314] Built Mathlib.Data.Fintype.Sigma (2.9s)
✔ [1262/1314] Built Mathlib.Algebra.GCDMonoid.Finset (2.6s)
✔ [1263/1314] Built Mathlib.Algebra.Quotient (2.2s)
✔ [1264/1314] Built Mathlib.Algebra.GroupWithZero.Action.Basic (2.7s)
✔ [1265/1315] Built Mathlib.Basic.Finite.Prod (2.5s)
✔ [1266/1315] Built Mathlib.Algebra.Group.Submonoid.BigOperators (3.1s)
✔ [1267/1315] Built Mathlib.Data.Set.Countable (2.8s)
✔ [1268/1315] Built Mathlib.Data.Set.Finite.Powerset (2.5s)
✔ [1269/1316] Built Mathlib.Data.Fintype.List (2.7s)
✔ [1270/1317] Built Mathlib.Data.Fintype.Powerset (2.3s)
✔ [1271/1319] Built Mathlib.Algebra.Group.Subgroup.Basic (7.9s)
✔ [1272/1319] Built Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set (2.4s)
✔ [1273/1319] Built Mathlib.GroupTheory.Coset.Defs (2.0s)
✔ [1274/1319] Built Mathlib.Algebra.Module.NatInt (2.6s)
✔ [1275/1325] Built Mathlib.Data.Fintype.Vector (2.7s)
✔ [1276/1325] Built Mathlib.GroupTheory.Congruence.Defs (4.2s)
✔ [1277/1325] Built Mathlib.Algebra.Group.Pointwise.Set.Finite (3.0s)
✔ [1278/1325] Built Mathlib.Algebra.Regular.Opposite (1.9s)
✔ [1279/1326] Built Mathlib.Algebra.GroupWithZero.Action.Opposite (2.4s)
✔ [1280/1328] Built Mathlib.Data.Set.Finite.Lattice (4.8s)
✔ [1281/1328] Built Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas (3.4s)
✔ [1282/1328] Built Mathlib.Logic.Equiv.Sigma (2.4s)
✔ [1283/1329] Built Mathlib.GroupTheory.Subgroup.Center (3.4s)
✔ [1284/1329] Built Mathlib.Data.List.Cycle (4.9s)
✔ [1285/1329] Built Mathlib.Order.Interval.Finset.Defs (7.4s)
✔ [1286/1329] Built Mathlib.Algebra.Module.Opposite (2.0s)
✔ [1287/1331] Built Mathlib.Data.Fintype.BigOperators (3.4s)
✔ [1288/1331] Built Mathlib.GroupTheory.Congruence.Hom (3.3s)
✔ [1289/1331] Built Mathlib.Data.Nat.Prime.Pow (2.2s)
✔ [1290/1331] Built Mathlib.Data.Nat.Log (2.5s)
✔ [1291/1331] Built Mathlib.Basic.Finite.Sigma (2.3s)
✔ [1292/1331] Built Mathlib.Algebra.Group.Subgroup.Actions (2.5s)
✔ [1293/1331] Built Mathlib.GroupTheory.Coset.Basic (5.8s)
✔ [1294/1335] Built Mathlib.Dynamics.PeriodicPts.Defs (2.9s)
✔ [1295/1335] Built Mathlib.GroupTheory.Subgroup.Centralizer (3.2s)
✔ [1296/1335] Built Mathlib.Order.ConditionallyCompleteLattice.Finset (3.7s)
✔ [1297/1335] Built Mathlib.Algebra.Order.BigOperators.Group.Multiset (2.7s)
✔ [1298/1336] Built Mathlib.Algebra.Order.Monoid.Multiset (1.9s)
✔ [1299/1336] Built Mathlib.Algebra.Module.Torsion.Free (2.6s)
✔ [1300/1339] Built Mathlib.Algebra.IsPrimePow (2.8s)
✔ [1301/1339] Built Mathlib.SetTheory.Cardinal.Basic (4.1s)
✔ [1302/1340] Built Mathlib.Algebra.Ring.CharZero (2.7s)
✔ [1303/1342] Built Mathlib.Order.Interval.Finset.Basic (5.3s)
✔ [1304/1342] Built Mathlib.GroupTheory.GroupAction.ConjAct (3.6s)
✔ [1305/1345] Built Mathlib.Order.Interval.Set.SuccPred (3.5s)
✔ [1306/1347] Built Mathlib.GroupTheory.QuotientGroup.Defs (4.0s)
✔ [1307/1347] Built Mathlib.Algebra.Order.Antidiag.Prod (3.7s)
✔ [1308/1347] Built Mathlib.Data.List.NatAntidiagonal (2.0s)
✔ [1309/1349] Built Mathlib.Data.List.Prime (1.9s)
✔ [1310/1349] Built Mathlib.Algebra.BigOperators.Ring.List (2.3s)
✔ [1311/1349] Built Mathlib.Order.Interval.Multiset (2.5s)
✔ [1312/1350] Built Mathlib.SetTheory.Cardinal.ENat (3.1s)
✔ [1313/1350] Built Mathlib.Algebra.Order.BigOperators.Group.Finset (5.4s)
✔ [1314/1350] Built Mathlib.GroupTheory.GroupAction.Basic (4.2s)
✔ [1315/1350] Built Mathlib.Data.Nat.Prime.Infinite (2.2s)
✔ [1316/1357] Built Mathlib.Order.Interval.Set.Infinite (2.2s)
✔ [1317/1357] Built Mathlib.GroupTheory.GroupAction.SubMulAction (7.3s)
✔ [1318/1357] Built Mathlib.Order.Interval.Finset.SuccPred (3.0s)
✔ [1319/1359] Built Mathlib.Data.Multiset.NatAntidiagonal (2.1s)
✔ [1320/1360] Built Mathlib.Tactic.FinCases (2.3s)
✔ [1321/1360] Built Aeneas.Tactic.Simproc.ReduceZMod.Init (1.7s)
✔ [1322/1362] Built Mathlib.Data.Nat.Factors (2.5s)
✔ [1323/1362] Built Mathlib.Algebra.Module.RingHom (2.0s)
✔ [1324/1362] Built Mathlib.SetTheory.Cardinal.ToNat (2.6s)
✔ [1325/1364] Built Mathlib.Order.Interval.Finset.Nat (3.0s)
✔ [1326/1364] Built Mathlib.Algebra.EuclideanDomain.Defs (1.0s)
✔ [1327/1365] Built Mathlib.Data.Finset.NatAntidiagonal (2.7s)
✔ [1328/1365] Built Mathlib.Algebra.Order.Interval.Finset.SuccPred (2.0s)
✔ [1329/1365] Built Mathlib.Data.Nat.Prime.Int (2.2s)
✔ [1330/1368] Built Mathlib.Data.Nat.PrimeFin (2.3s)
✔ [1331/1370] Built Mathlib.Algebra.GroupWithZero.Action.Regular (1.6s)
✔ [1332/1370] Built Aeneas.Tactic.Solver.ScalarTac.CondSimpTac (4.8s)
✔ [1333/1370] Built Mathlib.GroupTheory.Commutator.Basic (6.6s)
✔ [1334/1374] Built Mathlib.SetTheory.Cardinal.Finite (3.0s)
✔ [1335/1374] Built Mathlib.Algebra.EuclideanDomain.Field (2.0s)
✔ [1336/1374] Built Mathlib.Algebra.EuclideanDomain.Int (1.9s)
✔ [1337/1374] Built Mathlib.Algebra.Group.PUnit (1.5s)
✔ [1338/1374] Built Mathlib.Order.Lattice.Nat (2.7s)
✔ [1339/1374] Built Mathlib.Algebra.EuclideanDomain.Basic (2.0s)
✔ [1340/1374] Built Mathlib.Algebra.Ring.PUnit (1.3s)
✔ [1341/1374] Built Mathlib.Algebra.GroupWithZero.Units.Fintype (2.6s)
✔ [1342/1376] Built Mathlib.Algebra.GroupWithZero.NonZeroDivisors (3.9s)
✔ [1343/1376] Built Mathlib.Algebra.Module.Submodule.Defs (4.2s)
✔ [1344/1378] Built Mathlib.GroupTheory.Coset.Card (4.5s)
✔ [1345/1378] Built Mathlib.Tactic.Abel (4.6s)
✔ [1346/1379] Built Mathlib.GroupTheory.GroupAction.Quotient (5.5s)
✔ [1347/1389] Built Mathlib.Dynamics.PeriodicPts.Lemmas (3.2s)
✔ [1348/1390] Built Mathlib.Algebra.GroupWithZero.Idempotent (1.9s)
✔ [1349/1393] Built Mathlib.Algebra.Module.LinearMap.Defs (9.3s)
✔ [1350/1393] Built Mathlib.Algebra.Module.PUnit (2.3s)
✔ [1351/1393] Built Mathlib.Data.Set.Card (5.9s)
✔ [1352/1393] Built Mathlib.Order.OrderIsoNat (3.2s)
✔ [1353/1393] Built Mathlib.Algebra.GroupWithZero.Action.Prod (1.0s)
✔ [1354/1393] Built Mathlib.NumberTheory.Divisors (8.2s)
✔ [1355/1393] Built Mathlib.RingTheory.Ideal.Defs (2.3s)
✔ [1356/1396] Built Mathlib.Algebra.Ring.Idempotent (1.9s)
✔ [1357/1397] Built Mathlib.Algebra.Module.Submodule.Basic (2.4s)
✔ [1358/1397] Built Mathlib.Basic.Finite.Set (1.0s)
✔ [1359/1400] Built Mathlib.Data.Finset.Order (2.2s)
✔ [1360/1402] Built Mathlib.Data.Set.Lattice.Order (2.1s)
✔ [1361/1403] Built Mathlib.Order.WellQuasiOrder (2.3s)
✔ [1362/1405] Built Mathlib.Algebra.Algebra.Defs (3.1s)
✔ [1363/1410] Built Mathlib.Order.Hom.CompleteLattice (3.8s)
✔ [1364/1413] Built Mathlib.Algebra.Module.Prod (1.8s)
✔ [1365/1415] Built Mathlib.Data.Set.Monotone (2.1s)
✔ [1366/1415] Built Mathlib.SetTheory.Cardinal.NatCard (2.6s)
✔ [1367/1417] Built Mathlib.Order.Interval.Set.OrderIso (2.3s)
✔ [1368/1417] Built Mathlib.Order.Closure (2.7s)
✔ [1369/1419] Built Mathlib.Data.Finset.Lattice.Prod (2.7s)
✔ [1370/1419] Built Mathlib.Algebra.Module.Torsion.Field (2.2s)
✔ [1371/1419] Built Mathlib.Algebra.GroupWithZero.Pi (1.5s)
✔ [1372/1420] Built Mathlib.Algebra.Group.Action.Pi (2.2s)
✔ [1373/1421] Built Mathlib.Tactic.Ring.PNat (2.6s)
✔ [1374/1421] Built Mathlib.Order.WellFoundedSet (3.8s)
✔ [1375/1424] Built Mathlib.Algebra.Order.SuccPred.WithBot (2.1s)
✔ [1376/1424] Built Mathlib.Algebra.Group.Subgroup.Finite (3.4s)
✔ [1377/1424] Built Mathlib.Order.ModularLattice (3.9s)
✔ [1378/1424] Built Mathlib.Data.ENat.Lattice (3.3s)
✔ [1379/1424] Built Mathlib.Algebra.Ring.Pi (3.3s)
✔ [1380/1424] Built Mathlib.Algebra.Module.Equiv.Defs (9.1s)
✔ [1381/1424] Built Mathlib.Algebra.GroupWithZero.Action.Pi (2.9s)
✔ [1382/1424] Built Mathlib.Basic.Rel (3.0s)
✔ [1383/1424] Built Mathlib.Order.SupClosed (4.6s)
✔ [1384/1426] Built Mathlib.Tactic.Ring (2.0s)
✔ [1385/1429] Built Mathlib.Data.DFinsupp.Defs (5.6s)
✔ [1386/1434] Built Mathlib.Data.Fintype.Pigeonhole (2.2s)
✔ [1387/1434] Built Mathlib.Data.Fin.VecNotation (3.7s)
✔ [1388/1434] Built Mathlib.Algebra.Group.Submonoid.Pointwise (4.1s)
✔ [1389/1436] Built Mathlib.Algebra.Module.Equiv.Opposite (2.6s)
✔ [1390/1438] Built Mathlib.Algebra.Group.Hom.End (2.1s)
✔ [1391/1438] Built Mathlib.Algebra.Module.Pi (2.6s)
✔ [1392/1438] Built Mathlib.Algebra.GroupWithZero.Action.Hom (2.3s)
✔ [1393/1439] Built Mathlib.Algebra.GroupWithZero.ULift (2.0s)
✔ [1394/1439] Built Mathlib.Order.SupIndep (4.5s)
✔ [1395/1439] Built Mathlib.Algebra.Module.Submodule.Lattice (4.4s)
✔ [1396/1439] Built Mathlib.Algebra.GroupWithZero.Submonoid.Pointwise (2.6s)
✔ [1397/1439] Built Mathlib.Algebra.Module.End (2.3s)
✔ [1398/1439] Built Mathlib.Order.Atoms (6.0s)
✔ [1399/1439] Built Mathlib.Algebra.Module.Torsion.Pi (2.3s)
✔ [1400/1440] Built Mathlib.RingTheory.NonUnitalSubsemiring.Defs (3.1s)
✔ [1401/1441] Built Mathlib.Data.DFinsupp.Module (2.7s)
✔ [1402/1441] Built Mathlib.Algebra.Group.Subgroup.Pointwise (4.5s)
✔ [1403/1441] Built Mathlib.Algebra.Module.LinearMap.End (4.4s)
✔ [1404/1441] Built Mathlib.Order.RelSeries (5.0s)
✔ [1405/1442] Built Mathlib.Algebra.Ring.Action.Subobjects (2.3s)
✔ [1406/1442] Built Mathlib.GroupTheory.GroupAction.DomAct.Basic (3.2s)
✔ [1407/1443] Built Mathlib.Algebra.Module.ULift (2.9s)
✔ [1408/1443] Built Mathlib.RingTheory.Ideal.Lattice (2.4s)
✔ [1409/1443] Built Mathlib.Algebra.Module.Submodule.RestrictScalars (3.3s)
✔ [1410/1443] Built Mathlib.LinearAlgebra.Span.Defs (4.5s)
✔ [1411/1444] Built Mathlib.RingTheory.NonUnitalSubring.Defs (3.3s)
✔ [1412/1444] Built Mathlib.Algebra.Group.Subsemigroup.Membership (2.8s)
✔ [1413/1444] Built Mathlib.Order.CompactlyGenerated.Basic (4.3s)
✔ [1414/1444] Built Mathlib.Algebra.Ring.Subsemiring.Defs (3.7s)
✔ [1415/1447] Built Mathlib.Algebra.GroupWithZero.Subgroup (3.6s)
✔ [1416/1447] Built Mathlib.Algebra.GroupWithZero.Center (2.3s)
✔ [1417/1449] Built Mathlib.Algebra.Module.Submodule.LinearMap (5.1s)
✔ [1418/1449] Built Mathlib.Algebra.Group.Subsemigroup.Operations (6.2s)
✔ [1419/1453] Built Mathlib.Algebra.Ring.Center (3.7s)
✔ [1420/1455] Built Mathlib.Algebra.Module.Hom (4.3s)
✔ [1421/1459] Built Mathlib.Algebra.Ring.Centralizer (3.3s)
✔ [1422/1459] Built Mathlib.Algebra.Module.LinearMap.Basic (5.1s)
✔ [1423/1469] Built Mathlib.RingTheory.Ideal.Prime (4.3s)
✔ [1424/1472] Built Mathlib.Order.KrullDimension (6.8s)
✔ [1425/1473] Built Mathlib.Algebra.Ring.Submonoid.Basic (3.1s)
✔ [1426/1473] Built Mathlib.Algebra.Ring.Hom.InjSurj (2.3s)
✔ [1427/1473] Built Mathlib.GroupTheory.QuotientGroup.Basic (9.7s)
✔ [1428/1473] Built Mathlib.Algebra.Ring.Subring.Defs (5.4s)
✔ [1429/1473] Built Mathlib.Algebra.Group.Action.TransferInstance (3.3s)
✔ [1430/1473] Built Mathlib.Algebra.NoZeroSMulDivisors.Defs (3.1s)
✔ [1431/1473] Built Mathlib.Algebra.Ring.Aut (2.8s)
✔ [1432/1476] Built Mathlib.Algebra.Group.Pointwise.Set.ListOfFn (3.1s)
✔ [1433/1476] Built Mathlib.Algebra.Group.Pointwise.Set.BigOperators (3.6s)
✔ [1434/1478] Built Mathlib.Data.Finset.NAry (4.4s)
✔ [1435/1478] Built Mathlib.Algebra.GroupWithZero.Action.TransferInstance (3.2s)
✔ [1436/1478] Built Mathlib.Algebra.Ring.Action.Group (3.5s)
✔ [1437/1481] Built Mathlib.Algebra.Group.Shrink (3.9s)
✔ [1438/1483] Built Mathlib.Algebra.BigOperators.Group.Finset.Lemmas (3.6s)
✔ [1439/1483] Built Mathlib.Algebra.Module.Submodule.Map (8.7s)
✔ [1440/1483] Built Mathlib.Algebra.Group.IsApply (3.1s)
✔ [1441/1483] Built Mathlib.RingTheory.NonUnitalSubsemiring.Basic (6.6s)
✔ [1442/1484] Built Mathlib.Algebra.FiniteSupport.Defs (3.8s)
✔ [1443/1484] Built Mathlib.Algebra.GroupWithZero.Indicator (3.1s)
✔ [1444/1484] Built Mathlib.Algebra.Module.TransferInstance (4.3s)
✔ [1445/1484] Built Mathlib.Algebra.Group.Indicator (4.2s)
✔ [1446/1484] Built Mathlib.Algebra.Module.Basic (4.1s)
✔ [1447/1484] Built Mathlib.GroupTheory.Index (10s)
✔ [1448/1484] Built Mathlib.Algebra.Module.Submodule.Ker (5.2s)
✔ [1449/1488] Built Mathlib.Algebra.BigOperators.Pi (4.8s)
✔ [1450/1488] Built Mathlib.Algebra.Notation.FiniteSupport (3.2s)
✔ [1451/1488] Built Mathlib.Algebra.Module.Submodule.Pointwise (6.2s)
✔ [1452/1488] Built Mathlib.Algebra.BigOperators.Group.Finset.Pi (3.5s)
✔ [1453/1488] Built Mathlib.Algebra.Module.Equiv.Basic (16s)
✔ [1454/1492] Built Mathlib.Algebra.Module.Shrink (3.4s)
✔ [1455/1492] Built Mathlib.RingTheory.NonUnitalSubring.Basic (6.7s)
✔ [1456/1499] Built Mathlib.Algebra.Group.Pointwise.Finset.Basic (11s)
✔ [1457/1499] Built Mathlib.Algebra.Order.Group.Indicator (3.5s)
✔ [1458/1499] Built Mathlib.Algebra.Module.Submodule.EqLocus (3.8s)
✔ [1459/1500] Built Mathlib.Data.Multiset.Antidiagonal (3.3s)
✔ [1460/1506] Built Mathlib.Algebra.Ring.Subsemiring.Basic (8.3s)
✔ [1461/1506] Built Mathlib.Data.Multiset.Sections (3.0s)
✔ [1462/1508] Built Mathlib.Algebra.Order.Hom.GroupNorm (2.7s)
✔ [1463/1508] Built Mathlib.Algebra.Order.BigOperators.GroupWithZero.List (2.3s)
✔ [1464/1511] Built Mathlib.Algebra.Module.Submodule.Range (5.5s)
✔ [1465/1511] Built Mathlib.Algebra.Group.Pi.Torsion (2.1s)
✔ [1466/1511] Built Mathlib.Algebra.Order.BigOperators.Ring.List (2.9s)
✔ [1467/1517] Built Mathlib.Algebra.Order.BigOperators.GroupWithZero.Finset (3.5s)
✔ [1468/1519] Built Mathlib.Algebra.FiniteSupport.Basic (3.6s)
✔ [1469/1519] Built Mathlib.Data.List.Find (2.3s)
✔ [1470/1519] Built Mathlib.Algebra.Order.Hom.RingNorm (2.3s)
✔ [1471/1523] Built Mathlib.Algebra.BigOperators.Ring.Multiset (3.0s)
✔ [1472/1523] Built Mathlib.Algebra.Order.BigOperators.GroupWithZero.Multiset (2.6s)
✔ [1473/1523] Built Mathlib.Algebra.BigOperators.Group.Finset.Preimage (2.8s)
✔ [1474/1524] Built Mathlib.Data.Rat.BigOperators (2.6s)
✔ [1475/1524] Built Mathlib.Algebra.Ring.NonZeroDivisors (2.0s)
✔ [1476/1525] Built Mathlib.Data.Multiset.Find (2.8s)
✔ [1477/1525] Built Mathlib.Algebra.Ring.Submonoid.Pointwise (3.5s)
✔ [1478/1527] Built Mathlib.Algebra.Module.Submodule.Equiv (4.0s)
✔ [1479/1527] Built Mathlib.Algebra.Order.AbsoluteValue.Basic (4.0s)
✔ [1480/1527] Built Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise (3.7s)
✔ [1481/1528] Built Mathlib.Algebra.Order.Kleene (4.7s)
✔ [1482/1528] Built Mathlib.Algebra.BigOperators.Ring.Finset (4.6s)
✔ [1483/1528] Built Mathlib.Algebra.Order.BigOperators.Ring.Multiset (3.4s)
✔ [1484/1531] Built Mathlib.Data.Fintype.Lattice (3.2s)
✔ [1485/1531] Built Mathlib.Algebra.Ring.Subring.Basic (9.6s)
✔ [1486/1536] Built Mathlib.Data.Finsupp.Defs (4.1s)
✔ [1487/1536] Built Mathlib.Algebra.Field.IsField (2.9s)
✔ [1488/1536] Built Mathlib.RingTheory.Coprime.Basic (3.9s)
✔ [1489/1536] Built Mathlib.Data.Finset.Fin (3.0s)
✔ [1490/1536] Built Mathlib.Data.Set.Semiring (3.9s)
✔ [1491/1539] Built Mathlib.Order.Interval.Set.Fin (4.6s)
✔ [1492/1541] Built Mathlib.LinearAlgebra.Span.Basic (7.3s)
✔ [1493/1541] Built Mathlib.Algebra.Order.BigOperators.Ring.Finset (5.9s)
✔ [1494/1541] Built Mathlib.Data.Fintype.Order (4.4s)
✔ [1495/1541] Built Mathlib.Data.Finsupp.Single (4.3s)
✔ [1496/1545] Built Mathlib.GroupTheory.OrderOfElement (21s)
✔ [1497/1545] Built Mathlib.RingTheory.Coprime.Lemmas (4.6s)
✔ [1498/1545] Built Mathlib.Order.SuccPred.LinearLocallyFinite (4.0s)
✔ [1499/1545] Built Mathlib.Algebra.Algebra.Basic (6.9s)
✔ [1500/1545] Built Mathlib.Algebra.Order.Interval.Set.Monoid (2.7s)
✔ [1501/1545] Built Mathlib.Algebra.BigOperators.NatAntidiagonal (3.3s)
✔ [1502/1545] Built Mathlib.Order.Interval.Finset.Fin (5.0s)
✔ [1503/1547] Built Mathlib.Order.PartialSups (3.6s)
✔ [1504/1547] Built Mathlib.RingTheory.Ideal.Span (4.2s)
✔ [1505/1548] Built Mathlib.Data.Finsupp.Indicator (3.5s)
✔ [1506/1549] Built Mathlib.Algebra.Group.Finsupp (5.1s)
✔ [1507/1549] Built Mathlib.Algebra.Order.Interval.Finset.Basic (3.5s)
✔ [1508/1554] Built Mathlib.LinearAlgebra.BilinearMap (16s)
✔ [1509/1559] Built Mathlib.RingTheory.Multiplicity (6.3s)
✔ [1510/1559] Built Mathlib.Tactic.Order.CollectFacts (3.9s)
✔ [1511/1559] Built Mathlib.Data.ZMod.Basic (6.0s)
✔ [1512/1562] Built Mathlib.Order.Disjointed (4.0s)
✔ [1513/1562] Built Mathlib.Algebra.Algebra.Hom (6.4s)
✔ [1514/1564] Built Mathlib.RingTheory.Ideal.Maximal (4.5s)
✔ [1515/1564] Built Mathlib.Data.Finsupp.SMulWithZero (3.3s)
✔ [1516/1564] Built Mathlib.Data.Finsupp.Ext (2.9s)
✔ [1517/1564] Built Mathlib.Tactic.Order.Graph.Basic (2.0s)
✔ [1518/1564] Built Mathlib.Algebra.Module.Submodule.Bilinear (3.6s)
✔ [1519/1564] Built Mathlib.Algebra.BigOperators.Finprod (10s)
✔ [1520/1564] Built Mathlib.Tactic.Order.Preprocessing (2.6s)
✔ [1521/1564] Built Mathlib.Tactic.Order.ToInt (2.8s)
✔ [1522/1564] Built Mathlib.Order.Interval.Set.Disjoint (3.3s)
✔ [1523/1565] Built Mathlib.Order.Filter.Defs (3.9s)
✔ [1524/1565] Built Mathlib.Algebra.Algebra.ZMod (3.5s)
✔ [1525/1565] Built Mathlib.Tactic.Order.Graph.Tarjan (1.0s)
✔ [1526/1570] Built Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite (3.8s)
✔ [1527/1570] Built Mathlib.RingTheory.Ideal.Nonunits (3.2s)
✔ [1528/1570] Built Mathlib.Algebra.BigOperators.GroupWithZero.Action (3.3s)
✔ [1529/1570] Built Mathlib.Algebra.Order.Group.Basic (2.8s)
✔ [1530/1570] Built Mathlib.Algebra.Order.Group.Action.Synonym (2.1s)
✔ [1531/1571] Built Mathlib.Order.Filter.Basic (4.6s)
✔ [1532/1571] Built Mathlib.Tactic.Order (3.7s)
✔ [1533/1572] Built Mathlib.Algebra.BigOperators.Finsupp.Basic (6.1s)
✔ [1534/1574] Built Mathlib.Algebra.Order.GroupWithZero.Synonym (1.9s)
✔ [1535/1574] Built Mathlib.LinearAlgebra.TensorProduct.Defs (6.8s)
✔ [1536/1576] Built Mathlib.Algebra.Algebra.NonUnitalHom (7.5s)
✔ [1537/1576] Built Mathlib.Algebra.Algebra.Equiv (8.6s)
✔ [1538/1577] Built Mathlib.Algebra.Module.BigOperators (2.8s)
✔ [1539/1577] Built Mathlib.Algebra.Group.Fin.Tuple (2.7s)
✔ [1540/1577] Built Aeneas.Tactic.Simproc.ReduceZMod.ReduceZMod (6.3s)
✔ [1541/1577] Built Mathlib.Algebra.BigOperators.Intervals (4.6s)
✔ [1542/1577] Built Mathlib.Order.Filter.AtTopBot.Defs (2.5s)
✔ [1543/1577] Built Mathlib.Order.Filter.Map (3.8s)
✔ [1544/1577] Built Mathlib.Algebra.Order.GroupWithZero.Action.Synonym (2.9s)
✔ [1545/1578] Built Mathlib.Logic.Equiv.Fin.Basic (3.4s)
✔ [1546/1578] Built Mathlib.Algebra.Group.Graph (4.4s)
✔ [1547/1578] Built Mathlib.Algebra.Algebra.Prod (3.8s)
✔ [1548/1578] Built Mathlib.Order.Filter.AtTopBot.Disjoint (2.6s)
✔ [1549/1580] Built Mathlib.LinearAlgebra.Quotient.Defs (4.3s)
✔ [1550/1580] Built Mathlib.Algebra.Algebra.Opposite (4.0s)
✔ [1551/1585] Built Mathlib.Data.Nat.Choose.Sum (4.2s)
✔ [1552/1585] Built Mathlib.Order.Filter.Tendsto (2.7s)
✔ [1553/1595] Built Mathlib.Order.Filter.Bases.Basic (3.7s)
✔ [1554/1596] Built Mathlib.Data.Set.Finite.Lemmas (3.4s)
✔ [1555/1597] Built Mathlib.Data.Finsupp.Basic (10s)
✔ [1556/1597] Built Aeneas.Tactic.Solver.ScalarTac.Lemmas (8.2s)
✔ [1557/1597] Built Mathlib.LinearAlgebra.TensorProduct.Basic (9.1s)
✔ [1558/1597] Built Mathlib.Order.Filter.AtTopBot.Tendsto (2.7s)
✔ [1559/1597] Built Mathlib.Algebra.GroupWithZero.Submonoid.Primal (2.4s)
✔ [1560/1600] Built Mathlib.Data.BitVec (2.7s)
✔ [1561/1602] Built Mathlib.Algebra.Algebra.Tower (5.3s)
✔ [1562/1604] Built Mathlib.Algebra.Order.Module.Defs (7.9s)
✔ [1563/1610] Built Mathlib.Data.Finsupp.Option (3.4s)
✔ [1564/1611] Built Mathlib.Data.Finsupp.SMul (3.6s)
✔ [1565/1613] Built Mathlib.Order.Filter.AtTopBot.Basic (3.1s)
✔ [1566/1613] Built Aeneas.Std.Scalar.BvComp (4.8s)
✔ [1567/1613] Built Mathlib.GroupTheory.FreeGroup.Basic (8.0s)
✔ [1568/1620] Built Mathlib.RingTheory.UniqueFactorizationDomain.Defs (3.1s)
✔ [1569/1624] Built Mathlib.Data.List.GetD (1.6s)
✔ [1570/1624] Built Batteries.Data.Nat.Bitwise.Lemmas (724ms)
✔ [1571/1624] Built Mathlib.LinearAlgebra.Prod (9.7s)
✔ [1572/1624] Built Mathlib.Algebra.Order.Nonneg.Module (2.9s)
✔ [1573/1626] Built Aeneas.Tactic.Simp.SimpLemmas (1.8s)
✔ [1574/1628] Built Batteries.Data.Nat.Bitwise (610ms)
✔ [1575/1629] Built Mathlib.Tactic.Algebraize (3.9s)
✔ [1576/1629] Built Aeneas.Data.ListN (1.3s)
✔ [1577/1629] Built Batteries.Data.BitVec.Basic (735ms)
✔ [1578/1629] Built Batteries.Data.Fin.OfBits (598ms)
✔ [1579/1633] Built Batteries.Data.Int (724ms)
✔ [1580/1633] Built Aeneas.Std.Scalar.CloneCopy (4.4s)
✔ [1581/1639] Built Aeneas.Std.Core.Default (2.7s)
✔ [1582/1645] Built Batteries.Data.BitVec.Lemmas (781ms)
✔ [1583/1646] Built Aeneas.Tactic.Conv.Natify.Init (1.9s)
✔ [1584/1647] Built Mathlib.LinearAlgebra.Finsupp.Defs (5.5s)
✔ [1585/1647] Built Mathlib.Data.Nat.Bitwise (3.2s)
✔ [1586/1649] Built Aeneas.Data.Byte (2.9s)
✔ [1587/1649] Built Aeneas.Tactic.Conv.ZModify.Init (2.2s)
✔ [1588/1649] Built Mathlib.GroupTheory.Finiteness (6.2s)
✔ [1589/1650] Built Mathlib.LinearAlgebra.TensorProduct.Map (10s)
✔ [1590/1656] Built Aeneas.Tactic.Simproc.ReduceNat (2.0s)
✔ [1591/1657] Built Mathlib.LinearAlgebra.Pi (6.7s)
✔ [1592/1657] Built Aeneas.Std.SliceDef (4.4s)
✔ [1593/1657] Built Mathlib.LinearAlgebra.Finsupp.LSum (4.3s)
✔ [1594/1659] Built Aeneas.Std.Scalar.LeadingZeros (3.0s)
✔ [1595/1659] Built Mathlib.RingTheory.Finiteness.Defs (3.1s)
✔ [1596/1660] Built Aeneas.Tactic.Simp.SimpScalar.SimpScalar (4.1s)
✔ [1597/1661] Built Aeneas.Tactic.Simp.SimpLists.SimpLists (4.2s)
✔ [1598/1661] Built Aeneas.Std.Scalar.EqOrd (5.3s)
✔ [1599/1661] Built Mathlib.Algebra.Algebra.Bilinear (4.4s)
✔ [1600/1664] Built Aeneas.Std.Scalar.Pow (4.3s)
✔ [1601/1664] Built Aeneas.Std.Scalar.Rotate (4.1s)
✔ [1602/1670] Built Aeneas.Std.Scalar.SaturatingOps (4.0s)
✔ [1603/1670] Built Mathlib.LinearAlgebra.Finsupp.Supported (3.4s)
✔ [1604/1670] Built Aeneas.Std.StringDef (3.8s)
✔ [1605/1671] Built Aeneas.Std.Scalar.WrappingOps.Add (4.7s)
✔ [1606/1671] Built Aeneas.Std.Scalar.WrappingOps.Mul (4.5s)
✔ [1607/1678] Built Mathlib.RingTheory.Finiteness.Basic (4.5s)
✔ [1608/1678] Built Aeneas.Std.Scalar.WrappingOps.Shl (4.5s)
✔ [1609/1683] Built Aeneas.Std.Alloc.String (2.4s)
✔ [1610/1686] Built Aeneas.Std.Scalar.WrappingOps.Shr (4.1s)
✔ [1611/1692] Built Mathlib.Control.Lawful (1.3s)
✔ [1612/1693] Built Aeneas.Tactic.Simp.SimpScalar.Lemmas (4.8s)
✔ [1613/1695] Built Mathlib.Control.Monad.Writer (1.8s)
✔ [1614/1695] Built Aeneas.Std.RawPtr (4.1s)
✔ [1615/1696] Built Aeneas.Std.Scalar.WrappingOps.Sub (4.4s)
✔ [1616/1696] Built Mathlib.Algebra.Module.Submodule.Finsupp (3.2s)
✔ [1617/1696] Built Aeneas.Std.Core.Atomic (2.5s)
✔ [1618/1698] Built Mathlib.RingTheory.Noetherian.Defs (3.4s)
✔ [1619/1699] Built Mathlib.LinearAlgebra.Finsupp.LinearCombination (5.2s)
✔ [1620/1700] Built Aeneas.Std.Core.Panic (2.6s)
✔ [1621/1703] Built Aeneas.Std.Core.CoreResult (3.3s)
✔ [1622/1705] Built Aeneas.Std.Core.Marker (3.4s)
✔ [1623/1714] Built Aeneas.Std.Core.Pin (2.6s)
✔ [1624/1714] Built Mathlib.Control.Monad.Cont (2.0s)
✔ [1625/1716] Built Aeneas.Std.PrimitivesLemmas (3.3s)
✔ [1626/1716] Built Aeneas.Tactic.Simp.SimpScalar.Tests (4.5s)
✔ [1627/1719] Built Aeneas.Tactic.Simp.SimpIfs.Init (1.7s)
✔ [1628/1720] Built Aeneas.Data.Tuples (2.4s)
✔ [1629/1720] Built Mathlib.RingTheory.Ideal.Basic (3.2s)
✔ [1630/1722] Built Aeneas.Std.Core.Ptr (4.1s)
✔ [1631/1722] Built Aeneas.Std.Scalar.WrappingOps (3.0s)
✔ [1632/1724] Built Aeneas.Data.Range.DivRange.Basic (2.6s)
✔ [1633/1726] Built Aeneas.Data.Fin (3.9s)
✔ [1634/1743] Built Aeneas.Data.Range.Lemmas (2.5s)
✔ [1635/1744] Built Aeneas.Data.Range.MulRange.Basic (2.5s)
✔ [1636/1744] Built Aeneas.Tactic.Simp.SimpScalar (3.0s)
✔ [1637/1750] Built Aeneas.Do.Elab (5.2s)
✔ [1638/1750] Built Aeneas.Tactic.Simp.SimpIfs.SimpIfs (4.1s)
✔ [1639/1751] Built Aeneas.Data.Range.Notations (3.0s)
✔ [1640/1751] Built Aeneas.Tactic.Elab.TraitDefault.Test (1.0s)
✔ [1641/1751] Built Aeneas.Tactic.Misc.FCongr.FCongr (910ms)
✔ [1642/1752] Built Aeneas.Data.Range.SRRange.Basic (2.5s)
✔ [1643/1752] Built Mathlib.Algebra.Algebra.Operations (7.6s)
✔ [1644/1752] Built Aeneas.Std.Core.Alloc (4.0s)
✔ [1645/1752] Built Aeneas.Data.Range.DivRange.Lemmas (3.4s)
✔ [1646/1754] Built Aeneas.Tactic.Misc.FApplyExact (1.9s)
✔ [1647/1754] Built Aeneas.Tactic.Elab.TraitDefault (878ms)
✔ [1648/1755] Built Aeneas.Tactic.Misc.FCongr (819ms)
✔ [1649/1759] Built Aeneas.Tactic.RustAttributes (1.9s)
✔ [1650/1759] Built Aeneas.Tactic.Misc.Let.Let (2.4s)
✔ [1651/1762] Built Aeneas.Tactic.Elab (950ms)
✔ [1652/1765] Built Aeneas.Tactic.Simp.SimpIfs (3.6s)
✔ [1653/1768] Built Aeneas.Data.Range.DivRange.Notations (3.5s)
✔ [1654/1768] Built Aeneas.Tactic.Misc.Let (1.9s)
✔ [1655/1768] Built Aeneas.Data.Range.MulRange.Notations (3.9s)
✔ [1656/1773] Built Aeneas.Tactic.Solver.BvTac.Init (1.8s)
✔ [1657/1774] Built Aeneas.Tactic.Simp.SimpBoolProp (4.1s)
✔ [1658/1781] Built Aeneas.Data.Range.SRRange.Notations (4.1s)
✔ [1659/1782] Built Aeneas.Data.Range.MulRange.Lemmas (3.8s)
✔ [1660/1783] Built Aeneas.Tactic.Simp.RingEqNF.Tactic (3.6s)
✔ [1661/1783] Built Aeneas.Tactic.Solver.Grind (1.2s)
✔ [1662/1784] Built Aeneas.Tactic.Simproc.ReduceFin.Init (2.2s)
✔ [1663/1784] Built Aeneas.Tactic.Misc (2.6s)
✔ [1664/1805] Built Aeneas.Tactic.Simproc.ReduceZMod (4.1s)
✔ [1666/1817] Built Aeneas.Data.Range.DivRange (4.3s)
✔ [1667/1817] Built Aeneas.Tactic.Step.InferPost (3.7s)
✔ [1668/1817] Built Aeneas.Tactic.Simproc.ReduceFin.ReduceFin (2.6s)
✔ [1669/1817] Built Aeneas.Data.Range.MulRange (3.8s)
✔ [1670/1817] Built Mathlib.RingTheory.Ideal.Operations (8.1s)
✔ [1671/1817] Built Aeneas.Tactic.Simp.RingEqNF.Tests (3.0s)
✔ [1672/1817] Built Aeneas.Tactic.Solver.Grind.Tests (3.9s)
✔ [1673/1817] Built AeneasMeta.Split (4.8s)
⚠ [1674/1817] Built VarintSpec (2.3s)
warning: VarintSpec.lean: imports `Mathlib.Data.Nat.Log` from package `mathlib`, which is designed for use with the module system; consider adding `module` to the start of this file
✔ [1675/1817] Built Aeneas.Tactic.Simproc.ReduceFin (1.8s)
✔ [1676/1817] Built Mathlib.RingTheory.UniqueFactorizationDomain.Ideal (2.1s)
✔ [1677/1817] Built Aeneas.Tactic.Simp.RingEqNF (2.0s)
✔ [1678/1817] Built Mathlib.RingTheory.Noetherian.UniqueFactorizationDomain (2.1s)
✔ [1679/1817] Built Aeneas.Tactic.Solver.ScalarTac.Tests (8.5s)
✔ [1680/1817] Built Mathlib.RingTheory.Ideal.Maps (4.7s)
✔ [1681/1817] Built Mathlib.RingTheory.Ideal.Prod (1.6s)
✔ [1682/1817] Built Mathlib.RingTheory.PrincipalIdealDomain (2.0s)
✔ [1683/1817] Built Mathlib.RingTheory.Int.Basic (1.5s)
✔ [1684/1817] Built Aeneas.Tactic.Solver.Arith.Lemmas (2.5s)
✔ [1685/1817] Built Aeneas.Tactic.Solver.ScalarTac (2.4s)
✔ [1686/1817] Built Aeneas.Tactic.Solver.Arith (2.9s)
✔ [1687/1817] Built Aeneas.Tactic.Conv.Zify (2.0s)
✔ [1688/1817] Built Aeneas.Tactic.Conv.Natify.Natify (3.1s)
✔ [1689/1817] Built Aeneas.Tactic.Conv.ZModify.ZModify (3.4s)
✔ [1690/1817] Built Aeneas.Std.Range (4.2s)
✔ [1691/1817] Built Aeneas.Std.Scalar.Misc (4.5s)
✔ [1692/1817] Built Aeneas.Tactic.Step.GrindState (4.5s)
✔ [1693/1817] Built Aeneas.Tactic.Solver.ScalarDecrTac (4.8s)
✔ [1694/1817] Built Aeneas.Std.Scalar.Casts (5.1s)
✔ [1695/1817] Built Aeneas.Tactic.Conv.Natify (4.3s)
✔ [1696/1817] Built Aeneas.Tactic.Conv.ZModify (4.1s)
✔ [1697/1817] Built Aeneas.Std.Scalar.Bitwise (5.6s)
✔ [1698/1817] Built Aeneas.Data.List.List (8.3s)
✔ [1699/1817] Built Aeneas.Std.Scalar.Ops.Neg (4.3s)
✔ [1700/1817] Built Aeneas.Std.Scalar.Ops.Rem (5.2s)
✔ [1701/1817] Built Aeneas.Std.Scalar.Ops.Mul (5.3s)
✔ [1702/1817] Built Aeneas.Std.Scalar.Ops.Sub (5.5s)
✔ [1703/1817] Built Aeneas.Std.Scalar.Ops.Add (5.1s)
✔ [1704/1817] Built Aeneas.Std.Scalar.Ops.Div (6.6s)
✔ [1705/1817] Built Aeneas.Data.List (4.5s)
✔ [1706/1817] Built Aeneas.Std.Array.Core (5.0s)
✔ [1707/1817] Built Aeneas.Data.Range.SRRange.Lemmas (5.4s)
✔ [1708/1817] Built Aeneas.Std.Scalar.CheckedOps.Rem (4.8s)
✔ [1709/1817] Built Aeneas.Std.Scalar.CheckedOps.Mul (4.9s)
✔ [1710/1817] Built Aeneas.Std.Scalar.CheckedOps.Add (5.4s)
✔ [1711/1817] Built Aeneas.Std.Scalar.CheckedOps.Sub (5.6s)
✔ [1712/1817] Built Aeneas.Std.Scalar.Notations (5.8s)
✔ [1713/1817] Built Aeneas.Std.Scalar.Ops (4.9s)
✔ [1714/1817] Built Aeneas.Std.Scalar.CheckedOps.Div (5.5s)
✔ [1715/1817] Built Aeneas.Data.Array (5.2s)
✔ [1716/1817] Built Aeneas.Data.Range.SRRange (4.7s)
✔ [1717/1817] Built Aeneas.Std.Array.Array (6.3s)
✔ [1718/1817] Built Aeneas.Data.BitVec (7.3s)
✔ [1719/1817] Built Aeneas.Std.Scalar.Default (5.6s)
✔ [1720/1817] Built Aeneas.Std.Scalar.OverflowingOps.Mul (7.1s)
✔ [1721/1817] Built Aeneas.Std.Slice (9.3s)
✔ [1722/1817] Built Aeneas.Data.Discriminant (7.1s)
✔ [1723/1817] Built Aeneas.Std.Scalar.OverflowingOps.Sub (8.4s)
✔ [1724/1817] Built Aeneas.Std.Scalar.CheckedOps (5.6s)
✔ [1725/1817] Built Aeneas.Std.Scalar.OverflowingOps.Div (6.8s)
✔ [1726/1817] Built Aeneas.Data.Range (5.7s)
✔ [1727/1817] Built Aeneas.Data.Vector (6.4s)
✔ [1728/1817] Built Aeneas.Std.Core.Fmt (4.7s)
✔ [1729/1817] Built Aeneas.Std.Scalar.OverflowingOps.Add (12s)
✔ [1730/1817] Built Aeneas.Std.Core.Hash (5.1s)
✔ [1731/1817] Built Aeneas.Std.Scalar.CoreConvertNum (7.7s)
✔ [1732/1817] Built Aeneas.Data (5.2s)
✔ [1733/1817] Built Aeneas.Tactic.Setup (5.5s)
✔ [1734/1817] Built Aeneas.Std.Std.Io (5.3s)
✔ [1735/1817] Built Aeneas.Std.Core.Error (5.3s)
✔ [1736/1817] Built Aeneas.Std.Array.ArrayDebug (5.8s)
✔ [1737/1817] Built Aeneas.Std.Core.Iter (7.5s)
✔ [1738/1817] Built Aeneas.Std.Scalar.Fmt (5.2s)
✔ [1739/1817] Built Aeneas.Std.Scalar.Display (4.8s)
✔ [1740/1817] Built Aeneas.Std.Array.ArraySlice (7.1s)
✔ [1741/1817] Built Aeneas.Std.Scalar.OverflowingOps (3.0s)
✔ [1742/1817] Built Aeneas.Std.Core.Discriminant (3.8s)
✔ [1743/1817] Built Aeneas.Std.Std (3.8s)
✔ [1744/1817] Built Aeneas.Std.Array (2.8s)
✔ [1745/1817] Built Aeneas.Std.SliceIter (4.3s)
✔ [1746/1817] Built Aeneas.Std.Scalar (2.5s)
✔ [1747/1817] Built Aeneas.Std.String (3.1s)
✔ [1748/1817] Built Aeneas.Std.Target (3.4s)
✔ [1749/1817] Built Aeneas.Std.Alloc.Vec (4.8s)
✔ [1750/1817] Built Aeneas.Std.RangeIter (5.1s)
✔ [1751/1817] Built Aeneas.Std.Core.FmtWithSlice (3.7s)
✔ [1752/1817] Built Aeneas.Std.Core.CoreOption (3.8s)
✔ [1753/1817] Built Aeneas.Std.StringIter (3.0s)
✔ [1754/1817] Built Aeneas.Std.Alloc.Slice (3.3s)
✔ [1755/1817] Built Aeneas.Std.Alloc.Vec.IntoIter (3.3s)
✔ [1756/1817] Built Aeneas.Std.Core (2.5s)
✔ [1757/1817] Built Aeneas.Tactic.Conv.Bvify.Bvify (9.8s)
✔ [1758/1817] Built Aeneas.Std.Alloc (2.2s)
✔ [1759/1817] Built Aeneas.Std (2.2s)
✔ [1760/1817] Built Aeneas.Tactic.Conv.Bvify.Lemmas (3.1s)
✔ [1761/1817] Built Aeneas.Tactic.Conv.Bvify (2.0s)
✔ [1762/1817] Built Aeneas.Tactic.Conv.Bvify.Tests (3.3s)
✔ [1763/1817] Built Aeneas.Do.Delab (3.9s)
✔ [1764/1817] Built Aeneas.Tactic.Simp.SimpLists.Tests (6.1s)
✔ [1765/1817] Built Aeneas.Tactic.Conv (3.6s)
✔ [1766/1817] Built Aeneas.Command.Decompose.TestsRec (4.3s)
✔ [1767/1817] Built Aeneas.Do.Tests (4.0s)
✔ [1768/1817] Built Aeneas.Tactic.Simp.SimpLists (3.0s)
✔ [1769/1817] Built Aeneas.Command.Decompose.Tests (7.2s)
✔ [1770/1817] Built Aeneas.Tactic.Simp.SimpListsScalar (3.0s)
✔ [1771/1817] Built Aeneas.Do (3.6s)
✔ [1772/1817] Built Aeneas.Tactic.Simp (2.7s)
✔ [1773/1817] Built Aeneas.Command.Decompose.TestsBig (17s)
✔ [1774/1817] Built Aeneas.Tactic.Solver.BvTac.BvTac (19s)
✔ [1775/1817] Built Aeneas.Command (1.7s)
✔ [1776/1817] Built Aeneas.Tactic.Step.Step (10s)
✔ [1777/1817] Built Aeneas.Tactic.Simproc.BvSimprocs (3.9s)
✔ [1778/1817] Built Aeneas.Tactic.Step.Tests.DspecInduction (4.0s)
✔ [1779/1817] Built Aeneas.Tactic.Step.StepArraySpec (4.8s)
✔ [1780/1817] Built Aeneas.Tactic.Simproc (3.8s)
✔ [1781/1817] Built Aeneas.Tactic.Solver.BvTac.Lemmas (9.3s)
✔ [1782/1817] Built Aeneas.Tactic.Step.StepStar (9.7s)
✔ [1783/1817] Built Aeneas.Tactic.Solver.BvTac.Tests (12s)
✔ [1784/1817] Built Aeneas.Tactic.Solver.BvTac (2.9s)
✔ [1785/1817] Built Aeneas.Tactic.Step.Deprecated (2.8s)
✔ [1786/1817] Built Aeneas.Tactic.Solver (2.5s)
✔ [1787/1817] Built Aeneas.Tactic.Step (2.4s)
✔ [1788/1817] Built Aeneas.Tactic.Step.Tests.SpecParameters (4.5s)
✔ [1789/1817] Built Aeneas.Tactic.Step.Tests.MvcgenSpec (4.8s)
✔ [1790/1817] Built Aeneas.Tactic.Step.Tests.UncurryBind (5.1s)
✔ [1791/1817] Built Aeneas.Tactic.Step.Tests.MaxRecDepthMetavar (5.4s)
✔ [1792/1817] Built Aeneas.Tactic.Step.Tests.TupleDestruct (5.6s)
✔ [1793/1817] Built Aeneas.Tactic.Step.Tests.IntroOutputsRecursion (5.8s)
✔ [1794/1817] Built Aeneas.Tactic.Step.Tests.HigherOrderOption (6.1s)
✔ [1795/1817] Built Aeneas.Tactic.Step.Tests.Coin (6.5s)
✔ [1796/1817] Built Aeneas.Tactic.Step.Tests.HigherOrder (7.8s)
✔ [1797/1817] Built Aeneas.Tactic.Step.Tests.IntroOutputs (8.6s)
✔ [1798/1817] Built Aeneas.Tactic.Step.Tests.ParserErrors (4.4s)
✔ [1799/1817] Built Aeneas.Tactic.Step.Tests.DischargeTactic (4.3s)
✔ [1800/1817] Built Aeneas.Tactic.Step.Tests.Triple (4.3s)
✔ [1801/1817] Built Aeneas.Tactic.Step.Tests (2.3s)
✔ [1802/1817] Built Aeneas.Tactic.Tests (300ms)
✔ [1803/1817] Built Aeneas.Tactic (2.2s)
✔ [1804/1817] Built Aeneas (2.2s)
✔ [1805/1817] Built IntegerFixedDirect.Types (3.1s)
✔ [1806/1817] Built IntegerCore (3.3s)
✔ [1807/1817] Built IntegerFixedVec (3.3s)
✔ [1808/1817] Built IntegerVec (3.3s)
✔ [1809/1817] Built IntegerFixedDirect.FunsExternal (2.6s)
✔ [1810/1817] Built FixedSpec (7.2s)
✔ [1811/1817] Built Zigzag (3.0s)
✔ [1812/1817] Built IntegerFixedDirect.Funs (2.8s)
✔ [1813/1817] Built RequiredSpace (3.5s)
⚠ [1814/1817] Built FixedProofs (3.8s)
warning: FixedProofs.lean:936:15: This simp argument is unused:
IScalarTy.Isize_numBits_eq
Hint: Omit it from the simp argument list.
[apply] simp only [h64]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: FixedProofs.lean:947:13: This simp argument is unused:
IScalarTy.Isize_numBits_eq
Hint: Omit it from the simp argument list.
[apply] simp only [h64]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1815/1817] Built EncodeVar (3.0s)
✔ [1816/1817] Built FixedVec (4.1s)
✔ [1817/1817] Built VarintVec (3.0s)
Build completed successfully (1817 jobs).
$ lake env lean --stdin (proofs.rs formal extraction and axiom audit)
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.Usize","type_segments":[{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 8 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed","text":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"8"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.Usize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed","source":{"first_line":28,"last_line":43}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.bv","source":{"first_line":1112,"last_line":1112}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":674,"last_line":697,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.Usize) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Usize.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.usize_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.U16 (Aeneas.Std.Array Aeneas.Std.U8 2#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"2"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 2 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light","text":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"2"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light","source":{"first_line":205,"last_line":210}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}}],"definitions_truncated":false,"first_line":38,"last_line":42,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.U16\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.U16),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.U16\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.U16.bv x))))","theorem":"IntegerFixedVecProofs.u16_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I32","type_segments":[{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 4 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light","text":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"4"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32","source":{"first_line":677,"last_line":677}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light","source":{"first_line":397,"last_line":402}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32.bv","source":{"first_line":1116,"last_line":1116}}],"definitions_truncated":false,"first_line":67,"last_line":75,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I32),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1)))\n (IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.I32.bv x))))","theorem":"IntegerFixedProofs.i32_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 8 then\n ∃ v,\n out = Option.some v ∧\n ↑v = IntegerEncodingSpec.signedValue 64 (IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src))\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed","text":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"8"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":",\n "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"64"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize","source":{"first_line":674,"last_line":674}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed","source":{"first_line":285,"last_line":299}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.Isize","source":{"first_line":42,"last_line":42}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":922,"last_line":937,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1} (Option.{0} Aeneas.Std.Isize) fun (out : Option.{0} Aeneas.Std.Isize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.Isize))\n (IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.Isize) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Exists.{1} Aeneas.Std.Isize fun (v : Aeneas.Std.Isize) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.Isize) out (@Option.some.{0} Aeneas.Std.Isize v))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.Isize v)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))))))\n (@Eq.{1} (Option.{0} Aeneas.Std.Isize) out (@Option.none.{0} Aeneas.Std.Isize)))","theorem":"IntegerFixedProofs.isize_decode_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen ↑v ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"(↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U16","source":{"first_line":34,"last_line":34}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":185,"last_line":193}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":201,"last_line":211,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.U16) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U16 v))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U16 v) dst out)","theorem":"IntegerEncodingEncode.u16_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I32","type_segments":[{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness x = Aeneas.Std.Result.ok out ∧\n ↑out =\n IntegerEncodingSpec.signedValue 32\n (IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 4 x.bv.toNat).reverse)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness","text":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" =\n "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"32"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"4"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32","source":{"first_line":677,"last_line":677}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness","source":{"first_line":404,"last_line":410}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I32","source":{"first_line":45,"last_line":45}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32.bv","source":{"first_line":1116,"last_line":1116}}],"definitions_truncated":false,"first_line":888,"last_line":895,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I32),\n @Exists.{1} Aeneas.Std.I32 fun (out : Aeneas.Std.I32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.I32)\n (IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.I32 out))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I32 out)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (Aeneas.Std.I32.bv x)))))))","theorem":"IntegerFixedProofs.i32_switch_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I64","type_segments":[{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness x = Aeneas.Std.Result.ok out ∧\n ↑out =\n IntegerEncodingSpec.signedValue 64\n (IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 8 x.bv.toNat).reverse)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness","text":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" =\n "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"64"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64","source":{"first_line":678,"last_line":678}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness","source":{"first_line":356,"last_line":362}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I64","source":{"first_line":46,"last_line":46}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64.bv","source":{"first_line":1117,"last_line":1117}}],"definitions_truncated":false,"first_line":913,"last_line":920,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I64),\n @Exists.{1} Aeneas.Std.I64 fun (out : Aeneas.Std.I64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.I64)\n (IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.I64 out))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I64 out)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (Aeneas.Std.I64.bv x)))))))","theorem":"IntegerFixedProofs.i64_switch_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.I64","type_segments":[{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v) ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag ↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64","source":{"first_line":678,"last_line":678}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I64","source":{"first_line":46,"last_line":46}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":260,"last_line":276}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":171,"last_line":187,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.I64) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I64 v)))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I64 v))\n dst out)","theorem":"IntegerEncodingEncode.i64_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.I64","type_segments":[{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"}]}],"conclusion":"∃ out,\n integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64","source":{"first_line":678,"last_line":678}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":221,"last_line":226}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I64","source":{"first_line":46,"last_line":46}}],"definitions_truncated":false,"first_line":166,"last_line":170,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.I64),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I64 v))))","theorem":"IntegerRequiredSpace.i64_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 1 then\n ∃ v, out = Option.some v ∧ v.bv.toNat = IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src)\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed","text":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"1"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":", "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧ "},{"text":"v"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed","source":{"first_line":237,"last_line":251}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":330,"last_line":350,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Option.{0} Aeneas.Std.U8) fun (out : Option.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.U8))\n (IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.U8) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))\n (@Exists.{1} Aeneas.Std.U8 fun (v : Aeneas.Std.U8) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.U8) out (@Option.some.{0} Aeneas.Std.U8 v))\n (@Eq.{1} Nat\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.U8.bv v))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src)))))\n (@Eq.{1} (Option.{0} Aeneas.Std.U8) out (@Option.none.{0} Aeneas.Std.U8)))","theorem":"IntegerFixedProofs.u8_decode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.U64 (Aeneas.Std.Array Aeneas.Std.U8 8#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"8"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","text":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","source":{"first_line":109,"last_line":114}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}}],"definitions_truncated":false,"first_line":50,"last_line":54,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.U64\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.U64),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.U64\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.U64.bv x))))","theorem":"IntegerFixedVecProofs.u64_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.Usize","type_segments":[{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen ↑v ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"(↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":149,"last_line":157}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":225,"last_line":235,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.Usize) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize v))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize v) dst out)","theorem":"IntegerEncodingEncode.usize_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I32","type_segments":[{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 4 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 4 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed","text":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"4"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"4"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32","source":{"first_line":677,"last_line":677}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed","source":{"first_line":364,"last_line":379}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32.bv","source":{"first_line":1116,"last_line":1116}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":269,"last_line":292,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I32) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.I32.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.i32_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I64","type_segments":[{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 8 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed","text":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"8"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64","source":{"first_line":678,"last_line":678}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed","source":{"first_line":316,"last_line":331}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64.bv","source":{"first_line":1117,"last_line":1117}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":297,"last_line":320,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I64) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.I64.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.i64_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]}],"conclusion":"∃ out,\n integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen ↑v","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":93,"last_line":98}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U64","source":{"first_line":36,"last_line":36}}],"definitions_truncated":false,"first_line":116,"last_line":120,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.U64),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U64 v)))","theorem":"IntegerRequiredSpace.u64_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.Isize","type_segments":[{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.Isize × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.Isize → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyIsize\n integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (IntegerEncodingSpec.zigzag ↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyIsize","text":"Aeneas.Std.core.marker.CopyIsize"},{"text":"\n "},{"ref":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize","source":{"first_line":674,"last_line":674}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyIsize","source":{"first_line":33,"last_line":36}},{"module":"IntegerCore","name":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":213,"last_line":219}},{"module":"IntegerCore","name":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":278,"last_line":286}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.Isize","source":{"first_line":42,"last_line":42}}],"definitions_truncated":false,"first_line":159,"last_line":169,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.Isize)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.Isize Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.Isize → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.Isize\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.Isize Aeneas.Std.core.marker.CopyIsize\n integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec\n (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.Isize value)) out)","theorem":"IntegerEncodingVec.isize_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.I16","type_segments":[{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.I16 × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.I16 → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyI16\n integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (IntegerEncodingSpec.zigzag ↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyI16","text":"Aeneas.Std.core.marker.CopyI16"},{"text":"\n "},{"ref":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16","source":{"first_line":676,"last_line":676}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyI16","source":{"first_line":33,"last_line":36}},{"module":"IntegerCore","name":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":306,"last_line":312}},{"module":"IntegerCore","name":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":314,"last_line":322}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I16","source":{"first_line":44,"last_line":44}}],"definitions_truncated":false,"first_line":123,"last_line":133,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.I16)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.I16 Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.I16 → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.I16\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.I16 Aeneas.Std.core.marker.CopyI16\n integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec\n (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I16 value)) out)","theorem":"IntegerEncodingVec.i16_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.I32","type_segments":[{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.I32 × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.I32 → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyI32\n integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (IntegerEncodingSpec.zigzag ↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyI32","text":"Aeneas.Std.core.marker.CopyI32"},{"text":"\n "},{"ref":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32","source":{"first_line":677,"last_line":677}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyI32","source":{"first_line":33,"last_line":36}},{"module":"IntegerCore","name":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":288,"last_line":294}},{"module":"IntegerCore","name":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":296,"last_line":304}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I32","source":{"first_line":45,"last_line":45}}],"definitions_truncated":false,"first_line":135,"last_line":145,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.I32)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.I32 Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.I32 → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.I32\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.I32 Aeneas.Std.core.marker.CopyI32\n integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec\n (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I32 value)) out)","theorem":"IntegerEncodingVec.i32_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness x = Aeneas.Std.Result.ok out ∧\n out.bv.toNat = IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 2 x.bv.toNat).reverse","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness","text":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"2"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness","source":{"first_line":212,"last_line":218}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}}],"definitions_truncated":false,"first_line":393,"last_line":404,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U16),\n @Exists.{1} Aeneas.Std.U16 fun (out : Aeneas.Std.U16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U16)\n (IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U16 out))\n (@Eq.{1} Nat\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.U16.bv out))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.U16.bv x))))))","theorem":"IntegerFixedProofs.u16_switch","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I64","type_segments":[{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","text":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64","source":{"first_line":678,"last_line":678}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","source":{"first_line":349,"last_line":354}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64.bv","source":{"first_line":1117,"last_line":1117}}],"definitions_truncated":false,"first_line":77,"last_line":85,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I64),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)))\n (IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.I64.bv x))))","theorem":"IntegerFixedProofs.i64_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.U64 × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.U64 → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyU64\n integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyU64","text":"Aeneas.Std.core.marker.CopyU64"},{"text":"\n "},{"ref":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"(↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyU64","source":{"first_line":28,"last_line":31}},{"module":"IntegerCore","name":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":93,"last_line":98}},{"module":"IntegerCore","name":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":132,"last_line":147}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U64","source":{"first_line":36,"last_line":36}}],"definitions_truncated":false,"first_line":87,"last_line":97,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.U64)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.U64 Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.U64 → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.U64\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.U64 Aeneas.Std.core.marker.CopyU64\n integer_encoding.U64.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U64 value) out)","theorem":"IntegerEncodingVec.u64_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness x = Aeneas.Std.Result.ok out ∧\n out.bv.toNat = IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 1 x.bv.toNat).reverse","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness","text":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"1"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness","source":{"first_line":260,"last_line":266}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}}],"definitions_truncated":false,"first_line":352,"last_line":363,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U8),\n @Exists.{1} Aeneas.Std.U8 fun (out : Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U8)\n (IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U8 out))\n (@Eq.{1} Nat (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.U8.bv out))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.U8.bv x))))))","theorem":"IntegerFixedProofs.u8_switch","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.I32","type_segments":[{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v) ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag ↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32","source":{"first_line":677,"last_line":677}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I32","source":{"first_line":45,"last_line":45}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":296,"last_line":304}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":261,"last_line":271,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.I32) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I32 v)))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.I32.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I32 v))\n dst out)","theorem":"IntegerEncodingEncode.i32_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 2 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 2 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed","text":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"2"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"2"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed","source":{"first_line":172,"last_line":187}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":129,"last_line":152,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U16) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.U16.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.u16_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.I32","type_segments":[{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"}]}],"conclusion":"∃ out,\n integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32","source":{"first_line":677,"last_line":677}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":288,"last_line":294}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I32","source":{"first_line":45,"last_line":45}}],"definitions_truncated":false,"first_line":155,"last_line":164,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.I32),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.I32.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I32 v))))","theorem":"IntegerRequiredSpace.i32_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 2 then\n ∃ v, out = Option.some v ∧ v.bv.toNat = IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src)\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed","text":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"2"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":", "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧ "},{"text":"v"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed","source":{"first_line":189,"last_line":203}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":371,"last_line":391,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Option.{0} Aeneas.Std.U16) fun (out : Option.{0} Aeneas.Std.U16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.U16))\n (IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.U16) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))\n (@Exists.{1} Aeneas.Std.U16 fun (v : Aeneas.Std.U16) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.U16) out (@Option.some.{0} Aeneas.Std.U16 v))\n (@Eq.{1} Nat\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.U16.bv v))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src)))))\n (@Eq.{1} (Option.{0} Aeneas.Std.U16) out (@Option.none.{0} Aeneas.Std.U16)))","theorem":"IntegerFixedProofs.u16_decode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.I16","type_segments":[{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"}]}],"conclusion":"∃ out,\n integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16","source":{"first_line":676,"last_line":676}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":306,"last_line":312}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I16","source":{"first_line":44,"last_line":44}}],"definitions_truncated":false,"first_line":144,"last_line":153,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.I16),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.I16.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I16 v))))","theorem":"IntegerRequiredSpace.i16_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.Isize","type_segments":[{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness x = Aeneas.Std.Result.ok out ∧\n ↑out =\n IntegerEncodingSpec.signedValue 64\n (IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 8 x.bv.toNat).reverse)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness","text":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" =\n "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"64"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.Isize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize","source":{"first_line":674,"last_line":674}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness","source":{"first_line":308,"last_line":314}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.Isize","source":{"first_line":42,"last_line":42}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize.bv","source":{"first_line":1119,"last_line":1119}}],"definitions_truncated":false,"first_line":939,"last_line":947,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.Isize)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1} Aeneas.Std.Isize fun (out : Aeneas.Std.Isize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Isize)\n (IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Isize out))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.Isize out)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Isize.bv x)))))))","theorem":"IntegerFixedProofs.isize_switch_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 1 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 1 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed","text":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"1"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"1"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed","source":{"first_line":220,"last_line":235}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":101,"last_line":124,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U8) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.U8.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.u8_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.Usize","type_segments":[{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.Usize × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.Usize → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyUsize\n integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyUsize","text":"Aeneas.Std.core.marker.CopyUsize"},{"text":"\n "},{"ref":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"(↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyUsize","source":{"first_line":28,"last_line":31}},{"module":"IntegerCore","name":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":85,"last_line":91}},{"module":"IntegerCore","name":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":149,"last_line":157}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":99,"last_line":109,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.Usize)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.Usize Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.Usize → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.Usize\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.Usize Aeneas.Std.core.marker.CopyUsize\n integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize value) out)","theorem":"IntegerEncodingVec.usize_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.I8 (Aeneas.Std.Array Aeneas.Std.U8 1#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I8","type_segments":[{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 1 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light","text":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"1"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8","source":{"first_line":675,"last_line":675}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light","source":{"first_line":493,"last_line":498}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8.bv","source":{"first_line":1114,"last_line":1114}}],"definitions_truncated":false,"first_line":56,"last_line":60,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.I8\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.I8),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.I8\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.I8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.I8.bv x))))","theorem":"IntegerFixedVecProofs.i8_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 8 then\n ∃ v, out = Option.some v ∧ v.bv.toNat = IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src)\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed","text":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"8"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":", "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧ "},{"text":"v"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed","source":{"first_line":93,"last_line":107}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":453,"last_line":473,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Option.{0} Aeneas.Std.U64) fun (out : Option.{0} Aeneas.Std.U64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.U64))\n (IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.U64) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Exists.{1} Aeneas.Std.U64 fun (v : Aeneas.Std.U64) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.U64) out (@Option.some.{0} Aeneas.Std.U64 v))\n (@Eq.{1} Nat\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.U64.bv v))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src)))))\n (@Eq.{1} (Option.{0} Aeneas.Std.U64) out (@Option.none.{0} Aeneas.Std.U64)))","theorem":"IntegerFixedProofs.u64_decode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 4 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light","text":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"4"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light","source":{"first_line":157,"last_line":162}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}}],"definitions_truncated":false,"first_line":27,"last_line":35,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U32),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1)))\n (IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.U32.bv x))))","theorem":"IntegerFixedProofs.u32_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 1 then\n ∃ v,\n out = Option.some v ∧\n ↑v = IntegerEncodingSpec.signedValue 8 (IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src))\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed","text":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"1"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":",\n "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"8"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8","source":{"first_line":675,"last_line":675}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed","source":{"first_line":477,"last_line":491}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I8","source":{"first_line":43,"last_line":43}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":822,"last_line":836,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Option.{0} Aeneas.Std.I8) fun (out : Option.{0} Aeneas.Std.I8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.I8))\n (IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.I8) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))\n (@Exists.{1} Aeneas.Std.I8 fun (v : Aeneas.Std.I8) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.I8) out (@Option.some.{0} Aeneas.Std.I8 v))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I8 v)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))))))\n (@Eq.{1} (Option.{0} Aeneas.Std.I8) out (@Option.none.{0} Aeneas.Std.I8)))","theorem":"IntegerFixedProofs.i8_decode_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.I8","type_segments":[{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v) ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag ↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8","source":{"first_line":675,"last_line":675}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I8","source":{"first_line":43,"last_line":43}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":332,"last_line":340}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":237,"last_line":247,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.I8) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I8 v)))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I8 v))\n dst out)","theorem":"IntegerEncodingEncode.i8_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.I64","type_segments":[{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.I64 × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.I64 → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyI64\n integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (IntegerEncodingSpec.zigzag ↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyI64","text":"Aeneas.Std.core.marker.CopyI64"},{"text":"\n "},{"ref":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64","source":{"first_line":678,"last_line":678}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyI64","source":{"first_line":33,"last_line":36}},{"module":"IntegerCore","name":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":221,"last_line":226}},{"module":"IntegerCore","name":"integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":260,"last_line":276}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I64","source":{"first_line":46,"last_line":46}}],"definitions_truncated":false,"first_line":147,"last_line":157,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.I64)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.I64 Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.I64 → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.I64\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.I64 Aeneas.Std.core.marker.CopyI64\n integer_encoding.I64.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.I64.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec\n (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I64 value)) out)","theorem":"IntegerEncodingVec.i64_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 4 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 4 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed","text":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"4"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"4"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed","source":{"first_line":124,"last_line":139}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":157,"last_line":180,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U32) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.U32.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.u32_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 2 then\n ∃ v,\n out = Option.some v ∧\n ↑v = IntegerEncodingSpec.signedValue 16 (IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src))\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed","text":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"2"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":",\n "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"16"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16","source":{"first_line":676,"last_line":676}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed","source":{"first_line":429,"last_line":443}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I16","source":{"first_line":44,"last_line":44}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":847,"last_line":861,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Option.{0} Aeneas.Std.I16) fun (out : Option.{0} Aeneas.Std.I16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.I16))\n (IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.I16) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))\n (@Exists.{1} Aeneas.Std.I16 fun (v : Aeneas.Std.I16) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.I16) out (@Option.some.{0} Aeneas.Std.I16 v))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I16 v)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))))))\n (@Eq.{1} (Option.{0} Aeneas.Std.I16) out (@Option.none.{0} Aeneas.Std.I16)))","theorem":"IntegerFixedProofs.i16_decode_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.U32 (Aeneas.Std.Array Aeneas.Std.U8 4#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"4"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 4 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light","text":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"4"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light","source":{"first_line":157,"last_line":162}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}}],"definitions_truncated":false,"first_line":44,"last_line":48,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.U32\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.U32),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.U32\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.U32.bv x))))","theorem":"IntegerFixedVecProofs.u32_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 4 then\n ∃ v, out = Option.some v ∧ v.bv.toNat = IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src)\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed","text":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"4"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":", "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧ "},{"text":"v"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed","source":{"first_line":141,"last_line":155}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":412,"last_line":432,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Option.{0} Aeneas.Std.U32) fun (out : Option.{0} Aeneas.Std.U32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.U32))\n (IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.U32) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4))))\n (@Exists.{1} Aeneas.Std.U32 fun (v : Aeneas.Std.U32) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.U32) out (@Option.some.{0} Aeneas.Std.U32 v))\n (@Eq.{1} Nat\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.U32.bv v))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src)))))\n (@Eq.{1} (Option.{0} Aeneas.Std.U32) out (@Option.none.{0} Aeneas.Std.U32)))","theorem":"IntegerFixedProofs.u32_decode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen ↑v","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":195,"last_line":201}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}}],"definitions_truncated":false,"first_line":83,"last_line":92,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.U8),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 v)))","theorem":"IntegerRequiredSpace.u8_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.Isize","type_segments":[{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 8 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed","text":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"8"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.Isize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize","source":{"first_line":674,"last_line":674}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed","source":{"first_line":268,"last_line":283}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize.bv","source":{"first_line":1119,"last_line":1119}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":757,"last_line":780,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.Isize) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Isize.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.isize_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.U8 (Aeneas.Std.Array Aeneas.Std.U8 1#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 1 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light","text":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"1"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light","source":{"first_line":253,"last_line":258}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}}],"definitions_truncated":false,"first_line":32,"last_line":36,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.U8\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.U8),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.U8\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.U8.bv x))))","theorem":"IntegerFixedVecProofs.u8_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","text":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","source":{"first_line":109,"last_line":114}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}}],"definitions_truncated":false,"first_line":37,"last_line":45,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U64),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)))\n (IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.U64.bv x))))","theorem":"IntegerFixedProofs.u64_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I16","type_segments":[{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 2 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light","text":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"2"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16","source":{"first_line":676,"last_line":676}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light","source":{"first_line":445,"last_line":450}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16.bv","source":{"first_line":1115,"last_line":1115}}],"definitions_truncated":false,"first_line":57,"last_line":65,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I16),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1)))\n (IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.I16.bv x))))","theorem":"IntegerFixedProofs.i16_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 4 then\n ∃ v,\n out = Option.some v ∧\n ↑v = IntegerEncodingSpec.signedValue 32 (IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src))\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed","text":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"4"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":",\n "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"32"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32","source":{"first_line":677,"last_line":677}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed","source":{"first_line":381,"last_line":395}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I32","source":{"first_line":45,"last_line":45}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":872,"last_line":886,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Option.{0} Aeneas.Std.I32) fun (out : Option.{0} Aeneas.Std.I32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.I32))\n (IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.I32) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4))))\n (@Exists.{1} Aeneas.Std.I32 fun (v : Aeneas.Std.I32) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.I32) out (@Option.some.{0} Aeneas.Std.I32 v))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I32 v)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))))))\n (@Eq.{1} (Option.{0} Aeneas.Std.I32) out (@Option.none.{0} Aeneas.Std.I32)))","theorem":"IntegerFixedProofs.i32_decode_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.Isize","type_segments":[{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v) ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag ↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize","source":{"first_line":674,"last_line":674}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.Isize","source":{"first_line":42,"last_line":42}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":278,"last_line":286}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":273,"last_line":283,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.Isize) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.Isize v)))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.Isize v))\n dst out)","theorem":"IntegerEncodingEncode.isize_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.U8 × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.U8 → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyU8\n integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyU8","text":"Aeneas.Std.core.marker.CopyU8"},{"text":"\n "},{"ref":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"(↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyU8","source":{"first_line":28,"last_line":31}},{"module":"IntegerCore","name":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":195,"last_line":201}},{"module":"IntegerCore","name":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":203,"last_line":211}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}}],"definitions_truncated":false,"first_line":51,"last_line":61,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.U8)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.U8 Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.U8 → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.U8\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.U8 Aeneas.Std.core.marker.CopyU8\n integer_encoding.U8.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 value) out)","theorem":"IntegerEncodingVec.u8_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.I64 (Aeneas.Std.Array Aeneas.Std.U8 8#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"8"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I64","type_segments":[{"ref":"Aeneas.Std.I64","text":"Aeneas.Std.I64"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","text":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64","source":{"first_line":678,"last_line":678}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","source":{"first_line":349,"last_line":354}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64.bv","source":{"first_line":1117,"last_line":1117}}],"definitions_truncated":false,"first_line":74,"last_line":78,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.I64\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.I64),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.I64\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.I64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.I64.bv x))))","theorem":"IntegerFixedVecProofs.i64_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 1 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light","text":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"1"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light","source":{"first_line":253,"last_line":258}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}}],"definitions_truncated":false,"first_line":7,"last_line":15,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U8),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1)))\n (IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.U8.bv x))))","theorem":"IntegerFixedProofs.u8_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness x = Aeneas.Std.Result.ok out ∧\n out.bv.toNat = IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 4 x.bv.toNat).reverse","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness","text":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"4"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness","source":{"first_line":164,"last_line":170}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}}],"definitions_truncated":false,"first_line":434,"last_line":445,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U32),\n @Exists.{1} Aeneas.Std.U32 fun (out : Aeneas.Std.U32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U32)\n (IntegerFixedDirect.U32.Insts.Integer_encodingFixedFixedIntArrayU84.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U32 out))\n (@Eq.{1} Nat\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.U32.bv out))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.U32.bv x))))))","theorem":"IntegerFixedProofs.u32_switch","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"u","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen ↑u ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"u"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var u dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (↑u) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"u"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"(↑"},{"text":"u"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U64","source":{"first_line":36,"last_line":36}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":132,"last_line":147}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":130,"last_line":169,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (u : Aeneas.Std.U64) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U64 u))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.U64.Insts.Integer_encodingVarintVarInt.encode_var u dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U64 u) dst out)","theorem":"IntegerEncodingEncode.u64_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness x = Aeneas.Std.Result.ok out ∧\n out.bv.toNat = IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 8 x.bv.toNat).reverse","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness","text":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness","source":{"first_line":116,"last_line":122}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}}],"definitions_truncated":false,"first_line":475,"last_line":486,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U64),\n @Exists.{1} Aeneas.Std.U64 fun (out : Aeneas.Std.U64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U64)\n (IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U64 out))\n (@Eq.{1} Nat\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.U64.bv out))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.U64.bv x))))))","theorem":"IntegerFixedProofs.u64_switch","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.I16 (Aeneas.Std.Array Aeneas.Std.U8 2#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"2"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I16","type_segments":[{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 2 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light","text":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"2"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16","source":{"first_line":676,"last_line":676}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light","source":{"first_line":445,"last_line":450}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16.bv","source":{"first_line":1115,"last_line":1115}}],"definitions_truncated":false,"first_line":62,"last_line":66,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.I16\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.I16),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.I16\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.I16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.I16.bv x))))","theorem":"IntegerFixedVecProofs.i16_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.I8","type_segments":[{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.I8 × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.I8 → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyI8\n integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (IntegerEncodingSpec.zigzag ↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyI8","text":"Aeneas.Std.core.marker.CopyI8"},{"text":"\n "},{"ref":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8","source":{"first_line":675,"last_line":675}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyI8","source":{"first_line":33,"last_line":36}},{"module":"IntegerCore","name":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":324,"last_line":330}},{"module":"IntegerCore","name":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":332,"last_line":340}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I8","source":{"first_line":43,"last_line":43}}],"definitions_truncated":false,"first_line":111,"last_line":121,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.I8)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.I8 Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.I8 → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.I8\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.I8 Aeneas.Std.core.marker.CopyI8\n integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.I8.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec\n (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I8 value)) out)","theorem":"IntegerEncodingVec.i8_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.U32 × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.U32 → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyU32\n integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyU32","text":"Aeneas.Std.core.marker.CopyU32"},{"text":"\n "},{"ref":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"(↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyU32","source":{"first_line":28,"last_line":31}},{"module":"IntegerCore","name":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":159,"last_line":165}},{"module":"IntegerCore","name":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":167,"last_line":175}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U32","source":{"first_line":35,"last_line":35}}],"definitions_truncated":false,"first_line":75,"last_line":85,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.U32)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.U32 Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.U32 → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.U32\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.U32 Aeneas.Std.core.marker.CopyU32\n integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U32 value) out)","theorem":"IntegerEncodingVec.u32_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.I32 (Aeneas.Std.Array Aeneas.Std.U8 4#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"4"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I32","type_segments":[{"ref":"Aeneas.Std.I32","text":"Aeneas.Std.I32"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 4 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light","text":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"4"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I32.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32","source":{"first_line":677,"last_line":677}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light","source":{"first_line":397,"last_line":402}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I32.bv","source":{"first_line":1116,"last_line":1116}}],"definitions_truncated":false,"first_line":68,"last_line":72,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.I32\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.I32),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.I32\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.I32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.I32.Insts.Integer_encodingFixedFixedIntArrayU84.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 4) (instOfNatNat (nat_lit 4)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) (Aeneas.Std.I32.bv x))))","theorem":"IntegerFixedVecProofs.i32_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I16","type_segments":[{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness x = Aeneas.Std.Result.ok out ∧\n ↑out =\n IntegerEncodingSpec.signedValue 16\n (IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 2 x.bv.toNat).reverse)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness","text":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" =\n "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"16"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"2"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16","source":{"first_line":676,"last_line":676}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness","source":{"first_line":452,"last_line":458}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I16","source":{"first_line":44,"last_line":44}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16.bv","source":{"first_line":1115,"last_line":1115}}],"definitions_truncated":false,"first_line":863,"last_line":870,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I16),\n @Exists.{1} Aeneas.Std.I16 fun (out : Aeneas.Std.I16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.I16)\n (IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.I16 out))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I16 out)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.I16.bv x)))))))","theorem":"IntegerFixedProofs.i16_switch_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.Usize","type_segments":[{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","text":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.Usize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","source":{"first_line":61,"last_line":66}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.bv","source":{"first_line":1112,"last_line":1112}}],"definitions_truncated":false,"first_line":653,"last_line":661,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.Usize)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)))\n (IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Usize.bv x))))","theorem":"IntegerFixedProofs.usize_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]}],"conclusion":"∃ out,\n integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen ↑v","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":177,"last_line":183}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U16","source":{"first_line":34,"last_line":34}}],"definitions_truncated":false,"first_line":94,"last_line":103,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.U16),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U16 v)))","theorem":"IntegerRequiredSpace.u16_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I16","type_segments":[{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 2 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 2 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed","text":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"2"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"2"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16","source":{"first_line":676,"last_line":676}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed","source":{"first_line":412,"last_line":427}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16.bv","source":{"first_line":1115,"last_line":1115}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":241,"last_line":264,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I16) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.I16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.I16.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.i16_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I8","type_segments":[{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 1 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light","text":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"1"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8","source":{"first_line":675,"last_line":675}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light","source":{"first_line":493,"last_line":498}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8.bv","source":{"first_line":1114,"last_line":1114}}],"definitions_truncated":false,"first_line":47,"last_line":55,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I8),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1)))\n (IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n IntegerFixedDirect.U8.Insts.Integer_encodingFixedFixedIntArrayU81.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.I8.bv x))))","theorem":"IntegerFixedProofs.i8_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]}],"conclusion":"∃ out,\n integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen ↑v","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":159,"last_line":165}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U32","source":{"first_line":35,"last_line":35}}],"definitions_truncated":false,"first_line":105,"last_line":114,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.U32),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.U32.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U32 v)))","theorem":"IntegerRequiredSpace.u32_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.Isize (Aeneas.Std.Array Aeneas.Std.U8 8#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"8"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.Isize","type_segments":[{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","text":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.Isize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize","source":{"first_line":674,"last_line":674}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","source":{"first_line":301,"last_line":306}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize.bv","source":{"first_line":1119,"last_line":1119}}],"definitions_truncated":false,"first_line":88,"last_line":93,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.Isize\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.Isize)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.Isize\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.Isize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Isize.bv x))))","theorem":"IntegerFixedVecProofs.isize_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.I8","type_segments":[{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"}]}],"conclusion":"∃ out,\n integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8","source":{"first_line":675,"last_line":675}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":324,"last_line":330}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I8","source":{"first_line":43,"last_line":43}}],"definitions_truncated":false,"first_line":133,"last_line":142,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.I8),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.I8.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I8 v))))","theorem":"IntegerRequiredSpace.i8_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"value","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]},{"binder":"explicit","kind":"variable","name":"decode","type":"Aeneas.Std.Slice Aeneas.Std.U8 → Aeneas.Std.Result (Option (Aeneas.Std.U16 × Aeneas.Std.Usize))","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Option","text":"Option"},{"text":" "},{"ref":"Prod","text":"("},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"ref":"Prod","text":" × "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"ref":"Prod","text":")"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"encodeVec","type":"Aeneas.Std.U16 → Aeneas.Std.Result (Aeneas.Std.alloc.vec.Vec Aeneas.Std.U8)","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" → "},{"ref":"Aeneas.Std.Result","text":"Aeneas.Std.Result"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.alloc.vec.Vec","text":"Aeneas.Std.alloc.vec.Vec"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":")"}]}],"conclusion":"∃ out,\n integer_encoding.varint.VarInt.encode_var_vec.default\n (IntegerEncodingVec.sourceDictionary Aeneas.Std.core.marker.CopyU16\n integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value =\n Aeneas.Std.Result.ok out ∧\n IntegerEncodingVec.EncodedVec (↑value) out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.varint.VarInt.encode_var_vec.default","text":"integer_encoding.varint.VarInt.encode_var_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingVec.sourceDictionary","text":"IntegerEncodingVec.sourceDictionary"},{"text":" "},{"ref":"Aeneas.Std.core.marker.CopyU16","text":"Aeneas.Std.core.marker.CopyU16"},{"text":"\n "},{"ref":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space"},{"text":"\n "},{"ref":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"decode"},{"text":" "},{"text":"encodeVec"},{"text":")"},{"text":"\n "},{"text":"value"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingVec.EncodedVec","text":"IntegerEncodingVec.EncodedVec"},{"text":" "},{"text":"(↑"},{"text":"value"},{"text":")"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"IntegerVec","name":"integer_encoding.varint.VarInt.encode_var_vec.default","source":{"first_line":33,"last_line":45}},{"module":"VarintVec","name":"IntegerEncodingVec.sourceDictionary","source":{"first_line":38,"last_line":49}},{"module":"Aeneas.Std.Scalar.CloneCopy","name":"Aeneas.Std.core.marker.CopyU16","source":{"first_line":28,"last_line":31}},{"module":"IntegerCore","name":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":177,"last_line":183}},{"module":"IntegerCore","name":"integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":185,"last_line":193}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"VarintVec","name":"IntegerEncodingVec.EncodedVec","source":{"first_line":7,"last_line":10}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U16","source":{"first_line":34,"last_line":34}}],"definitions_truncated":false,"first_line":63,"last_line":73,"module":"VarintVec","program":null,"program_head":null,"statement":"∀ (value : Aeneas.Std.U16)\n (decode :\n Aeneas.Std.Slice.{0} Aeneas.Std.U8 →\n Aeneas.Std.Result.{0} (Option.{0} (Prod.{0, 0} Aeneas.Std.U16 Aeneas.Std.Usize)))\n (encodeVec : Aeneas.Std.U16 → Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8)),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.varint.VarInt.encode_var_vec.default.{0} Aeneas.Std.U16\n (@IntegerEncodingVec.sourceDictionary Aeneas.Std.U16 Aeneas.Std.core.marker.CopyU16\n integer_encoding.U16.Insts.Integer_encodingVarintVarInt.required_space\n integer_encoding.U16.Insts.Integer_encodingVarintVarInt.encode_var decode encodeVec)\n value)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (IntegerEncodingVec.EncodedVec (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U16 value) out)","theorem":"IntegerEncodingVec.u16_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.Isize","type_segments":[{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"}]}],"conclusion":"∃ out,\n integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize","source":{"first_line":674,"last_line":674}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":213,"last_line":219}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.Isize","source":{"first_line":42,"last_line":42}}],"definitions_truncated":false,"first_line":172,"last_line":181,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.Isize),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.Isize.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.Isize v))))","theorem":"IntegerRequiredSpace.isize_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen ↑v ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"(↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":203,"last_line":211}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":189,"last_line":199,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.U8) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 v))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.U8.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 v) dst out)","theorem":"IntegerEncodingEncode.u8_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 8 then\n ∃ v,\n out = Option.some v ∧\n ↑v = IntegerEncodingSpec.signedValue 64 (IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src))\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed","text":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"8"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":",\n "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"64"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I64","source":{"first_line":678,"last_line":678}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed","source":{"first_line":333,"last_line":347}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I64","source":{"first_line":46,"last_line":46}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":897,"last_line":911,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Option.{0} Aeneas.Std.I64) fun (out : Option.{0} Aeneas.Std.I64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.I64))\n (IntegerFixedDirect.I64.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.I64) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Exists.{1} Aeneas.Std.I64 fun (v : Aeneas.Std.I64) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.I64) out (@Option.some.{0} Aeneas.Std.I64 v))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I64 v)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))))))\n (@Eq.{1} (Option.{0} Aeneas.Std.I64) out (@Option.none.{0} Aeneas.Std.I64)))","theorem":"IntegerFixedProofs.i64_decode_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 8 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed","text":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"8"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed","source":{"first_line":76,"last_line":91}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":185,"last_line":208,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U64) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.U64.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) (Aeneas.Std.U64.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.u64_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.Isize","type_segments":[{"ref":"Aeneas.Std.Isize","text":"Aeneas.Std.Isize"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","text":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.Isize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize","source":{"first_line":674,"last_line":674}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","source":{"first_line":301,"last_line":306}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Isize.bv","source":{"first_line":1119,"last_line":1119}}],"definitions_truncated":false,"first_line":736,"last_line":744,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.Isize)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)))\n (IntegerFixedDirect.Isize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Isize.bv x))))","theorem":"IntegerFixedProofs.isize_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I8","type_segments":[{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed x dst = Aeneas.Std.Result.ok out ∧\n if (↑dst).length = 1 then\n out.1 = Option.some () ∧ List.map (fun b => ↑b) ↑out.2 = IntegerEncodingSpec.fixedBytes 1 x.bv.toNat\n else out = (Option.none, dst)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed","text":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed"},{"text":" "},{"text":"x"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"1"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"out"},{"text":".1"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"ref":"Unit.unit","text":"("},{"ref":"Unit.unit","text":")"},{"ref":"And","text":" ∧ "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"text":".2"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"1"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Prod.mk","text":"("},{"ref":"Option.none","text":"Option.none"},{"ref":"Prod.mk","text":", "},{"text":"dst"},{"ref":"Prod.mk","text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8","source":{"first_line":675,"last_line":675}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Init.Prelude","name":"Unit","source":{"first_line":214,"last_line":224}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed","source":{"first_line":460,"last_line":475}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Prod.fst","source":{"first_line":616,"last_line":616}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"Unit.unit","source":{"first_line":226,"last_line":231}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Prod.snd","source":{"first_line":618,"last_line":618}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8.bv","source":{"first_line":1114,"last_line":1114}},{"module":"Init.Prelude","name":"Prod.mk","source":{"first_line":614,"last_line":614}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":213,"last_line":236,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I8) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.encode_fixed x dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))\n (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))))\n (And\n (@Eq.{1} (Option.{0} Unit) (@Prod.fst.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)\n (@Option.some.{0} Unit Unit.unit))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8\n (@Prod.snd.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) out)))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.I8.bv x)))))\n (@Eq.{1} (Prod.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out\n (@Prod.mk.{0, 0} (Option.{0} Unit) (Aeneas.Std.Slice.{0} Aeneas.Std.U8) (@Option.none.{0} Unit) dst)))","theorem":"IntegerFixedProofs.i8_encode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.Usize","type_segments":[{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"}]}],"conclusion":"∃ out,\n integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space v = Aeneas.Std.Result.ok out ∧\n ↑out = IntegerEncodingSpec.uLen ↑v","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space","text":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space"},{"text":" "},{"text":"v"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space","source":{"first_line":85,"last_line":91}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}}],"definitions_truncated":false,"first_line":122,"last_line":131,"module":"RequiredSpace","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.Usize),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (integer_encoding.Usize.Insts.Integer_encodingVarintVarInt.required_space v)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize out)\n (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.Usize v)))","theorem":"IntegerRequiredSpace.usize_required_space","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.I16","type_segments":[{"ref":"Aeneas.Std.I16","text":"Aeneas.Std.I16"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag ↑v) ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag ↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.zigzag","text":"IntegerEncodingSpec.zigzag"},{"text":" "},{"text":"↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I16","source":{"first_line":676,"last_line":676}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"VarintSpec","name":"IntegerEncodingSpec.zigzag","source":{"first_line":29,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I16","source":{"first_line":44,"last_line":44}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":314,"last_line":322}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":249,"last_line":259,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.I16) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat\n (IntegerEncodingSpec.uLen (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I16 v)))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.I16.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (IntegerEncodingSpec.zigzag (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I16 v))\n dst out)","theorem":"IntegerEncodingEncode.i16_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"v","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]},{"binder":"explicit","kind":"variable","name":"dst","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hcap","type":"IntegerEncodingSpec.uLen ↑v ≤ (↑dst).length","type_segments":[{"ref":"IntegerEncodingSpec.uLen","text":"IntegerEncodingSpec.uLen"},{"text":" "},{"text":"↑"},{"text":"v"},{"ref":"LE.le","text":" ≤ "},{"text":"(↑"},{"text":"dst"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"}]}],"conclusion":"∃ out,\n integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var v dst = Aeneas.Std.Result.ok out ∧\n IntegerEncodingEncode.Encoded (↑v) dst out","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var","text":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var"},{"text":" "},{"text":"v"},{"text":" "},{"text":"dst"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"IntegerEncodingEncode.Encoded","text":"IntegerEncodingEncode.Encoded"},{"text":" "},{"text":"(↑"},{"text":"v"},{"text":")"},{"text":" "},{"text":"dst"},{"text":" "},{"text":"out"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"VarintSpec","name":"IntegerEncodingSpec.uLen","source":{"first_line":4,"last_line":5}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U32","source":{"first_line":35,"last_line":35}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Prod","source":{"first_line":603,"last_line":618}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerCore","name":"integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var","source":{"first_line":167,"last_line":175}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"EncodeVar","name":"IntegerEncodingEncode.Encoded","source":{"first_line":123,"last_line":128}}],"definitions_truncated":false,"first_line":213,"last_line":223,"module":"EncodeVar","program":null,"program_head":null,"statement":"∀ (v : Aeneas.Std.U32) (dst : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (hcap :\n @LE.le.{0} Nat instLENat (IntegerEncodingSpec.uLen (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U32 v))\n (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 dst))),\n @Exists.{1} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8))\n fun (out : Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)))\n (integer_encoding.U32.Insts.Integer_encodingVarintVarInt.encode_var v dst)\n (@Aeneas.Std.Result.ok.{0} (Prod.{0, 0} Aeneas.Std.Usize (Aeneas.Std.Slice.{0} Aeneas.Std.U8)) out))\n (IntegerEncodingEncode.Encoded (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U32 v) dst out)","theorem":"IntegerEncodingEncode.u32_total","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.I8","type_segments":[{"ref":"Aeneas.Std.I8","text":"Aeneas.Std.I8"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness x = Aeneas.Std.Result.ok out ∧\n ↑out =\n IntegerEncodingSpec.signedValue 8\n (IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 1 x.bv.toNat).reverse)","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness","text":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" =\n "},{"ref":"IntegerEncodingSpec.signedValue","text":"IntegerEncodingSpec.signedValue"},{"text":" "},{"text":"8"},{"text":"\n "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"1"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.I8.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"},{"text":")"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8","source":{"first_line":675,"last_line":675}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness","source":{"first_line":500,"last_line":506}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Data.Int.Basic","name":"Int","source":{"first_line":35,"last_line":58}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalar.val","source":{"first_line":84,"last_line":84}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.IScalarTy.I8","source":{"first_line":43,"last_line":43}},{"module":"FixedSpec","name":"IntegerEncodingSpec.signedValue","source":{"first_line":56,"last_line":57}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.I8.bv","source":{"first_line":1114,"last_line":1114}}],"definitions_truncated":false,"first_line":838,"last_line":845,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.I8),\n @Exists.{1} Aeneas.Std.I8 fun (out : Aeneas.Std.I8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.I8)\n (IntegerFixedDirect.I8.Insts.Integer_encodingFixedFixedIntArrayU81.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.I8 out))\n (@Eq.{1} Int (@Aeneas.Std.IScalar.val Aeneas.Std.IScalarTy.I8 out)\n (IntegerEncodingSpec.signedValue (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) (Aeneas.Std.I8.bv x)))))))","theorem":"IntegerFixedProofs.i8_switch_signed","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light x = Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 2 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light","text":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"2"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light","source":{"first_line":205,"last_line":210}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array.val","source":{"first_line":32,"last_line":33}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}}],"definitions_truncated":false,"first_line":17,"last_line":25,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.U16),\n @Exists.{1}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1))\n fun\n (out :\n Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1)) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1)))\n (IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.encode_fixed_light x)\n (@Aeneas.Std.Result.ok.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1))\n out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Array.val.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n IntegerFixedDirect.U16.Insts.Integer_encodingFixedFixedIntArrayU82.decode_fixed._proof_1)\n out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 2) (instOfNatNat (nat_lit 2)))\n (@BitVec.toNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) (Aeneas.Std.U16.bv x))))","theorem":"IntegerFixedProofs.u16_light","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.Usize","type_segments":[{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness x = Aeneas.Std.Result.ok out ∧\n out.bv.toNat = IntegerEncodingSpec.fixedValue (IntegerEncodingSpec.fixedBytes 8 x.bv.toNat).reverse","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness","text":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness"},{"text":" "},{"text":"x"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.Usize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.Usize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"text":")"},{"text":"."},{"ref":"List.reverse","text":"reverse"}],"definitions":[{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness","source":{"first_line":68,"last_line":74}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.bv","source":{"first_line":1112,"last_line":1112}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Data.List.Basic","name":"List.reverse","source":{"first_line":553,"last_line":567}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}}],"definitions_truncated":false,"first_line":721,"last_line":734,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (x : Aeneas.Std.Usize)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1} Aeneas.Std.Usize fun (out : Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.Usize)\n (IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.switch_endianness x)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.Usize out))\n (@Eq.{1} Nat (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Usize.bv out))\n (IntegerEncodingSpec.fixedValue\n (@List.reverse.{0} Nat\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Usize.bv x))))))","theorem":"IntegerFixedProofs.usize_switch","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"src","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed src = Aeneas.Std.Result.ok out ∧\n if (↑src).length = 8 then\n ∃ v, out = Option.some v ∧ v.bv.toNat = IntegerEncodingSpec.fixedValue (List.map (fun b => ↑b) ↑src)\n else out = Option.none","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed","text":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed"},{"text":" "},{"text":"src"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"ite","text":"if "},{"text":"(↑"},{"text":"src"},{"text":")"},{"text":"."},{"ref":"List.length","text":"length"},{"ref":"Eq","text":" = "},{"text":"8"},{"ref":"ite","text":" then"},{"ref":"ite","text":"\n "},{"text":"∃ "},{"text":"v"},{"text":", "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.some","text":"Option.some"},{"text":" "},{"text":"v"},{"ref":"And","text":" ∧ "},{"text":"v"},{"text":"."},{"ref":"Aeneas.Std.Usize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedValue","text":"IntegerEncodingSpec.fixedValue"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"src"},{"text":")"},{"ref":"ite","text":"\n "},{"ref":"ite","text":"else "},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"Option.none","text":"Option.none"}],"definitions":[{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Init.Prelude","name":"Option","source":{"first_line":3047,"last_line":3058}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed","source":{"first_line":45,"last_line":59}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"ite","source":{"first_line":1324,"last_line":1346}},{"module":"Init.Prelude","name":"List.length","source":{"first_line":3182,"last_line":3195}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}},{"module":"Init.Prelude","name":"instDecidableEqNat","source":{"first_line":1995,"last_line":1995}},{"module":"Init.Prelude","name":"Option.some","source":{"first_line":3057,"last_line":3058}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.bv","source":{"first_line":1112,"last_line":1112}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedValue","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"Option.none","source":{"first_line":3055,"last_line":3056}}],"definitions_truncated":false,"first_line":699,"last_line":719,"module":"FixedProofs","program":null,"program_head":null,"statement":"∀ (src : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1} (Option.{0} Aeneas.Std.Usize) fun (out : Option.{0} Aeneas.Std.Usize) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Option.{0} Aeneas.Std.Usize))\n (IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.decode_fixed src)\n (@Aeneas.Std.Result.ok.{0} (Option.{0} Aeneas.Std.Usize) out))\n (@ite.{1} Prop\n (@Eq.{1} Nat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (instDecidableEqNat (@List.length.{0} Aeneas.Std.U8 (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Exists.{1} Aeneas.Std.Usize fun (v : Aeneas.Std.Usize) =>\n And (@Eq.{1} (Option.{0} Aeneas.Std.Usize) out (@Option.some.{0} Aeneas.Std.Usize v))\n (@Eq.{1} Nat (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Usize.bv v))\n (IntegerEncodingSpec.fixedValue\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 src)))))\n (@Eq.{1} (Option.{0} Aeneas.Std.Usize) out (@Option.none.{0} Aeneas.Std.Usize)))","theorem":"IntegerFixedProofs.usize_decode","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"d","type":"integer_encoding.fixed.FixedInt Aeneas.Std.Usize (Aeneas.Std.Array Aeneas.Std.U8 8#usize)","type_segments":[{"ref":"integer_encoding.fixed.FixedInt","text":"integer_encoding.fixed.FixedInt"},{"text":" "},{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"8"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"x","type":"Aeneas.Std.Usize","type_segments":[{"ref":"Aeneas.Std.Usize","text":"Aeneas.Std.Usize"}]},{"binder":"explicit","kind":"hypothesis","name":"h64","type":"System.Platform.numBits = 64","type_segments":[{"ref":"System.Platform.numBits","text":"System.Platform.numBits"},{"ref":"Eq","text":" = "},{"text":"64"}]}],"conclusion":"∃ out,\n integer_encoding.fixed.FixedInt.encode_fixed_vec.default\n (IntegerFixedVecProofs.specialize d\n IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light)\n x =\n Aeneas.Std.Result.ok out ∧\n List.map (fun b => ↑b) ↑out = IntegerEncodingSpec.fixedBytes 8 x.bv.toNat","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","text":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default"},{"text":"\n "},{"text":"("},{"ref":"IntegerFixedVecProofs.specialize","text":"IntegerFixedVecProofs.specialize"},{"text":" "},{"text":"d"},{"text":"\n "},{"ref":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","text":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light"},{"text":")"},{"text":"\n "},{"text":"x"},{"ref":"Eq","text":" =\n "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"ref":"List.map","text":"List.map"},{"text":" "},{"text":"(fun "},{"text":"b"},{"text":" => "},{"text":"↑"},{"text":"b"},{"text":")"},{"text":" "},{"text":"↑"},{"text":"out"},{"ref":"Eq","text":" = "},{"ref":"IntegerEncodingSpec.fixedBytes","text":"IntegerEncodingSpec.fixedBytes"},{"text":" "},{"text":"8"},{"text":" "},{"text":"x"},{"text":"."},{"ref":"Aeneas.Std.Usize.bv","text":"bv"},{"text":"."},{"ref":"BitVec.toNat","text":"toNat"}],"definitions":[{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt","source":{"first_line":23,"last_line":35}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize","source":{"first_line":668,"last_line":668}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Init.Prelude","name":"System.Platform.numBits","source":{"first_line":2429,"last_line":2433}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec","source":{"first_line":30,"last_line":33}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"IntegerFixedVec","name":"integer_encoding.fixed.FixedInt.encode_fixed_vec.default","source":{"first_line":37,"last_line":48}},{"module":"FixedVec","name":"IntegerFixedVecProofs.specialize","source":{"first_line":6,"last_line":13}},{"module":"IntegerFixedDirect.Funs","name":"IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light","source":{"first_line":61,"last_line":66}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"List","source":{"first_line":3096,"last_line":3115}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"Aeneas.Std.Alloc.Vec","name":"Aeneas.Std.alloc.vec.Vec.val","source":{"first_line":35,"last_line":36}},{"module":"FixedSpec","name":"IntegerEncodingSpec.fixedBytes","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec.toNat","source":{"first_line":2540,"last_line":2546}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.bv","source":{"first_line":1112,"last_line":1112}}],"definitions_truncated":false,"first_line":81,"last_line":86,"module":"FixedVec","program":null,"program_head":null,"statement":"∀\n (d :\n integer_encoding.fixed.FixedInt.{0, 0} Aeneas.Std.Usize\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (x : Aeneas.Std.Usize)\n (h64 : @Eq.{1} Nat System.Platform.numBits (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))),\n @Exists.{1} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) fun (out : Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8))\n (@integer_encoding.fixed.FixedInt.encode_fixed_vec.default.{0, 0} Aeneas.Std.Usize\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@IntegerFixedVecProofs.specialize Aeneas.Std.Usize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n d IntegerFixedDirect.Usize.Insts.Integer_encodingFixedFixedIntArrayU88.encode_fixed_light)\n x)\n (@Aeneas.Std.Result.ok.{0} (Aeneas.Std.alloc.vec.Vec.{0} Aeneas.Std.U8) out))\n (@Eq.{1} (List.{0} Nat)\n (@List.map.{0, 0} Aeneas.Std.U8 Nat\n (fun (b : Aeneas.Std.U8) => @Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 b)\n (@Aeneas.Std.alloc.vec.Vec.val.{0} Aeneas.Std.U8 out))\n (IntegerEncodingSpec.fixedBytes (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@BitVec.toNat System.Platform.numBits (Aeneas.Std.Usize.bv x))))","theorem":"IntegerFixedVecProofs.usize_total","translation_rerun":false,"version":1}
=== stderr ===
info: aeneas: materializing new dependency
info: aeneas: fetching revision 'be86ab0f1989d04944292b345b24c435be3ad10a' from https://github.com/AeneasVerif/aeneas
info: aeneas: checking out revision 'be86ab0f1989d04944292b345b24c435be3ad10a'
info: mathlib: materializing new dependency
info: mathlib: fetching revision '56a005855ea17e0b0958f73ec801ae140b0a1679' from https://github.com/leanprover-community/mathlib4.git
info: mathlib: checking out revision '56a005855ea17e0b0958f73ec801ae140b0a1679'
info: plausible: materializing new dependency
info: plausible: fetching revision 'dfa4f38190d07c37e315953e08b90fe2d95b3c24' from https://github.com/leanprover-community/plausible
info: plausible: checking out revision 'dfa4f38190d07c37e315953e08b90fe2d95b3c24'
info: LeanSearchClient: materializing new dependency
info: LeanSearchClient: fetching revision 'd6b4c7be5be75ec4917c873ac50c756dc1436372' from https://github.com/leanprover-community/LeanSearchClient
info: LeanSearchClient: checking out revision 'd6b4c7be5be75ec4917c873ac50c756dc1436372'
info: importGraph: materializing new dependency
info: importGraph: fetching revision 'a41f0e9a4dea23188ea9cc1c41ac9f8bbafe0b93' from https://github.com/leanprover-community/import-graph
info: importGraph: checking out revision 'a41f0e9a4dea23188ea9cc1c41ac9f8bbafe0b93'
info: proofwidgets: materializing new dependency
info: proofwidgets: fetching revision 'df72b022e558978a1c50264cfc4d7fec86fa8e04' from https://github.com/leanprover-community/ProofWidgets4
info: proofwidgets: checking out revision 'df72b022e558978a1c50264cfc4d7fec86fa8e04'
info: aesop: materializing new dependency
info: aesop: fetching revision '4a174c490d8707121c4a9290800489f105d85e07' from https://github.com/leanprover-community/aesop
info: aesop: checking out revision '4a174c490d8707121c4a9290800489f105d85e07'
info: Qq: materializing new dependency
info: Qq: fetching revision 'dce0ad79c486cb1fb504af04f953c3466b0c6db8' from https://github.com/leanprover-community/quote4
info: Qq: checking out revision 'dce0ad79c486cb1fb504af04f953c3466b0c6db8'
info: batteries: materializing new dependency
info: batteries: fetching revision '66e469188fe07963e5cf666c7d4433f45b8131c5' from https://github.com/leanprover-community/batteries
info: batteries: checking out revision '66e469188fe07963e5cf666c7d4433f45b8131c5'
info: Cli: materializing new dependency
info: Cli: fetching revision 'c24fe6078c630e89b489bffe59b3e20ac30d12c8' from https://github.com/leanprover/lean4-cli
info: Cli: checking out revision 'c24fe6078c630e89b489bffe59b3e20ac30d12c8'
Environment
The October 27, 2026 current-input run used aarch64-apple-darwin, default crate features, debug assertions in extraction, the pinned Charon and Aeneas revisions and Lean 4.35.0. Native checks separately used default features in debug and release. Fresh extraction matched the maintained models, and the Lean build, theorem dependency audit and API mapping checks passed with matching before-and-after input fingerprints. The earlier accepted archive records its own historical inputs. The run predates this editorial revision; its input fingerprint does not cover the revised prose.
The cargo-proofs preparation patch prepares pinned inputs and tools before discovery and records the standard Lake build and audit results; it does not patch Charon or Aeneas. Its CLI tests and real Lean/Aeneas integration tests passed, including rejection cases. The patch’s operational tests do not prove translation or model fidelity. See the results, specification, API inventory, model boundary review, tool lock, and preparation patch.
What is trusted
The result relies on Rust-to-Charon/Aeneas translation, Lean and the standard scalar and library models. The fixed-width supplement models size_of by scalar cardinality only for the ten selected primitive types, where the resulting 1, 2, 4 or 8 bytes agree with Rust's primitive sizes. Its clone_from_slice model copies bytes on equal lengths and panics otherwise; the extracted calls use the standard u8 clone implementation, not arbitrary user-defined cloning. Pointer-sized endian conversions use 64-bit primitives and preserve all bits under the stated 64-bit premise.
For fixed decoding, the model erases the formatting dictionary for the standard TryFromSliceError: the modeled unwrap still returns the Ok payload or panics on Err, but does not represent panic formatting or its effects. Source inspection supports these restricted model choices; it is not a proof of the Rust compiler or standard library. Allocation failures, panic text, hooks and unwinding effects are not established. The theorem audit allowed Lean's propext, Classical.choice and Quot.sound, with no application axioms.
Technical limitations
The checked executable bodies come from the locked crates.io 4.1.0 source, with generated bodies checked against fresh extraction. This is not a proof of compiler or translation correctness. The ten decode_var instances are blocked by the pinned translator and are not proved. Generic and asynchronous I/O, custom trait implementations and other unselected APIs are outside the formal scope. A destination shorter than the canonical varint is outside the successful encoding contract and may panic. The short-buffer theorem's modeled debug assertion does not describe release behavior or unwind state.
The accepted run is for macOS arm64; the separately maintained Linux models have not been accepted in this configuration. Native examples are finite observations, not proofs of the excluded I/O behavior or of big-endian execution.
Tool limitations
Lean backend only, requiring cargo-proofs 0.4.0 or later. The version identifies the official Aeneas Git revision pinned in lake-manifest.json (backends/lean); this revision uses Lean 4.35.0. The recorder checks committed Lean theorem declarations and permits only propext, Classical.choice, and Quot.sound as transitive axioms. It rejects sorryAx and custom axioms, including axiomatized external models. Charon/Aeneas extraction is not rerun. The author must review that the committed functional model matches the recorded Rust source, that the named theorem corresponds to the public API, and that the reported precondition matches the theorem. A checked theorem alone does not establish those links or the adequacy of the specification. The current adapter records the default Cargo configuration, with ordinary Lean module paths and a pinned official Git dependency. Other backends, custom Lake source directories, and local-path Aeneas dependencies are unsupported. See https://proofs.rs/book/aeneas.html and https://github.com/AeneasVerif/aeneas/tree/be86ab0f1989d04944292b345b24c435be3ad10a.
Aeneas be86ab0f1989d04944292b345b24c435be3ad10a — version details
Dependencies (5)
CrateReports
async-trait ^0.1 · optional—bencher ~0.1 · dev—futures-util ^0.3 · optional—tokio ^1.0 · dev—tokio ^1.0 · optional—Comments (0)
No comments.