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'