From 051e2a19f3268d272a0acd0425d2107ebea020c5 Mon Sep 17 00:00:00 2001 From: Son Ho Date: Tue, 7 Mar 2023 13:46:55 +0100 Subject: Reorganize the Lean tests and extract the Polonius tests to Lean --- tests/lean/betree/Base/Primitives.lean | 392 +++++++ tests/lean/betree/BetreeMain/Clauses/Template.lean | 185 +++ tests/lean/betree/BetreeMain/Funs.lean | 1222 ++++++++++++++++++++ tests/lean/betree/BetreeMain/Opaque.lean | 33 + tests/lean/betree/BetreeMain/Types.lean | 61 + tests/lean/betree/lakefile.lean | 18 + tests/lean/misc-constants/Base/Primitives.lean | 392 +++++++ tests/lean/misc-constants/Constants.lean | 141 +++ tests/lean/misc-constants/lakefile.lean | 18 + tests/lean/misc-external/Base/Primitives.lean | 392 +++++++ tests/lean/misc-external/External/Funs.lean | 93 ++ tests/lean/misc-external/External/Opaque.lean | 28 + tests/lean/misc-external/External/Types.lean | 8 + tests/lean/misc-external/lakefile.lean | 18 + tests/lean/misc-loops/Base/Primitives.lean | 392 +++++++ tests/lean/misc-loops/Loops/Clauses/Clauses.lean | 209 ++++ tests/lean/misc-loops/Loops/Clauses/Template.lean | 210 ++++ tests/lean/misc-loops/Loops/Funs.lean | 740 ++++++++++++ tests/lean/misc-loops/Loops/Types.lean | 9 + tests/lean/misc-loops/lakefile.lean | 18 + .../misc-no_nested_borrows/Base/Primitives.lean | 392 +++++++ .../misc-no_nested_borrows/NoNestedBorrows.lean | 556 +++++++++ tests/lean/misc-no_nested_borrows/lakefile.lean | 18 + tests/lean/misc-paper/Base/Primitives.lean | 392 +++++++ tests/lean/misc-paper/Paper.lean | 128 ++ tests/lean/misc-paper/lakefile.lean | 18 + tests/lean/misc-polonius_list/Base/Primitives.lean | 392 +++++++ tests/lean/misc-polonius_list/PoloniusList.lean | 36 + tests/lean/misc-polonius_list/lakefile.lean | 18 + tests/lean/misc/constants/Base/Primitives.lean | 392 ------- tests/lean/misc/constants/Constants.lean | 141 --- tests/lean/misc/constants/lakefile.lean | 18 - tests/lean/misc/external/Base/Primitives.lean | 392 ------- tests/lean/misc/external/External/Funs.lean | 93 -- tests/lean/misc/external/External/Opaque.lean | 28 - tests/lean/misc/external/External/Types.lean | 8 - tests/lean/misc/external/lakefile.lean | 18 - tests/lean/misc/loops/Base/Primitives.lean | 392 ------- tests/lean/misc/loops/Loops/Clauses/Clauses.lean | 209 ---- tests/lean/misc/loops/Loops/Clauses/Template.lean | 210 ---- tests/lean/misc/loops/Loops/Funs.lean | 740 ------------ tests/lean/misc/loops/Loops/Types.lean | 9 - tests/lean/misc/loops/lakefile.lean | 18 - .../misc/no_nested_borrows/Base/Primitives.lean | 392 ------- .../misc/no_nested_borrows/NoNestedBorrows.lean | 556 --------- tests/lean/misc/no_nested_borrows/lakefile.lean | 18 - tests/lean/misc/paper/Base/Primitives.lean | 392 ------- tests/lean/misc/paper/Paper.lean | 128 -- tests/lean/misc/paper/lakefile.lean | 18 - 49 files changed, 6529 insertions(+), 4172 deletions(-) create mode 100644 tests/lean/betree/Base/Primitives.lean create mode 100644 tests/lean/betree/BetreeMain/Clauses/Template.lean create mode 100644 tests/lean/betree/BetreeMain/Funs.lean create mode 100644 tests/lean/betree/BetreeMain/Opaque.lean create mode 100644 tests/lean/betree/BetreeMain/Types.lean create mode 100644 tests/lean/betree/lakefile.lean create mode 100644 tests/lean/misc-constants/Base/Primitives.lean create mode 100644 tests/lean/misc-constants/Constants.lean create mode 100644 tests/lean/misc-constants/lakefile.lean create mode 100644 tests/lean/misc-external/Base/Primitives.lean create mode 100644 tests/lean/misc-external/External/Funs.lean create mode 100644 tests/lean/misc-external/External/Opaque.lean create mode 100644 tests/lean/misc-external/External/Types.lean create mode 100644 tests/lean/misc-external/lakefile.lean create mode 100644 tests/lean/misc-loops/Base/Primitives.lean create mode 100644 tests/lean/misc-loops/Loops/Clauses/Clauses.lean create mode 100644 tests/lean/misc-loops/Loops/Clauses/Template.lean create mode 100644 tests/lean/misc-loops/Loops/Funs.lean create mode 100644 tests/lean/misc-loops/Loops/Types.lean create mode 100644 tests/lean/misc-loops/lakefile.lean create mode 100644 tests/lean/misc-no_nested_borrows/Base/Primitives.lean create mode 100644 tests/lean/misc-no_nested_borrows/NoNestedBorrows.lean create mode 100644 tests/lean/misc-no_nested_borrows/lakefile.lean create mode 100644 tests/lean/misc-paper/Base/Primitives.lean create mode 100644 tests/lean/misc-paper/Paper.lean create mode 100644 tests/lean/misc-paper/lakefile.lean create mode 100644 tests/lean/misc-polonius_list/Base/Primitives.lean create mode 100644 tests/lean/misc-polonius_list/PoloniusList.lean create mode 100644 tests/lean/misc-polonius_list/lakefile.lean delete mode 100644 tests/lean/misc/constants/Base/Primitives.lean delete mode 100644 tests/lean/misc/constants/Constants.lean delete mode 100644 tests/lean/misc/constants/lakefile.lean delete mode 100644 tests/lean/misc/external/Base/Primitives.lean delete mode 100644 tests/lean/misc/external/External/Funs.lean delete mode 100644 tests/lean/misc/external/External/Opaque.lean delete mode 100644 tests/lean/misc/external/External/Types.lean delete mode 100644 tests/lean/misc/external/lakefile.lean delete mode 100644 tests/lean/misc/loops/Base/Primitives.lean delete mode 100644 tests/lean/misc/loops/Loops/Clauses/Clauses.lean delete mode 100644 tests/lean/misc/loops/Loops/Clauses/Template.lean delete mode 100644 tests/lean/misc/loops/Loops/Funs.lean delete mode 100644 tests/lean/misc/loops/Loops/Types.lean delete mode 100644 tests/lean/misc/loops/lakefile.lean delete mode 100644 tests/lean/misc/no_nested_borrows/Base/Primitives.lean delete mode 100644 tests/lean/misc/no_nested_borrows/NoNestedBorrows.lean delete mode 100644 tests/lean/misc/no_nested_borrows/lakefile.lean delete mode 100644 tests/lean/misc/paper/Base/Primitives.lean delete mode 100644 tests/lean/misc/paper/Paper.lean delete mode 100644 tests/lean/misc/paper/lakefile.lean (limited to 'tests/lean') diff --git a/tests/lean/betree/Base/Primitives.lean b/tests/lean/betree/Base/Primitives.lean new file mode 100644 index 00000000..5b64e908 --- /dev/null +++ b/tests/lean/betree/Base/Primitives.lean @@ -0,0 +1,392 @@ +import Lean +import Lean.Meta.Tactic.Simp +import Init.Data.List.Basic +import Mathlib.Tactic.RunCmd + +------------- +-- PRELUDE -- +------------- + +-- Results & monadic combinators + +inductive Error where + | assertionFailure: Error + | integerOverflow: Error + | arrayOutOfBounds: Error + | maximumSizeExceeded: Error + | panic: Error +deriving Repr, BEq + +open Error + +inductive Result (α : Type u) where + | ret (v: α): Result α + | fail (e: Error): Result α +deriving Repr, BEq + +open Result + +/- HELPERS -/ + +def ret? {α: Type} (r: Result α): Bool := + match r with + | Result.ret _ => true + | Result.fail _ => false + +def massert (b:Bool) : Result Unit := + if b then .ret () else fail assertionFailure + +def eval_global {α: Type} (x: Result α) (_: ret? x): α := + match x with + | Result.fail _ => by contradiction + | Result.ret x => x + +/- DO-DSL SUPPORT -/ + +def bind (x: Result α) (f: α -> Result β) : Result β := + match x with + | ret v => f v + | fail v => fail v + +-- Allows using Result in do-blocks +instance : Bind Result where + bind := bind + +-- Allows using return x in do-blocks +instance : Pure Result where + pure := fun x => ret x + +/- CUSTOM-DSL SUPPORT -/ + +-- Let-binding the Result of a monadic operation is oftentimes not sufficient, +-- because we may need a hypothesis for equational reasoning in the scope. We +-- rely on subtype, and a custom let-binding operator, in effect recreating our +-- own variant of the do-dsl + +def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := + match o with + | .ret x => .ret ⟨x, rfl⟩ + | .fail e => .fail e + +macro "let" e:term " ⟵ " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- TODO: any way to factorize both definitions? +macro "let" e:term " <-- " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- We call the hypothesis `h`, in effect making it unavailable to the user +-- (because too much shadowing). But in practice, once can use the French single +-- quote notation (input with f< and f>), where `‹ h ›` finds a suitable +-- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` +#eval do + let y <-- .ret (0: Nat) + let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide + let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ + .ret r + +---------------------- +-- MACHINE INTEGERS -- +---------------------- + +-- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., +-- USize. They are generally defined in an idiomatic style, except that there is +-- not a single type class to rule them all (more on that below). The absence of +-- type class is intentional, and allows the Lean compiler to efficiently map +-- them to machine integers during compilation. + +-- USize is designed properly: you cannot reduce `getNumBits` using the +-- simplifier, meaning that proofs do not depend on the compile-time value of +-- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really +-- support, at least officially, 16-bit microcontrollers, so this seems like a +-- fine design decision for now.) + +-- Note from Chris Bailey: "If there's more than one salient property of your +-- definition then the subtyping strategy might get messy, and the property part +-- of a subtype is less discoverable by the simplifier or tactics like +-- library_search." So, we will not add refinements on the return values of the +-- operations defined on Primitives, but will rather rely on custom lemmas to +-- invert on possible return values of the primitive operations. + +-- Machine integer constants, done via `ofNatCore`, which requires a proof that +-- the `Nat` fits within the desired integer type. We provide a custom tactic. + +syntax "intlit" : tactic + +macro_rules + | `(tactic| intlit) => `(tactic| + match USize.size, usize_size_eq with + | _, Or.inl rfl => decide + | _, Or.inr rfl => decide) + +-- This is how the macro is expected to be used +#eval USize.ofNatCore 0 (by intlit) + +-- Also works for other integer types (at the expense of a needless disjunction) +#eval UInt32.ofNatCore 0 (by intlit) + +-- The machine integer operations (e.g. sub) are always total, which is not what +-- we want. We therefore define "checked" variants, below. Note that we add a +-- tiny bit of complexity for the USize variant: we first check whether the +-- result is < 2^32; if it is, we can compute the definition, rather than +-- returning a term that is computationally stuck (the comparison to USize.size +-- cannot reduce at compile-time, per the remark about regarding `getNumBits`). +-- This is useful for the various #asserts that we want to reduce at +-- type-checking time. + +-- Further thoughts: look at what has been done here: +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean +-- and +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean +-- which both contain a fair amount of reasoning already! +def USize.checked_sub (n: USize) (m: USize): Result USize := + -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? + if n >= m then + let n' := USize.toNat n + let m' := USize.toNat n + let r := USize.ofNatCore (n' - m') (by + have h: n' - m' <= n' := by + apply Nat.sub_le_of_le_add + case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left + apply Nat.lt_of_le_of_lt h + apply n.val.isLt + ) + return r + else + fail integerOverflow + +@[simp] +theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := + match USize.size, usize_size_eq with + | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) + | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) + +def USize.checked_add (n: USize) (m: USize): Result USize := + if h: n.val + m.val < USize.size then + .ret ⟨ n.val + m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_rem (n: USize) (m: USize): Result USize := + if h: m > 0 then + .ret ⟨ n.val % m.val, by + have h1: ↑m.val < USize.size := m.val.isLt + have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h + apply Nat.lt_trans h2 h1 + ⟩ + else + .fail integerOverflow + +def USize.checked_mul (n: USize) (m: USize): Result USize := + if h: n.val * m.val < USize.size then + .ret ⟨ n.val * m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_div (n: USize) (m: USize): Result USize := + if m > 0 then + .ret ⟨ n.val / m.val, by + have h1: ↑n.val < USize.size := n.val.isLt + have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val + apply Nat.lt_of_le_of_lt h2 h1 + ⟩ + else + .fail integerOverflow + +-- Test behavior... +#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 + +#eval USize.checked_sub 20 10 +-- NOTE: compare with concrete behavior here, which I do not think we want +#eval USize.sub 0 1 +#eval UInt8.add 255 255 + +-- We now define a type class that subsumes the various machine integer types, so +-- as to write a concise definition for scalar_cast, rather than exhaustively +-- enumerating all of the possible pairs. We remark that Rust has sane semantics +-- and fails if a cast operation would involve a truncation or modulo. + +class MachineInteger (t: Type) where + size: Nat + val: t -> Fin size + ofNatCore: (n:Nat) -> LT.lt n size -> t + +set_option hygiene false in +run_cmd + for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do + Lean.Elab.Command.elabCommand (← `( + namespace $typeName + instance: MachineInteger $typeName where + size := size + val := val + ofNatCore := ofNatCore + end $typeName + )) + +-- Aeneas only instantiates the destination type (`src` is implicit). We rely on +-- Lean to infer `src`. + +def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := + if h: MachineInteger.val x < MachineInteger.size dst then + .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) + else + .fail integerOverflow + +------------- +-- VECTORS -- +------------- + +-- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) +-- rather than maximum values (usize_max). +def Vec (α : Type u) := { l : List α // List.length l < USize.size } + +def vec_new (α : Type u): Vec α := ⟨ [], by { + match USize.size, usize_size_eq with + | _, Or.inl rfl => simp + | _, Or.inr rfl => simp + } ⟩ + +#check vec_new + +def vec_len (α : Type u) (v : Vec α) : USize := + let ⟨ v, l ⟩ := v + USize.ofNatCore (List.length v) l + +#eval vec_len Nat (vec_new Nat) + +def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () + +-- NOTE: old version trying to use a subtype notation, but probably better to +-- leave Result elimination to auxiliary lemmas with suitable preconditions +-- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one +-- make the proof work in that case? Probably need to import tactics from +-- mathlib to deal with inequalities... would love to see an example. +def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // + match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} + := + if h : List.length v.val + 1 < USize.size then + ⟨ return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩, by simp ⟩ + else + ⟨ fail maximumSizeExceeded, by simp ⟩ + +#eval do + -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with + -- fields val and property. However, Lean's elaborator can automatically + -- select the `val` field if the context provides a type annotation. We + -- annotate `x`, which relieves us of having to write `.val` on the right-hand + -- side of the monadic let. + let v := vec_new Nat + let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? + -- TODO: strengthen post-condition above and do a demo to show that we can + -- safely eliminate the `fail` case + return (vec_len Nat x) + +def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) + := + if h : List.length v.val + 1 <= 4294967295 then + return ⟨ List.concat v.val x, + by + rw [List.length_concat] + have h': 4294967295 < USize.size := by intlit + apply Nat.lt_of_le_of_lt h h' + ⟩ + else if h: List.length v.val + 1 < USize.size then + return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩ + else + fail maximumSizeExceeded + +def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +---------- +-- MISC -- +---------- + +def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := + x + +def mem_replace_back (a : Type) (_ : a) (y : a) : a := + y + +/-- Aeneas-translated function -- useful to reduce non-recursive definitions. + Use with `simp [ aeneas ]` -/ +register_simp_attr aeneas + +-------------------- +-- ASSERT COMMAND -- +-------------------- + +open Lean Elab Command Term Meta + +syntax (name := assert) "#assert" term: command + +@[command_elab assert] +unsafe +def assertImpl : CommandElab := fun (_stx: Syntax) => do + runTermElabM (fun _ => do + let r ← evalTerm Bool (mkConst ``Bool) _stx[1] + if not r then + logInfo "Assertion failed for: " + logInfo _stx[1] + logError "Expression reduced to false" + pure ()) + +#eval 2 == 2 +#assert (2 == 2) + +------------------- +-- SANITY CHECKS -- +------------------- + +-- TODO: add more once we have signed integers + +#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/betree/BetreeMain/Clauses/Template.lean b/tests/lean/betree/BetreeMain/Clauses/Template.lean new file mode 100644 index 00000000..1d18174e --- /dev/null +++ b/tests/lean/betree/BetreeMain/Clauses/Template.lean @@ -0,0 +1,185 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [betree_main]: templates for the decreases clauses +import Base.Primitives +import BetreeMain.Types + +/- [betree_main::betree::List::{1}::len]: termination measure -/ +@[simp] +def betree_list_len_terminates (T : Type) (self : betree_list_t T) := self + +/- [betree_main::betree::List::{1}::len]: decreases_by tactic -/ +syntax "betree_list_len_decreases" term+ : tactic +macro_rules +| `(tactic| betree_list_len_decreases $self) =>`(tactic| sorry) + +/- [betree_main::betree::List::{1}::split_at]: termination measure -/ +@[simp] +def betree_list_split_at_terminates (T : Type) (self : betree_list_t T) + (n : UInt64) := + (self, n) + +/- [betree_main::betree::List::{1}::split_at]: decreases_by tactic -/ +syntax "betree_list_split_at_decreases" term+ : tactic +macro_rules +| `(tactic| betree_list_split_at_decreases $self $n) =>`(tactic| sorry) + +/- [betree_main::betree::List::{2}::partition_at_pivot]: termination measure -/ +@[simp] +def betree_list_partition_at_pivot_terminates (T : Type) + (self : betree_list_t (UInt64 × T)) (pivot : UInt64) := + (self, pivot) + +/- [betree_main::betree::List::{2}::partition_at_pivot]: decreases_by tactic -/ +syntax "betree_list_partition_at_pivot_decreases" term+ : tactic +macro_rules +| `(tactic| betree_list_partition_at_pivot_decreases $self $pivot) => + `(tactic| sorry) + +/- [betree_main::betree::Node::{5}::lookup_in_bindings]: termination measure -/ +@[simp] +def betree_node_lookup_in_bindings_terminates (key : UInt64) + (bindings : betree_list_t (UInt64 × UInt64)) := + (key, bindings) + +/- [betree_main::betree::Node::{5}::lookup_in_bindings]: decreases_by tactic -/ +syntax "betree_node_lookup_in_bindings_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_lookup_in_bindings_decreases $key $bindings) => + `(tactic| sorry) + +/- [betree_main::betree::Node::{5}::lookup_first_message_for_key]: termination measure -/ +@[simp] +def betree_node_lookup_first_message_for_key_terminates (key : UInt64) + (msgs : betree_list_t (UInt64 × betree_message_t)) := + (key, msgs) + +/- [betree_main::betree::Node::{5}::lookup_first_message_for_key]: decreases_by tactic -/ +syntax "betree_node_lookup_first_message_for_key_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_lookup_first_message_for_key_decreases $key $msgs) => + `(tactic| sorry) + +/- [betree_main::betree::Node::{5}::apply_upserts]: termination measure -/ +@[simp] +def betree_node_apply_upserts_terminates + (msgs : betree_list_t (UInt64 × betree_message_t)) (prev : Option UInt64) + (key : UInt64) (st : State) := + (msgs, prev, key, st) + +/- [betree_main::betree::Node::{5}::apply_upserts]: decreases_by tactic -/ +syntax "betree_node_apply_upserts_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_apply_upserts_decreases $msgs $prev $key $st) => + `(tactic| sorry) + +/- [betree_main::betree::Node::{5}::lookup]: termination measure -/ +@[simp] +def betree_node_lookup_terminates (self : betree_node_t) (key : UInt64) + (st : State) := + (self, key, st) + +/- [betree_main::betree::Node::{5}::lookup]: decreases_by tactic -/ +syntax "betree_node_lookup_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_lookup_decreases $self $key $st) =>`(tactic| sorry) + +/- [betree_main::betree::Internal::{4}::lookup_in_children]: termination measure -/ +@[simp] +def betree_internal_lookup_in_children_terminates (self : betree_internal_t) + (key : UInt64) (st : State) := + (self, key, st) + +/- [betree_main::betree::Internal::{4}::lookup_in_children]: decreases_by tactic -/ +syntax "betree_internal_lookup_in_children_decreases" term+ : tactic +macro_rules +| `(tactic| betree_internal_lookup_in_children_decreases $self $key $st) => + `(tactic| sorry) + +/- [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: termination measure -/ +@[simp] +def betree_node_lookup_mut_in_bindings_terminates (key : UInt64) + (bindings : betree_list_t (UInt64 × UInt64)) := + (key, bindings) + +/- [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: decreases_by tactic -/ +syntax "betree_node_lookup_mut_in_bindings_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_lookup_mut_in_bindings_decreases $key $bindings) => + `(tactic| sorry) + +/- [betree_main::betree::Node::{5}::apply_messages_to_leaf]: termination measure -/ +@[simp] +def betree_node_apply_messages_to_leaf_terminates + (bindings : betree_list_t (UInt64 × UInt64)) + (new_msgs : betree_list_t (UInt64 × betree_message_t)) := + (bindings, new_msgs) + +/- [betree_main::betree::Node::{5}::apply_messages_to_leaf]: decreases_by tactic -/ +syntax "betree_node_apply_messages_to_leaf_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_apply_messages_to_leaf_decreases $bindings +$new_msgs) =>`(tactic| sorry) + +/- [betree_main::betree::Node::{5}::filter_messages_for_key]: termination measure -/ +@[simp] +def betree_node_filter_messages_for_key_terminates (key : UInt64) + (msgs : betree_list_t (UInt64 × betree_message_t)) := + (key, msgs) + +/- [betree_main::betree::Node::{5}::filter_messages_for_key]: decreases_by tactic -/ +syntax "betree_node_filter_messages_for_key_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_filter_messages_for_key_decreases $key $msgs) => + `(tactic| sorry) + +/- [betree_main::betree::Node::{5}::lookup_first_message_after_key]: termination measure -/ +@[simp] +def betree_node_lookup_first_message_after_key_terminates (key : UInt64) + (msgs : betree_list_t (UInt64 × betree_message_t)) := + (key, msgs) + +/- [betree_main::betree::Node::{5}::lookup_first_message_after_key]: decreases_by tactic -/ +syntax "betree_node_lookup_first_message_after_key_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_lookup_first_message_after_key_decreases $key $msgs) => + `(tactic| sorry) + +/- [betree_main::betree::Node::{5}::apply_messages_to_internal]: termination measure -/ +@[simp] +def betree_node_apply_messages_to_internal_terminates + (msgs : betree_list_t (UInt64 × betree_message_t)) + (new_msgs : betree_list_t (UInt64 × betree_message_t)) := + (msgs, new_msgs) + +/- [betree_main::betree::Node::{5}::apply_messages_to_internal]: decreases_by tactic -/ +syntax "betree_node_apply_messages_to_internal_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_apply_messages_to_internal_decreases $msgs +$new_msgs) =>`(tactic| sorry) + +/- [betree_main::betree::Node::{5}::apply_messages]: termination measure -/ +@[simp] +def betree_node_apply_messages_terminates (self : betree_node_t) + (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t) + (msgs : betree_list_t (UInt64 × betree_message_t)) (st : State) := + (self, params, node_id_cnt, msgs, st) + +/- [betree_main::betree::Node::{5}::apply_messages]: decreases_by tactic -/ +syntax "betree_node_apply_messages_decreases" term+ : tactic +macro_rules +| `(tactic| betree_node_apply_messages_decreases $self $params $node_id_cnt +$msgs $st) =>`(tactic| sorry) + +/- [betree_main::betree::Internal::{4}::flush]: termination measure -/ +@[simp] +def betree_internal_flush_terminates (self : betree_internal_t) + (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t) + (content : betree_list_t (UInt64 × betree_message_t)) (st : State) := + (self, params, node_id_cnt, content, st) + +/- [betree_main::betree::Internal::{4}::flush]: decreases_by tactic -/ +syntax "betree_internal_flush_decreases" term+ : tactic +macro_rules +| `(tactic| betree_internal_flush_decreases $self $params $node_id_cnt $content +$st) =>`(tactic| sorry) + diff --git a/tests/lean/betree/BetreeMain/Funs.lean b/tests/lean/betree/BetreeMain/Funs.lean new file mode 100644 index 00000000..e40ca4ca --- /dev/null +++ b/tests/lean/betree/BetreeMain/Funs.lean @@ -0,0 +1,1222 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [betree_main]: function definitions +import Base.Primitives +import BetreeMain.Types +import BetreeMain.Opaque +import BetreeMain.Clauses.Clauses + +section variable (opaque_defs: OpaqueDefs) + +/- [betree_main::betree::load_internal_node] -/ +def betree_load_internal_node_fwd + (id : UInt64) (st : State) : + Result (State × (betree_list_t (UInt64 × betree_message_t))) + := + opaque_defs.betree_utils_load_internal_node_fwd id st + +/- [betree_main::betree::store_internal_node] -/ +def betree_store_internal_node_fwd + (id : UInt64) (content : betree_list_t (UInt64 × betree_message_t)) + (st : State) : + Result (State × Unit) + := + do + let (st0, _) ← + opaque_defs.betree_utils_store_internal_node_fwd id content st + Result.ret (st0, ()) + +/- [betree_main::betree::load_leaf_node] -/ +def betree_load_leaf_node_fwd + (id : UInt64) (st : State) : + Result (State × (betree_list_t (UInt64 × UInt64))) + := + opaque_defs.betree_utils_load_leaf_node_fwd id st + +/- [betree_main::betree::store_leaf_node] -/ +def betree_store_leaf_node_fwd + (id : UInt64) (content : betree_list_t (UInt64 × UInt64)) (st : State) : + Result (State × Unit) + := + do + let (st0, _) ← opaque_defs.betree_utils_store_leaf_node_fwd id content st + Result.ret (st0, ()) + +/- [betree_main::betree::fresh_node_id] -/ +def betree_fresh_node_id_fwd (counter : UInt64) : Result UInt64 := + do + let _ ← UInt64.checked_add counter (UInt64.ofNatCore 1 (by intlit)) + Result.ret counter + +/- [betree_main::betree::fresh_node_id] -/ +def betree_fresh_node_id_back (counter : UInt64) : Result UInt64 := + UInt64.checked_add counter (UInt64.ofNatCore 1 (by intlit)) + +/- [betree_main::betree::NodeIdCounter::{0}::new] -/ +def betree_node_id_counter_new_fwd : Result betree_node_id_counter_t := + Result.ret + { betree_node_id_counter_next_node_id := (UInt64.ofNatCore 0 (by intlit)) } + +/- [betree_main::betree::NodeIdCounter::{0}::fresh_id] -/ +def betree_node_id_counter_fresh_id_fwd + (self : betree_node_id_counter_t) : Result UInt64 := + do + let _ ← UInt64.checked_add self.betree_node_id_counter_next_node_id + (UInt64.ofNatCore 1 (by intlit)) + Result.ret self.betree_node_id_counter_next_node_id + +/- [betree_main::betree::NodeIdCounter::{0}::fresh_id] -/ +def betree_node_id_counter_fresh_id_back + (self : betree_node_id_counter_t) : Result betree_node_id_counter_t := + do + let i ← UInt64.checked_add self.betree_node_id_counter_next_node_id + (UInt64.ofNatCore 1 (by intlit)) + Result.ret { betree_node_id_counter_next_node_id := i } + +/- [core::num::u64::{10}::MAX] -/ +def core_num_u64_max_body : Result UInt64 := + Result.ret (UInt64.ofNatCore 18446744073709551615 (by intlit)) +def core_num_u64_max_c : UInt64 := eval_global core_num_u64_max_body (by simp) + +/- [betree_main::betree::upsert_update] -/ +def betree_upsert_update_fwd + (prev : Option UInt64) (st : betree_upsert_fun_state_t) : Result UInt64 := + match h: prev with + | Option.none => + match h: st with + | betree_upsert_fun_state_t.BetreeUpsertFunStateAdd v => Result.ret v + | betree_upsert_fun_state_t.BetreeUpsertFunStateSub i => + Result.ret (UInt64.ofNatCore 0 (by intlit)) + | Option.some prev0 => + match h: st with + | betree_upsert_fun_state_t.BetreeUpsertFunStateAdd v => + do + let margin ← UInt64.checked_sub core_num_u64_max_c prev0 + if h: margin >= v + then UInt64.checked_add prev0 v + else Result.ret core_num_u64_max_c + | betree_upsert_fun_state_t.BetreeUpsertFunStateSub v => + if h: prev0 >= v + then UInt64.checked_sub prev0 v + else Result.ret (UInt64.ofNatCore 0 (by intlit)) + +/- [betree_main::betree::List::{1}::len] -/ +def betree_list_len_fwd + (T : Type) (self : betree_list_t T) : (Result UInt64) := + match h: self with + | betree_list_t.BetreeListCons t tl => + do + let i ← betree_list_len_fwd T tl + UInt64.checked_add (UInt64.ofNatCore 1 (by intlit)) i + | betree_list_t.BetreeListNil => Result.ret (UInt64.ofNatCore 0 (by intlit)) +termination_by betree_list_len_fwd self => betree_list_len_terminates T self +decreasing_by betree_list_len_decreases self + +/- [betree_main::betree::List::{1}::split_at] -/ +def betree_list_split_at_fwd + (T : Type) (self : betree_list_t T) (n : UInt64) : + (Result ((betree_list_t T) × (betree_list_t T))) + := + if h: n = (UInt64.ofNatCore 0 (by intlit)) + then Result.ret (betree_list_t.BetreeListNil, self) + else + match h: self with + | betree_list_t.BetreeListCons hd tl => + do + let i ← UInt64.checked_sub n (UInt64.ofNatCore 1 (by intlit)) + let p ← betree_list_split_at_fwd T tl i + let (ls0, ls1) := p + let l := ls0 + Result.ret (betree_list_t.BetreeListCons hd l, ls1) + | betree_list_t.BetreeListNil => Result.fail Error.panic +termination_by betree_list_split_at_fwd self n => + betree_list_split_at_terminates T self n +decreasing_by betree_list_split_at_decreases self n + +/- [betree_main::betree::List::{1}::push_front] -/ +def betree_list_push_front_fwd_back + (T : Type) (self : betree_list_t T) (x : T) : Result (betree_list_t T) := + let tl := mem_replace_fwd (betree_list_t T) self betree_list_t.BetreeListNil + let l := tl + Result.ret (betree_list_t.BetreeListCons x l) + +/- [betree_main::betree::List::{1}::pop_front] -/ +def betree_list_pop_front_fwd (T : Type) (self : betree_list_t T) : Result T := + let ls := mem_replace_fwd (betree_list_t T) self betree_list_t.BetreeListNil + match h: ls with + | betree_list_t.BetreeListCons x tl => Result.ret x + | betree_list_t.BetreeListNil => Result.fail Error.panic + +/- [betree_main::betree::List::{1}::pop_front] -/ +def betree_list_pop_front_back + (T : Type) (self : betree_list_t T) : Result (betree_list_t T) := + let ls := mem_replace_fwd (betree_list_t T) self betree_list_t.BetreeListNil + match h: ls with + | betree_list_t.BetreeListCons x tl => Result.ret tl + | betree_list_t.BetreeListNil => Result.fail Error.panic + +/- [betree_main::betree::List::{1}::hd] -/ +def betree_list_hd_fwd (T : Type) (self : betree_list_t T) : Result T := + match h: self with + | betree_list_t.BetreeListCons hd l => Result.ret hd + | betree_list_t.BetreeListNil => Result.fail Error.panic + +/- [betree_main::betree::List::{2}::head_has_key] -/ +def betree_list_head_has_key_fwd + (T : Type) (self : betree_list_t (UInt64 × T)) (key : UInt64) : + Result Bool + := + match h: self with + | betree_list_t.BetreeListCons hd l => let (i, _) := hd + Result.ret (i = key) + | betree_list_t.BetreeListNil => Result.ret false + +/- [betree_main::betree::List::{2}::partition_at_pivot] -/ +def betree_list_partition_at_pivot_fwd + (T : Type) (self : betree_list_t (UInt64 × T)) (pivot : UInt64) : + (Result ((betree_list_t (UInt64 × T)) × (betree_list_t (UInt64 × T)))) + := + match h: self with + | betree_list_t.BetreeListCons hd tl => + let (i, t) := hd + if h: i >= pivot + then + Result.ret (betree_list_t.BetreeListNil, betree_list_t.BetreeListCons (i, + t) tl) + else + do + let p ← betree_list_partition_at_pivot_fwd T tl pivot + let (ls0, ls1) := p + let l := ls0 + Result.ret (betree_list_t.BetreeListCons (i, t) l, ls1) + | betree_list_t.BetreeListNil => + Result.ret (betree_list_t.BetreeListNil, betree_list_t.BetreeListNil) +termination_by betree_list_partition_at_pivot_fwd self pivot => + betree_list_partition_at_pivot_terminates T self pivot +decreasing_by betree_list_partition_at_pivot_decreases self pivot + +/- [betree_main::betree::Leaf::{3}::split] -/ +def betree_leaf_split_fwd + (self : betree_leaf_t) (content : betree_list_t (UInt64 × UInt64)) + (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t) + (st : State) : + Result (State × betree_internal_t) + := + do + let p ← + betree_list_split_at_fwd (UInt64 × UInt64) content + params.betree_params_split_size + let (content0, content1) := p + let p0 ← betree_list_hd_fwd (UInt64 × UInt64) content1 + let (pivot, _) := p0 + let id0 ← betree_node_id_counter_fresh_id_fwd node_id_cnt + let node_id_cnt0 ← betree_node_id_counter_fresh_id_back node_id_cnt + let id1 ← betree_node_id_counter_fresh_id_fwd node_id_cnt0 + let (st0, _) ← betree_store_leaf_node_fwd id0 content0 st + let (st1, _) ← betree_store_leaf_node_fwd id1 content1 st0 + let n := betree_node_t.BetreeNodeLeaf + { + betree_leaf_id := id0, + betree_leaf_size := params.betree_params_split_size + } + let n0 := betree_node_t.BetreeNodeLeaf + { + betree_leaf_id := id1, + betree_leaf_size := params.betree_params_split_size + } + Result.ret (st1, + { + betree_internal_id := self.betree_leaf_id, + betree_internal_pivot := pivot, + betree_internal_left := n, + betree_internal_right := n0 + }) + +/- [betree_main::betree::Leaf::{3}::split] -/ +def betree_leaf_split_back + (self : betree_leaf_t) (content : betree_list_t (UInt64 × UInt64)) + (params : betree_params_t) (node_id_cnt : betree_node_id_counter_t) + (st : State) : + Result betree_node_id_counter_t + := + do + let p ← + betree_list_split_at_fwd (UInt64 × UInt64) content + params.betree_params_split_size + let (content0, content1) := p + let _ ← betree_list_hd_fwd (UInt64 × UInt64) content1 + let id0 ← betree_node_id_counter_fresh_id_fwd node_id_cnt + let node_id_cnt0 ← betree_node_id_counter_fresh_id_back node_id_cnt + let id1 ← betree_node_id_counter_fresh_id_fwd node_id_cnt0 + let (st0, _) ← betree_store_leaf_node_fwd id0 content0 st + let _ ← betree_store_leaf_node_fwd id1 content1 st0 + betree_node_id_counter_fresh_id_back node_id_cnt0 + +/- [betree_main::betree::Node::{5}::lookup_in_bindings] -/ +def betree_node_lookup_in_bindings_fwd + (key : UInt64) (bindings : betree_list_t (UInt64 × UInt64)) : + (Result (Option UInt64)) + := + match h: bindings with + | betree_list_t.BetreeListCons hd tl => + let (i, i0) := hd + if h: i = key + then Result.ret (Option.some i0) + else + if h: i > key + then Result.ret Option.none + else betree_node_lookup_in_bindings_fwd key tl + | betree_list_t.BetreeListNil => Result.ret Option.none +termination_by betree_node_lookup_in_bindings_fwd key bindings => + betree_node_lookup_in_bindings_terminates key bindings +decreasing_by betree_node_lookup_in_bindings_decreases key bindings + +/- [betree_main::betree::Node::{5}::lookup_first_message_for_key] -/ +def betree_node_lookup_first_message_for_key_fwd + (key : UInt64) (msgs : betree_list_t (UInt64 × betree_message_t)) : + (Result (betree_list_t (UInt64 × betree_message_t))) + := + match h: msgs with + | betree_list_t.BetreeListCons x next_msgs => + let (i, m) := x + if h: i >= key + then Result.ret (betree_list_t.BetreeListCons (i, m) next_msgs) + else betree_node_lookup_first_message_for_key_fwd key next_msgs + | betree_list_t.BetreeListNil => Result.ret betree_list_t.BetreeListNil +termination_by betree_node_lookup_first_message_for_key_fwd key msgs => + betree_node_lookup_first_message_for_key_terminates key msgs +decreasing_by betree_node_lookup_first_message_for_key_decreases key msgs + +/- [betree_main::betree::Node::{5}::lookup_first_message_for_key] -/ +def betree_node_lookup_first_message_for_key_back + (key : UInt64) (msgs : betree_list_t (UInt64 × betree_message_t)) + (ret0 : betree_list_t (UInt64 × betree_message_t)) : + (Result (betree_list_t (UInt64 × betree_message_t))) + := + match h: msgs with + | betree_list_t.BetreeListCons x next_msgs => + let (i, m) := x + if h: i >= key + then Result.ret ret0 + else + do + let next_msgs0 ← + betree_node_lookup_first_message_for_key_back key next_msgs ret0 + Result.ret (betree_list_t.BetreeListCons (i, m) next_msgs0) + | betree_list_t.BetreeListNil => Result.ret ret0 +termination_by betree_node_lookup_first_message_for_key_back key msgs ret0 => + betree_node_lookup_first_message_for_key_terminates key msgs +decreasing_by betree_node_lookup_first_message_for_key_decreases key msgs + +/- [betree_main::betree::Node::{5}::apply_upserts] -/ +def betree_node_apply_upserts_fwd + (msgs : betree_list_t (UInt64 × betree_message_t)) (prev : Option UInt64) + (key : UInt64) (st : State) : + (Result (State × UInt64)) + := + do + let b ← betree_list_head_has_key_fwd betree_message_t msgs key + if h: b + then + do + let msg ← betree_list_pop_front_fwd (UInt64 × betree_message_t) msgs + let (_, m) := msg + match h: m with + | betree_message_t.BetreeMessageInsert i => Result.fail Error.panic + | betree_message_t.BetreeMessageDelete => Result.fail Error.panic + | betree_message_t.BetreeMessageUpsert s => + do + let v ← betree_upsert_update_fwd prev s + let msgs0 ← + betree_list_pop_front_back (UInt64 × betree_message_t) msgs + betree_node_apply_upserts_fwd msgs0 (Option.some v) key st + else + do + let (st0, v) ← + opaque_defs.core_option_option_unwrap_fwd UInt64 prev st + let _ ← + betree_list_push_front_fwd_back (UInt64 × betree_message_t) msgs + (key, betree_message_t.BetreeMessageInsert v) + Result.ret (st0, v) +termination_by betree_node_apply_upserts_fwd msgs prev key st => + betree_node_apply_upserts_terminates msgs prev key st +decreasing_by betree_node_apply_upserts_decreases msgs prev key st + +/- [betree_main::betree::Node::{5}::apply_upserts] -/ +def betree_node_apply_upserts_back + (msgs : betree_list_t (UInt64 × betree_message_t)) (prev : Option UInt64) + (key : UInt64) (st : State) : + (Result (betree_list_t (UInt64 × betree_message_t))) + := + do + let b ← betree_list_head_has_key_fwd betree_message_t msgs key + if h: b + then + do + let msg ← betree_list_pop_front_fwd (UInt64 × betree_message_t) msgs + let (_, m) := msg + match h: m with + | betree_message_t.BetreeMessageInsert i => Result.fail Error.panic + | betree_message_t.BetreeMessageDelete => Result.fail Error.panic + | betree_message_t.BetreeMessageUpsert s => + do + let v ← betree_upsert_update_fwd prev s + let msgs0 ← + betree_list_pop_front_back (UInt64 × betree_message_t) msgs + betree_node_apply_upserts_back msgs0 (Option.some v) key st + else + do + let (_, v) ← opaque_defs.core_option_option_unwrap_fwd UInt64 prev st + betree_list_push_front_fwd_back (UInt64 × betree_message_t) msgs (key, + betree_message_t.BetreeMessageInsert v) +termination_by betree_node_apply_upserts_back msgs prev key st => + betree_node_apply_upserts_terminates msgs prev key st +decreasing_by betree_node_apply_upserts_decreases msgs prev key st + +/- [betree_main::betree::Node::{5}::lookup] -/ +mutual def betree_node_lookup_fwd + (self : betree_node_t) (key : UInt64) (st : State) : + (Result (State × (Option UInt64))) + := + match h: self with + | betree_node_t.BetreeNodeInternal node => + do + let (st0, msgs) ← + betree_load_internal_node_fwd node.betree_internal_id st + let pending ← betree_node_lookup_first_message_for_key_fwd key msgs + match h: pending with + | betree_list_t.BetreeListCons p l => + let (k, msg) := p + if h: k != key + then + do + let (st1, opt) ← + betree_internal_lookup_in_children_fwd node key st0 + let _ ← + betree_node_lookup_first_message_for_key_back key msgs + (betree_list_t.BetreeListCons (k, msg) l) + Result.ret (st1, opt) + else + match h: msg with + | betree_message_t.BetreeMessageInsert v => + do + let _ ← + betree_node_lookup_first_message_for_key_back key msgs + (betree_list_t.BetreeListCons (k, + betree_message_t.BetreeMessageInsert v) l) + Result.ret (st0, Option.some v) + | betree_message_t.BetreeMessageDelete => + do + let _ ← + betree_node_lookup_first_message_for_key_back key msgs + (betree_list_t.BetreeListCons (k, + betree_message_t.BetreeMessageDelete) l) + Result.ret (st0, Option.none) + | betree_message_t.BetreeMessageUpsert ufs => + do + let (st1, v) ← + betree_internal_lookup_in_children_fwd node key st0 + let (st2, v0) ← + betree_node_apply_upserts_fwd (betree_list_t.BetreeListCons (k, + betree_message_t.BetreeMessageUpsert ufs) l) v key st1 + let node0 ← + betree_internal_lookup_in_children_back node key st0 + let pending0 ← + betree_node_apply_upserts_back (betree_list_t.BetreeListCons + (k, betree_message_t.BetreeMessageUpsert ufs) l) v key st1 + let msgs0 ← + betree_node_lookup_first_message_for_key_back key msgs pending0 + let (st3, _) ← + betree_store_internal_node_fwd node0.betree_internal_id msgs0 + st2 + Result.ret (st3, Option.some v0) + | betree_list_t.BetreeListNil => + do + let (st1, opt) ← + betree_internal_lookup_in_children_fwd node key st0 + let _ ← + betree_node_lookup_first_message_for_key_back key msgs + betree_list_t.BetreeListNil + Result.ret (st1, opt) + | betree_node_t.BetreeNodeLeaf node => + do + let (st0, bindings) ← betree_load_leaf_node_fwd node.betree_leaf_id st + let opt ← betree_node_lookup_in_bindings_fwd key bindings + Result.ret (st0, opt) +termination_by betree_node_lookup_fwd self key st => + betree_node_lookup_terminates self key st +decreasing_by betree_node_lookup_decreases self key st + +/- [betree_main::betree::Node::{5}::lookup] -/ +def betree_node_lookup_back + (self : betree_node_t) (key : UInt64) (st : State) : + (Result betree_node_t) + := + match h: self with + | betree_node_t.BetreeNodeInternal node => + do + let (st0, msgs) ← + betree_load_internal_node_fwd node.betree_internal_id st + let pending ← betree_node_lookup_first_message_for_key_fwd key msgs + match h: pending with + | betree_list_t.BetreeListCons p l => + let (k, msg) := p + if h: k != key + then + do + let _ ← + betree_node_lookup_first_message_for_key_back key msgs + (betree_list_t.BetreeListCons (k, msg) l) + let node0 ← betree_internal_lookup_in_children_back node key st0 + Result.ret (betree_node_t.BetreeNodeInternal node0) + else + match h: msg with + | betree_message_t.BetreeMessageInsert v => + do + let _ ← + betree_node_lookup_first_message_for_key_back key msgs + (betree_list_t.BetreeListCons (k, + betree_message_t.BetreeMessageInsert v) l) + Result.ret (betree_node_t.BetreeNodeInternal node) + | betree_message_t.BetreeMessageDelete => + do + let _ ← + betree_node_lookup_first_message_for_key_back key msgs + (betree_list_t.BetreeListCons (k, + betree_message_t.BetreeMessageDelete) l) + Result.ret (betree_node_t.BetreeNodeInternal node) + | betree_message_t.BetreeMessageUpsert ufs => + do + let (st1, v) ← + betree_internal_lookup_in_children_fwd node key st0 + let (st2, _) ← + betree_node_apply_upserts_fwd (betree_list_t.BetreeListCons (k, + betree_message_t.BetreeMessageUpsert ufs) l) v key st1 + let node0 ← + betree_internal_lookup_in_children_back node key st0 + let pending0 ← + betree_node_apply_upserts_back (betree_list_t.BetreeListCons + (k, betree_message_t.BetreeMessageUpsert ufs) l) v key st1 + let msgs0 ← + betree_node_lookup_first_message_for_key_back key msgs pending0 + let _ ← + betree_store_internal_node_fwd node0.betree_internal_id msgs0 + st2 + Result.ret (betree_node_t.BetreeNodeInternal node0) + | betree_list_t.BetreeListNil => + do + let _ ← + betree_node_lookup_first_message_for_key_back key msgs + betree_list_t.BetreeListNil + let node0 ← betree_internal_lookup_in_children_back node key st0 + Result.ret (betree_node_t.BetreeNodeInternal node0) + | betree_node_t.BetreeNodeLeaf node => + do + let (_, bindings) ← betree_load_leaf_node_fwd node.betree_leaf_id st + let _ ← betree_node_lookup_in_bindings_fwd key bindings + Result.ret (betree_node_t.BetreeNodeLeaf node) +termination_by betree_node_lookup_back self key st => + betree_node_lookup_terminates self key st +decreasing_by betree_node_lookup_decreases self key st + +/- [betree_main::betree::Internal::{4}::lookup_in_children] -/ +def betree_internal_lookup_in_children_fwd + (self : betree_internal_t) (key : UInt64) (st : State) : + (Result (State × (Option UInt64))) + := + if h: key < self.betree_internal_pivot + then betree_node_lookup_fwd self.betree_internal_left key st + else betree_node_lookup_fwd self.betree_internal_right key st +termination_by betree_internal_lookup_in_children_fwd self key st => + betree_internal_lookup_in_children_terminates self key st +decreasing_by betree_internal_lookup_in_children_decreases self key st + +/- [betree_main::betree::Internal::{4}::lookup_in_children] -/ +def betree_internal_lookup_in_children_back + (self : betree_internal_t) (key : UInt64) (st : State) : + (Result betree_internal_t) + := + if h: key < self.betree_internal_pivot + then + do + let n ← betree_node_lookup_back self.betree_internal_left key st + Result.ret + { + betree_internal_id := self.betree_internal_id, + betree_internal_pivot := self.betree_internal_pivot, + betree_internal_left := n, + betree_internal_right := self.betree_internal_right + } + else + do + let n ← betree_node_lookup_back self.betree_internal_right key st + Result.ret + { + betree_internal_id := self.betree_internal_id, + betree_internal_pivot := self.betree_internal_pivot, + betree_internal_left := self.betree_internal_left, + betree_internal_right := n + } +termination_by betree_internal_lookup_in_children_back self key st => + betree_internal_lookup_in_children_terminates self key st +decreasing_by betree_internal_lookup_in_children_decreases self key st + +/- [betree_main::betree::Node::{5}::lookup_mut_in_bindings] -/ +def betree_node_lookup_mut_in_bindings_fwd + (key : UInt64) (bindings : betree_list_t (UInt64 × UInt64)) : + (Result (betree_list_t (UInt64 × UInt64))) + := + match h: bindings with + | betree_list_t.BetreeListCons hd tl => + let (i, i0) := hd + if h: i >= key + then Result.ret (betree_list_t.BetreeListCons (i, i0) tl) + else betree_node_lookup_mut_in_bindings_fwd key tl + | betree_list_t.BetreeListNil => Result.ret betree_list_t.BetreeListNil +termination_by betree_node_lookup_mut_in_bindings_fwd key bindings => + betree_node_lookup_mut_in_bindings_terminates key bindings +decreasing_by betree_node_lookup_mut_in_bindings_decreases key bindings + +/- [betree_main::betree::Node::{5}::lookup_mut_in_bindings] -/ +def betree_node_lookup_mut_in_bindings_back + (key : UInt64) (bindings : betree_list_t (UInt64 × UInt64)) + (ret0 : betree_list_t (UInt64 × UInt64)) : + (Result (betree_list_t (UInt64 × UInt64))) + := + match h: bindings with + | betree_list_t.BetreeListCons hd tl => + let (i, i0) := hd + if h: i >= key + then Result.ret ret0 + else + do + let tl0 ← betree_node_lookup_mut_in_bindings_back key tl ret0 + Result.ret (betree_list_t.BetreeListCons (i, i0) tl0) + | betree_list_t.BetreeListNil => Result.ret ret0 +termination_by betree_node_lookup_mut_in_bindings_back key bindings ret0 => + betree_node_lookup_mut_in_bindings_terminates key bindings +decreasing_by betree_node_lookup_mut_in_bindings_decreases key bindings + +/- [betree_main::betree::Node::{5}::apply_to_leaf] -/ +def betree_node_apply_to_leaf_fwd_back + (bindings : betree_list_t (UInt64 × UInt64)) (key : UInt64) + (new_msg : betree_message_t) : + Result (betree_list_t (UInt64 × UInt64)) + := + do + let bindings0 ← betree_node_lookup_mut_in_bindings_fwd key bindings + let b ← betree_list_head_has_key_fwd UInt64 bindings0 key + if h: b + then + do + let hd ← betree_list_pop_front_fwd (UInt64 × UInt64) bindings0 + match h: new_msg with + | betree_message_t.BetreeMessageInsert v => + do + let bindings1 ← + betree_list_pop_front_back (UInt64 × UInt64) bindings0 + let bindings2 ← + betree_list_push_front_fwd_back (UInt64 × UInt64) bindings1 + (key, v) + betree_node_lookup_mut_in_bindings_back key bindings bindings2 + | betree_message_t.BetreeMessageDelete => + do + let bindings1 ← + betree_list_pop_front_back (UInt64 × UInt64) bindings0 + betree_node_lookup_mut_in_bindings_back key bindings bindings1 + | betree_message_t.BetreeMessageUpsert s => + do + let (_, i) := hd + let v ← betree_upsert_update_fwd (Option.some i) s + let bindings1 ← + betree_list_pop_front_back (UInt64 × UInt64) bindings0 + let bindings2 ← + betree_list_push_front_fwd_back (UInt64 × UInt64) bindings1 + (key, v) + betree_node_lookup_mut_in_bindings_back key bindings bindings2 + else + match h: new_msg with + | betree_message_t.BetreeMessageInsert v => + do + let bindings1 ← + betree_list_push_front_fwd_back (UInt64 × UInt64) bindings0 (key, + v) + betree_node_lookup_mut_in_bindings_back key bindings bindings1 + | betree_message_t.BetreeMessageDelete => + betree_node_lookup_mut_in_bindings_back key bindings bindings0 + | betree_message_t.BetreeMessageUpsert s => + do + let v ← betree_upsert_update_fwd Option.none s + let bindings1 ← + betree_list_push_front_fwd_back (UInt64 × UInt64) bindings0 (key, + v) + betree_node_lookup_mut_in_bindings_back key bindings bindings1 + +/- [betree_main::betree::Node::{5}::apply_messages_to_leaf] -/ +def betree_node_apply_messages_to_leaf_fwd_back + (bindings : betree_list_t (UInt64 × UInt64)) + (new_msgs : betree_list_t (UInt64 × betree_message_t)) : + (Result (betree_list_t (UInt64 × UInt64))) + := + match h: new_msgs with + | betree_list_t.BetreeListCons new_msg new_msgs_tl => + do + let (i, m) := new_msg + let bindings0 ← betree_node_apply_to_leaf_fwd_back bindings i m + betree_node_apply_messages_to_leaf_fwd_back bindings0 new_msgs_tl + | betree_list_t.BetreeListNil => Result.ret bindings +termination_by betree_node_apply_messages_to_leaf_fwd_back bindings new_msgs => + betree_node_apply_messages_to_leaf_terminates bindings new_msgs +decreasing_by betree_node_apply_messages_to_leaf_decreases bindings new_msgs + +/- [betree_main::betree::Node::{5}::filter_messages_for_key] -/ +def betree_node_filter_messages_for_key_fwd_back + (key : UInt64) (msgs : betree_list_t (UInt64 × betree_message_t)) : + (Result (betree_list_t (UInt64 × betree_message_t))) + := + match h: msgs with + | betree_list_t.BetreeListCons p l => + let (k, m) := p + if h: k = key + then + do + let msgs0 ← + betree_list_pop_front_back (UInt64 × betree_message_t) + (betree_list_t.BetreeListCons (k, m) l) + betree_node_filter_messages_for_key_fwd_back key msgs0 + else Result.ret (betree_list_t.BetreeListCons (k, m) l) + | betree_list_t.BetreeListNil => Result.ret betree_list_t.BetreeListNil +termination_by betree_node_filter_messages_for_key_fwd_back key msgs => + betree_node_filter_messages_for_key_terminates key msgs +decreasing_by betree_node_filter_messages_for_key_decreases key msgs + +/- [betree_main::betree::Node::{5}::lookup_first_message_after_key] -/ +def betree_node_lookup_first_message_after_key_fwd + (key : UInt64) (msgs : betree_list_t (UInt64 × betree_message_t)) : + (Result (betree_list_t (UInt64 × betree_message_t))) + := + match h: msgs with + | betree_list_t.BetreeListCons p next_msgs => + let (k, m) := p + if h: k = key + then betree_node_lookup_first_message_after_key_fwd key next_msgs + else Result.ret (betree_list_t.BetreeListCons (k, m) next_msgs) + | betree_list_t.BetreeListNil => Result.ret betree_list_t.BetreeListNil +termination_by betree_node_lookup_first_message_after_key_fwd key msgs => + betree_node_lookup_first_message_after_key_terminates key msgs +decreasing_by betree_node_lookup_first_message_after_key_decreases key msgs + +/- [betree_main::betree::Node::{5}::lookup_first_message_after_key] -/ +def betree_node_lookup_first_message_after_key_back + (key : UInt64) (msgs : betree_list_t (UInt64 × betree_message_t)) + (ret0 : betree_list_t (UInt64 × betree_message_t)) : + (Result (betree_list_t (UInt64 × betree_message_t))) + := + match h: msgs with + | betree_list_t.BetreeListCons p next_msgs => + let (k, m) := p + if h: k = key + then + do + let next_msgs0 ← + betree_node_lookup_first_message_after_key_back key next_msgs ret0 + Result.ret (betree_list_t.BetreeListCons (k, m) next_msgs0) + else Result.ret ret0 + | betree_list_t.BetreeListNil => Result.ret ret0 +termination_by betree_node_lookup_first_message_after_key_back key msgs ret0 => + betree_node_lookup_first_message_after_key_terminates key msgs +decreasing_by betree_node_lookup_first_message_after_key_decreases key msgs + +/- [betree_main::betree::Node::{5}::apply_to_internal] -/ +def betree_node_apply_to_internal_fwd_back + (msgs : betree_list_t (UInt64 × betree_message_t)) (key : UInt64) + (new_msg : betree_message_t) : + Result (betree_list_t (UInt64 × betree_message_t)) + := + do + let msgs0 ← betree_node_lookup_first_message_for_key_fwd key msgs + let b ← betree_list_head_has_key_fwd betree_message_t msgs0 key + if h: b + then + match h: new_msg with + | betree_message_t.BetreeMessageInsert i => + do + let msgs1 ← betree_node_filter_messages_for_key_fwd_back key msgs0 + let msgs2 ← + betree_list_push_front_fwd_back (UInt64 × betree_message_t) msgs1 + (key, betree_message_t.BetreeMessageInsert i) + betree_node_lookup_first_message_for_key_back key msgs msgs2 + | betree_message_t.BetreeMessageDelete => + do + let msgs1 ← betree_node_filter_messages_for_key_fwd_back key msgs0 + let msgs2 ← + betree_list_push_front_fwd_back (UInt64 × betree_message_t) msgs1 + (key, betree_message_t.BetreeMessageDelete) + betree_node_lookup_first_message_for_key_back key msgs msgs2 + | betree_message_t.BetreeMessageUpsert s => + do + let p ← betree_list_hd_fwd (UInt64 × betree_message_t) msgs0 + let (_, m) := p + match h: m with + | betree_message_t.BetreeMessageInsert prev => + do + let v ← betree_upsert_update_fwd (Option.some prev) s + let msgs1 ← + betree_list_pop_front_back (UInt64 × betree_message_t) msgs0 + let msgs2 ← + betree_list_push_front_fwd_back (UInt64 × betree_message_t) + msgs1 (key, betree_message_t.BetreeMessageInsert v) + betree_node_lookup_first_message_for_key_back key msgs msgs2 + | betree_message_t.BetreeMessageDelete => + do + let v ← betree_upsert_update_fwd Option.none s + let msgs1 ← + betree_list_pop_front_back (UInt64 × betree_message_t) msgs0 + let msgs2 ← + betree_list_push_front_fwd_back (UInt64 × betree_message_t) + msgs1 (key, betree_message_t.BetreeMessageInsert v) + betree_node_lookup_first_message_for_key_back key msgs msgs2 + | betree_message_t.BetreeMessageUpsert ufs => + do + let msgs1 ← + betree_node_lookup_first_message_after_key_fwd key msgs0 + let msgs2 ← + betree_list_push_front_fwd_back (UInt64 × betree_message_t) + msgs1 (key, betree_message_t.BetreeMessageUpsert s) + let msgs3 ← + betree_node_lookup_first_message_after_key_back key msgs0 msgs2 + betree_node_lookup_first_message_for_key_back key msgs msgs3 + else + do + let msgs1 ← + betree_list_push_front_fwd_back (UInt64 × betree_message_t) msgs0 + (key, new_msg) + betree_node_lookup_first_message_for_key_back key msgs msgs1 + +/- [betree_main::betree::Node::{5}::apply_messages_to_internal] -/ +def betree_node_apply_messages_to_internal_fwd_back + (msgs : betree_list_t (UInt64 × betree_message_t)) + (new_msgs : betree_list_t (UInt64 × betree_message_t)) : + (Result (betree_list_t (UInt64 × betree_message_t))) + := + match h: new_msgs with + | betree_list_t.BetreeListCons new_msg new_msgs_tl => + do + let (i, m) := new_msg + let msgs0 ← betree_node_apply_to_internal_fwd_back msgs i m + betree_node_apply_messages_to_internal_fwd_back msgs0 new_msgs_tl + | betree_list_t.BetreeListNil => Result.ret msgs +termination_by betree_node_apply_messages_to_internal_fwd_back msgs new_msgs => + betree_node_apply_messages_to_internal_terminates msgs new_msgs +decreasing_by betree_node_apply_messages_to_internal_decreases msgs new_msgs + +/- [betree_main::betree::Node::{5}::apply_messages] -/ +mutual def betree_node_apply_messages_fwd + (self : betree_node_t) (params : betree_params_t) + (node_id_cnt : betree_node_id_counter_t) + (msgs : betree_list_t (UInt64 × betree_message_t)) (st : State) : + (Result (State × Unit)) + := + match h: self with + | betree_node_t.BetreeNodeInternal node => + do + let (st0, content) ← + betree_load_internal_node_fwd node.betree_internal_id st + let content0 ← + betree_node_apply_messages_to_internal_fwd_back content msgs + let num_msgs ← + betree_list_len_fwd (UInt64 × betree_message_t) content0 + if h: num_msgs >= params.betree_params_min_flush_size + then + do + let (st1, content1) ← + betree_internal_flush_fwd node params node_id_cnt content0 st0 + let (node0, _) ← + betree_internal_flush_back node params node_id_cnt content0 st0 + let (st2, _) ← + betree_store_internal_node_fwd node0.betree_internal_id content1 + st1 + Result.ret (st2, ()) + else + do + let (st1, _) ← + betree_store_internal_node_fwd node.betree_internal_id content0 st0 + Result.ret (st1, ()) + | betree_node_t.BetreeNodeLeaf node => + do + let (st0, content) ← betree_load_leaf_node_fwd node.betree_leaf_id st + let content0 ← betree_node_apply_messages_to_leaf_fwd_back content msgs + let len ← betree_list_len_fwd (UInt64 × UInt64) content0 + let i ← UInt64.checked_mul (UInt64.ofNatCore 2 (by intlit)) + params.betree_params_split_size + if h: len >= i + then + do + let (st1, _) ← + betree_leaf_split_fwd node content0 params node_id_cnt st0 + let (st2, _) ← + betree_store_leaf_node_fwd node.betree_leaf_id + betree_list_t.BetreeListNil st1 + Result.ret (st2, ()) + else + do + let (st1, _) ← + betree_store_leaf_node_fwd node.betree_leaf_id content0 st0 + Result.ret (st1, ()) +termination_by betree_node_apply_messages_fwd self params node_id_cnt msgs st + => + betree_node_apply_messages_terminates self params node_id_cnt msgs st +decreasing_by + betree_node_apply_messages_decreases self params node_id_cnt msgs st + +/- [betree_main::betree::Node::{5}::apply_messages] -/ +def betree_node_apply_messages_back + (self : betree_node_t) (params : betree_params_t) + (node_id_cnt : betree_node_id_counter_t) + (msgs : betree_list_t (UInt64 × betree_message_t)) (st : State) : + (Result (betree_node_t × betree_node_id_counter_t)) + := + match h: self with + | betree_node_t.BetreeNodeInternal node => + do + let (st0, content) ← + betree_load_internal_node_fwd node.betree_internal_id st + let content0 ← + betree_node_apply_messages_to_internal_fwd_back content msgs + let num_msgs ← + betree_list_len_fwd (UInt64 × betree_message_t) content0 + if h: num_msgs >= params.betree_params_min_flush_size + then + do + let (st1, content1) ← + betree_internal_flush_fwd node params node_id_cnt content0 st0 + let (node0, node_id_cnt0) ← + betree_internal_flush_back node params node_id_cnt content0 st0 + let _ ← + betree_store_internal_node_fwd node0.betree_internal_id content1 + st1 + Result.ret (betree_node_t.BetreeNodeInternal node0, node_id_cnt0) + else + do + let _ ← + betree_store_internal_node_fwd node.betree_internal_id content0 st0 + Result.ret (betree_node_t.BetreeNodeInternal node, node_id_cnt) + | betree_node_t.BetreeNodeLeaf node => + do + let (st0, content) ← betree_load_leaf_node_fwd node.betree_leaf_id st + let content0 ← betree_node_apply_messages_to_leaf_fwd_back content msgs + let len ← betree_list_len_fwd (UInt64 × UInt64) content0 + let i ← UInt64.checked_mul (UInt64.ofNatCore 2 (by intlit)) + params.betree_params_split_size + if h: len >= i + then + do + let (st1, new_node) ← + betree_leaf_split_fwd node content0 params node_id_cnt st0 + let _ ← + betree_store_leaf_node_fwd node.betree_leaf_id + betree_list_t.BetreeListNil st1 + let node_id_cnt0 ← + betree_leaf_split_back node content0 params node_id_cnt st0 + Result.ret (betree_node_t.BetreeNodeInternal new_node, node_id_cnt0) + else + do + let _ ← betree_store_leaf_node_fwd node.betree_leaf_id content0 st0 + Result.ret (betree_node_t.BetreeNodeLeaf + { betree_leaf_id := node.betree_leaf_id, betree_leaf_size := len }, + node_id_cnt) +termination_by betree_node_apply_messages_back self params node_id_cnt msgs st + => + betree_node_apply_messages_terminates self params node_id_cnt msgs st +decreasing_by + betree_node_apply_messages_decreases self params node_id_cnt msgs st + +/- [betree_main::betree::Internal::{4}::flush] -/ +def betree_internal_flush_fwd + (self : betree_internal_t) (params : betree_params_t) + (node_id_cnt : betree_node_id_counter_t) + (content : betree_list_t (UInt64 × betree_message_t)) (st : State) : + (Result (State × (betree_list_t (UInt64 × betree_message_t)))) + := + do + let p ← + betree_list_partition_at_pivot_fwd betree_message_t content + self.betree_internal_pivot + let (msgs_left, msgs_right) := p + let len_left ← betree_list_len_fwd (UInt64 × betree_message_t) msgs_left + if h: len_left >= params.betree_params_min_flush_size + then + do + let (st0, _) ← + betree_node_apply_messages_fwd self.betree_internal_left params + node_id_cnt msgs_left st + let (_, node_id_cnt0) ← + betree_node_apply_messages_back self.betree_internal_left params + node_id_cnt msgs_left st + let len_right ← + betree_list_len_fwd (UInt64 × betree_message_t) msgs_right + if h: len_right >= params.betree_params_min_flush_size + then + do + let (st1, _) ← + betree_node_apply_messages_fwd self.betree_internal_right params + node_id_cnt0 msgs_right st0 + let _ ← + betree_node_apply_messages_back self.betree_internal_right params + node_id_cnt0 msgs_right st0 + Result.ret (st1, betree_list_t.BetreeListNil) + else Result.ret (st0, msgs_right) + else + do + let (st0, _) ← + betree_node_apply_messages_fwd self.betree_internal_right params + node_id_cnt msgs_right st + let _ ← + betree_node_apply_messages_back self.betree_internal_right params + node_id_cnt msgs_right st + Result.ret (st0, msgs_left) +termination_by betree_internal_flush_fwd self params node_id_cnt content st => + betree_internal_flush_terminates self params node_id_cnt content st +decreasing_by + betree_internal_flush_decreases self params node_id_cnt content st + +/- [betree_main::betree::Internal::{4}::flush] -/ +def betree_internal_flush_back + (self : betree_internal_t) (params : betree_params_t) + (node_id_cnt : betree_node_id_counter_t) + (content : betree_list_t (UInt64 × betree_message_t)) (st : State) : + (Result (betree_internal_t × betree_node_id_counter_t)) + := + do + let p ← + betree_list_partition_at_pivot_fwd betree_message_t content + self.betree_internal_pivot + let (msgs_left, msgs_right) := p + let len_left ← betree_list_len_fwd (UInt64 × betree_message_t) msgs_left + if h: len_left >= params.betree_params_min_flush_size + then + do + let (st0, _) ← + betree_node_apply_messages_fwd self.betree_internal_left params + node_id_cnt msgs_left st + let (n, node_id_cnt0) ← + betree_node_apply_messages_back self.betree_internal_left params + node_id_cnt msgs_left st + let len_right ← + betree_list_len_fwd (UInt64 × betree_message_t) msgs_right + if h: len_right >= params.betree_params_min_flush_size + then + do + let (n0, node_id_cnt1) ← + betree_node_apply_messages_back self.betree_internal_right params + node_id_cnt0 msgs_right st0 + Result.ret + ({ + betree_internal_id := self.betree_internal_id, + betree_internal_pivot := self.betree_internal_pivot, + betree_internal_left := n, + betree_internal_right := n0 + }, node_id_cnt1) + else + Result.ret + ({ + betree_internal_id := self.betree_internal_id, + betree_internal_pivot := self.betree_internal_pivot, + betree_internal_left := n, + betree_internal_right := self.betree_internal_right + }, node_id_cnt0) + else + do + let (n, node_id_cnt0) ← + betree_node_apply_messages_back self.betree_internal_right params + node_id_cnt msgs_right st + Result.ret + ({ + betree_internal_id := self.betree_internal_id, + betree_internal_pivot := self.betree_internal_pivot, + betree_internal_left := self.betree_internal_left, + betree_internal_right := n + }, node_id_cnt0) +termination_by betree_internal_flush_back self params node_id_cnt content st => + betree_internal_flush_terminates self params node_id_cnt content st +decreasing_by + betree_internal_flush_decreases self params node_id_cnt content st + +/- [betree_main::betree::Node::{5}::apply] -/ +def betree_node_apply_fwd + (self : betree_node_t) (params : betree_params_t) + (node_id_cnt : betree_node_id_counter_t) (key : UInt64) + (new_msg : betree_message_t) (st : State) : + Result (State × Unit) + := + do + let l := betree_list_t.BetreeListNil + let (st0, _) ← + betree_node_apply_messages_fwd self params node_id_cnt + (betree_list_t.BetreeListCons (key, new_msg) l) st + let _ ← + betree_node_apply_messages_back self params node_id_cnt + (betree_list_t.BetreeListCons (key, new_msg) l) st + Result.ret (st0, ()) + +/- [betree_main::betree::Node::{5}::apply] -/ +def betree_node_apply_back + (self : betree_node_t) (params : betree_params_t) + (node_id_cnt : betree_node_id_counter_t) (key : UInt64) + (new_msg : betree_message_t) (st : State) : + Result (betree_node_t × betree_node_id_counter_t) + := + let l := betree_list_t.BetreeListNil + betree_node_apply_messages_back self params node_id_cnt + (betree_list_t.BetreeListCons (key, new_msg) l) st + +/- [betree_main::betree::BeTree::{6}::new] -/ +def betree_be_tree_new_fwd + (min_flush_size : UInt64) (split_size : UInt64) (st : State) : + Result (State × betree_be_tree_t) + := + do + let node_id_cnt ← betree_node_id_counter_new_fwd + let id ← betree_node_id_counter_fresh_id_fwd node_id_cnt + let (st0, _) ← + betree_store_leaf_node_fwd id betree_list_t.BetreeListNil st + let node_id_cnt0 ← betree_node_id_counter_fresh_id_back node_id_cnt + Result.ret (st0, + { + betree_be_tree_params := { + betree_params_min_flush_size := min_flush_size, + betree_params_split_size := split_size + }, + betree_be_tree_node_id_cnt := node_id_cnt0, + betree_be_tree_root := (betree_node_t.BetreeNodeLeaf + { + betree_leaf_id := id, + betree_leaf_size := (UInt64.ofNatCore 0 (by intlit)) + }) + }) + +/- [betree_main::betree::BeTree::{6}::apply] -/ +def betree_be_tree_apply_fwd + (self : betree_be_tree_t) (key : UInt64) (msg : betree_message_t) + (st : State) : + Result (State × Unit) + := + do + let (st0, _) ← + betree_node_apply_fwd self.betree_be_tree_root self.betree_be_tree_params + self.betree_be_tree_node_id_cnt key msg st + let _ ← + betree_node_apply_back self.betree_be_tree_root + self.betree_be_tree_params self.betree_be_tree_node_id_cnt key msg st + Result.ret (st0, ()) + +/- [betree_main::betree::BeTree::{6}::apply] -/ +def betree_be_tree_apply_back + (self : betree_be_tree_t) (key : UInt64) (msg : betree_message_t) + (st : State) : + Result betree_be_tree_t + := + do + let (n, nic) ← + betree_node_apply_back self.betree_be_tree_root + self.betree_be_tree_params self.betree_be_tree_node_id_cnt key msg st + Result.ret + { + betree_be_tree_params := self.betree_be_tree_params, + betree_be_tree_node_id_cnt := nic, + betree_be_tree_root := n + } + +/- [betree_main::betree::BeTree::{6}::insert] -/ +def betree_be_tree_insert_fwd + (self : betree_be_tree_t) (key : UInt64) (value : UInt64) (st : State) : + Result (State × Unit) + := + do + let (st0, _) ← + betree_be_tree_apply_fwd self key (betree_message_t.BetreeMessageInsert + value) st + let _ ← + betree_be_tree_apply_back self key (betree_message_t.BetreeMessageInsert + value) st + Result.ret (st0, ()) + +/- [betree_main::betree::BeTree::{6}::insert] -/ +def betree_be_tree_insert_back + (self : betree_be_tree_t) (key : UInt64) (value : UInt64) (st : State) : + Result betree_be_tree_t + := + betree_be_tree_apply_back self key (betree_message_t.BetreeMessageInsert + value) st + +/- [betree_main::betree::BeTree::{6}::delete] -/ +def betree_be_tree_delete_fwd + (self : betree_be_tree_t) (key : UInt64) (st : State) : + Result (State × Unit) + := + do + let (st0, _) ← + betree_be_tree_apply_fwd self key betree_message_t.BetreeMessageDelete st + let _ ← + betree_be_tree_apply_back self key betree_message_t.BetreeMessageDelete + st + Result.ret (st0, ()) + +/- [betree_main::betree::BeTree::{6}::delete] -/ +def betree_be_tree_delete_back + (self : betree_be_tree_t) (key : UInt64) (st : State) : + Result betree_be_tree_t + := + betree_be_tree_apply_back self key betree_message_t.BetreeMessageDelete st + +/- [betree_main::betree::BeTree::{6}::upsert] -/ +def betree_be_tree_upsert_fwd + (self : betree_be_tree_t) (key : UInt64) (upd : betree_upsert_fun_state_t) + (st : State) : + Result (State × Unit) + := + do + let (st0, _) ← + betree_be_tree_apply_fwd self key (betree_message_t.BetreeMessageUpsert + upd) st + let _ ← + betree_be_tree_apply_back self key (betree_message_t.BetreeMessageUpsert + upd) st + Result.ret (st0, ()) + +/- [betree_main::betree::BeTree::{6}::upsert] -/ +def betree_be_tree_upsert_back + (self : betree_be_tree_t) (key : UInt64) (upd : betree_upsert_fun_state_t) + (st : State) : + Result betree_be_tree_t + := + betree_be_tree_apply_back self key (betree_message_t.BetreeMessageUpsert upd) + st + +/- [betree_main::betree::BeTree::{6}::lookup] -/ +def betree_be_tree_lookup_fwd + (self : betree_be_tree_t) (key : UInt64) (st : State) : + Result (State × (Option UInt64)) + := + betree_node_lookup_fwd self.betree_be_tree_root key st + +/- [betree_main::betree::BeTree::{6}::lookup] -/ +def betree_be_tree_lookup_back + (self : betree_be_tree_t) (key : UInt64) (st : State) : + Result betree_be_tree_t + := + do + let n ← betree_node_lookup_back self.betree_be_tree_root key st + Result.ret + { + betree_be_tree_params := self.betree_be_tree_params, + betree_be_tree_node_id_cnt := self.betree_be_tree_node_id_cnt, + betree_be_tree_root := n + } + +/- [betree_main::main] -/ +def main_fwd : Result Unit := + Result.ret () + +/- Unit test for [betree_main::main] -/ +#assert (main_fwd == .ret ()) + diff --git a/tests/lean/betree/BetreeMain/Opaque.lean b/tests/lean/betree/BetreeMain/Opaque.lean new file mode 100644 index 00000000..b3db37c2 --- /dev/null +++ b/tests/lean/betree/BetreeMain/Opaque.lean @@ -0,0 +1,33 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [betree_main]: opaque function definitions +import Base.Primitives +import BetreeMain.Types + +structure OpaqueDefs where + + /- [betree_main::betree_utils::load_internal_node] -/ + betree_utils_load_internal_node_fwd + : + UInt64 -> State -> Result (State × (betree_list_t (UInt64 × + betree_message_t))) + + /- [betree_main::betree_utils::store_internal_node] -/ + betree_utils_store_internal_node_fwd + : + UInt64 -> betree_list_t (UInt64 × betree_message_t) -> State -> Result + (State × Unit) + + /- [betree_main::betree_utils::load_leaf_node] -/ + betree_utils_load_leaf_node_fwd + : UInt64 -> State -> Result (State × (betree_list_t (UInt64 × UInt64))) + + /- [betree_main::betree_utils::store_leaf_node] -/ + betree_utils_store_leaf_node_fwd + : + UInt64 -> betree_list_t (UInt64 × UInt64) -> State -> Result (State × + Unit) + + /- [core::option::Option::{0}::unwrap] -/ + core_option_option_unwrap_fwd + (T : Type) : Option T -> State -> Result (State × T) + diff --git a/tests/lean/betree/BetreeMain/Types.lean b/tests/lean/betree/BetreeMain/Types.lean new file mode 100644 index 00000000..2726e1f0 --- /dev/null +++ b/tests/lean/betree/BetreeMain/Types.lean @@ -0,0 +1,61 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [betree_main]: type definitions +import Base.Primitives + +/- [betree_main::betree::List] -/ +inductive betree_list_t (T : Type) := +| BetreeListCons : T -> betree_list_t T -> betree_list_t T +| BetreeListNil : betree_list_t T + +/- [betree_main::betree::UpsertFunState] -/ +inductive betree_upsert_fun_state_t := +| BetreeUpsertFunStateAdd : UInt64 -> betree_upsert_fun_state_t +| BetreeUpsertFunStateSub : UInt64 -> betree_upsert_fun_state_t + +/- [betree_main::betree::Message] -/ +inductive betree_message_t := +| BetreeMessageInsert : UInt64 -> betree_message_t +| BetreeMessageDelete : betree_message_t +| BetreeMessageUpsert : betree_upsert_fun_state_t -> betree_message_t + +/- [betree_main::betree::Leaf] -/ +structure betree_leaf_t where + + betree_leaf_id : UInt64 betree_leaf_size : UInt64 + + +/- [betree_main::betree::Node] -/ +mutual inductive betree_node_t := +| BetreeNodeInternal : betree_internal_t -> betree_node_t +| BetreeNodeLeaf : betree_leaf_t -> betree_node_t + +/- [betree_main::betree::Internal] -/ +inductive betree_internal_t := + + betree_internal_id : UInt64 + betree_internal_pivot : UInt64 + betree_internal_left : betree_node_t + betree_internal_right : betree_node_t + + +/- [betree_main::betree::Params] -/ +structure betree_params_t where + + betree_params_min_flush_size : UInt64 betree_params_split_size : UInt64 + + +/- [betree_main::betree::NodeIdCounter] -/ +structure betree_node_id_counter_t where + + betree_node_id_counter_next_node_id : UInt64 + + +/- [betree_main::betree::BeTree] -/ +structure betree_be_tree_t where + + betree_be_tree_params : betree_params_t + betree_be_tree_node_id_cnt : betree_node_id_counter_t + betree_be_tree_root : betree_node_t + +/- The state type used in the state-error monad -/ axiom State : Type + diff --git a/tests/lean/betree/lakefile.lean b/tests/lean/betree/lakefile.lean new file mode 100644 index 00000000..aa702300 --- /dev/null +++ b/tests/lean/betree/lakefile.lean @@ -0,0 +1,18 @@ +import Lake +open Lake DSL + +require mathlib from git + "https://github.com/leanprover-community/mathlib4.git" + +package «betree_main» { + -- add package configuration options here +} + +lean_lib «Base» { + -- add library configuration options here +} + +lean_lib «BetreeMain» { + -- add library configuration options here +} + diff --git a/tests/lean/misc-constants/Base/Primitives.lean b/tests/lean/misc-constants/Base/Primitives.lean new file mode 100644 index 00000000..5b64e908 --- /dev/null +++ b/tests/lean/misc-constants/Base/Primitives.lean @@ -0,0 +1,392 @@ +import Lean +import Lean.Meta.Tactic.Simp +import Init.Data.List.Basic +import Mathlib.Tactic.RunCmd + +------------- +-- PRELUDE -- +------------- + +-- Results & monadic combinators + +inductive Error where + | assertionFailure: Error + | integerOverflow: Error + | arrayOutOfBounds: Error + | maximumSizeExceeded: Error + | panic: Error +deriving Repr, BEq + +open Error + +inductive Result (α : Type u) where + | ret (v: α): Result α + | fail (e: Error): Result α +deriving Repr, BEq + +open Result + +/- HELPERS -/ + +def ret? {α: Type} (r: Result α): Bool := + match r with + | Result.ret _ => true + | Result.fail _ => false + +def massert (b:Bool) : Result Unit := + if b then .ret () else fail assertionFailure + +def eval_global {α: Type} (x: Result α) (_: ret? x): α := + match x with + | Result.fail _ => by contradiction + | Result.ret x => x + +/- DO-DSL SUPPORT -/ + +def bind (x: Result α) (f: α -> Result β) : Result β := + match x with + | ret v => f v + | fail v => fail v + +-- Allows using Result in do-blocks +instance : Bind Result where + bind := bind + +-- Allows using return x in do-blocks +instance : Pure Result where + pure := fun x => ret x + +/- CUSTOM-DSL SUPPORT -/ + +-- Let-binding the Result of a monadic operation is oftentimes not sufficient, +-- because we may need a hypothesis for equational reasoning in the scope. We +-- rely on subtype, and a custom let-binding operator, in effect recreating our +-- own variant of the do-dsl + +def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := + match o with + | .ret x => .ret ⟨x, rfl⟩ + | .fail e => .fail e + +macro "let" e:term " ⟵ " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- TODO: any way to factorize both definitions? +macro "let" e:term " <-- " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- We call the hypothesis `h`, in effect making it unavailable to the user +-- (because too much shadowing). But in practice, once can use the French single +-- quote notation (input with f< and f>), where `‹ h ›` finds a suitable +-- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` +#eval do + let y <-- .ret (0: Nat) + let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide + let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ + .ret r + +---------------------- +-- MACHINE INTEGERS -- +---------------------- + +-- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., +-- USize. They are generally defined in an idiomatic style, except that there is +-- not a single type class to rule them all (more on that below). The absence of +-- type class is intentional, and allows the Lean compiler to efficiently map +-- them to machine integers during compilation. + +-- USize is designed properly: you cannot reduce `getNumBits` using the +-- simplifier, meaning that proofs do not depend on the compile-time value of +-- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really +-- support, at least officially, 16-bit microcontrollers, so this seems like a +-- fine design decision for now.) + +-- Note from Chris Bailey: "If there's more than one salient property of your +-- definition then the subtyping strategy might get messy, and the property part +-- of a subtype is less discoverable by the simplifier or tactics like +-- library_search." So, we will not add refinements on the return values of the +-- operations defined on Primitives, but will rather rely on custom lemmas to +-- invert on possible return values of the primitive operations. + +-- Machine integer constants, done via `ofNatCore`, which requires a proof that +-- the `Nat` fits within the desired integer type. We provide a custom tactic. + +syntax "intlit" : tactic + +macro_rules + | `(tactic| intlit) => `(tactic| + match USize.size, usize_size_eq with + | _, Or.inl rfl => decide + | _, Or.inr rfl => decide) + +-- This is how the macro is expected to be used +#eval USize.ofNatCore 0 (by intlit) + +-- Also works for other integer types (at the expense of a needless disjunction) +#eval UInt32.ofNatCore 0 (by intlit) + +-- The machine integer operations (e.g. sub) are always total, which is not what +-- we want. We therefore define "checked" variants, below. Note that we add a +-- tiny bit of complexity for the USize variant: we first check whether the +-- result is < 2^32; if it is, we can compute the definition, rather than +-- returning a term that is computationally stuck (the comparison to USize.size +-- cannot reduce at compile-time, per the remark about regarding `getNumBits`). +-- This is useful for the various #asserts that we want to reduce at +-- type-checking time. + +-- Further thoughts: look at what has been done here: +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean +-- and +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean +-- which both contain a fair amount of reasoning already! +def USize.checked_sub (n: USize) (m: USize): Result USize := + -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? + if n >= m then + let n' := USize.toNat n + let m' := USize.toNat n + let r := USize.ofNatCore (n' - m') (by + have h: n' - m' <= n' := by + apply Nat.sub_le_of_le_add + case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left + apply Nat.lt_of_le_of_lt h + apply n.val.isLt + ) + return r + else + fail integerOverflow + +@[simp] +theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := + match USize.size, usize_size_eq with + | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) + | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) + +def USize.checked_add (n: USize) (m: USize): Result USize := + if h: n.val + m.val < USize.size then + .ret ⟨ n.val + m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_rem (n: USize) (m: USize): Result USize := + if h: m > 0 then + .ret ⟨ n.val % m.val, by + have h1: ↑m.val < USize.size := m.val.isLt + have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h + apply Nat.lt_trans h2 h1 + ⟩ + else + .fail integerOverflow + +def USize.checked_mul (n: USize) (m: USize): Result USize := + if h: n.val * m.val < USize.size then + .ret ⟨ n.val * m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_div (n: USize) (m: USize): Result USize := + if m > 0 then + .ret ⟨ n.val / m.val, by + have h1: ↑n.val < USize.size := n.val.isLt + have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val + apply Nat.lt_of_le_of_lt h2 h1 + ⟩ + else + .fail integerOverflow + +-- Test behavior... +#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 + +#eval USize.checked_sub 20 10 +-- NOTE: compare with concrete behavior here, which I do not think we want +#eval USize.sub 0 1 +#eval UInt8.add 255 255 + +-- We now define a type class that subsumes the various machine integer types, so +-- as to write a concise definition for scalar_cast, rather than exhaustively +-- enumerating all of the possible pairs. We remark that Rust has sane semantics +-- and fails if a cast operation would involve a truncation or modulo. + +class MachineInteger (t: Type) where + size: Nat + val: t -> Fin size + ofNatCore: (n:Nat) -> LT.lt n size -> t + +set_option hygiene false in +run_cmd + for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do + Lean.Elab.Command.elabCommand (← `( + namespace $typeName + instance: MachineInteger $typeName where + size := size + val := val + ofNatCore := ofNatCore + end $typeName + )) + +-- Aeneas only instantiates the destination type (`src` is implicit). We rely on +-- Lean to infer `src`. + +def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := + if h: MachineInteger.val x < MachineInteger.size dst then + .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) + else + .fail integerOverflow + +------------- +-- VECTORS -- +------------- + +-- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) +-- rather than maximum values (usize_max). +def Vec (α : Type u) := { l : List α // List.length l < USize.size } + +def vec_new (α : Type u): Vec α := ⟨ [], by { + match USize.size, usize_size_eq with + | _, Or.inl rfl => simp + | _, Or.inr rfl => simp + } ⟩ + +#check vec_new + +def vec_len (α : Type u) (v : Vec α) : USize := + let ⟨ v, l ⟩ := v + USize.ofNatCore (List.length v) l + +#eval vec_len Nat (vec_new Nat) + +def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () + +-- NOTE: old version trying to use a subtype notation, but probably better to +-- leave Result elimination to auxiliary lemmas with suitable preconditions +-- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one +-- make the proof work in that case? Probably need to import tactics from +-- mathlib to deal with inequalities... would love to see an example. +def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // + match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} + := + if h : List.length v.val + 1 < USize.size then + ⟨ return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩, by simp ⟩ + else + ⟨ fail maximumSizeExceeded, by simp ⟩ + +#eval do + -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with + -- fields val and property. However, Lean's elaborator can automatically + -- select the `val` field if the context provides a type annotation. We + -- annotate `x`, which relieves us of having to write `.val` on the right-hand + -- side of the monadic let. + let v := vec_new Nat + let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? + -- TODO: strengthen post-condition above and do a demo to show that we can + -- safely eliminate the `fail` case + return (vec_len Nat x) + +def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) + := + if h : List.length v.val + 1 <= 4294967295 then + return ⟨ List.concat v.val x, + by + rw [List.length_concat] + have h': 4294967295 < USize.size := by intlit + apply Nat.lt_of_le_of_lt h h' + ⟩ + else if h: List.length v.val + 1 < USize.size then + return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩ + else + fail maximumSizeExceeded + +def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +---------- +-- MISC -- +---------- + +def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := + x + +def mem_replace_back (a : Type) (_ : a) (y : a) : a := + y + +/-- Aeneas-translated function -- useful to reduce non-recursive definitions. + Use with `simp [ aeneas ]` -/ +register_simp_attr aeneas + +-------------------- +-- ASSERT COMMAND -- +-------------------- + +open Lean Elab Command Term Meta + +syntax (name := assert) "#assert" term: command + +@[command_elab assert] +unsafe +def assertImpl : CommandElab := fun (_stx: Syntax) => do + runTermElabM (fun _ => do + let r ← evalTerm Bool (mkConst ``Bool) _stx[1] + if not r then + logInfo "Assertion failed for: " + logInfo _stx[1] + logError "Expression reduced to false" + pure ()) + +#eval 2 == 2 +#assert (2 == 2) + +------------------- +-- SANITY CHECKS -- +------------------- + +-- TODO: add more once we have signed integers + +#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc-constants/Constants.lean b/tests/lean/misc-constants/Constants.lean new file mode 100644 index 00000000..57f6e403 --- /dev/null +++ b/tests/lean/misc-constants/Constants.lean @@ -0,0 +1,141 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [constants] +import Base.Primitives + +structure OpaqueDefs where + + /- [constants::X0] -/ + def x0_body : Result UInt32 := Result.ret (UInt32.ofNatCore 0 (by intlit)) + def x0_c : UInt32 := eval_global x0_body (by simp) + + /- [core::num::u32::{9}::MAX] -/ + def core_num_u32_max_body : Result UInt32 := + Result.ret (UInt32.ofNatCore 4294967295 (by intlit)) + def core_num_u32_max_c : UInt32 := + eval_global core_num_u32_max_body (by simp) + + /- [constants::X1] -/ + def x1_body : Result UInt32 := Result.ret core_num_u32_max_c + def x1_c : UInt32 := eval_global x1_body (by simp) + + /- [constants::X2] -/ + def x2_body : Result UInt32 := Result.ret (UInt32.ofNatCore 3 (by intlit)) + def x2_c : UInt32 := eval_global x2_body (by simp) + + /- [constants::incr] -/ + def incr_fwd (n : UInt32) : Result UInt32 := + UInt32.checked_add n (UInt32.ofNatCore 1 (by intlit)) + + /- [constants::X3] -/ + def x3_body : Result UInt32 := incr_fwd (UInt32.ofNatCore 32 (by intlit)) + def x3_c : UInt32 := eval_global x3_body (by simp) + + /- [constants::mk_pair0] -/ + def mk_pair0_fwd (x : UInt32) (y : UInt32) : Result (UInt32 × UInt32) := + Result.ret (x, y) + + /- [constants::Pair] -/ + structure pair_t (T1 T2 : Type) where pair_x : T1 pair_y : T2 + + /- [constants::mk_pair1] -/ + def mk_pair1_fwd (x : UInt32) (y : UInt32) : Result (pair_t UInt32 UInt32) := + Result.ret { pair_x := x, pair_y := y } + + /- [constants::P0] -/ + def p0_body : Result (UInt32 × UInt32) := + mk_pair0_fwd (UInt32.ofNatCore 0 (by intlit)) + (UInt32.ofNatCore 1 (by intlit)) + def p0_c : (UInt32 × UInt32) := eval_global p0_body (by simp) + + /- [constants::P1] -/ + def p1_body : Result (pair_t UInt32 UInt32) := + mk_pair1_fwd (UInt32.ofNatCore 0 (by intlit)) + (UInt32.ofNatCore 1 (by intlit)) + def p1_c : pair_t UInt32 UInt32 := eval_global p1_body (by simp) + + /- [constants::P2] -/ + def p2_body : Result (UInt32 × UInt32) := + Result.ret + ((UInt32.ofNatCore 0 (by intlit)), + (UInt32.ofNatCore 1 (by intlit))) + def p2_c : (UInt32 × UInt32) := eval_global p2_body (by simp) + + /- [constants::P3] -/ + def p3_body : Result (pair_t UInt32 UInt32) := + Result.ret + { + pair_x := (UInt32.ofNatCore 0 (by intlit)), + pair_y := (UInt32.ofNatCore 1 (by intlit)) + } + def p3_c : pair_t UInt32 UInt32 := eval_global p3_body (by simp) + + /- [constants::Wrap] -/ + structure wrap_t (T : Type) where wrap_val : T + + /- [constants::Wrap::{0}::new] -/ + def wrap_new_fwd (T : Type) (val : T) : Result (wrap_t T) := + Result.ret { wrap_val := val } + + /- [constants::Y] -/ + def y_body : Result (wrap_t Int32) := + wrap_new_fwd Int32 (Int32.ofNatCore 2 (by intlit)) + def y_c : wrap_t Int32 := eval_global y_body (by simp) + + /- [constants::unwrap_y] -/ + def unwrap_y_fwd : Result Int32 := + Result.ret y_c.wrap_val + + /- [constants::YVAL] -/ + def yval_body : Result Int32 := unwrap_y_fwd + def yval_c : Int32 := eval_global yval_body (by simp) + + /- [constants::get_z1::Z1] -/ + def get_z1_z1_body : Result Int32 := + Result.ret (Int32.ofNatCore 3 (by intlit)) + def get_z1_z1_c : Int32 := eval_global get_z1_z1_body (by simp) + + /- [constants::get_z1] -/ + def get_z1_fwd : Result Int32 := + Result.ret get_z1_z1_c + + /- [constants::add] -/ + def add_fwd (a : Int32) (b : Int32) : Result Int32 := + Int32.checked_add a b + + /- [constants::Q1] -/ + def q1_body : Result Int32 := Result.ret (Int32.ofNatCore 5 (by intlit)) + def q1_c : Int32 := eval_global q1_body (by simp) + + /- [constants::Q2] -/ + def q2_body : Result Int32 := Result.ret q1_c + def q2_c : Int32 := eval_global q2_body (by simp) + + /- [constants::Q3] -/ + def q3_body : Result Int32 := add_fwd q2_c (Int32.ofNatCore 3 (by intlit)) + def q3_c : Int32 := eval_global q3_body (by simp) + + /- [constants::get_z2] -/ + def get_z2_fwd : Result Int32 := + do + let i ← get_z1_fwd + let i0 ← add_fwd i q3_c + add_fwd q1_c i0 + + /- [constants::S1] -/ + def s1_body : Result UInt32 := Result.ret (UInt32.ofNatCore 6 (by intlit)) + def s1_c : UInt32 := eval_global s1_body (by simp) + + /- [constants::S2] -/ + def s2_body : Result UInt32 := incr_fwd s1_c + def s2_c : UInt32 := eval_global s2_body (by simp) + + /- [constants::S3] -/ + def s3_body : Result (pair_t UInt32 UInt32) := Result.ret p3_c + def s3_c : pair_t UInt32 UInt32 := eval_global s3_body (by simp) + + /- [constants::S4] -/ + def s4_body : Result (pair_t UInt32 UInt32) := + mk_pair1_fwd (UInt32.ofNatCore 7 (by intlit)) + (UInt32.ofNatCore 8 (by intlit)) + def s4_c : pair_t UInt32 UInt32 := eval_global s4_body (by simp) + diff --git a/tests/lean/misc-constants/lakefile.lean b/tests/lean/misc-constants/lakefile.lean new file mode 100644 index 00000000..ed8eebc2 --- /dev/null +++ b/tests/lean/misc-constants/lakefile.lean @@ -0,0 +1,18 @@ +import Lake +open Lake DSL + +require mathlib from git + "https://github.com/leanprover-community/mathlib4.git" + +package «constants» { + -- add package configuration options here +} + +lean_lib «Base» { + -- add library configuration options here +} + +lean_lib «Constants» { + -- add library configuration options here +} + diff --git a/tests/lean/misc-external/Base/Primitives.lean b/tests/lean/misc-external/Base/Primitives.lean new file mode 100644 index 00000000..5b64e908 --- /dev/null +++ b/tests/lean/misc-external/Base/Primitives.lean @@ -0,0 +1,392 @@ +import Lean +import Lean.Meta.Tactic.Simp +import Init.Data.List.Basic +import Mathlib.Tactic.RunCmd + +------------- +-- PRELUDE -- +------------- + +-- Results & monadic combinators + +inductive Error where + | assertionFailure: Error + | integerOverflow: Error + | arrayOutOfBounds: Error + | maximumSizeExceeded: Error + | panic: Error +deriving Repr, BEq + +open Error + +inductive Result (α : Type u) where + | ret (v: α): Result α + | fail (e: Error): Result α +deriving Repr, BEq + +open Result + +/- HELPERS -/ + +def ret? {α: Type} (r: Result α): Bool := + match r with + | Result.ret _ => true + | Result.fail _ => false + +def massert (b:Bool) : Result Unit := + if b then .ret () else fail assertionFailure + +def eval_global {α: Type} (x: Result α) (_: ret? x): α := + match x with + | Result.fail _ => by contradiction + | Result.ret x => x + +/- DO-DSL SUPPORT -/ + +def bind (x: Result α) (f: α -> Result β) : Result β := + match x with + | ret v => f v + | fail v => fail v + +-- Allows using Result in do-blocks +instance : Bind Result where + bind := bind + +-- Allows using return x in do-blocks +instance : Pure Result where + pure := fun x => ret x + +/- CUSTOM-DSL SUPPORT -/ + +-- Let-binding the Result of a monadic operation is oftentimes not sufficient, +-- because we may need a hypothesis for equational reasoning in the scope. We +-- rely on subtype, and a custom let-binding operator, in effect recreating our +-- own variant of the do-dsl + +def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := + match o with + | .ret x => .ret ⟨x, rfl⟩ + | .fail e => .fail e + +macro "let" e:term " ⟵ " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- TODO: any way to factorize both definitions? +macro "let" e:term " <-- " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- We call the hypothesis `h`, in effect making it unavailable to the user +-- (because too much shadowing). But in practice, once can use the French single +-- quote notation (input with f< and f>), where `‹ h ›` finds a suitable +-- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` +#eval do + let y <-- .ret (0: Nat) + let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide + let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ + .ret r + +---------------------- +-- MACHINE INTEGERS -- +---------------------- + +-- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., +-- USize. They are generally defined in an idiomatic style, except that there is +-- not a single type class to rule them all (more on that below). The absence of +-- type class is intentional, and allows the Lean compiler to efficiently map +-- them to machine integers during compilation. + +-- USize is designed properly: you cannot reduce `getNumBits` using the +-- simplifier, meaning that proofs do not depend on the compile-time value of +-- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really +-- support, at least officially, 16-bit microcontrollers, so this seems like a +-- fine design decision for now.) + +-- Note from Chris Bailey: "If there's more than one salient property of your +-- definition then the subtyping strategy might get messy, and the property part +-- of a subtype is less discoverable by the simplifier or tactics like +-- library_search." So, we will not add refinements on the return values of the +-- operations defined on Primitives, but will rather rely on custom lemmas to +-- invert on possible return values of the primitive operations. + +-- Machine integer constants, done via `ofNatCore`, which requires a proof that +-- the `Nat` fits within the desired integer type. We provide a custom tactic. + +syntax "intlit" : tactic + +macro_rules + | `(tactic| intlit) => `(tactic| + match USize.size, usize_size_eq with + | _, Or.inl rfl => decide + | _, Or.inr rfl => decide) + +-- This is how the macro is expected to be used +#eval USize.ofNatCore 0 (by intlit) + +-- Also works for other integer types (at the expense of a needless disjunction) +#eval UInt32.ofNatCore 0 (by intlit) + +-- The machine integer operations (e.g. sub) are always total, which is not what +-- we want. We therefore define "checked" variants, below. Note that we add a +-- tiny bit of complexity for the USize variant: we first check whether the +-- result is < 2^32; if it is, we can compute the definition, rather than +-- returning a term that is computationally stuck (the comparison to USize.size +-- cannot reduce at compile-time, per the remark about regarding `getNumBits`). +-- This is useful for the various #asserts that we want to reduce at +-- type-checking time. + +-- Further thoughts: look at what has been done here: +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean +-- and +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean +-- which both contain a fair amount of reasoning already! +def USize.checked_sub (n: USize) (m: USize): Result USize := + -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? + if n >= m then + let n' := USize.toNat n + let m' := USize.toNat n + let r := USize.ofNatCore (n' - m') (by + have h: n' - m' <= n' := by + apply Nat.sub_le_of_le_add + case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left + apply Nat.lt_of_le_of_lt h + apply n.val.isLt + ) + return r + else + fail integerOverflow + +@[simp] +theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := + match USize.size, usize_size_eq with + | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) + | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) + +def USize.checked_add (n: USize) (m: USize): Result USize := + if h: n.val + m.val < USize.size then + .ret ⟨ n.val + m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_rem (n: USize) (m: USize): Result USize := + if h: m > 0 then + .ret ⟨ n.val % m.val, by + have h1: ↑m.val < USize.size := m.val.isLt + have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h + apply Nat.lt_trans h2 h1 + ⟩ + else + .fail integerOverflow + +def USize.checked_mul (n: USize) (m: USize): Result USize := + if h: n.val * m.val < USize.size then + .ret ⟨ n.val * m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_div (n: USize) (m: USize): Result USize := + if m > 0 then + .ret ⟨ n.val / m.val, by + have h1: ↑n.val < USize.size := n.val.isLt + have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val + apply Nat.lt_of_le_of_lt h2 h1 + ⟩ + else + .fail integerOverflow + +-- Test behavior... +#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 + +#eval USize.checked_sub 20 10 +-- NOTE: compare with concrete behavior here, which I do not think we want +#eval USize.sub 0 1 +#eval UInt8.add 255 255 + +-- We now define a type class that subsumes the various machine integer types, so +-- as to write a concise definition for scalar_cast, rather than exhaustively +-- enumerating all of the possible pairs. We remark that Rust has sane semantics +-- and fails if a cast operation would involve a truncation or modulo. + +class MachineInteger (t: Type) where + size: Nat + val: t -> Fin size + ofNatCore: (n:Nat) -> LT.lt n size -> t + +set_option hygiene false in +run_cmd + for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do + Lean.Elab.Command.elabCommand (← `( + namespace $typeName + instance: MachineInteger $typeName where + size := size + val := val + ofNatCore := ofNatCore + end $typeName + )) + +-- Aeneas only instantiates the destination type (`src` is implicit). We rely on +-- Lean to infer `src`. + +def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := + if h: MachineInteger.val x < MachineInteger.size dst then + .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) + else + .fail integerOverflow + +------------- +-- VECTORS -- +------------- + +-- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) +-- rather than maximum values (usize_max). +def Vec (α : Type u) := { l : List α // List.length l < USize.size } + +def vec_new (α : Type u): Vec α := ⟨ [], by { + match USize.size, usize_size_eq with + | _, Or.inl rfl => simp + | _, Or.inr rfl => simp + } ⟩ + +#check vec_new + +def vec_len (α : Type u) (v : Vec α) : USize := + let ⟨ v, l ⟩ := v + USize.ofNatCore (List.length v) l + +#eval vec_len Nat (vec_new Nat) + +def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () + +-- NOTE: old version trying to use a subtype notation, but probably better to +-- leave Result elimination to auxiliary lemmas with suitable preconditions +-- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one +-- make the proof work in that case? Probably need to import tactics from +-- mathlib to deal with inequalities... would love to see an example. +def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // + match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} + := + if h : List.length v.val + 1 < USize.size then + ⟨ return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩, by simp ⟩ + else + ⟨ fail maximumSizeExceeded, by simp ⟩ + +#eval do + -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with + -- fields val and property. However, Lean's elaborator can automatically + -- select the `val` field if the context provides a type annotation. We + -- annotate `x`, which relieves us of having to write `.val` on the right-hand + -- side of the monadic let. + let v := vec_new Nat + let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? + -- TODO: strengthen post-condition above and do a demo to show that we can + -- safely eliminate the `fail` case + return (vec_len Nat x) + +def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) + := + if h : List.length v.val + 1 <= 4294967295 then + return ⟨ List.concat v.val x, + by + rw [List.length_concat] + have h': 4294967295 < USize.size := by intlit + apply Nat.lt_of_le_of_lt h h' + ⟩ + else if h: List.length v.val + 1 < USize.size then + return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩ + else + fail maximumSizeExceeded + +def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +---------- +-- MISC -- +---------- + +def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := + x + +def mem_replace_back (a : Type) (_ : a) (y : a) : a := + y + +/-- Aeneas-translated function -- useful to reduce non-recursive definitions. + Use with `simp [ aeneas ]` -/ +register_simp_attr aeneas + +-------------------- +-- ASSERT COMMAND -- +-------------------- + +open Lean Elab Command Term Meta + +syntax (name := assert) "#assert" term: command + +@[command_elab assert] +unsafe +def assertImpl : CommandElab := fun (_stx: Syntax) => do + runTermElabM (fun _ => do + let r ← evalTerm Bool (mkConst ``Bool) _stx[1] + if not r then + logInfo "Assertion failed for: " + logInfo _stx[1] + logError "Expression reduced to false" + pure ()) + +#eval 2 == 2 +#assert (2 == 2) + +------------------- +-- SANITY CHECKS -- +------------------- + +-- TODO: add more once we have signed integers + +#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc-external/External/Funs.lean b/tests/lean/misc-external/External/Funs.lean new file mode 100644 index 00000000..4e1f36a1 --- /dev/null +++ b/tests/lean/misc-external/External/Funs.lean @@ -0,0 +1,93 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [external]: function definitions +import Base.Primitives +import External.Types +import External.Opaque + +section variable (opaque_defs: OpaqueDefs) + +/- [external::swap] -/ +def swap_fwd + (T : Type) (x : T) (y : T) (st : State) : Result (State × Unit) := + do + let (st0, _) ← opaque_defs.core_mem_swap_fwd T x y st + let (st1, _) ← opaque_defs.core_mem_swap_back0 T x y st st0 + let (st2, _) ← opaque_defs.core_mem_swap_back1 T x y st st1 + Result.ret (st2, ()) + +/- [external::swap] -/ +def swap_back + (T : Type) (x : T) (y : T) (st : State) (st0 : State) : + Result (State × (T × T)) + := + do + let (st1, _) ← opaque_defs.core_mem_swap_fwd T x y st + let (st2, x0) ← opaque_defs.core_mem_swap_back0 T x y st st1 + let (_, y0) ← opaque_defs.core_mem_swap_back1 T x y st st2 + Result.ret (st0, (x0, y0)) + +/- [external::test_new_non_zero_u32] -/ +def test_new_non_zero_u32_fwd + (x : UInt32) (st : State) : + Result (State × core_num_nonzero_non_zero_u32_t) + := + do + let (st0, opt) ← opaque_defs.core_num_nonzero_non_zero_u32_new_fwd x st + opaque_defs.core_option_option_unwrap_fwd core_num_nonzero_non_zero_u32_t + opt st0 + +/- [external::test_vec] -/ +def test_vec_fwd : Result Unit := + do + let v := vec_new UInt32 + let _ ← vec_push_back UInt32 v (UInt32.ofNatCore 0 (by intlit)) + Result.ret () + +/- Unit test for [external::test_vec] -/ +#assert (test_vec_fwd == .ret ()) + +/- [external::custom_swap] -/ +def custom_swap_fwd + (T : Type) (x : T) (y : T) (st : State) : Result (State × T) := + do + let (st0, _) ← opaque_defs.core_mem_swap_fwd T x y st + let (st1, x0) ← opaque_defs.core_mem_swap_back0 T x y st st0 + let (st2, _) ← opaque_defs.core_mem_swap_back1 T x y st st1 + Result.ret (st2, x0) + +/- [external::custom_swap] -/ +def custom_swap_back + (T : Type) (x : T) (y : T) (st : State) (ret0 : T) (st0 : State) : + Result (State × (T × T)) + := + do + let (st1, _) ← opaque_defs.core_mem_swap_fwd T x y st + let (st2, _) ← opaque_defs.core_mem_swap_back0 T x y st st1 + let (_, y0) ← opaque_defs.core_mem_swap_back1 T x y st st2 + Result.ret (st0, (ret0, y0)) + +/- [external::test_custom_swap] -/ +def test_custom_swap_fwd + (x : UInt32) (y : UInt32) (st : State) : Result (State × Unit) := + do + let (st0, _) ← custom_swap_fwd UInt32 x y st + Result.ret (st0, ()) + +/- [external::test_custom_swap] -/ +def test_custom_swap_back + (x : UInt32) (y : UInt32) (st : State) (st0 : State) : + Result (State × (UInt32 × UInt32)) + := + custom_swap_back UInt32 x y st (UInt32.ofNatCore 1 (by intlit)) st0 + +/- [external::test_swap_non_zero] -/ +def test_swap_non_zero_fwd + (x : UInt32) (st : State) : Result (State × UInt32) := + do + let (st0, _) ← swap_fwd UInt32 x (UInt32.ofNatCore 0 (by intlit)) st + let (st1, (x0, _)) ← + swap_back UInt32 x (UInt32.ofNatCore 0 (by intlit)) st st0 + if h: x0 = (UInt32.ofNatCore 0 (by intlit)) + then Result.fail Error.panic + else Result.ret (st1, x0) + diff --git a/tests/lean/misc-external/External/Opaque.lean b/tests/lean/misc-external/External/Opaque.lean new file mode 100644 index 00000000..d3582de3 --- /dev/null +++ b/tests/lean/misc-external/External/Opaque.lean @@ -0,0 +1,28 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [external]: opaque function definitions +import Base.Primitives +import External.Types + +structure OpaqueDefs where + + /- [core::mem::swap] -/ + core_mem_swap_fwd (T : Type) : T -> T -> State -> Result (State × Unit) + + /- [core::mem::swap] -/ + core_mem_swap_back0 + (T : Type) : T -> T -> State -> State -> Result (State × T) + + /- [core::mem::swap] -/ + core_mem_swap_back1 + (T : Type) : T -> T -> State -> State -> Result (State × T) + + /- [core::num::nonzero::NonZeroU32::{14}::new] -/ + core_num_nonzero_non_zero_u32_new_fwd + : + UInt32 -> State -> Result (State × (Option + core_num_nonzero_non_zero_u32_t)) + + /- [core::option::Option::{0}::unwrap] -/ + core_option_option_unwrap_fwd + (T : Type) : Option T -> State -> Result (State × T) + diff --git a/tests/lean/misc-external/External/Types.lean b/tests/lean/misc-external/External/Types.lean new file mode 100644 index 00000000..386832f4 --- /dev/null +++ b/tests/lean/misc-external/External/Types.lean @@ -0,0 +1,8 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [external]: type definitions +import Base.Primitives + +/- [core::num::nonzero::NonZeroU32] -/ +axiom core_num_nonzero_non_zero_u32_t : Type +/- The state type used in the state-error monad -/ axiom State : Type + diff --git a/tests/lean/misc-external/lakefile.lean b/tests/lean/misc-external/lakefile.lean new file mode 100644 index 00000000..b883f4b9 --- /dev/null +++ b/tests/lean/misc-external/lakefile.lean @@ -0,0 +1,18 @@ +import Lake +open Lake DSL + +require mathlib from git + "https://github.com/leanprover-community/mathlib4.git" + +package «external» { + -- add package configuration options here +} + +lean_lib «Base» { + -- add library configuration options here +} + +lean_lib «External» { + -- add library configuration options here +} + diff --git a/tests/lean/misc-loops/Base/Primitives.lean b/tests/lean/misc-loops/Base/Primitives.lean new file mode 100644 index 00000000..5b64e908 --- /dev/null +++ b/tests/lean/misc-loops/Base/Primitives.lean @@ -0,0 +1,392 @@ +import Lean +import Lean.Meta.Tactic.Simp +import Init.Data.List.Basic +import Mathlib.Tactic.RunCmd + +------------- +-- PRELUDE -- +------------- + +-- Results & monadic combinators + +inductive Error where + | assertionFailure: Error + | integerOverflow: Error + | arrayOutOfBounds: Error + | maximumSizeExceeded: Error + | panic: Error +deriving Repr, BEq + +open Error + +inductive Result (α : Type u) where + | ret (v: α): Result α + | fail (e: Error): Result α +deriving Repr, BEq + +open Result + +/- HELPERS -/ + +def ret? {α: Type} (r: Result α): Bool := + match r with + | Result.ret _ => true + | Result.fail _ => false + +def massert (b:Bool) : Result Unit := + if b then .ret () else fail assertionFailure + +def eval_global {α: Type} (x: Result α) (_: ret? x): α := + match x with + | Result.fail _ => by contradiction + | Result.ret x => x + +/- DO-DSL SUPPORT -/ + +def bind (x: Result α) (f: α -> Result β) : Result β := + match x with + | ret v => f v + | fail v => fail v + +-- Allows using Result in do-blocks +instance : Bind Result where + bind := bind + +-- Allows using return x in do-blocks +instance : Pure Result where + pure := fun x => ret x + +/- CUSTOM-DSL SUPPORT -/ + +-- Let-binding the Result of a monadic operation is oftentimes not sufficient, +-- because we may need a hypothesis for equational reasoning in the scope. We +-- rely on subtype, and a custom let-binding operator, in effect recreating our +-- own variant of the do-dsl + +def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := + match o with + | .ret x => .ret ⟨x, rfl⟩ + | .fail e => .fail e + +macro "let" e:term " ⟵ " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- TODO: any way to factorize both definitions? +macro "let" e:term " <-- " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- We call the hypothesis `h`, in effect making it unavailable to the user +-- (because too much shadowing). But in practice, once can use the French single +-- quote notation (input with f< and f>), where `‹ h ›` finds a suitable +-- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` +#eval do + let y <-- .ret (0: Nat) + let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide + let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ + .ret r + +---------------------- +-- MACHINE INTEGERS -- +---------------------- + +-- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., +-- USize. They are generally defined in an idiomatic style, except that there is +-- not a single type class to rule them all (more on that below). The absence of +-- type class is intentional, and allows the Lean compiler to efficiently map +-- them to machine integers during compilation. + +-- USize is designed properly: you cannot reduce `getNumBits` using the +-- simplifier, meaning that proofs do not depend on the compile-time value of +-- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really +-- support, at least officially, 16-bit microcontrollers, so this seems like a +-- fine design decision for now.) + +-- Note from Chris Bailey: "If there's more than one salient property of your +-- definition then the subtyping strategy might get messy, and the property part +-- of a subtype is less discoverable by the simplifier or tactics like +-- library_search." So, we will not add refinements on the return values of the +-- operations defined on Primitives, but will rather rely on custom lemmas to +-- invert on possible return values of the primitive operations. + +-- Machine integer constants, done via `ofNatCore`, which requires a proof that +-- the `Nat` fits within the desired integer type. We provide a custom tactic. + +syntax "intlit" : tactic + +macro_rules + | `(tactic| intlit) => `(tactic| + match USize.size, usize_size_eq with + | _, Or.inl rfl => decide + | _, Or.inr rfl => decide) + +-- This is how the macro is expected to be used +#eval USize.ofNatCore 0 (by intlit) + +-- Also works for other integer types (at the expense of a needless disjunction) +#eval UInt32.ofNatCore 0 (by intlit) + +-- The machine integer operations (e.g. sub) are always total, which is not what +-- we want. We therefore define "checked" variants, below. Note that we add a +-- tiny bit of complexity for the USize variant: we first check whether the +-- result is < 2^32; if it is, we can compute the definition, rather than +-- returning a term that is computationally stuck (the comparison to USize.size +-- cannot reduce at compile-time, per the remark about regarding `getNumBits`). +-- This is useful for the various #asserts that we want to reduce at +-- type-checking time. + +-- Further thoughts: look at what has been done here: +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean +-- and +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean +-- which both contain a fair amount of reasoning already! +def USize.checked_sub (n: USize) (m: USize): Result USize := + -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? + if n >= m then + let n' := USize.toNat n + let m' := USize.toNat n + let r := USize.ofNatCore (n' - m') (by + have h: n' - m' <= n' := by + apply Nat.sub_le_of_le_add + case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left + apply Nat.lt_of_le_of_lt h + apply n.val.isLt + ) + return r + else + fail integerOverflow + +@[simp] +theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := + match USize.size, usize_size_eq with + | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) + | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) + +def USize.checked_add (n: USize) (m: USize): Result USize := + if h: n.val + m.val < USize.size then + .ret ⟨ n.val + m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_rem (n: USize) (m: USize): Result USize := + if h: m > 0 then + .ret ⟨ n.val % m.val, by + have h1: ↑m.val < USize.size := m.val.isLt + have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h + apply Nat.lt_trans h2 h1 + ⟩ + else + .fail integerOverflow + +def USize.checked_mul (n: USize) (m: USize): Result USize := + if h: n.val * m.val < USize.size then + .ret ⟨ n.val * m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_div (n: USize) (m: USize): Result USize := + if m > 0 then + .ret ⟨ n.val / m.val, by + have h1: ↑n.val < USize.size := n.val.isLt + have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val + apply Nat.lt_of_le_of_lt h2 h1 + ⟩ + else + .fail integerOverflow + +-- Test behavior... +#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 + +#eval USize.checked_sub 20 10 +-- NOTE: compare with concrete behavior here, which I do not think we want +#eval USize.sub 0 1 +#eval UInt8.add 255 255 + +-- We now define a type class that subsumes the various machine integer types, so +-- as to write a concise definition for scalar_cast, rather than exhaustively +-- enumerating all of the possible pairs. We remark that Rust has sane semantics +-- and fails if a cast operation would involve a truncation or modulo. + +class MachineInteger (t: Type) where + size: Nat + val: t -> Fin size + ofNatCore: (n:Nat) -> LT.lt n size -> t + +set_option hygiene false in +run_cmd + for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do + Lean.Elab.Command.elabCommand (← `( + namespace $typeName + instance: MachineInteger $typeName where + size := size + val := val + ofNatCore := ofNatCore + end $typeName + )) + +-- Aeneas only instantiates the destination type (`src` is implicit). We rely on +-- Lean to infer `src`. + +def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := + if h: MachineInteger.val x < MachineInteger.size dst then + .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) + else + .fail integerOverflow + +------------- +-- VECTORS -- +------------- + +-- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) +-- rather than maximum values (usize_max). +def Vec (α : Type u) := { l : List α // List.length l < USize.size } + +def vec_new (α : Type u): Vec α := ⟨ [], by { + match USize.size, usize_size_eq with + | _, Or.inl rfl => simp + | _, Or.inr rfl => simp + } ⟩ + +#check vec_new + +def vec_len (α : Type u) (v : Vec α) : USize := + let ⟨ v, l ⟩ := v + USize.ofNatCore (List.length v) l + +#eval vec_len Nat (vec_new Nat) + +def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () + +-- NOTE: old version trying to use a subtype notation, but probably better to +-- leave Result elimination to auxiliary lemmas with suitable preconditions +-- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one +-- make the proof work in that case? Probably need to import tactics from +-- mathlib to deal with inequalities... would love to see an example. +def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // + match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} + := + if h : List.length v.val + 1 < USize.size then + ⟨ return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩, by simp ⟩ + else + ⟨ fail maximumSizeExceeded, by simp ⟩ + +#eval do + -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with + -- fields val and property. However, Lean's elaborator can automatically + -- select the `val` field if the context provides a type annotation. We + -- annotate `x`, which relieves us of having to write `.val` on the right-hand + -- side of the monadic let. + let v := vec_new Nat + let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? + -- TODO: strengthen post-condition above and do a demo to show that we can + -- safely eliminate the `fail` case + return (vec_len Nat x) + +def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) + := + if h : List.length v.val + 1 <= 4294967295 then + return ⟨ List.concat v.val x, + by + rw [List.length_concat] + have h': 4294967295 < USize.size := by intlit + apply Nat.lt_of_le_of_lt h h' + ⟩ + else if h: List.length v.val + 1 < USize.size then + return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩ + else + fail maximumSizeExceeded + +def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +---------- +-- MISC -- +---------- + +def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := + x + +def mem_replace_back (a : Type) (_ : a) (y : a) : a := + y + +/-- Aeneas-translated function -- useful to reduce non-recursive definitions. + Use with `simp [ aeneas ]` -/ +register_simp_attr aeneas + +-------------------- +-- ASSERT COMMAND -- +-------------------- + +open Lean Elab Command Term Meta + +syntax (name := assert) "#assert" term: command + +@[command_elab assert] +unsafe +def assertImpl : CommandElab := fun (_stx: Syntax) => do + runTermElabM (fun _ => do + let r ← evalTerm Bool (mkConst ``Bool) _stx[1] + if not r then + logInfo "Assertion failed for: " + logInfo _stx[1] + logError "Expression reduced to false" + pure ()) + +#eval 2 == 2 +#assert (2 == 2) + +------------------- +-- SANITY CHECKS -- +------------------- + +-- TODO: add more once we have signed integers + +#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc-loops/Loops/Clauses/Clauses.lean b/tests/lean/misc-loops/Loops/Clauses/Clauses.lean new file mode 100644 index 00000000..5ddb65ca --- /dev/null +++ b/tests/lean/misc-loops/Loops/Clauses/Clauses.lean @@ -0,0 +1,209 @@ +-- [loops]: decreases clauses +import Base.Primitives +import Loops.Types + +/- [loops::sum]: termination measure -/ +@[simp] +def sum_loop_terminates (max : UInt32) (i : UInt32) (s : UInt32) := (max, i, s) + +syntax "sum_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| sum_loop_decreases $max $i $s) =>`(tactic| sorry) + +/- [loops::sum_with_mut_borrows]: termination measure -/ +@[simp] +def sum_with_mut_borrows_loop_terminates (max : UInt32) (mi : UInt32) + (ms : UInt32) := + (max, mi, ms) + +syntax "sum_with_mut_borrows_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| sum_with_mut_borrows_loop_decreases $max $mi $ms) =>`(tactic| sorry) + +/- [loops::sum_with_shared_borrows]: termination measure -/ +@[simp] +def sum_with_shared_borrows_loop_terminates (max : UInt32) (i : UInt32) + (s : UInt32) := + (max, i, s) + +syntax "sum_with_shared_borrows_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| sum_with_shared_borrows_loop_decreases $max $i $s) =>`(tactic| sorry) + +/- [loops::clear]: termination measure -/ +@[simp] def clear_loop_terminates (v : vec UInt32) (i : USize) := (v, i) + +syntax "clear_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| clear_loop_decreases $v $i) =>`(tactic| sorry) + +/- [loops::list_mem]: termination measure -/ +@[simp] +def list_mem_loop_terminates (x : UInt32) (ls : list_t UInt32) := (x, ls) + +syntax "list_mem_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_mem_loop_decreases $x $ls) =>`(tactic| sorry) + +/- [loops::list_nth_mut_loop]: termination measure -/ +@[simp] +def list_nth_mut_loop_loop_terminates (T : Type) (ls : list_t T) (i : UInt32) + := + (ls, i) + +syntax "list_nth_mut_loop_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_mut_loop_loop_decreases $ls $i) =>`(tactic| sorry) + +/- [loops::list_nth_shared_loop]: termination measure -/ +@[simp] +def list_nth_shared_loop_loop_terminates (T : Type) (ls : list_t T) + (i : UInt32) := + (ls, i) + +syntax "list_nth_shared_loop_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_shared_loop_loop_decreases $ls $i) =>`(tactic| sorry) + +/- [loops::get_elem_mut]: termination measure -/ +@[simp] +def get_elem_mut_loop_terminates (x : USize) (ls : list_t USize) := (x, ls) + +syntax "get_elem_mut_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| get_elem_mut_loop_decreases $x $ls) =>`(tactic| sorry) + +/- [loops::get_elem_shared]: termination measure -/ +@[simp] +def get_elem_shared_loop_terminates (x : USize) (ls : list_t USize) := (x, ls) + +syntax "get_elem_shared_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| get_elem_shared_loop_decreases $x $ls) =>`(tactic| sorry) + +/- [loops::list_nth_mut_loop_with_id]: termination measure -/ +@[simp] +def list_nth_mut_loop_with_id_loop_terminates (T : Type) (i : UInt32) + (ls : list_t T) := + (i, ls) + +syntax "list_nth_mut_loop_with_id_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_mut_loop_with_id_loop_decreases $i $ls) =>`(tactic| sorry) + +/- [loops::list_nth_shared_loop_with_id]: termination measure -/ +@[simp] +def list_nth_shared_loop_with_id_loop_terminates (T : Type) (i : UInt32) + (ls : list_t T) := + (i, ls) + +syntax "list_nth_shared_loop_with_id_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_shared_loop_with_id_loop_decreases $i $ls) =>`(tactic| sorry) + +/- [loops::list_nth_mut_loop_pair]: termination measure -/ +@[simp] +def list_nth_mut_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +syntax "list_nth_mut_loop_pair_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_mut_loop_pair_loop_decreases $ls0 $ls1 $i) =>`(tactic| sorry) + +/- [loops::list_nth_shared_loop_pair]: termination measure -/ +@[simp] +def list_nth_shared_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +syntax "list_nth_shared_loop_pair_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_shared_loop_pair_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_mut_loop_pair_merge]: termination measure -/ +@[simp] +def list_nth_mut_loop_pair_merge_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +syntax "list_nth_mut_loop_pair_merge_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_mut_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_shared_loop_pair_merge]: termination measure -/ +@[simp] +def list_nth_shared_loop_pair_merge_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +syntax "list_nth_shared_loop_pair_merge_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_shared_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_mut_shared_loop_pair]: termination measure -/ +@[simp] +def list_nth_mut_shared_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +syntax "list_nth_mut_shared_loop_pair_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_mut_shared_loop_pair_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_mut_shared_loop_pair_merge]: termination measure -/ +@[simp] +def list_nth_mut_shared_loop_pair_merge_loop_terminates (T : Type) + (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +syntax "list_nth_mut_shared_loop_pair_merge_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_mut_shared_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_shared_mut_loop_pair]: termination measure -/ +@[simp] +def list_nth_shared_mut_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +syntax "list_nth_shared_mut_loop_pair_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_shared_mut_loop_pair_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_shared_mut_loop_pair_merge]: termination measure -/ +@[simp] +def list_nth_shared_mut_loop_pair_merge_loop_terminates (T : Type) + (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +syntax "list_nth_shared_mut_loop_pair_merge_loop_decreases" term+ : tactic + +macro_rules +| `(tactic| list_nth_shared_mut_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + diff --git a/tests/lean/misc-loops/Loops/Clauses/Template.lean b/tests/lean/misc-loops/Loops/Clauses/Template.lean new file mode 100644 index 00000000..d1e72d65 --- /dev/null +++ b/tests/lean/misc-loops/Loops/Clauses/Template.lean @@ -0,0 +1,210 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [loops]: templates for the decreases clauses +import Base.Primitives +import Loops.Types + +/- [loops::sum]: termination measure -/ +@[simp] +def sum_loop_terminates (max : UInt32) (i : UInt32) (s : UInt32) := (max, i, s) + +/- [loops::sum]: decreases_by tactic -/ +syntax "sum_loop_decreases" term+ : tactic +macro_rules +| `(tactic| sum_loop_decreases $max $i $s) =>`(tactic| sorry) + +/- [loops::sum_with_mut_borrows]: termination measure -/ +@[simp] +def sum_with_mut_borrows_loop_terminates (max : UInt32) (mi : UInt32) + (ms : UInt32) := + (max, mi, ms) + +/- [loops::sum_with_mut_borrows]: decreases_by tactic -/ +syntax "sum_with_mut_borrows_loop_decreases" term+ : tactic +macro_rules +| `(tactic| sum_with_mut_borrows_loop_decreases $max $mi $ms) =>`(tactic| sorry) + +/- [loops::sum_with_shared_borrows]: termination measure -/ +@[simp] +def sum_with_shared_borrows_loop_terminates (max : UInt32) (i : UInt32) + (s : UInt32) := + (max, i, s) + +/- [loops::sum_with_shared_borrows]: decreases_by tactic -/ +syntax "sum_with_shared_borrows_loop_decreases" term+ : tactic +macro_rules +| `(tactic| sum_with_shared_borrows_loop_decreases $max $i $s) =>`(tactic| sorry) + +/- [loops::clear]: termination measure -/ +@[simp] def clear_loop_terminates (v : Vec UInt32) (i : USize) := (v, i) + +/- [loops::clear]: decreases_by tactic -/ +syntax "clear_loop_decreases" term+ : tactic +macro_rules +| `(tactic| clear_loop_decreases $v $i) =>`(tactic| sorry) + +/- [loops::list_mem]: termination measure -/ +@[simp] +def list_mem_loop_terminates (x : UInt32) (ls : list_t UInt32) := (x, ls) + +/- [loops::list_mem]: decreases_by tactic -/ +syntax "list_mem_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_mem_loop_decreases $x $ls) =>`(tactic| sorry) + +/- [loops::list_nth_mut_loop]: termination measure -/ +@[simp] +def list_nth_mut_loop_loop_terminates (T : Type) (ls : list_t T) (i : UInt32) + := + (ls, i) + +/- [loops::list_nth_mut_loop]: decreases_by tactic -/ +syntax "list_nth_mut_loop_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_mut_loop_loop_decreases $ls $i) =>`(tactic| sorry) + +/- [loops::list_nth_shared_loop]: termination measure -/ +@[simp] +def list_nth_shared_loop_loop_terminates (T : Type) (ls : list_t T) + (i : UInt32) := + (ls, i) + +/- [loops::list_nth_shared_loop]: decreases_by tactic -/ +syntax "list_nth_shared_loop_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_shared_loop_loop_decreases $ls $i) =>`(tactic| sorry) + +/- [loops::get_elem_mut]: termination measure -/ +@[simp] +def get_elem_mut_loop_terminates (x : USize) (ls : list_t USize) := (x, ls) + +/- [loops::get_elem_mut]: decreases_by tactic -/ +syntax "get_elem_mut_loop_decreases" term+ : tactic +macro_rules +| `(tactic| get_elem_mut_loop_decreases $x $ls) =>`(tactic| sorry) + +/- [loops::get_elem_shared]: termination measure -/ +@[simp] +def get_elem_shared_loop_terminates (x : USize) (ls : list_t USize) := (x, ls) + +/- [loops::get_elem_shared]: decreases_by tactic -/ +syntax "get_elem_shared_loop_decreases" term+ : tactic +macro_rules +| `(tactic| get_elem_shared_loop_decreases $x $ls) =>`(tactic| sorry) + +/- [loops::list_nth_mut_loop_with_id]: termination measure -/ +@[simp] +def list_nth_mut_loop_with_id_loop_terminates (T : Type) (i : UInt32) + (ls : list_t T) := + (i, ls) + +/- [loops::list_nth_mut_loop_with_id]: decreases_by tactic -/ +syntax "list_nth_mut_loop_with_id_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_mut_loop_with_id_loop_decreases $i $ls) =>`(tactic| sorry) + +/- [loops::list_nth_shared_loop_with_id]: termination measure -/ +@[simp] +def list_nth_shared_loop_with_id_loop_terminates (T : Type) (i : UInt32) + (ls : list_t T) := + (i, ls) + +/- [loops::list_nth_shared_loop_with_id]: decreases_by tactic -/ +syntax "list_nth_shared_loop_with_id_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_shared_loop_with_id_loop_decreases $i $ls) =>`(tactic| sorry) + +/- [loops::list_nth_mut_loop_pair]: termination measure -/ +@[simp] +def list_nth_mut_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +/- [loops::list_nth_mut_loop_pair]: decreases_by tactic -/ +syntax "list_nth_mut_loop_pair_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_mut_loop_pair_loop_decreases $ls0 $ls1 $i) =>`(tactic| sorry) + +/- [loops::list_nth_shared_loop_pair]: termination measure -/ +@[simp] +def list_nth_shared_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +/- [loops::list_nth_shared_loop_pair]: decreases_by tactic -/ +syntax "list_nth_shared_loop_pair_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_shared_loop_pair_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_mut_loop_pair_merge]: termination measure -/ +@[simp] +def list_nth_mut_loop_pair_merge_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +/- [loops::list_nth_mut_loop_pair_merge]: decreases_by tactic -/ +syntax "list_nth_mut_loop_pair_merge_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_mut_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_shared_loop_pair_merge]: termination measure -/ +@[simp] +def list_nth_shared_loop_pair_merge_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +/- [loops::list_nth_shared_loop_pair_merge]: decreases_by tactic -/ +syntax "list_nth_shared_loop_pair_merge_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_shared_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_mut_shared_loop_pair]: termination measure -/ +@[simp] +def list_nth_mut_shared_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +/- [loops::list_nth_mut_shared_loop_pair]: decreases_by tactic -/ +syntax "list_nth_mut_shared_loop_pair_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_mut_shared_loop_pair_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_mut_shared_loop_pair_merge]: termination measure -/ +@[simp] +def list_nth_mut_shared_loop_pair_merge_loop_terminates (T : Type) + (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +/- [loops::list_nth_mut_shared_loop_pair_merge]: decreases_by tactic -/ +syntax "list_nth_mut_shared_loop_pair_merge_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_mut_shared_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_shared_mut_loop_pair]: termination measure -/ +@[simp] +def list_nth_shared_mut_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) + (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +/- [loops::list_nth_shared_mut_loop_pair]: decreases_by tactic -/ +syntax "list_nth_shared_mut_loop_pair_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_shared_mut_loop_pair_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + +/- [loops::list_nth_shared_mut_loop_pair_merge]: termination measure -/ +@[simp] +def list_nth_shared_mut_loop_pair_merge_loop_terminates (T : Type) + (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) := + (ls0, ls1, i) + +/- [loops::list_nth_shared_mut_loop_pair_merge]: decreases_by tactic -/ +syntax "list_nth_shared_mut_loop_pair_merge_loop_decreases" term+ : tactic +macro_rules +| `(tactic| list_nth_shared_mut_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => + `(tactic| sorry) + diff --git a/tests/lean/misc-loops/Loops/Funs.lean b/tests/lean/misc-loops/Loops/Funs.lean new file mode 100644 index 00000000..5a81ebff --- /dev/null +++ b/tests/lean/misc-loops/Loops/Funs.lean @@ -0,0 +1,740 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [loops]: function definitions +import Base.Primitives +import Loops.Types +import Loops.Clauses.Clauses + +/- [loops::sum] -/ +def sum_loop_fwd (max : UInt32) (i : UInt32) (s : UInt32) : (Result UInt32) := + if h: i < max + then + do + let s0 ← UInt32.checked_add s i + let i0 ← UInt32.checked_add i (UInt32.ofNatCore 1 (by intlit)) + sum_loop_fwd max i0 s0 + else UInt32.checked_mul s (UInt32.ofNatCore 2 (by intlit)) +termination_by sum_loop_fwd max i s => sum_loop_terminates max i s +decreasing_by sum_loop_decreases max i s + +/- [loops::sum] -/ +def sum_fwd (max : UInt32) : Result UInt32 := + sum_loop_fwd max (UInt32.ofNatCore 0 (by intlit)) + (UInt32.ofNatCore 0 (by intlit)) + +/- [loops::sum_with_mut_borrows] -/ +def sum_with_mut_borrows_loop_fwd + (max : UInt32) (mi : UInt32) (ms : UInt32) : (Result UInt32) := + if h: mi < max + then + do + let ms0 ← UInt32.checked_add ms mi + let mi0 ← UInt32.checked_add mi (UInt32.ofNatCore 1 (by intlit)) + sum_with_mut_borrows_loop_fwd max mi0 ms0 + else UInt32.checked_mul ms (UInt32.ofNatCore 2 (by intlit)) +termination_by sum_with_mut_borrows_loop_fwd max mi ms => + sum_with_mut_borrows_loop_terminates max mi ms +decreasing_by sum_with_mut_borrows_loop_decreases max mi ms + +/- [loops::sum_with_mut_borrows] -/ +def sum_with_mut_borrows_fwd (max : UInt32) : Result UInt32 := + sum_with_mut_borrows_loop_fwd max (UInt32.ofNatCore 0 (by intlit)) + (UInt32.ofNatCore 0 (by intlit)) + +/- [loops::sum_with_shared_borrows] -/ +def sum_with_shared_borrows_loop_fwd + (max : UInt32) (i : UInt32) (s : UInt32) : (Result UInt32) := + if h: i < max + then + do + let i0 ← UInt32.checked_add i (UInt32.ofNatCore 1 (by intlit)) + let s0 ← UInt32.checked_add s i0 + sum_with_shared_borrows_loop_fwd max i0 s0 + else UInt32.checked_mul s (UInt32.ofNatCore 2 (by intlit)) +termination_by sum_with_shared_borrows_loop_fwd max i s => + sum_with_shared_borrows_loop_terminates max i s +decreasing_by sum_with_shared_borrows_loop_decreases max i s + +/- [loops::sum_with_shared_borrows] -/ +def sum_with_shared_borrows_fwd (max : UInt32) : Result UInt32 := + sum_with_shared_borrows_loop_fwd max (UInt32.ofNatCore 0 (by intlit)) + (UInt32.ofNatCore 0 (by intlit)) + +/- [loops::clear] -/ +def clear_loop_fwd_back (v : Vec UInt32) (i : USize) : (Result (Vec UInt32)) := + let i0 := vec_len UInt32 v + if h: i < i0 + then + do + let i1 ← USize.checked_add i (USize.ofNatCore 1 (by intlit)) + let v0 ← vec_index_mut_back UInt32 v i (UInt32.ofNatCore 0 (by intlit)) + clear_loop_fwd_back v0 i1 + else Result.ret v +termination_by clear_loop_fwd_back v i => clear_loop_terminates v i +decreasing_by clear_loop_decreases v i + +/- [loops::clear] -/ +def clear_fwd_back (v : Vec UInt32) : Result (Vec UInt32) := + clear_loop_fwd_back v (USize.ofNatCore 0 (by intlit)) + +/- [loops::list_mem] -/ +def list_mem_loop_fwd (x : UInt32) (ls : list_t UInt32) : (Result Bool) := + match h: ls with + | list_t.ListCons y tl => + if h: y = x + then Result.ret true + else list_mem_loop_fwd x tl + | list_t.ListNil => Result.ret false +termination_by list_mem_loop_fwd x ls => list_mem_loop_terminates x ls +decreasing_by list_mem_loop_decreases x ls + +/- [loops::list_mem] -/ +def list_mem_fwd (x : UInt32) (ls : list_t UInt32) : Result Bool := + list_mem_loop_fwd x ls + +/- [loops::list_nth_mut_loop] -/ +def list_nth_mut_loop_loop_fwd + (T : Type) (ls : list_t T) (i : UInt32) : (Result T) := + match h: ls with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret x + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_mut_loop_loop_fwd T tl i0 + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_loop_fwd ls i => + list_nth_mut_loop_loop_terminates T ls i +decreasing_by list_nth_mut_loop_loop_decreases ls i + +/- [loops::list_nth_mut_loop] -/ +def list_nth_mut_loop_fwd (T : Type) (ls : list_t T) (i : UInt32) : Result T := + list_nth_mut_loop_loop_fwd T ls i + +/- [loops::list_nth_mut_loop] -/ +def list_nth_mut_loop_loop_back + (T : Type) (ls : list_t T) (i : UInt32) (ret0 : T) : (Result (list_t T)) := + match h: ls with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl0 ← list_nth_mut_loop_loop_back T tl i0 ret0 + Result.ret (list_t.ListCons x tl0) + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_loop_back ls i ret0 => + list_nth_mut_loop_loop_terminates T ls i +decreasing_by list_nth_mut_loop_loop_decreases ls i + +/- [loops::list_nth_mut_loop] -/ +def list_nth_mut_loop_back + (T : Type) (ls : list_t T) (i : UInt32) (ret0 : T) : Result (list_t T) := + list_nth_mut_loop_loop_back T ls i ret0 + +/- [loops::list_nth_shared_loop] -/ +def list_nth_shared_loop_loop_fwd + (T : Type) (ls : list_t T) (i : UInt32) : (Result T) := + match h: ls with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret x + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_shared_loop_loop_fwd T tl i0 + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_shared_loop_loop_fwd ls i => + list_nth_shared_loop_loop_terminates T ls i +decreasing_by list_nth_shared_loop_loop_decreases ls i + +/- [loops::list_nth_shared_loop] -/ +def list_nth_shared_loop_fwd + (T : Type) (ls : list_t T) (i : UInt32) : Result T := + list_nth_shared_loop_loop_fwd T ls i + +/- [loops::get_elem_mut] -/ +def get_elem_mut_loop_fwd (x : USize) (ls : list_t USize) : (Result USize) := + match h: ls with + | list_t.ListCons y tl => + if h: y = x + then Result.ret y + else get_elem_mut_loop_fwd x tl + | list_t.ListNil => Result.fail Error.panic +termination_by get_elem_mut_loop_fwd x ls => get_elem_mut_loop_terminates x ls +decreasing_by get_elem_mut_loop_decreases x ls + +/- [loops::get_elem_mut] -/ +def get_elem_mut_fwd (slots : Vec (list_t USize)) (x : USize) : Result USize := + do + let l ← + vec_index_mut_fwd (list_t USize) slots (USize.ofNatCore 0 (by intlit)) + get_elem_mut_loop_fwd x l + +/- [loops::get_elem_mut] -/ +def get_elem_mut_loop_back + (x : USize) (ls : list_t USize) (ret0 : USize) : (Result (list_t USize)) := + match h: ls with + | list_t.ListCons y tl => + if h: y = x + then Result.ret (list_t.ListCons ret0 tl) + else + do + let tl0 ← get_elem_mut_loop_back x tl ret0 + Result.ret (list_t.ListCons y tl0) + | list_t.ListNil => Result.fail Error.panic +termination_by get_elem_mut_loop_back x ls ret0 => + get_elem_mut_loop_terminates x ls +decreasing_by get_elem_mut_loop_decreases x ls + +/- [loops::get_elem_mut] -/ +def get_elem_mut_back + (slots : Vec (list_t USize)) (x : USize) (ret0 : USize) : + Result (Vec (list_t USize)) + := + do + let l ← + vec_index_mut_fwd (list_t USize) slots (USize.ofNatCore 0 (by intlit)) + let l0 ← get_elem_mut_loop_back x l ret0 + vec_index_mut_back (list_t USize) slots (USize.ofNatCore 0 (by intlit)) l0 + +/- [loops::get_elem_shared] -/ +def get_elem_shared_loop_fwd + (x : USize) (ls : list_t USize) : (Result USize) := + match h: ls with + | list_t.ListCons y tl => + if h: y = x + then Result.ret y + else get_elem_shared_loop_fwd x tl + | list_t.ListNil => Result.fail Error.panic +termination_by get_elem_shared_loop_fwd x ls => + get_elem_shared_loop_terminates x ls +decreasing_by get_elem_shared_loop_decreases x ls + +/- [loops::get_elem_shared] -/ +def get_elem_shared_fwd + (slots : Vec (list_t USize)) (x : USize) : Result USize := + do + let l ← + vec_index_fwd (list_t USize) slots (USize.ofNatCore 0 (by intlit)) + get_elem_shared_loop_fwd x l + +/- [loops::id_mut] -/ +def id_mut_fwd (T : Type) (ls : list_t T) : Result (list_t T) := + Result.ret ls + +/- [loops::id_mut] -/ +def id_mut_back + (T : Type) (ls : list_t T) (ret0 : list_t T) : Result (list_t T) := + Result.ret ret0 + +/- [loops::id_shared] -/ +def id_shared_fwd (T : Type) (ls : list_t T) : Result (list_t T) := + Result.ret ls + +/- [loops::list_nth_mut_loop_with_id] -/ +def list_nth_mut_loop_with_id_loop_fwd + (T : Type) (i : UInt32) (ls : list_t T) : (Result T) := + match h: ls with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret x + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_mut_loop_with_id_loop_fwd T i0 tl + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_with_id_loop_fwd i ls => + list_nth_mut_loop_with_id_loop_terminates T i ls +decreasing_by list_nth_mut_loop_with_id_loop_decreases i ls + +/- [loops::list_nth_mut_loop_with_id] -/ +def list_nth_mut_loop_with_id_fwd + (T : Type) (ls : list_t T) (i : UInt32) : Result T := + do + let ls0 ← id_mut_fwd T ls + list_nth_mut_loop_with_id_loop_fwd T i ls0 + +/- [loops::list_nth_mut_loop_with_id] -/ +def list_nth_mut_loop_with_id_loop_back + (T : Type) (i : UInt32) (ls : list_t T) (ret0 : T) : (Result (list_t T)) := + match h: ls with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl0 ← list_nth_mut_loop_with_id_loop_back T i0 tl ret0 + Result.ret (list_t.ListCons x tl0) + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_with_id_loop_back i ls ret0 => + list_nth_mut_loop_with_id_loop_terminates T i ls +decreasing_by list_nth_mut_loop_with_id_loop_decreases i ls + +/- [loops::list_nth_mut_loop_with_id] -/ +def list_nth_mut_loop_with_id_back + (T : Type) (ls : list_t T) (i : UInt32) (ret0 : T) : Result (list_t T) := + do + let ls0 ← id_mut_fwd T ls + let l ← list_nth_mut_loop_with_id_loop_back T i ls0 ret0 + id_mut_back T ls l + +/- [loops::list_nth_shared_loop_with_id] -/ +def list_nth_shared_loop_with_id_loop_fwd + (T : Type) (i : UInt32) (ls : list_t T) : (Result T) := + match h: ls with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret x + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_shared_loop_with_id_loop_fwd T i0 tl + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_shared_loop_with_id_loop_fwd i ls => + list_nth_shared_loop_with_id_loop_terminates T i ls +decreasing_by list_nth_shared_loop_with_id_loop_decreases i ls + +/- [loops::list_nth_shared_loop_with_id] -/ +def list_nth_shared_loop_with_id_fwd + (T : Type) (ls : list_t T) (i : UInt32) : Result T := + do + let ls0 ← id_shared_fwd T ls + list_nth_shared_loop_with_id_loop_fwd T i ls0 + +/- [loops::list_nth_mut_loop_pair] -/ +def list_nth_mut_loop_pair_loop_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + (Result (T × T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (x0, x1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_mut_loop_pair_loop_fwd T tl0 tl1 i0 + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_pair_loop_fwd ls0 ls1 i => + list_nth_mut_loop_pair_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_loop_pair_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_loop_pair] -/ +def list_nth_mut_loop_pair_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + Result (T × T) + := + list_nth_mut_loop_pair_loop_fwd T ls0 ls1 i + +/- [loops::list_nth_mut_loop_pair] -/ +def list_nth_mut_loop_pair_loop_back'a + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + (Result (list_t T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl0) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl00 ← list_nth_mut_loop_pair_loop_back'a T tl0 tl1 i0 ret0 + Result.ret (list_t.ListCons x0 tl00) + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_pair_loop_back'a ls0 ls1 i ret0 => + list_nth_mut_loop_pair_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_loop_pair_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_loop_pair] -/ +def list_nth_mut_loop_pair_back'a + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + Result (list_t T) + := + list_nth_mut_loop_pair_loop_back'a T ls0 ls1 i ret0 + +/- [loops::list_nth_mut_loop_pair] -/ +def list_nth_mut_loop_pair_loop_back'b + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + (Result (list_t T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl10 ← list_nth_mut_loop_pair_loop_back'b T tl0 tl1 i0 ret0 + Result.ret (list_t.ListCons x1 tl10) + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_pair_loop_back'b ls0 ls1 i ret0 => + list_nth_mut_loop_pair_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_loop_pair_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_loop_pair] -/ +def list_nth_mut_loop_pair_back'b + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + Result (list_t T) + := + list_nth_mut_loop_pair_loop_back'b T ls0 ls1 i ret0 + +/- [loops::list_nth_shared_loop_pair] -/ +def list_nth_shared_loop_pair_loop_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + (Result (T × T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (x0, x1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_shared_loop_pair_loop_fwd T tl0 tl1 i0 + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_shared_loop_pair_loop_fwd ls0 ls1 i => + list_nth_shared_loop_pair_loop_terminates T ls0 ls1 i +decreasing_by list_nth_shared_loop_pair_loop_decreases ls0 ls1 i + +/- [loops::list_nth_shared_loop_pair] -/ +def list_nth_shared_loop_pair_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + Result (T × T) + := + list_nth_shared_loop_pair_loop_fwd T ls0 ls1 i + +/- [loops::list_nth_mut_loop_pair_merge] -/ +def list_nth_mut_loop_pair_merge_loop_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + (Result (T × T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (x0, x1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_mut_loop_pair_merge_loop_fwd T tl0 tl1 i0 + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_pair_merge_loop_fwd ls0 ls1 i => + list_nth_mut_loop_pair_merge_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_loop_pair_merge_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_loop_pair_merge] -/ +def list_nth_mut_loop_pair_merge_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + Result (T × T) + := + list_nth_mut_loop_pair_merge_loop_fwd T ls0 ls1 i + +/- [loops::list_nth_mut_loop_pair_merge] -/ +def list_nth_mut_loop_pair_merge_loop_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : (T × T)) : + (Result ((list_t T) × (list_t T))) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then + let (t, t0) := ret0 + Result.ret (list_t.ListCons t tl0, list_t.ListCons t0 tl1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let (tl00, tl10) ← + list_nth_mut_loop_pair_merge_loop_back T tl0 tl1 i0 ret0 + Result.ret (list_t.ListCons x0 tl00, list_t.ListCons x1 tl10) + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_loop_pair_merge_loop_back ls0 ls1 i ret0 => + list_nth_mut_loop_pair_merge_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_loop_pair_merge_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_loop_pair_merge] -/ +def list_nth_mut_loop_pair_merge_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : (T × T)) : + Result ((list_t T) × (list_t T)) + := + list_nth_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0 + +/- [loops::list_nth_shared_loop_pair_merge] -/ +def list_nth_shared_loop_pair_merge_loop_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + (Result (T × T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (x0, x1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_shared_loop_pair_merge_loop_fwd T tl0 tl1 i0 + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_shared_loop_pair_merge_loop_fwd ls0 ls1 i => + list_nth_shared_loop_pair_merge_loop_terminates T ls0 ls1 i +decreasing_by list_nth_shared_loop_pair_merge_loop_decreases ls0 ls1 i + +/- [loops::list_nth_shared_loop_pair_merge] -/ +def list_nth_shared_loop_pair_merge_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + Result (T × T) + := + list_nth_shared_loop_pair_merge_loop_fwd T ls0 ls1 i + +/- [loops::list_nth_mut_shared_loop_pair] -/ +def list_nth_mut_shared_loop_pair_loop_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + (Result (T × T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (x0, x1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_mut_shared_loop_pair_loop_fwd T tl0 tl1 i0 + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_shared_loop_pair_loop_fwd ls0 ls1 i => + list_nth_mut_shared_loop_pair_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_shared_loop_pair_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_shared_loop_pair] -/ +def list_nth_mut_shared_loop_pair_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + Result (T × T) + := + list_nth_mut_shared_loop_pair_loop_fwd T ls0 ls1 i + +/- [loops::list_nth_mut_shared_loop_pair] -/ +def list_nth_mut_shared_loop_pair_loop_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + (Result (list_t T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl0) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl00 ← + list_nth_mut_shared_loop_pair_loop_back T tl0 tl1 i0 ret0 + Result.ret (list_t.ListCons x0 tl00) + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_shared_loop_pair_loop_back ls0 ls1 i ret0 => + list_nth_mut_shared_loop_pair_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_shared_loop_pair_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_shared_loop_pair] -/ +def list_nth_mut_shared_loop_pair_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + Result (list_t T) + := + list_nth_mut_shared_loop_pair_loop_back T ls0 ls1 i ret0 + +/- [loops::list_nth_mut_shared_loop_pair_merge] -/ +def list_nth_mut_shared_loop_pair_merge_loop_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + (Result (T × T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (x0, x1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_mut_shared_loop_pair_merge_loop_fwd T tl0 tl1 i0 + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_shared_loop_pair_merge_loop_fwd ls0 ls1 i => + list_nth_mut_shared_loop_pair_merge_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_shared_loop_pair_merge_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_shared_loop_pair_merge] -/ +def list_nth_mut_shared_loop_pair_merge_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + Result (T × T) + := + list_nth_mut_shared_loop_pair_merge_loop_fwd T ls0 ls1 i + +/- [loops::list_nth_mut_shared_loop_pair_merge] -/ +def list_nth_mut_shared_loop_pair_merge_loop_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + (Result (list_t T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl0) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl00 ← + list_nth_mut_shared_loop_pair_merge_loop_back T tl0 tl1 i0 ret0 + Result.ret (list_t.ListCons x0 tl00) + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_mut_shared_loop_pair_merge_loop_back ls0 ls1 i ret0 => + list_nth_mut_shared_loop_pair_merge_loop_terminates T ls0 ls1 i +decreasing_by list_nth_mut_shared_loop_pair_merge_loop_decreases ls0 ls1 i + +/- [loops::list_nth_mut_shared_loop_pair_merge] -/ +def list_nth_mut_shared_loop_pair_merge_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + Result (list_t T) + := + list_nth_mut_shared_loop_pair_merge_loop_back T ls0 ls1 i ret0 + +/- [loops::list_nth_shared_mut_loop_pair] -/ +def list_nth_shared_mut_loop_pair_loop_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + (Result (T × T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (x0, x1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_shared_mut_loop_pair_loop_fwd T tl0 tl1 i0 + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_shared_mut_loop_pair_loop_fwd ls0 ls1 i => + list_nth_shared_mut_loop_pair_loop_terminates T ls0 ls1 i +decreasing_by list_nth_shared_mut_loop_pair_loop_decreases ls0 ls1 i + +/- [loops::list_nth_shared_mut_loop_pair] -/ +def list_nth_shared_mut_loop_pair_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + Result (T × T) + := + list_nth_shared_mut_loop_pair_loop_fwd T ls0 ls1 i + +/- [loops::list_nth_shared_mut_loop_pair] -/ +def list_nth_shared_mut_loop_pair_loop_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + (Result (list_t T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl10 ← + list_nth_shared_mut_loop_pair_loop_back T tl0 tl1 i0 ret0 + Result.ret (list_t.ListCons x1 tl10) + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_shared_mut_loop_pair_loop_back ls0 ls1 i ret0 => + list_nth_shared_mut_loop_pair_loop_terminates T ls0 ls1 i +decreasing_by list_nth_shared_mut_loop_pair_loop_decreases ls0 ls1 i + +/- [loops::list_nth_shared_mut_loop_pair] -/ +def list_nth_shared_mut_loop_pair_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + Result (list_t T) + := + list_nth_shared_mut_loop_pair_loop_back T ls0 ls1 i ret0 + +/- [loops::list_nth_shared_mut_loop_pair_merge] -/ +def list_nth_shared_mut_loop_pair_merge_loop_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + (Result (T × T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (x0, x1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_shared_mut_loop_pair_merge_loop_fwd T tl0 tl1 i0 + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_shared_mut_loop_pair_merge_loop_fwd ls0 ls1 i => + list_nth_shared_mut_loop_pair_merge_loop_terminates T ls0 ls1 i +decreasing_by list_nth_shared_mut_loop_pair_merge_loop_decreases ls0 ls1 i + +/- [loops::list_nth_shared_mut_loop_pair_merge] -/ +def list_nth_shared_mut_loop_pair_merge_fwd + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : + Result (T × T) + := + list_nth_shared_mut_loop_pair_merge_loop_fwd T ls0 ls1 i + +/- [loops::list_nth_shared_mut_loop_pair_merge] -/ +def list_nth_shared_mut_loop_pair_merge_loop_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + (Result (list_t T)) + := + match h: ls0 with + | list_t.ListCons x0 tl0 => + match h: ls1 with + | list_t.ListCons x1 tl1 => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl1) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl10 ← + list_nth_shared_mut_loop_pair_merge_loop_back T tl0 tl1 i0 ret0 + Result.ret (list_t.ListCons x1 tl10) + | list_t.ListNil => Result.fail Error.panic + | list_t.ListNil => Result.fail Error.panic +termination_by list_nth_shared_mut_loop_pair_merge_loop_back ls0 ls1 i ret0 => + list_nth_shared_mut_loop_pair_merge_loop_terminates T ls0 ls1 i +decreasing_by list_nth_shared_mut_loop_pair_merge_loop_decreases ls0 ls1 i + +/- [loops::list_nth_shared_mut_loop_pair_merge] -/ +def list_nth_shared_mut_loop_pair_merge_back + (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : + Result (list_t T) + := + list_nth_shared_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0 + diff --git a/tests/lean/misc-loops/Loops/Types.lean b/tests/lean/misc-loops/Loops/Types.lean new file mode 100644 index 00000000..f4b6809e --- /dev/null +++ b/tests/lean/misc-loops/Loops/Types.lean @@ -0,0 +1,9 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [loops]: type definitions +import Base.Primitives + +/- [loops::List] -/ +inductive list_t (T : Type) := +| ListCons : T -> list_t T -> list_t T +| ListNil : list_t T + diff --git a/tests/lean/misc-loops/lakefile.lean b/tests/lean/misc-loops/lakefile.lean new file mode 100644 index 00000000..0d20ba1f --- /dev/null +++ b/tests/lean/misc-loops/lakefile.lean @@ -0,0 +1,18 @@ +import Lake +open Lake DSL + +require mathlib from git + "https://github.com/leanprover-community/mathlib4.git" + +package «loops» { + -- add package configuration options here +} + +lean_lib «Base» { + -- add library configuration options here +} + +lean_lib «Loops» { + -- add library configuration options here +} + diff --git a/tests/lean/misc-no_nested_borrows/Base/Primitives.lean b/tests/lean/misc-no_nested_borrows/Base/Primitives.lean new file mode 100644 index 00000000..5b64e908 --- /dev/null +++ b/tests/lean/misc-no_nested_borrows/Base/Primitives.lean @@ -0,0 +1,392 @@ +import Lean +import Lean.Meta.Tactic.Simp +import Init.Data.List.Basic +import Mathlib.Tactic.RunCmd + +------------- +-- PRELUDE -- +------------- + +-- Results & monadic combinators + +inductive Error where + | assertionFailure: Error + | integerOverflow: Error + | arrayOutOfBounds: Error + | maximumSizeExceeded: Error + | panic: Error +deriving Repr, BEq + +open Error + +inductive Result (α : Type u) where + | ret (v: α): Result α + | fail (e: Error): Result α +deriving Repr, BEq + +open Result + +/- HELPERS -/ + +def ret? {α: Type} (r: Result α): Bool := + match r with + | Result.ret _ => true + | Result.fail _ => false + +def massert (b:Bool) : Result Unit := + if b then .ret () else fail assertionFailure + +def eval_global {α: Type} (x: Result α) (_: ret? x): α := + match x with + | Result.fail _ => by contradiction + | Result.ret x => x + +/- DO-DSL SUPPORT -/ + +def bind (x: Result α) (f: α -> Result β) : Result β := + match x with + | ret v => f v + | fail v => fail v + +-- Allows using Result in do-blocks +instance : Bind Result where + bind := bind + +-- Allows using return x in do-blocks +instance : Pure Result where + pure := fun x => ret x + +/- CUSTOM-DSL SUPPORT -/ + +-- Let-binding the Result of a monadic operation is oftentimes not sufficient, +-- because we may need a hypothesis for equational reasoning in the scope. We +-- rely on subtype, and a custom let-binding operator, in effect recreating our +-- own variant of the do-dsl + +def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := + match o with + | .ret x => .ret ⟨x, rfl⟩ + | .fail e => .fail e + +macro "let" e:term " ⟵ " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- TODO: any way to factorize both definitions? +macro "let" e:term " <-- " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- We call the hypothesis `h`, in effect making it unavailable to the user +-- (because too much shadowing). But in practice, once can use the French single +-- quote notation (input with f< and f>), where `‹ h ›` finds a suitable +-- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` +#eval do + let y <-- .ret (0: Nat) + let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide + let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ + .ret r + +---------------------- +-- MACHINE INTEGERS -- +---------------------- + +-- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., +-- USize. They are generally defined in an idiomatic style, except that there is +-- not a single type class to rule them all (more on that below). The absence of +-- type class is intentional, and allows the Lean compiler to efficiently map +-- them to machine integers during compilation. + +-- USize is designed properly: you cannot reduce `getNumBits` using the +-- simplifier, meaning that proofs do not depend on the compile-time value of +-- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really +-- support, at least officially, 16-bit microcontrollers, so this seems like a +-- fine design decision for now.) + +-- Note from Chris Bailey: "If there's more than one salient property of your +-- definition then the subtyping strategy might get messy, and the property part +-- of a subtype is less discoverable by the simplifier or tactics like +-- library_search." So, we will not add refinements on the return values of the +-- operations defined on Primitives, but will rather rely on custom lemmas to +-- invert on possible return values of the primitive operations. + +-- Machine integer constants, done via `ofNatCore`, which requires a proof that +-- the `Nat` fits within the desired integer type. We provide a custom tactic. + +syntax "intlit" : tactic + +macro_rules + | `(tactic| intlit) => `(tactic| + match USize.size, usize_size_eq with + | _, Or.inl rfl => decide + | _, Or.inr rfl => decide) + +-- This is how the macro is expected to be used +#eval USize.ofNatCore 0 (by intlit) + +-- Also works for other integer types (at the expense of a needless disjunction) +#eval UInt32.ofNatCore 0 (by intlit) + +-- The machine integer operations (e.g. sub) are always total, which is not what +-- we want. We therefore define "checked" variants, below. Note that we add a +-- tiny bit of complexity for the USize variant: we first check whether the +-- result is < 2^32; if it is, we can compute the definition, rather than +-- returning a term that is computationally stuck (the comparison to USize.size +-- cannot reduce at compile-time, per the remark about regarding `getNumBits`). +-- This is useful for the various #asserts that we want to reduce at +-- type-checking time. + +-- Further thoughts: look at what has been done here: +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean +-- and +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean +-- which both contain a fair amount of reasoning already! +def USize.checked_sub (n: USize) (m: USize): Result USize := + -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? + if n >= m then + let n' := USize.toNat n + let m' := USize.toNat n + let r := USize.ofNatCore (n' - m') (by + have h: n' - m' <= n' := by + apply Nat.sub_le_of_le_add + case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left + apply Nat.lt_of_le_of_lt h + apply n.val.isLt + ) + return r + else + fail integerOverflow + +@[simp] +theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := + match USize.size, usize_size_eq with + | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) + | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) + +def USize.checked_add (n: USize) (m: USize): Result USize := + if h: n.val + m.val < USize.size then + .ret ⟨ n.val + m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_rem (n: USize) (m: USize): Result USize := + if h: m > 0 then + .ret ⟨ n.val % m.val, by + have h1: ↑m.val < USize.size := m.val.isLt + have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h + apply Nat.lt_trans h2 h1 + ⟩ + else + .fail integerOverflow + +def USize.checked_mul (n: USize) (m: USize): Result USize := + if h: n.val * m.val < USize.size then + .ret ⟨ n.val * m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_div (n: USize) (m: USize): Result USize := + if m > 0 then + .ret ⟨ n.val / m.val, by + have h1: ↑n.val < USize.size := n.val.isLt + have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val + apply Nat.lt_of_le_of_lt h2 h1 + ⟩ + else + .fail integerOverflow + +-- Test behavior... +#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 + +#eval USize.checked_sub 20 10 +-- NOTE: compare with concrete behavior here, which I do not think we want +#eval USize.sub 0 1 +#eval UInt8.add 255 255 + +-- We now define a type class that subsumes the various machine integer types, so +-- as to write a concise definition for scalar_cast, rather than exhaustively +-- enumerating all of the possible pairs. We remark that Rust has sane semantics +-- and fails if a cast operation would involve a truncation or modulo. + +class MachineInteger (t: Type) where + size: Nat + val: t -> Fin size + ofNatCore: (n:Nat) -> LT.lt n size -> t + +set_option hygiene false in +run_cmd + for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do + Lean.Elab.Command.elabCommand (← `( + namespace $typeName + instance: MachineInteger $typeName where + size := size + val := val + ofNatCore := ofNatCore + end $typeName + )) + +-- Aeneas only instantiates the destination type (`src` is implicit). We rely on +-- Lean to infer `src`. + +def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := + if h: MachineInteger.val x < MachineInteger.size dst then + .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) + else + .fail integerOverflow + +------------- +-- VECTORS -- +------------- + +-- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) +-- rather than maximum values (usize_max). +def Vec (α : Type u) := { l : List α // List.length l < USize.size } + +def vec_new (α : Type u): Vec α := ⟨ [], by { + match USize.size, usize_size_eq with + | _, Or.inl rfl => simp + | _, Or.inr rfl => simp + } ⟩ + +#check vec_new + +def vec_len (α : Type u) (v : Vec α) : USize := + let ⟨ v, l ⟩ := v + USize.ofNatCore (List.length v) l + +#eval vec_len Nat (vec_new Nat) + +def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () + +-- NOTE: old version trying to use a subtype notation, but probably better to +-- leave Result elimination to auxiliary lemmas with suitable preconditions +-- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one +-- make the proof work in that case? Probably need to import tactics from +-- mathlib to deal with inequalities... would love to see an example. +def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // + match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} + := + if h : List.length v.val + 1 < USize.size then + ⟨ return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩, by simp ⟩ + else + ⟨ fail maximumSizeExceeded, by simp ⟩ + +#eval do + -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with + -- fields val and property. However, Lean's elaborator can automatically + -- select the `val` field if the context provides a type annotation. We + -- annotate `x`, which relieves us of having to write `.val` on the right-hand + -- side of the monadic let. + let v := vec_new Nat + let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? + -- TODO: strengthen post-condition above and do a demo to show that we can + -- safely eliminate the `fail` case + return (vec_len Nat x) + +def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) + := + if h : List.length v.val + 1 <= 4294967295 then + return ⟨ List.concat v.val x, + by + rw [List.length_concat] + have h': 4294967295 < USize.size := by intlit + apply Nat.lt_of_le_of_lt h h' + ⟩ + else if h: List.length v.val + 1 < USize.size then + return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩ + else + fail maximumSizeExceeded + +def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +---------- +-- MISC -- +---------- + +def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := + x + +def mem_replace_back (a : Type) (_ : a) (y : a) : a := + y + +/-- Aeneas-translated function -- useful to reduce non-recursive definitions. + Use with `simp [ aeneas ]` -/ +register_simp_attr aeneas + +-------------------- +-- ASSERT COMMAND -- +-------------------- + +open Lean Elab Command Term Meta + +syntax (name := assert) "#assert" term: command + +@[command_elab assert] +unsafe +def assertImpl : CommandElab := fun (_stx: Syntax) => do + runTermElabM (fun _ => do + let r ← evalTerm Bool (mkConst ``Bool) _stx[1] + if not r then + logInfo "Assertion failed for: " + logInfo _stx[1] + logError "Expression reduced to false" + pure ()) + +#eval 2 == 2 +#assert (2 == 2) + +------------------- +-- SANITY CHECKS -- +------------------- + +-- TODO: add more once we have signed integers + +#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc-no_nested_borrows/NoNestedBorrows.lean b/tests/lean/misc-no_nested_borrows/NoNestedBorrows.lean new file mode 100644 index 00000000..a20ee9fd --- /dev/null +++ b/tests/lean/misc-no_nested_borrows/NoNestedBorrows.lean @@ -0,0 +1,556 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [no_nested_borrows] +import Base.Primitives + +structure OpaqueDefs where + + /- [no_nested_borrows::Pair] -/ + structure pair_t (T1 T2 : Type) where pair_x : T1 pair_y : T2 + + /- [no_nested_borrows::List] -/ + inductive list_t (T : Type) := + | ListCons : T -> list_t T -> list_t T + | ListNil : list_t T + + /- [no_nested_borrows::One] -/ + inductive one_t (T1 : Type) := | OneOne : T1 -> one_t T1 + + /- [no_nested_borrows::EmptyEnum] -/ + inductive empty_enum_t := | EmptyEnumEmpty : empty_enum_t + + /- [no_nested_borrows::Enum] -/ + inductive enum_t := | EnumVariant1 : enum_t | EnumVariant2 : enum_t + + /- [no_nested_borrows::EmptyStruct] -/ + structure empty_struct_t where + + /- [no_nested_borrows::Sum] -/ + inductive sum_t (T1 T2 : Type) := + | SumLeft : T1 -> sum_t T1 T2 + | SumRight : T2 -> sum_t T1 T2 + + /- [no_nested_borrows::neg_test] -/ + def neg_test_fwd (x : Int32) : Result Int32 := + Int32.checked_neg x + + /- [no_nested_borrows::add_test] -/ + def add_test_fwd (x : UInt32) (y : UInt32) : Result UInt32 := + UInt32.checked_add x y + + /- [no_nested_borrows::subs_test] -/ + def subs_test_fwd (x : UInt32) (y : UInt32) : Result UInt32 := + UInt32.checked_sub x y + + /- [no_nested_borrows::div_test] -/ + def div_test_fwd (x : UInt32) (y : UInt32) : Result UInt32 := + UInt32.checked_div x y + + /- [no_nested_borrows::div_test1] -/ + def div_test1_fwd (x : UInt32) : Result UInt32 := + UInt32.checked_div x (UInt32.ofNatCore 2 (by intlit)) + + /- [no_nested_borrows::rem_test] -/ + def rem_test_fwd (x : UInt32) (y : UInt32) : Result UInt32 := + UInt32.checked_rem x y + + /- [no_nested_borrows::cast_test] -/ + def cast_test_fwd (x : UInt32) : Result Int32 := + scalar_cast Int32 x + + /- [no_nested_borrows::test2] -/ + def test2_fwd : Result Unit := + do + let _ ← UInt32.checked_add (UInt32.ofNatCore 23 (by intlit)) + (UInt32.ofNatCore 44 (by intlit)) + Result.ret () + + /- Unit test for [no_nested_borrows::test2] -/ + #assert (test2_fwd == .ret ()) + + /- [no_nested_borrows::get_max] -/ + def get_max_fwd (x : UInt32) (y : UInt32) : Result UInt32 := + if h: x >= y + then Result.ret x + else Result.ret y + + /- [no_nested_borrows::test3] -/ + def test3_fwd : Result Unit := + do + let x ← + get_max_fwd (UInt32.ofNatCore 4 (by intlit)) + (UInt32.ofNatCore 3 (by intlit)) + let y ← + get_max_fwd (UInt32.ofNatCore 10 (by intlit)) + (UInt32.ofNatCore 11 (by intlit)) + let z ← UInt32.checked_add x y + if h: not (z = (UInt32.ofNatCore 15 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::test3] -/ + #assert (test3_fwd == .ret ()) + + /- [no_nested_borrows::test_neg1] -/ + def test_neg1_fwd : Result Unit := + do + let y ← Int32.checked_neg (Int32.ofNatCore 3 (by intlit)) + if h: not (y = (Int32.ofNatCore -3 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::test_neg1] -/ + #assert (test_neg1_fwd == .ret ()) + + /- [no_nested_borrows::refs_test1] -/ + def refs_test1_fwd : Result Unit := + if h: not ((Int32.ofNatCore 1 (by intlit)) = + (Int32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::refs_test1] -/ + #assert (refs_test1_fwd == .ret ()) + + /- [no_nested_borrows::refs_test2] -/ + def refs_test2_fwd : Result Unit := + if h: not ((Int32.ofNatCore 2 (by intlit)) = + (Int32.ofNatCore 2 (by intlit))) + then Result.fail Error.panic + else + if h: not ((Int32.ofNatCore 0 (by intlit)) = + (Int32.ofNatCore 0 (by intlit))) + then Result.fail Error.panic + else + if h: not ((Int32.ofNatCore 2 (by intlit)) = + (Int32.ofNatCore 2 (by intlit))) + then Result.fail Error.panic + else + if h: not ((Int32.ofNatCore 2 (by intlit)) = + (Int32.ofNatCore 2 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::refs_test2] -/ + #assert (refs_test2_fwd == .ret ()) + + /- [no_nested_borrows::test_list1] -/ + def test_list1_fwd : Result Unit := + Result.ret () + + /- Unit test for [no_nested_borrows::test_list1] -/ + #assert (test_list1_fwd == .ret ()) + + /- [no_nested_borrows::test_box1] -/ + def test_box1_fwd : Result Unit := + let b := (Int32.ofNatCore 1 (by intlit)) + let x := b + if h: not (x = (Int32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::test_box1] -/ + #assert (test_box1_fwd == .ret ()) + + /- [no_nested_borrows::copy_int] -/ + def copy_int_fwd (x : Int32) : Result Int32 := + Result.ret x + + /- [no_nested_borrows::test_unreachable] -/ + def test_unreachable_fwd (b : Bool) : Result Unit := + if h: b + then Result.fail Error.panic + else Result.ret () + + /- [no_nested_borrows::test_panic] -/ + def test_panic_fwd (b : Bool) : Result Unit := + if h: b + then Result.fail Error.panic + else Result.ret () + + /- [no_nested_borrows::test_copy_int] -/ + def test_copy_int_fwd : Result Unit := + do + let y ← copy_int_fwd (Int32.ofNatCore 0 (by intlit)) + if h: not ((Int32.ofNatCore 0 (by intlit)) = y) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::test_copy_int] -/ + #assert (test_copy_int_fwd == .ret ()) + + /- [no_nested_borrows::is_cons] -/ + def is_cons_fwd (T : Type) (l : list_t T) : Result Bool := + match h: l with + | list_t.ListCons t l0 => Result.ret true + | list_t.ListNil => Result.ret false + + /- [no_nested_borrows::test_is_cons] -/ + def test_is_cons_fwd : Result Unit := + do + let l := list_t.ListNil + let b ← + is_cons_fwd Int32 (list_t.ListCons (Int32.ofNatCore 0 (by intlit)) l) + if h: not b + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::test_is_cons] -/ + #assert (test_is_cons_fwd == .ret ()) + + /- [no_nested_borrows::split_list] -/ + def split_list_fwd (T : Type) (l : list_t T) : Result (T × (list_t T)) := + match h: l with + | list_t.ListCons hd tl => Result.ret (hd, tl) + | list_t.ListNil => Result.fail Error.panic + + /- [no_nested_borrows::test_split_list] -/ + def test_split_list_fwd : Result Unit := + do + let l := list_t.ListNil + let p ← + split_list_fwd Int32 (list_t.ListCons (Int32.ofNatCore 0 (by intlit)) + l) + let (hd, _) := p + if h: not (hd = (Int32.ofNatCore 0 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::test_split_list] -/ + #assert (test_split_list_fwd == .ret ()) + + /- [no_nested_borrows::choose] -/ + def choose_fwd (T : Type) (b : Bool) (x : T) (y : T) : Result T := + if h: b + then Result.ret x + else Result.ret y + + /- [no_nested_borrows::choose] -/ + def choose_back + (T : Type) (b : Bool) (x : T) (y : T) (ret0 : T) : Result (T × T) := + if h: b + then Result.ret (ret0, y) + else Result.ret (x, ret0) + + /- [no_nested_borrows::choose_test] -/ + def choose_test_fwd : Result Unit := + do + let z ← + choose_fwd Int32 true (Int32.ofNatCore 0 (by intlit)) + (Int32.ofNatCore 0 (by intlit)) + let z0 ← Int32.checked_add z (Int32.ofNatCore 1 (by intlit)) + if h: not (z0 = (Int32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else + do + let (x, y) ← + choose_back Int32 true (Int32.ofNatCore 0 (by intlit)) + (Int32.ofNatCore 0 (by intlit)) z0 + if h: not (x = (Int32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else + if h: not (y = (Int32.ofNatCore 0 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::choose_test] -/ + #assert (choose_test_fwd == .ret ()) + + /- [no_nested_borrows::test_char] -/ + def test_char_fwd : Result Char := + Result.ret 'a' + + /- [no_nested_borrows::NodeElem] -/ + mutual inductive node_elem_t (T : Type) := + | NodeElemCons : tree_t T -> node_elem_t T -> node_elem_t T + | NodeElemNil : node_elem_t T + + /- [no_nested_borrows::Tree] -/ + inductive tree_t (T : Type) := + | TreeLeaf : T -> tree_t T + | TreeNode : T -> node_elem_t T -> tree_t T -> tree_t T + + /- [no_nested_borrows::list_length] -/ + def list_length_fwd (T : Type) (l : list_t T) : Result UInt32 := + match h: l with + | list_t.ListCons t l1 => + do + let i ← list_length_fwd T l1 + UInt32.checked_add (UInt32.ofNatCore 1 (by intlit)) i + | list_t.ListNil => Result.ret (UInt32.ofNatCore 0 (by intlit)) + + /- [no_nested_borrows::list_nth_shared] -/ + def list_nth_shared_fwd (T : Type) (l : list_t T) (i : UInt32) : Result T := + match h: l with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret x + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_shared_fwd T tl i0 + | list_t.ListNil => Result.fail Error.panic + + /- [no_nested_borrows::list_nth_mut] -/ + def list_nth_mut_fwd (T : Type) (l : list_t T) (i : UInt32) : Result T := + match h: l with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret x + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_mut_fwd T tl i0 + | list_t.ListNil => Result.fail Error.panic + + /- [no_nested_borrows::list_nth_mut] -/ + def list_nth_mut_back + (T : Type) (l : list_t T) (i : UInt32) (ret0 : T) : Result (list_t T) := + match h: l with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl0 ← list_nth_mut_back T tl i0 ret0 + Result.ret (list_t.ListCons x tl0) + | list_t.ListNil => Result.fail Error.panic + + /- [no_nested_borrows::list_rev_aux] -/ + def list_rev_aux_fwd + (T : Type) (li : list_t T) (lo : list_t T) : Result (list_t T) := + match h: li with + | list_t.ListCons hd tl => list_rev_aux_fwd T tl (list_t.ListCons hd lo) + | list_t.ListNil => Result.ret lo + + /- [no_nested_borrows::list_rev] -/ + def list_rev_fwd_back (T : Type) (l : list_t T) : Result (list_t T) := + let li := mem_replace_fwd (list_t T) l list_t.ListNil + list_rev_aux_fwd T li list_t.ListNil + + /- [no_nested_borrows::test_list_functions] -/ + def test_list_functions_fwd : Result Unit := + do + let l := list_t.ListNil + let l0 := list_t.ListCons (Int32.ofNatCore 2 (by intlit)) l + let l1 := list_t.ListCons (Int32.ofNatCore 1 (by intlit)) l0 + let i ← + list_length_fwd Int32 (list_t.ListCons (Int32.ofNatCore 0 (by intlit)) + l1) + if h: not (i = (UInt32.ofNatCore 3 (by intlit))) + then Result.fail Error.panic + else + do + let i0 ← + list_nth_shared_fwd Int32 (list_t.ListCons + (Int32.ofNatCore 0 (by intlit)) l1) + (UInt32.ofNatCore 0 (by intlit)) + if h: not (i0 = (Int32.ofNatCore 0 (by intlit))) + then Result.fail Error.panic + else + do + let i1 ← + list_nth_shared_fwd Int32 (list_t.ListCons + (Int32.ofNatCore 0 (by intlit)) l1) + (UInt32.ofNatCore 1 (by intlit)) + if h: not (i1 = (Int32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else + do + let i2 ← + list_nth_shared_fwd Int32 (list_t.ListCons + (Int32.ofNatCore 0 (by intlit)) l1) + (UInt32.ofNatCore 2 (by intlit)) + if h: not (i2 = (Int32.ofNatCore 2 (by intlit))) + then Result.fail Error.panic + else + do + let ls ← + list_nth_mut_back Int32 (list_t.ListCons + (Int32.ofNatCore 0 (by intlit)) l1) + (UInt32.ofNatCore 1 (by intlit)) + (Int32.ofNatCore 3 (by intlit)) + let i3 ← + list_nth_shared_fwd Int32 ls + (UInt32.ofNatCore 0 (by intlit)) + if h: not (i3 = (Int32.ofNatCore 0 (by intlit))) + then Result.fail Error.panic + else + do + let i4 ← + list_nth_shared_fwd Int32 ls + (UInt32.ofNatCore 1 (by intlit)) + if h: not (i4 = (Int32.ofNatCore 3 (by intlit))) + then Result.fail Error.panic + else + do + let i5 ← + list_nth_shared_fwd Int32 ls + (UInt32.ofNatCore 2 (by intlit)) + if h: not (i5 = (Int32.ofNatCore 2 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::test_list_functions] -/ + #assert (test_list_functions_fwd == .ret ()) + + /- [no_nested_borrows::id_mut_pair1] -/ + def id_mut_pair1_fwd (T1 T2 : Type) (x : T1) (y : T2) : Result (T1 × T2) := + Result.ret (x, y) + + /- [no_nested_borrows::id_mut_pair1] -/ + def id_mut_pair1_back + (T1 T2 : Type) (x : T1) (y : T2) (ret0 : (T1 × T2)) : Result (T1 × T2) := + let (t, t0) := ret0 + Result.ret (t, t0) + + /- [no_nested_borrows::id_mut_pair2] -/ + def id_mut_pair2_fwd (T1 T2 : Type) (p : (T1 × T2)) : Result (T1 × T2) := + let (t, t0) := p + Result.ret (t, t0) + + /- [no_nested_borrows::id_mut_pair2] -/ + def id_mut_pair2_back + (T1 T2 : Type) (p : (T1 × T2)) (ret0 : (T1 × T2)) : Result (T1 × T2) := + let (t, t0) := ret0 + Result.ret (t, t0) + + /- [no_nested_borrows::id_mut_pair3] -/ + def id_mut_pair3_fwd (T1 T2 : Type) (x : T1) (y : T2) : Result (T1 × T2) := + Result.ret (x, y) + + /- [no_nested_borrows::id_mut_pair3] -/ + def id_mut_pair3_back'a + (T1 T2 : Type) (x : T1) (y : T2) (ret0 : T1) : Result T1 := + Result.ret ret0 + + /- [no_nested_borrows::id_mut_pair3] -/ + def id_mut_pair3_back'b + (T1 T2 : Type) (x : T1) (y : T2) (ret0 : T2) : Result T2 := + Result.ret ret0 + + /- [no_nested_borrows::id_mut_pair4] -/ + def id_mut_pair4_fwd (T1 T2 : Type) (p : (T1 × T2)) : Result (T1 × T2) := + let (t, t0) := p + Result.ret (t, t0) + + /- [no_nested_borrows::id_mut_pair4] -/ + def id_mut_pair4_back'a + (T1 T2 : Type) (p : (T1 × T2)) (ret0 : T1) : Result T1 := + Result.ret ret0 + + /- [no_nested_borrows::id_mut_pair4] -/ + def id_mut_pair4_back'b + (T1 T2 : Type) (p : (T1 × T2)) (ret0 : T2) : Result T2 := + Result.ret ret0 + + /- [no_nested_borrows::StructWithTuple] -/ + structure struct_with_tuple_t (T1 T2 : Type) where + + struct_with_tuple_p : (T1 × T2) + + + /- [no_nested_borrows::new_tuple1] -/ + def new_tuple1_fwd : Result (struct_with_tuple_t UInt32 UInt32) := + Result.ret + { + struct_with_tuple_p := ((UInt32.ofNatCore 1 (by intlit)), + (UInt32.ofNatCore 2 (by intlit))) + } + + /- [no_nested_borrows::new_tuple2] -/ + def new_tuple2_fwd : Result (struct_with_tuple_t Int16 Int16) := + Result.ret + { + struct_with_tuple_p := ((Int16.ofNatCore 1 (by intlit)), + (Int16.ofNatCore 2 (by intlit))) + } + + /- [no_nested_borrows::new_tuple3] -/ + def new_tuple3_fwd : Result (struct_with_tuple_t UInt64 Int64) := + Result.ret + { + struct_with_tuple_p := ((UInt64.ofNatCore 1 (by intlit)), + (Int64.ofNatCore 2 (by intlit))) + } + + /- [no_nested_borrows::StructWithPair] -/ + structure struct_with_pair_t (T1 T2 : Type) where + + struct_with_pair_p : pair_t T1 T2 + + + /- [no_nested_borrows::new_pair1] -/ + def new_pair1_fwd : Result (struct_with_pair_t UInt32 UInt32) := + Result.ret + { + struct_with_pair_p := { + pair_x := (UInt32.ofNatCore 1 (by intlit)), + pair_y := (UInt32.ofNatCore 2 (by intlit)) + } + } + + /- [no_nested_borrows::test_constants] -/ + def test_constants_fwd : Result Unit := + do + let swt ← new_tuple1_fwd + let (i, _) := swt.struct_with_tuple_p + if h: not (i = (UInt32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else + do + let swt0 ← new_tuple2_fwd + let (i0, _) := swt0.struct_with_tuple_p + if h: not (i0 = (Int16.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else + do + let swt1 ← new_tuple3_fwd + let (i1, _) := swt1.struct_with_tuple_p + if h: not (i1 = (UInt64.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else + do + let swp ← new_pair1_fwd + if h: not (swp.struct_with_pair_p.pair_x = + (UInt32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [no_nested_borrows::test_constants] -/ + #assert (test_constants_fwd == .ret ()) + + /- [no_nested_borrows::test_weird_borrows1] -/ + def test_weird_borrows1_fwd : Result Unit := + Result.ret () + + /- Unit test for [no_nested_borrows::test_weird_borrows1] -/ + #assert (test_weird_borrows1_fwd == .ret ()) + + /- [no_nested_borrows::test_mem_replace] -/ + def test_mem_replace_fwd_back (px : UInt32) : Result UInt32 := + let y := mem_replace_fwd UInt32 px (UInt32.ofNatCore 1 (by intlit)) + if h: not (y = (UInt32.ofNatCore 0 (by intlit))) + then Result.fail Error.panic + else Result.ret (UInt32.ofNatCore 2 (by intlit)) + + /- [no_nested_borrows::test_shared_borrow_bool1] -/ + def test_shared_borrow_bool1_fwd (b : Bool) : Result UInt32 := + if h: b + then Result.ret (UInt32.ofNatCore 0 (by intlit)) + else Result.ret (UInt32.ofNatCore 1 (by intlit)) + + /- [no_nested_borrows::test_shared_borrow_bool2] -/ + def test_shared_borrow_bool2_fwd : Result UInt32 := + Result.ret (UInt32.ofNatCore 0 (by intlit)) + + /- [no_nested_borrows::test_shared_borrow_enum1] -/ + def test_shared_borrow_enum1_fwd (l : list_t UInt32) : Result UInt32 := + match h: l with + | list_t.ListCons i l0 => Result.ret (UInt32.ofNatCore 1 (by intlit)) + | list_t.ListNil => Result.ret (UInt32.ofNatCore 0 (by intlit)) + + /- [no_nested_borrows::test_shared_borrow_enum2] -/ + def test_shared_borrow_enum2_fwd : Result UInt32 := + Result.ret (UInt32.ofNatCore 0 (by intlit)) + diff --git a/tests/lean/misc-no_nested_borrows/lakefile.lean b/tests/lean/misc-no_nested_borrows/lakefile.lean new file mode 100644 index 00000000..e4460813 --- /dev/null +++ b/tests/lean/misc-no_nested_borrows/lakefile.lean @@ -0,0 +1,18 @@ +import Lake +open Lake DSL + +require mathlib from git + "https://github.com/leanprover-community/mathlib4.git" + +package «no_nested_borrows» { + -- add package configuration options here +} + +lean_lib «Base» { + -- add library configuration options here +} + +lean_lib «NoNestedBorrows» { + -- add library configuration options here +} + diff --git a/tests/lean/misc-paper/Base/Primitives.lean b/tests/lean/misc-paper/Base/Primitives.lean new file mode 100644 index 00000000..5b64e908 --- /dev/null +++ b/tests/lean/misc-paper/Base/Primitives.lean @@ -0,0 +1,392 @@ +import Lean +import Lean.Meta.Tactic.Simp +import Init.Data.List.Basic +import Mathlib.Tactic.RunCmd + +------------- +-- PRELUDE -- +------------- + +-- Results & monadic combinators + +inductive Error where + | assertionFailure: Error + | integerOverflow: Error + | arrayOutOfBounds: Error + | maximumSizeExceeded: Error + | panic: Error +deriving Repr, BEq + +open Error + +inductive Result (α : Type u) where + | ret (v: α): Result α + | fail (e: Error): Result α +deriving Repr, BEq + +open Result + +/- HELPERS -/ + +def ret? {α: Type} (r: Result α): Bool := + match r with + | Result.ret _ => true + | Result.fail _ => false + +def massert (b:Bool) : Result Unit := + if b then .ret () else fail assertionFailure + +def eval_global {α: Type} (x: Result α) (_: ret? x): α := + match x with + | Result.fail _ => by contradiction + | Result.ret x => x + +/- DO-DSL SUPPORT -/ + +def bind (x: Result α) (f: α -> Result β) : Result β := + match x with + | ret v => f v + | fail v => fail v + +-- Allows using Result in do-blocks +instance : Bind Result where + bind := bind + +-- Allows using return x in do-blocks +instance : Pure Result where + pure := fun x => ret x + +/- CUSTOM-DSL SUPPORT -/ + +-- Let-binding the Result of a monadic operation is oftentimes not sufficient, +-- because we may need a hypothesis for equational reasoning in the scope. We +-- rely on subtype, and a custom let-binding operator, in effect recreating our +-- own variant of the do-dsl + +def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := + match o with + | .ret x => .ret ⟨x, rfl⟩ + | .fail e => .fail e + +macro "let" e:term " ⟵ " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- TODO: any way to factorize both definitions? +macro "let" e:term " <-- " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- We call the hypothesis `h`, in effect making it unavailable to the user +-- (because too much shadowing). But in practice, once can use the French single +-- quote notation (input with f< and f>), where `‹ h ›` finds a suitable +-- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` +#eval do + let y <-- .ret (0: Nat) + let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide + let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ + .ret r + +---------------------- +-- MACHINE INTEGERS -- +---------------------- + +-- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., +-- USize. They are generally defined in an idiomatic style, except that there is +-- not a single type class to rule them all (more on that below). The absence of +-- type class is intentional, and allows the Lean compiler to efficiently map +-- them to machine integers during compilation. + +-- USize is designed properly: you cannot reduce `getNumBits` using the +-- simplifier, meaning that proofs do not depend on the compile-time value of +-- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really +-- support, at least officially, 16-bit microcontrollers, so this seems like a +-- fine design decision for now.) + +-- Note from Chris Bailey: "If there's more than one salient property of your +-- definition then the subtyping strategy might get messy, and the property part +-- of a subtype is less discoverable by the simplifier or tactics like +-- library_search." So, we will not add refinements on the return values of the +-- operations defined on Primitives, but will rather rely on custom lemmas to +-- invert on possible return values of the primitive operations. + +-- Machine integer constants, done via `ofNatCore`, which requires a proof that +-- the `Nat` fits within the desired integer type. We provide a custom tactic. + +syntax "intlit" : tactic + +macro_rules + | `(tactic| intlit) => `(tactic| + match USize.size, usize_size_eq with + | _, Or.inl rfl => decide + | _, Or.inr rfl => decide) + +-- This is how the macro is expected to be used +#eval USize.ofNatCore 0 (by intlit) + +-- Also works for other integer types (at the expense of a needless disjunction) +#eval UInt32.ofNatCore 0 (by intlit) + +-- The machine integer operations (e.g. sub) are always total, which is not what +-- we want. We therefore define "checked" variants, below. Note that we add a +-- tiny bit of complexity for the USize variant: we first check whether the +-- result is < 2^32; if it is, we can compute the definition, rather than +-- returning a term that is computationally stuck (the comparison to USize.size +-- cannot reduce at compile-time, per the remark about regarding `getNumBits`). +-- This is useful for the various #asserts that we want to reduce at +-- type-checking time. + +-- Further thoughts: look at what has been done here: +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean +-- and +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean +-- which both contain a fair amount of reasoning already! +def USize.checked_sub (n: USize) (m: USize): Result USize := + -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? + if n >= m then + let n' := USize.toNat n + let m' := USize.toNat n + let r := USize.ofNatCore (n' - m') (by + have h: n' - m' <= n' := by + apply Nat.sub_le_of_le_add + case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left + apply Nat.lt_of_le_of_lt h + apply n.val.isLt + ) + return r + else + fail integerOverflow + +@[simp] +theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := + match USize.size, usize_size_eq with + | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) + | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) + +def USize.checked_add (n: USize) (m: USize): Result USize := + if h: n.val + m.val < USize.size then + .ret ⟨ n.val + m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_rem (n: USize) (m: USize): Result USize := + if h: m > 0 then + .ret ⟨ n.val % m.val, by + have h1: ↑m.val < USize.size := m.val.isLt + have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h + apply Nat.lt_trans h2 h1 + ⟩ + else + .fail integerOverflow + +def USize.checked_mul (n: USize) (m: USize): Result USize := + if h: n.val * m.val < USize.size then + .ret ⟨ n.val * m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_div (n: USize) (m: USize): Result USize := + if m > 0 then + .ret ⟨ n.val / m.val, by + have h1: ↑n.val < USize.size := n.val.isLt + have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val + apply Nat.lt_of_le_of_lt h2 h1 + ⟩ + else + .fail integerOverflow + +-- Test behavior... +#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 + +#eval USize.checked_sub 20 10 +-- NOTE: compare with concrete behavior here, which I do not think we want +#eval USize.sub 0 1 +#eval UInt8.add 255 255 + +-- We now define a type class that subsumes the various machine integer types, so +-- as to write a concise definition for scalar_cast, rather than exhaustively +-- enumerating all of the possible pairs. We remark that Rust has sane semantics +-- and fails if a cast operation would involve a truncation or modulo. + +class MachineInteger (t: Type) where + size: Nat + val: t -> Fin size + ofNatCore: (n:Nat) -> LT.lt n size -> t + +set_option hygiene false in +run_cmd + for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do + Lean.Elab.Command.elabCommand (← `( + namespace $typeName + instance: MachineInteger $typeName where + size := size + val := val + ofNatCore := ofNatCore + end $typeName + )) + +-- Aeneas only instantiates the destination type (`src` is implicit). We rely on +-- Lean to infer `src`. + +def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := + if h: MachineInteger.val x < MachineInteger.size dst then + .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) + else + .fail integerOverflow + +------------- +-- VECTORS -- +------------- + +-- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) +-- rather than maximum values (usize_max). +def Vec (α : Type u) := { l : List α // List.length l < USize.size } + +def vec_new (α : Type u): Vec α := ⟨ [], by { + match USize.size, usize_size_eq with + | _, Or.inl rfl => simp + | _, Or.inr rfl => simp + } ⟩ + +#check vec_new + +def vec_len (α : Type u) (v : Vec α) : USize := + let ⟨ v, l ⟩ := v + USize.ofNatCore (List.length v) l + +#eval vec_len Nat (vec_new Nat) + +def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () + +-- NOTE: old version trying to use a subtype notation, but probably better to +-- leave Result elimination to auxiliary lemmas with suitable preconditions +-- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one +-- make the proof work in that case? Probably need to import tactics from +-- mathlib to deal with inequalities... would love to see an example. +def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // + match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} + := + if h : List.length v.val + 1 < USize.size then + ⟨ return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩, by simp ⟩ + else + ⟨ fail maximumSizeExceeded, by simp ⟩ + +#eval do + -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with + -- fields val and property. However, Lean's elaborator can automatically + -- select the `val` field if the context provides a type annotation. We + -- annotate `x`, which relieves us of having to write `.val` on the right-hand + -- side of the monadic let. + let v := vec_new Nat + let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? + -- TODO: strengthen post-condition above and do a demo to show that we can + -- safely eliminate the `fail` case + return (vec_len Nat x) + +def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) + := + if h : List.length v.val + 1 <= 4294967295 then + return ⟨ List.concat v.val x, + by + rw [List.length_concat] + have h': 4294967295 < USize.size := by intlit + apply Nat.lt_of_le_of_lt h h' + ⟩ + else if h: List.length v.val + 1 < USize.size then + return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩ + else + fail maximumSizeExceeded + +def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +---------- +-- MISC -- +---------- + +def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := + x + +def mem_replace_back (a : Type) (_ : a) (y : a) : a := + y + +/-- Aeneas-translated function -- useful to reduce non-recursive definitions. + Use with `simp [ aeneas ]` -/ +register_simp_attr aeneas + +-------------------- +-- ASSERT COMMAND -- +-------------------- + +open Lean Elab Command Term Meta + +syntax (name := assert) "#assert" term: command + +@[command_elab assert] +unsafe +def assertImpl : CommandElab := fun (_stx: Syntax) => do + runTermElabM (fun _ => do + let r ← evalTerm Bool (mkConst ``Bool) _stx[1] + if not r then + logInfo "Assertion failed for: " + logInfo _stx[1] + logError "Expression reduced to false" + pure ()) + +#eval 2 == 2 +#assert (2 == 2) + +------------------- +-- SANITY CHECKS -- +------------------- + +-- TODO: add more once we have signed integers + +#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc-paper/Paper.lean b/tests/lean/misc-paper/Paper.lean new file mode 100644 index 00000000..4faf36ee --- /dev/null +++ b/tests/lean/misc-paper/Paper.lean @@ -0,0 +1,128 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [paper] +import Base.Primitives + +structure OpaqueDefs where + + /- [paper::ref_incr] -/ + def ref_incr_fwd_back (x : Int32) : Result Int32 := + Int32.checked_add x (Int32.ofNatCore 1 (by intlit)) + + /- [paper::test_incr] -/ + def test_incr_fwd : Result Unit := + do + let x ← ref_incr_fwd_back (Int32.ofNatCore 0 (by intlit)) + if h: not (x = (Int32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [paper::test_incr] -/ + #assert (test_incr_fwd == .ret ()) + + /- [paper::choose] -/ + def choose_fwd (T : Type) (b : Bool) (x : T) (y : T) : Result T := + if h: b + then Result.ret x + else Result.ret y + + /- [paper::choose] -/ + def choose_back + (T : Type) (b : Bool) (x : T) (y : T) (ret0 : T) : Result (T × T) := + if h: b + then Result.ret (ret0, y) + else Result.ret (x, ret0) + + /- [paper::test_choose] -/ + def test_choose_fwd : Result Unit := + do + let z ← + choose_fwd Int32 true (Int32.ofNatCore 0 (by intlit)) + (Int32.ofNatCore 0 (by intlit)) + let z0 ← Int32.checked_add z (Int32.ofNatCore 1 (by intlit)) + if h: not (z0 = (Int32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else + do + let (x, y) ← + choose_back Int32 true (Int32.ofNatCore 0 (by intlit)) + (Int32.ofNatCore 0 (by intlit)) z0 + if h: not (x = (Int32.ofNatCore 1 (by intlit))) + then Result.fail Error.panic + else + if h: not (y = (Int32.ofNatCore 0 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [paper::test_choose] -/ + #assert (test_choose_fwd == .ret ()) + + /- [paper::List] -/ + inductive list_t (T : Type) := + | ListCons : T -> list_t T -> list_t T + | ListNil : list_t T + + /- [paper::list_nth_mut] -/ + def list_nth_mut_fwd (T : Type) (l : list_t T) (i : UInt32) : Result T := + match h: l with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret x + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + list_nth_mut_fwd T tl i0 + | list_t.ListNil => Result.fail Error.panic + + /- [paper::list_nth_mut] -/ + def list_nth_mut_back + (T : Type) (l : list_t T) (i : UInt32) (ret0 : T) : Result (list_t T) := + match h: l with + | list_t.ListCons x tl => + if h: i = (UInt32.ofNatCore 0 (by intlit)) + then Result.ret (list_t.ListCons ret0 tl) + else + do + let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) + let tl0 ← list_nth_mut_back T tl i0 ret0 + Result.ret (list_t.ListCons x tl0) + | list_t.ListNil => Result.fail Error.panic + + /- [paper::sum] -/ + def sum_fwd (l : list_t Int32) : Result Int32 := + match h: l with + | list_t.ListCons x tl => do + let i ← sum_fwd tl + Int32.checked_add x i + | list_t.ListNil => Result.ret (Int32.ofNatCore 0 (by intlit)) + + /- [paper::test_nth] -/ + def test_nth_fwd : Result Unit := + do + let l := list_t.ListNil + let l0 := list_t.ListCons (Int32.ofNatCore 3 (by intlit)) l + let l1 := list_t.ListCons (Int32.ofNatCore 2 (by intlit)) l0 + let x ← + list_nth_mut_fwd Int32 (list_t.ListCons (Int32.ofNatCore 1 (by intlit)) + l1) (UInt32.ofNatCore 2 (by intlit)) + let x0 ← Int32.checked_add x (Int32.ofNatCore 1 (by intlit)) + let l2 ← + list_nth_mut_back Int32 (list_t.ListCons + (Int32.ofNatCore 1 (by intlit)) l1) (UInt32.ofNatCore 2 (by intlit)) + x0 + let i ← sum_fwd l2 + if h: not (i = (Int32.ofNatCore 7 (by intlit))) + then Result.fail Error.panic + else Result.ret () + + /- Unit test for [paper::test_nth] -/ + #assert (test_nth_fwd == .ret ()) + + /- [paper::call_choose] -/ + def call_choose_fwd (p : (UInt32 × UInt32)) : Result UInt32 := + do + let (px, py) := p + let pz ← choose_fwd UInt32 true px py + let pz0 ← UInt32.checked_add pz (UInt32.ofNatCore 1 (by intlit)) + let (px0, _) ← choose_back UInt32 true px py pz0 + Result.ret px0 + diff --git a/tests/lean/misc-paper/lakefile.lean b/tests/lean/misc-paper/lakefile.lean new file mode 100644 index 00000000..d8affff8 --- /dev/null +++ b/tests/lean/misc-paper/lakefile.lean @@ -0,0 +1,18 @@ +import Lake +open Lake DSL + +require mathlib from git + "https://github.com/leanprover-community/mathlib4.git" + +package «paper» { + -- add package configuration options here +} + +lean_lib «Base» { + -- add library configuration options here +} + +lean_lib «Paper» { + -- add library configuration options here +} + diff --git a/tests/lean/misc-polonius_list/Base/Primitives.lean b/tests/lean/misc-polonius_list/Base/Primitives.lean new file mode 100644 index 00000000..5b64e908 --- /dev/null +++ b/tests/lean/misc-polonius_list/Base/Primitives.lean @@ -0,0 +1,392 @@ +import Lean +import Lean.Meta.Tactic.Simp +import Init.Data.List.Basic +import Mathlib.Tactic.RunCmd + +------------- +-- PRELUDE -- +------------- + +-- Results & monadic combinators + +inductive Error where + | assertionFailure: Error + | integerOverflow: Error + | arrayOutOfBounds: Error + | maximumSizeExceeded: Error + | panic: Error +deriving Repr, BEq + +open Error + +inductive Result (α : Type u) where + | ret (v: α): Result α + | fail (e: Error): Result α +deriving Repr, BEq + +open Result + +/- HELPERS -/ + +def ret? {α: Type} (r: Result α): Bool := + match r with + | Result.ret _ => true + | Result.fail _ => false + +def massert (b:Bool) : Result Unit := + if b then .ret () else fail assertionFailure + +def eval_global {α: Type} (x: Result α) (_: ret? x): α := + match x with + | Result.fail _ => by contradiction + | Result.ret x => x + +/- DO-DSL SUPPORT -/ + +def bind (x: Result α) (f: α -> Result β) : Result β := + match x with + | ret v => f v + | fail v => fail v + +-- Allows using Result in do-blocks +instance : Bind Result where + bind := bind + +-- Allows using return x in do-blocks +instance : Pure Result where + pure := fun x => ret x + +/- CUSTOM-DSL SUPPORT -/ + +-- Let-binding the Result of a monadic operation is oftentimes not sufficient, +-- because we may need a hypothesis for equational reasoning in the scope. We +-- rely on subtype, and a custom let-binding operator, in effect recreating our +-- own variant of the do-dsl + +def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := + match o with + | .ret x => .ret ⟨x, rfl⟩ + | .fail e => .fail e + +macro "let" e:term " ⟵ " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- TODO: any way to factorize both definitions? +macro "let" e:term " <-- " f:term : doElem => + `(doElem| let ⟨$e, h⟩ ← Result.attach $f) + +-- We call the hypothesis `h`, in effect making it unavailable to the user +-- (because too much shadowing). But in practice, once can use the French single +-- quote notation (input with f< and f>), where `‹ h ›` finds a suitable +-- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` +#eval do + let y <-- .ret (0: Nat) + let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide + let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ + .ret r + +---------------------- +-- MACHINE INTEGERS -- +---------------------- + +-- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., +-- USize. They are generally defined in an idiomatic style, except that there is +-- not a single type class to rule them all (more on that below). The absence of +-- type class is intentional, and allows the Lean compiler to efficiently map +-- them to machine integers during compilation. + +-- USize is designed properly: you cannot reduce `getNumBits` using the +-- simplifier, meaning that proofs do not depend on the compile-time value of +-- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really +-- support, at least officially, 16-bit microcontrollers, so this seems like a +-- fine design decision for now.) + +-- Note from Chris Bailey: "If there's more than one salient property of your +-- definition then the subtyping strategy might get messy, and the property part +-- of a subtype is less discoverable by the simplifier or tactics like +-- library_search." So, we will not add refinements on the return values of the +-- operations defined on Primitives, but will rather rely on custom lemmas to +-- invert on possible return values of the primitive operations. + +-- Machine integer constants, done via `ofNatCore`, which requires a proof that +-- the `Nat` fits within the desired integer type. We provide a custom tactic. + +syntax "intlit" : tactic + +macro_rules + | `(tactic| intlit) => `(tactic| + match USize.size, usize_size_eq with + | _, Or.inl rfl => decide + | _, Or.inr rfl => decide) + +-- This is how the macro is expected to be used +#eval USize.ofNatCore 0 (by intlit) + +-- Also works for other integer types (at the expense of a needless disjunction) +#eval UInt32.ofNatCore 0 (by intlit) + +-- The machine integer operations (e.g. sub) are always total, which is not what +-- we want. We therefore define "checked" variants, below. Note that we add a +-- tiny bit of complexity for the USize variant: we first check whether the +-- result is < 2^32; if it is, we can compute the definition, rather than +-- returning a term that is computationally stuck (the comparison to USize.size +-- cannot reduce at compile-time, per the remark about regarding `getNumBits`). +-- This is useful for the various #asserts that we want to reduce at +-- type-checking time. + +-- Further thoughts: look at what has been done here: +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean +-- and +-- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean +-- which both contain a fair amount of reasoning already! +def USize.checked_sub (n: USize) (m: USize): Result USize := + -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? + if n >= m then + let n' := USize.toNat n + let m' := USize.toNat n + let r := USize.ofNatCore (n' - m') (by + have h: n' - m' <= n' := by + apply Nat.sub_le_of_le_add + case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left + apply Nat.lt_of_le_of_lt h + apply n.val.isLt + ) + return r + else + fail integerOverflow + +@[simp] +theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := + match USize.size, usize_size_eq with + | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) + | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) + +def USize.checked_add (n: USize) (m: USize): Result USize := + if h: n.val + m.val < USize.size then + .ret ⟨ n.val + m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_rem (n: USize) (m: USize): Result USize := + if h: m > 0 then + .ret ⟨ n.val % m.val, by + have h1: ↑m.val < USize.size := m.val.isLt + have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h + apply Nat.lt_trans h2 h1 + ⟩ + else + .fail integerOverflow + +def USize.checked_mul (n: USize) (m: USize): Result USize := + if h: n.val * m.val < USize.size then + .ret ⟨ n.val * m.val, h ⟩ + else + .fail integerOverflow + +def USize.checked_div (n: USize) (m: USize): Result USize := + if m > 0 then + .ret ⟨ n.val / m.val, by + have h1: ↑n.val < USize.size := n.val.isLt + have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val + apply Nat.lt_of_le_of_lt h2 h1 + ⟩ + else + .fail integerOverflow + +-- Test behavior... +#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 + +#eval USize.checked_sub 20 10 +-- NOTE: compare with concrete behavior here, which I do not think we want +#eval USize.sub 0 1 +#eval UInt8.add 255 255 + +-- We now define a type class that subsumes the various machine integer types, so +-- as to write a concise definition for scalar_cast, rather than exhaustively +-- enumerating all of the possible pairs. We remark that Rust has sane semantics +-- and fails if a cast operation would involve a truncation or modulo. + +class MachineInteger (t: Type) where + size: Nat + val: t -> Fin size + ofNatCore: (n:Nat) -> LT.lt n size -> t + +set_option hygiene false in +run_cmd + for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do + Lean.Elab.Command.elabCommand (← `( + namespace $typeName + instance: MachineInteger $typeName where + size := size + val := val + ofNatCore := ofNatCore + end $typeName + )) + +-- Aeneas only instantiates the destination type (`src` is implicit). We rely on +-- Lean to infer `src`. + +def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := + if h: MachineInteger.val x < MachineInteger.size dst then + .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) + else + .fail integerOverflow + +------------- +-- VECTORS -- +------------- + +-- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) +-- rather than maximum values (usize_max). +def Vec (α : Type u) := { l : List α // List.length l < USize.size } + +def vec_new (α : Type u): Vec α := ⟨ [], by { + match USize.size, usize_size_eq with + | _, Or.inl rfl => simp + | _, Or.inr rfl => simp + } ⟩ + +#check vec_new + +def vec_len (α : Type u) (v : Vec α) : USize := + let ⟨ v, l ⟩ := v + USize.ofNatCore (List.length v) l + +#eval vec_len Nat (vec_new Nat) + +def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () + +-- NOTE: old version trying to use a subtype notation, but probably better to +-- leave Result elimination to auxiliary lemmas with suitable preconditions +-- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one +-- make the proof work in that case? Probably need to import tactics from +-- mathlib to deal with inequalities... would love to see an example. +def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // + match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} + := + if h : List.length v.val + 1 < USize.size then + ⟨ return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩, by simp ⟩ + else + ⟨ fail maximumSizeExceeded, by simp ⟩ + +#eval do + -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with + -- fields val and property. However, Lean's elaborator can automatically + -- select the `val` field if the context provides a type annotation. We + -- annotate `x`, which relieves us of having to write `.val` on the right-hand + -- side of the monadic let. + let v := vec_new Nat + let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? + -- TODO: strengthen post-condition above and do a demo to show that we can + -- safely eliminate the `fail` case + return (vec_len Nat x) + +def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) + := + if h : List.length v.val + 1 <= 4294967295 then + return ⟨ List.concat v.val x, + by + rw [List.length_concat] + have h': 4294967295 < USize.size := by intlit + apply Nat.lt_of_le_of_lt h h' + ⟩ + else if h: List.length v.val + 1 < USize.size then + return ⟨List.concat v.val x, + by + rw [List.length_concat] + assumption + ⟩ + else + fail maximumSizeExceeded + +def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := + if i.val < List.length v.val then + .ret () + else + .fail arrayOutOfBounds + +def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := + if h: i.val < List.length v.val then + .ret (List.get v.val ⟨i.val, h⟩) + else + .fail arrayOutOfBounds + +def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := + if i.val < List.length v.val then + .ret ⟨ List.set v.val i.val x, by + have h: List.length v.val < USize.size := v.property + rewrite [ List.length_set v.val i.val x ] + assumption + ⟩ + else + .fail arrayOutOfBounds + +---------- +-- MISC -- +---------- + +def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := + x + +def mem_replace_back (a : Type) (_ : a) (y : a) : a := + y + +/-- Aeneas-translated function -- useful to reduce non-recursive definitions. + Use with `simp [ aeneas ]` -/ +register_simp_attr aeneas + +-------------------- +-- ASSERT COMMAND -- +-------------------- + +open Lean Elab Command Term Meta + +syntax (name := assert) "#assert" term: command + +@[command_elab assert] +unsafe +def assertImpl : CommandElab := fun (_stx: Syntax) => do + runTermElabM (fun _ => do + let r ← evalTerm Bool (mkConst ``Bool) _stx[1] + if not r then + logInfo "Assertion failed for: " + logInfo _stx[1] + logError "Expression reduced to false" + pure ()) + +#eval 2 == 2 +#assert (2 == 2) + +------------------- +-- SANITY CHECKS -- +------------------- + +-- TODO: add more once we have signed integers + +#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc-polonius_list/PoloniusList.lean b/tests/lean/misc-polonius_list/PoloniusList.lean new file mode 100644 index 00000000..d679230d --- /dev/null +++ b/tests/lean/misc-polonius_list/PoloniusList.lean @@ -0,0 +1,36 @@ +-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS +-- [polonius_list] +import Base.Primitives + +structure OpaqueDefs where + + /- [polonius_list::List] -/ + inductive list_t (T : Type) := + | ListCons : T -> list_t T -> list_t T + | ListNil : list_t T + + /- [polonius_list::get_list_at_x] -/ + def get_list_at_x_fwd + (ls : list_t UInt32) (x : UInt32) : Result (list_t UInt32) := + match h: ls with + | list_t.ListCons hd tl => + if h: hd = x + then Result.ret (list_t.ListCons hd tl) + else get_list_at_x_fwd tl x + | list_t.ListNil => Result.ret list_t.ListNil + + /- [polonius_list::get_list_at_x] -/ + def get_list_at_x_back + (ls : list_t UInt32) (x : UInt32) (ret0 : list_t UInt32) : + Result (list_t UInt32) + := + match h: ls with + | list_t.ListCons hd tl => + if h: hd = x + then Result.ret ret0 + else + do + let tl0 ← get_list_at_x_back tl x ret0 + Result.ret (list_t.ListCons hd tl0) + | list_t.ListNil => Result.ret ret0 + diff --git a/tests/lean/misc-polonius_list/lakefile.lean b/tests/lean/misc-polonius_list/lakefile.lean new file mode 100644 index 00000000..f941effc --- /dev/null +++ b/tests/lean/misc-polonius_list/lakefile.lean @@ -0,0 +1,18 @@ +import Lake +open Lake DSL + +require mathlib from git + "https://github.com/leanprover-community/mathlib4.git" + +package «polonius_list» { + -- add package configuration options here +} + +lean_lib «Base» { + -- add library configuration options here +} + +lean_lib «PoloniusList» { + -- add library configuration options here +} + diff --git a/tests/lean/misc/constants/Base/Primitives.lean b/tests/lean/misc/constants/Base/Primitives.lean deleted file mode 100644 index 5b64e908..00000000 --- a/tests/lean/misc/constants/Base/Primitives.lean +++ /dev/null @@ -1,392 +0,0 @@ -import Lean -import Lean.Meta.Tactic.Simp -import Init.Data.List.Basic -import Mathlib.Tactic.RunCmd - -------------- --- PRELUDE -- -------------- - --- Results & monadic combinators - -inductive Error where - | assertionFailure: Error - | integerOverflow: Error - | arrayOutOfBounds: Error - | maximumSizeExceeded: Error - | panic: Error -deriving Repr, BEq - -open Error - -inductive Result (α : Type u) where - | ret (v: α): Result α - | fail (e: Error): Result α -deriving Repr, BEq - -open Result - -/- HELPERS -/ - -def ret? {α: Type} (r: Result α): Bool := - match r with - | Result.ret _ => true - | Result.fail _ => false - -def massert (b:Bool) : Result Unit := - if b then .ret () else fail assertionFailure - -def eval_global {α: Type} (x: Result α) (_: ret? x): α := - match x with - | Result.fail _ => by contradiction - | Result.ret x => x - -/- DO-DSL SUPPORT -/ - -def bind (x: Result α) (f: α -> Result β) : Result β := - match x with - | ret v => f v - | fail v => fail v - --- Allows using Result in do-blocks -instance : Bind Result where - bind := bind - --- Allows using return x in do-blocks -instance : Pure Result where - pure := fun x => ret x - -/- CUSTOM-DSL SUPPORT -/ - --- Let-binding the Result of a monadic operation is oftentimes not sufficient, --- because we may need a hypothesis for equational reasoning in the scope. We --- rely on subtype, and a custom let-binding operator, in effect recreating our --- own variant of the do-dsl - -def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := - match o with - | .ret x => .ret ⟨x, rfl⟩ - | .fail e => .fail e - -macro "let" e:term " ⟵ " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- TODO: any way to factorize both definitions? -macro "let" e:term " <-- " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- We call the hypothesis `h`, in effect making it unavailable to the user --- (because too much shadowing). But in practice, once can use the French single --- quote notation (input with f< and f>), where `‹ h ›` finds a suitable --- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` -#eval do - let y <-- .ret (0: Nat) - let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide - let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ - .ret r - ----------------------- --- MACHINE INTEGERS -- ----------------------- - --- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., --- USize. They are generally defined in an idiomatic style, except that there is --- not a single type class to rule them all (more on that below). The absence of --- type class is intentional, and allows the Lean compiler to efficiently map --- them to machine integers during compilation. - --- USize is designed properly: you cannot reduce `getNumBits` using the --- simplifier, meaning that proofs do not depend on the compile-time value of --- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really --- support, at least officially, 16-bit microcontrollers, so this seems like a --- fine design decision for now.) - --- Note from Chris Bailey: "If there's more than one salient property of your --- definition then the subtyping strategy might get messy, and the property part --- of a subtype is less discoverable by the simplifier or tactics like --- library_search." So, we will not add refinements on the return values of the --- operations defined on Primitives, but will rather rely on custom lemmas to --- invert on possible return values of the primitive operations. - --- Machine integer constants, done via `ofNatCore`, which requires a proof that --- the `Nat` fits within the desired integer type. We provide a custom tactic. - -syntax "intlit" : tactic - -macro_rules - | `(tactic| intlit) => `(tactic| - match USize.size, usize_size_eq with - | _, Or.inl rfl => decide - | _, Or.inr rfl => decide) - --- This is how the macro is expected to be used -#eval USize.ofNatCore 0 (by intlit) - --- Also works for other integer types (at the expense of a needless disjunction) -#eval UInt32.ofNatCore 0 (by intlit) - --- The machine integer operations (e.g. sub) are always total, which is not what --- we want. We therefore define "checked" variants, below. Note that we add a --- tiny bit of complexity for the USize variant: we first check whether the --- result is < 2^32; if it is, we can compute the definition, rather than --- returning a term that is computationally stuck (the comparison to USize.size --- cannot reduce at compile-time, per the remark about regarding `getNumBits`). --- This is useful for the various #asserts that we want to reduce at --- type-checking time. - --- Further thoughts: look at what has been done here: --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean --- and --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean --- which both contain a fair amount of reasoning already! -def USize.checked_sub (n: USize) (m: USize): Result USize := - -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? - if n >= m then - let n' := USize.toNat n - let m' := USize.toNat n - let r := USize.ofNatCore (n' - m') (by - have h: n' - m' <= n' := by - apply Nat.sub_le_of_le_add - case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left - apply Nat.lt_of_le_of_lt h - apply n.val.isLt - ) - return r - else - fail integerOverflow - -@[simp] -theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := - match USize.size, usize_size_eq with - | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) - | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) - -def USize.checked_add (n: USize) (m: USize): Result USize := - if h: n.val + m.val < USize.size then - .ret ⟨ n.val + m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_rem (n: USize) (m: USize): Result USize := - if h: m > 0 then - .ret ⟨ n.val % m.val, by - have h1: ↑m.val < USize.size := m.val.isLt - have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h - apply Nat.lt_trans h2 h1 - ⟩ - else - .fail integerOverflow - -def USize.checked_mul (n: USize) (m: USize): Result USize := - if h: n.val * m.val < USize.size then - .ret ⟨ n.val * m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_div (n: USize) (m: USize): Result USize := - if m > 0 then - .ret ⟨ n.val / m.val, by - have h1: ↑n.val < USize.size := n.val.isLt - have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val - apply Nat.lt_of_le_of_lt h2 h1 - ⟩ - else - .fail integerOverflow - --- Test behavior... -#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 - -#eval USize.checked_sub 20 10 --- NOTE: compare with concrete behavior here, which I do not think we want -#eval USize.sub 0 1 -#eval UInt8.add 255 255 - --- We now define a type class that subsumes the various machine integer types, so --- as to write a concise definition for scalar_cast, rather than exhaustively --- enumerating all of the possible pairs. We remark that Rust has sane semantics --- and fails if a cast operation would involve a truncation or modulo. - -class MachineInteger (t: Type) where - size: Nat - val: t -> Fin size - ofNatCore: (n:Nat) -> LT.lt n size -> t - -set_option hygiene false in -run_cmd - for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do - Lean.Elab.Command.elabCommand (← `( - namespace $typeName - instance: MachineInteger $typeName where - size := size - val := val - ofNatCore := ofNatCore - end $typeName - )) - --- Aeneas only instantiates the destination type (`src` is implicit). We rely on --- Lean to infer `src`. - -def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := - if h: MachineInteger.val x < MachineInteger.size dst then - .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) - else - .fail integerOverflow - -------------- --- VECTORS -- -------------- - --- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) --- rather than maximum values (usize_max). -def Vec (α : Type u) := { l : List α // List.length l < USize.size } - -def vec_new (α : Type u): Vec α := ⟨ [], by { - match USize.size, usize_size_eq with - | _, Or.inl rfl => simp - | _, Or.inr rfl => simp - } ⟩ - -#check vec_new - -def vec_len (α : Type u) (v : Vec α) : USize := - let ⟨ v, l ⟩ := v - USize.ofNatCore (List.length v) l - -#eval vec_len Nat (vec_new Nat) - -def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () - --- NOTE: old version trying to use a subtype notation, but probably better to --- leave Result elimination to auxiliary lemmas with suitable preconditions --- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one --- make the proof work in that case? Probably need to import tactics from --- mathlib to deal with inequalities... would love to see an example. -def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // - match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} - := - if h : List.length v.val + 1 < USize.size then - ⟨ return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩, by simp ⟩ - else - ⟨ fail maximumSizeExceeded, by simp ⟩ - -#eval do - -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with - -- fields val and property. However, Lean's elaborator can automatically - -- select the `val` field if the context provides a type annotation. We - -- annotate `x`, which relieves us of having to write `.val` on the right-hand - -- side of the monadic let. - let v := vec_new Nat - let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? - -- TODO: strengthen post-condition above and do a demo to show that we can - -- safely eliminate the `fail` case - return (vec_len Nat x) - -def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) - := - if h : List.length v.val + 1 <= 4294967295 then - return ⟨ List.concat v.val x, - by - rw [List.length_concat] - have h': 4294967295 < USize.size := by intlit - apply Nat.lt_of_le_of_lt h h' - ⟩ - else if h: List.length v.val + 1 < USize.size then - return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩ - else - fail maximumSizeExceeded - -def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - -def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - ----------- --- MISC -- ----------- - -def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := - x - -def mem_replace_back (a : Type) (_ : a) (y : a) : a := - y - -/-- Aeneas-translated function -- useful to reduce non-recursive definitions. - Use with `simp [ aeneas ]` -/ -register_simp_attr aeneas - --------------------- --- ASSERT COMMAND -- --------------------- - -open Lean Elab Command Term Meta - -syntax (name := assert) "#assert" term: command - -@[command_elab assert] -unsafe -def assertImpl : CommandElab := fun (_stx: Syntax) => do - runTermElabM (fun _ => do - let r ← evalTerm Bool (mkConst ``Bool) _stx[1] - if not r then - logInfo "Assertion failed for: " - logInfo _stx[1] - logError "Expression reduced to false" - pure ()) - -#eval 2 == 2 -#assert (2 == 2) - -------------------- --- SANITY CHECKS -- -------------------- - --- TODO: add more once we have signed integers - -#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc/constants/Constants.lean b/tests/lean/misc/constants/Constants.lean deleted file mode 100644 index 57f6e403..00000000 --- a/tests/lean/misc/constants/Constants.lean +++ /dev/null @@ -1,141 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [constants] -import Base.Primitives - -structure OpaqueDefs where - - /- [constants::X0] -/ - def x0_body : Result UInt32 := Result.ret (UInt32.ofNatCore 0 (by intlit)) - def x0_c : UInt32 := eval_global x0_body (by simp) - - /- [core::num::u32::{9}::MAX] -/ - def core_num_u32_max_body : Result UInt32 := - Result.ret (UInt32.ofNatCore 4294967295 (by intlit)) - def core_num_u32_max_c : UInt32 := - eval_global core_num_u32_max_body (by simp) - - /- [constants::X1] -/ - def x1_body : Result UInt32 := Result.ret core_num_u32_max_c - def x1_c : UInt32 := eval_global x1_body (by simp) - - /- [constants::X2] -/ - def x2_body : Result UInt32 := Result.ret (UInt32.ofNatCore 3 (by intlit)) - def x2_c : UInt32 := eval_global x2_body (by simp) - - /- [constants::incr] -/ - def incr_fwd (n : UInt32) : Result UInt32 := - UInt32.checked_add n (UInt32.ofNatCore 1 (by intlit)) - - /- [constants::X3] -/ - def x3_body : Result UInt32 := incr_fwd (UInt32.ofNatCore 32 (by intlit)) - def x3_c : UInt32 := eval_global x3_body (by simp) - - /- [constants::mk_pair0] -/ - def mk_pair0_fwd (x : UInt32) (y : UInt32) : Result (UInt32 × UInt32) := - Result.ret (x, y) - - /- [constants::Pair] -/ - structure pair_t (T1 T2 : Type) where pair_x : T1 pair_y : T2 - - /- [constants::mk_pair1] -/ - def mk_pair1_fwd (x : UInt32) (y : UInt32) : Result (pair_t UInt32 UInt32) := - Result.ret { pair_x := x, pair_y := y } - - /- [constants::P0] -/ - def p0_body : Result (UInt32 × UInt32) := - mk_pair0_fwd (UInt32.ofNatCore 0 (by intlit)) - (UInt32.ofNatCore 1 (by intlit)) - def p0_c : (UInt32 × UInt32) := eval_global p0_body (by simp) - - /- [constants::P1] -/ - def p1_body : Result (pair_t UInt32 UInt32) := - mk_pair1_fwd (UInt32.ofNatCore 0 (by intlit)) - (UInt32.ofNatCore 1 (by intlit)) - def p1_c : pair_t UInt32 UInt32 := eval_global p1_body (by simp) - - /- [constants::P2] -/ - def p2_body : Result (UInt32 × UInt32) := - Result.ret - ((UInt32.ofNatCore 0 (by intlit)), - (UInt32.ofNatCore 1 (by intlit))) - def p2_c : (UInt32 × UInt32) := eval_global p2_body (by simp) - - /- [constants::P3] -/ - def p3_body : Result (pair_t UInt32 UInt32) := - Result.ret - { - pair_x := (UInt32.ofNatCore 0 (by intlit)), - pair_y := (UInt32.ofNatCore 1 (by intlit)) - } - def p3_c : pair_t UInt32 UInt32 := eval_global p3_body (by simp) - - /- [constants::Wrap] -/ - structure wrap_t (T : Type) where wrap_val : T - - /- [constants::Wrap::{0}::new] -/ - def wrap_new_fwd (T : Type) (val : T) : Result (wrap_t T) := - Result.ret { wrap_val := val } - - /- [constants::Y] -/ - def y_body : Result (wrap_t Int32) := - wrap_new_fwd Int32 (Int32.ofNatCore 2 (by intlit)) - def y_c : wrap_t Int32 := eval_global y_body (by simp) - - /- [constants::unwrap_y] -/ - def unwrap_y_fwd : Result Int32 := - Result.ret y_c.wrap_val - - /- [constants::YVAL] -/ - def yval_body : Result Int32 := unwrap_y_fwd - def yval_c : Int32 := eval_global yval_body (by simp) - - /- [constants::get_z1::Z1] -/ - def get_z1_z1_body : Result Int32 := - Result.ret (Int32.ofNatCore 3 (by intlit)) - def get_z1_z1_c : Int32 := eval_global get_z1_z1_body (by simp) - - /- [constants::get_z1] -/ - def get_z1_fwd : Result Int32 := - Result.ret get_z1_z1_c - - /- [constants::add] -/ - def add_fwd (a : Int32) (b : Int32) : Result Int32 := - Int32.checked_add a b - - /- [constants::Q1] -/ - def q1_body : Result Int32 := Result.ret (Int32.ofNatCore 5 (by intlit)) - def q1_c : Int32 := eval_global q1_body (by simp) - - /- [constants::Q2] -/ - def q2_body : Result Int32 := Result.ret q1_c - def q2_c : Int32 := eval_global q2_body (by simp) - - /- [constants::Q3] -/ - def q3_body : Result Int32 := add_fwd q2_c (Int32.ofNatCore 3 (by intlit)) - def q3_c : Int32 := eval_global q3_body (by simp) - - /- [constants::get_z2] -/ - def get_z2_fwd : Result Int32 := - do - let i ← get_z1_fwd - let i0 ← add_fwd i q3_c - add_fwd q1_c i0 - - /- [constants::S1] -/ - def s1_body : Result UInt32 := Result.ret (UInt32.ofNatCore 6 (by intlit)) - def s1_c : UInt32 := eval_global s1_body (by simp) - - /- [constants::S2] -/ - def s2_body : Result UInt32 := incr_fwd s1_c - def s2_c : UInt32 := eval_global s2_body (by simp) - - /- [constants::S3] -/ - def s3_body : Result (pair_t UInt32 UInt32) := Result.ret p3_c - def s3_c : pair_t UInt32 UInt32 := eval_global s3_body (by simp) - - /- [constants::S4] -/ - def s4_body : Result (pair_t UInt32 UInt32) := - mk_pair1_fwd (UInt32.ofNatCore 7 (by intlit)) - (UInt32.ofNatCore 8 (by intlit)) - def s4_c : pair_t UInt32 UInt32 := eval_global s4_body (by simp) - diff --git a/tests/lean/misc/constants/lakefile.lean b/tests/lean/misc/constants/lakefile.lean deleted file mode 100644 index ed8eebc2..00000000 --- a/tests/lean/misc/constants/lakefile.lean +++ /dev/null @@ -1,18 +0,0 @@ -import Lake -open Lake DSL - -require mathlib from git - "https://github.com/leanprover-community/mathlib4.git" - -package «constants» { - -- add package configuration options here -} - -lean_lib «Base» { - -- add library configuration options here -} - -lean_lib «Constants» { - -- add library configuration options here -} - diff --git a/tests/lean/misc/external/Base/Primitives.lean b/tests/lean/misc/external/Base/Primitives.lean deleted file mode 100644 index 5b64e908..00000000 --- a/tests/lean/misc/external/Base/Primitives.lean +++ /dev/null @@ -1,392 +0,0 @@ -import Lean -import Lean.Meta.Tactic.Simp -import Init.Data.List.Basic -import Mathlib.Tactic.RunCmd - -------------- --- PRELUDE -- -------------- - --- Results & monadic combinators - -inductive Error where - | assertionFailure: Error - | integerOverflow: Error - | arrayOutOfBounds: Error - | maximumSizeExceeded: Error - | panic: Error -deriving Repr, BEq - -open Error - -inductive Result (α : Type u) where - | ret (v: α): Result α - | fail (e: Error): Result α -deriving Repr, BEq - -open Result - -/- HELPERS -/ - -def ret? {α: Type} (r: Result α): Bool := - match r with - | Result.ret _ => true - | Result.fail _ => false - -def massert (b:Bool) : Result Unit := - if b then .ret () else fail assertionFailure - -def eval_global {α: Type} (x: Result α) (_: ret? x): α := - match x with - | Result.fail _ => by contradiction - | Result.ret x => x - -/- DO-DSL SUPPORT -/ - -def bind (x: Result α) (f: α -> Result β) : Result β := - match x with - | ret v => f v - | fail v => fail v - --- Allows using Result in do-blocks -instance : Bind Result where - bind := bind - --- Allows using return x in do-blocks -instance : Pure Result where - pure := fun x => ret x - -/- CUSTOM-DSL SUPPORT -/ - --- Let-binding the Result of a monadic operation is oftentimes not sufficient, --- because we may need a hypothesis for equational reasoning in the scope. We --- rely on subtype, and a custom let-binding operator, in effect recreating our --- own variant of the do-dsl - -def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := - match o with - | .ret x => .ret ⟨x, rfl⟩ - | .fail e => .fail e - -macro "let" e:term " ⟵ " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- TODO: any way to factorize both definitions? -macro "let" e:term " <-- " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- We call the hypothesis `h`, in effect making it unavailable to the user --- (because too much shadowing). But in practice, once can use the French single --- quote notation (input with f< and f>), where `‹ h ›` finds a suitable --- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` -#eval do - let y <-- .ret (0: Nat) - let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide - let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ - .ret r - ----------------------- --- MACHINE INTEGERS -- ----------------------- - --- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., --- USize. They are generally defined in an idiomatic style, except that there is --- not a single type class to rule them all (more on that below). The absence of --- type class is intentional, and allows the Lean compiler to efficiently map --- them to machine integers during compilation. - --- USize is designed properly: you cannot reduce `getNumBits` using the --- simplifier, meaning that proofs do not depend on the compile-time value of --- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really --- support, at least officially, 16-bit microcontrollers, so this seems like a --- fine design decision for now.) - --- Note from Chris Bailey: "If there's more than one salient property of your --- definition then the subtyping strategy might get messy, and the property part --- of a subtype is less discoverable by the simplifier or tactics like --- library_search." So, we will not add refinements on the return values of the --- operations defined on Primitives, but will rather rely on custom lemmas to --- invert on possible return values of the primitive operations. - --- Machine integer constants, done via `ofNatCore`, which requires a proof that --- the `Nat` fits within the desired integer type. We provide a custom tactic. - -syntax "intlit" : tactic - -macro_rules - | `(tactic| intlit) => `(tactic| - match USize.size, usize_size_eq with - | _, Or.inl rfl => decide - | _, Or.inr rfl => decide) - --- This is how the macro is expected to be used -#eval USize.ofNatCore 0 (by intlit) - --- Also works for other integer types (at the expense of a needless disjunction) -#eval UInt32.ofNatCore 0 (by intlit) - --- The machine integer operations (e.g. sub) are always total, which is not what --- we want. We therefore define "checked" variants, below. Note that we add a --- tiny bit of complexity for the USize variant: we first check whether the --- result is < 2^32; if it is, we can compute the definition, rather than --- returning a term that is computationally stuck (the comparison to USize.size --- cannot reduce at compile-time, per the remark about regarding `getNumBits`). --- This is useful for the various #asserts that we want to reduce at --- type-checking time. - --- Further thoughts: look at what has been done here: --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean --- and --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean --- which both contain a fair amount of reasoning already! -def USize.checked_sub (n: USize) (m: USize): Result USize := - -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? - if n >= m then - let n' := USize.toNat n - let m' := USize.toNat n - let r := USize.ofNatCore (n' - m') (by - have h: n' - m' <= n' := by - apply Nat.sub_le_of_le_add - case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left - apply Nat.lt_of_le_of_lt h - apply n.val.isLt - ) - return r - else - fail integerOverflow - -@[simp] -theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := - match USize.size, usize_size_eq with - | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) - | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) - -def USize.checked_add (n: USize) (m: USize): Result USize := - if h: n.val + m.val < USize.size then - .ret ⟨ n.val + m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_rem (n: USize) (m: USize): Result USize := - if h: m > 0 then - .ret ⟨ n.val % m.val, by - have h1: ↑m.val < USize.size := m.val.isLt - have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h - apply Nat.lt_trans h2 h1 - ⟩ - else - .fail integerOverflow - -def USize.checked_mul (n: USize) (m: USize): Result USize := - if h: n.val * m.val < USize.size then - .ret ⟨ n.val * m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_div (n: USize) (m: USize): Result USize := - if m > 0 then - .ret ⟨ n.val / m.val, by - have h1: ↑n.val < USize.size := n.val.isLt - have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val - apply Nat.lt_of_le_of_lt h2 h1 - ⟩ - else - .fail integerOverflow - --- Test behavior... -#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 - -#eval USize.checked_sub 20 10 --- NOTE: compare with concrete behavior here, which I do not think we want -#eval USize.sub 0 1 -#eval UInt8.add 255 255 - --- We now define a type class that subsumes the various machine integer types, so --- as to write a concise definition for scalar_cast, rather than exhaustively --- enumerating all of the possible pairs. We remark that Rust has sane semantics --- and fails if a cast operation would involve a truncation or modulo. - -class MachineInteger (t: Type) where - size: Nat - val: t -> Fin size - ofNatCore: (n:Nat) -> LT.lt n size -> t - -set_option hygiene false in -run_cmd - for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do - Lean.Elab.Command.elabCommand (← `( - namespace $typeName - instance: MachineInteger $typeName where - size := size - val := val - ofNatCore := ofNatCore - end $typeName - )) - --- Aeneas only instantiates the destination type (`src` is implicit). We rely on --- Lean to infer `src`. - -def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := - if h: MachineInteger.val x < MachineInteger.size dst then - .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) - else - .fail integerOverflow - -------------- --- VECTORS -- -------------- - --- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) --- rather than maximum values (usize_max). -def Vec (α : Type u) := { l : List α // List.length l < USize.size } - -def vec_new (α : Type u): Vec α := ⟨ [], by { - match USize.size, usize_size_eq with - | _, Or.inl rfl => simp - | _, Or.inr rfl => simp - } ⟩ - -#check vec_new - -def vec_len (α : Type u) (v : Vec α) : USize := - let ⟨ v, l ⟩ := v - USize.ofNatCore (List.length v) l - -#eval vec_len Nat (vec_new Nat) - -def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () - --- NOTE: old version trying to use a subtype notation, but probably better to --- leave Result elimination to auxiliary lemmas with suitable preconditions --- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one --- make the proof work in that case? Probably need to import tactics from --- mathlib to deal with inequalities... would love to see an example. -def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // - match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} - := - if h : List.length v.val + 1 < USize.size then - ⟨ return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩, by simp ⟩ - else - ⟨ fail maximumSizeExceeded, by simp ⟩ - -#eval do - -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with - -- fields val and property. However, Lean's elaborator can automatically - -- select the `val` field if the context provides a type annotation. We - -- annotate `x`, which relieves us of having to write `.val` on the right-hand - -- side of the monadic let. - let v := vec_new Nat - let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? - -- TODO: strengthen post-condition above and do a demo to show that we can - -- safely eliminate the `fail` case - return (vec_len Nat x) - -def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) - := - if h : List.length v.val + 1 <= 4294967295 then - return ⟨ List.concat v.val x, - by - rw [List.length_concat] - have h': 4294967295 < USize.size := by intlit - apply Nat.lt_of_le_of_lt h h' - ⟩ - else if h: List.length v.val + 1 < USize.size then - return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩ - else - fail maximumSizeExceeded - -def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - -def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - ----------- --- MISC -- ----------- - -def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := - x - -def mem_replace_back (a : Type) (_ : a) (y : a) : a := - y - -/-- Aeneas-translated function -- useful to reduce non-recursive definitions. - Use with `simp [ aeneas ]` -/ -register_simp_attr aeneas - --------------------- --- ASSERT COMMAND -- --------------------- - -open Lean Elab Command Term Meta - -syntax (name := assert) "#assert" term: command - -@[command_elab assert] -unsafe -def assertImpl : CommandElab := fun (_stx: Syntax) => do - runTermElabM (fun _ => do - let r ← evalTerm Bool (mkConst ``Bool) _stx[1] - if not r then - logInfo "Assertion failed for: " - logInfo _stx[1] - logError "Expression reduced to false" - pure ()) - -#eval 2 == 2 -#assert (2 == 2) - -------------------- --- SANITY CHECKS -- -------------------- - --- TODO: add more once we have signed integers - -#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc/external/External/Funs.lean b/tests/lean/misc/external/External/Funs.lean deleted file mode 100644 index 4e1f36a1..00000000 --- a/tests/lean/misc/external/External/Funs.lean +++ /dev/null @@ -1,93 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [external]: function definitions -import Base.Primitives -import External.Types -import External.Opaque - -section variable (opaque_defs: OpaqueDefs) - -/- [external::swap] -/ -def swap_fwd - (T : Type) (x : T) (y : T) (st : State) : Result (State × Unit) := - do - let (st0, _) ← opaque_defs.core_mem_swap_fwd T x y st - let (st1, _) ← opaque_defs.core_mem_swap_back0 T x y st st0 - let (st2, _) ← opaque_defs.core_mem_swap_back1 T x y st st1 - Result.ret (st2, ()) - -/- [external::swap] -/ -def swap_back - (T : Type) (x : T) (y : T) (st : State) (st0 : State) : - Result (State × (T × T)) - := - do - let (st1, _) ← opaque_defs.core_mem_swap_fwd T x y st - let (st2, x0) ← opaque_defs.core_mem_swap_back0 T x y st st1 - let (_, y0) ← opaque_defs.core_mem_swap_back1 T x y st st2 - Result.ret (st0, (x0, y0)) - -/- [external::test_new_non_zero_u32] -/ -def test_new_non_zero_u32_fwd - (x : UInt32) (st : State) : - Result (State × core_num_nonzero_non_zero_u32_t) - := - do - let (st0, opt) ← opaque_defs.core_num_nonzero_non_zero_u32_new_fwd x st - opaque_defs.core_option_option_unwrap_fwd core_num_nonzero_non_zero_u32_t - opt st0 - -/- [external::test_vec] -/ -def test_vec_fwd : Result Unit := - do - let v := vec_new UInt32 - let _ ← vec_push_back UInt32 v (UInt32.ofNatCore 0 (by intlit)) - Result.ret () - -/- Unit test for [external::test_vec] -/ -#assert (test_vec_fwd == .ret ()) - -/- [external::custom_swap] -/ -def custom_swap_fwd - (T : Type) (x : T) (y : T) (st : State) : Result (State × T) := - do - let (st0, _) ← opaque_defs.core_mem_swap_fwd T x y st - let (st1, x0) ← opaque_defs.core_mem_swap_back0 T x y st st0 - let (st2, _) ← opaque_defs.core_mem_swap_back1 T x y st st1 - Result.ret (st2, x0) - -/- [external::custom_swap] -/ -def custom_swap_back - (T : Type) (x : T) (y : T) (st : State) (ret0 : T) (st0 : State) : - Result (State × (T × T)) - := - do - let (st1, _) ← opaque_defs.core_mem_swap_fwd T x y st - let (st2, _) ← opaque_defs.core_mem_swap_back0 T x y st st1 - let (_, y0) ← opaque_defs.core_mem_swap_back1 T x y st st2 - Result.ret (st0, (ret0, y0)) - -/- [external::test_custom_swap] -/ -def test_custom_swap_fwd - (x : UInt32) (y : UInt32) (st : State) : Result (State × Unit) := - do - let (st0, _) ← custom_swap_fwd UInt32 x y st - Result.ret (st0, ()) - -/- [external::test_custom_swap] -/ -def test_custom_swap_back - (x : UInt32) (y : UInt32) (st : State) (st0 : State) : - Result (State × (UInt32 × UInt32)) - := - custom_swap_back UInt32 x y st (UInt32.ofNatCore 1 (by intlit)) st0 - -/- [external::test_swap_non_zero] -/ -def test_swap_non_zero_fwd - (x : UInt32) (st : State) : Result (State × UInt32) := - do - let (st0, _) ← swap_fwd UInt32 x (UInt32.ofNatCore 0 (by intlit)) st - let (st1, (x0, _)) ← - swap_back UInt32 x (UInt32.ofNatCore 0 (by intlit)) st st0 - if h: x0 = (UInt32.ofNatCore 0 (by intlit)) - then Result.fail Error.panic - else Result.ret (st1, x0) - diff --git a/tests/lean/misc/external/External/Opaque.lean b/tests/lean/misc/external/External/Opaque.lean deleted file mode 100644 index d3582de3..00000000 --- a/tests/lean/misc/external/External/Opaque.lean +++ /dev/null @@ -1,28 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [external]: opaque function definitions -import Base.Primitives -import External.Types - -structure OpaqueDefs where - - /- [core::mem::swap] -/ - core_mem_swap_fwd (T : Type) : T -> T -> State -> Result (State × Unit) - - /- [core::mem::swap] -/ - core_mem_swap_back0 - (T : Type) : T -> T -> State -> State -> Result (State × T) - - /- [core::mem::swap] -/ - core_mem_swap_back1 - (T : Type) : T -> T -> State -> State -> Result (State × T) - - /- [core::num::nonzero::NonZeroU32::{14}::new] -/ - core_num_nonzero_non_zero_u32_new_fwd - : - UInt32 -> State -> Result (State × (Option - core_num_nonzero_non_zero_u32_t)) - - /- [core::option::Option::{0}::unwrap] -/ - core_option_option_unwrap_fwd - (T : Type) : Option T -> State -> Result (State × T) - diff --git a/tests/lean/misc/external/External/Types.lean b/tests/lean/misc/external/External/Types.lean deleted file mode 100644 index 386832f4..00000000 --- a/tests/lean/misc/external/External/Types.lean +++ /dev/null @@ -1,8 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [external]: type definitions -import Base.Primitives - -/- [core::num::nonzero::NonZeroU32] -/ -axiom core_num_nonzero_non_zero_u32_t : Type -/- The state type used in the state-error monad -/ axiom State : Type - diff --git a/tests/lean/misc/external/lakefile.lean b/tests/lean/misc/external/lakefile.lean deleted file mode 100644 index b883f4b9..00000000 --- a/tests/lean/misc/external/lakefile.lean +++ /dev/null @@ -1,18 +0,0 @@ -import Lake -open Lake DSL - -require mathlib from git - "https://github.com/leanprover-community/mathlib4.git" - -package «external» { - -- add package configuration options here -} - -lean_lib «Base» { - -- add library configuration options here -} - -lean_lib «External» { - -- add library configuration options here -} - diff --git a/tests/lean/misc/loops/Base/Primitives.lean b/tests/lean/misc/loops/Base/Primitives.lean deleted file mode 100644 index 5b64e908..00000000 --- a/tests/lean/misc/loops/Base/Primitives.lean +++ /dev/null @@ -1,392 +0,0 @@ -import Lean -import Lean.Meta.Tactic.Simp -import Init.Data.List.Basic -import Mathlib.Tactic.RunCmd - -------------- --- PRELUDE -- -------------- - --- Results & monadic combinators - -inductive Error where - | assertionFailure: Error - | integerOverflow: Error - | arrayOutOfBounds: Error - | maximumSizeExceeded: Error - | panic: Error -deriving Repr, BEq - -open Error - -inductive Result (α : Type u) where - | ret (v: α): Result α - | fail (e: Error): Result α -deriving Repr, BEq - -open Result - -/- HELPERS -/ - -def ret? {α: Type} (r: Result α): Bool := - match r with - | Result.ret _ => true - | Result.fail _ => false - -def massert (b:Bool) : Result Unit := - if b then .ret () else fail assertionFailure - -def eval_global {α: Type} (x: Result α) (_: ret? x): α := - match x with - | Result.fail _ => by contradiction - | Result.ret x => x - -/- DO-DSL SUPPORT -/ - -def bind (x: Result α) (f: α -> Result β) : Result β := - match x with - | ret v => f v - | fail v => fail v - --- Allows using Result in do-blocks -instance : Bind Result where - bind := bind - --- Allows using return x in do-blocks -instance : Pure Result where - pure := fun x => ret x - -/- CUSTOM-DSL SUPPORT -/ - --- Let-binding the Result of a monadic operation is oftentimes not sufficient, --- because we may need a hypothesis for equational reasoning in the scope. We --- rely on subtype, and a custom let-binding operator, in effect recreating our --- own variant of the do-dsl - -def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := - match o with - | .ret x => .ret ⟨x, rfl⟩ - | .fail e => .fail e - -macro "let" e:term " ⟵ " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- TODO: any way to factorize both definitions? -macro "let" e:term " <-- " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- We call the hypothesis `h`, in effect making it unavailable to the user --- (because too much shadowing). But in practice, once can use the French single --- quote notation (input with f< and f>), where `‹ h ›` finds a suitable --- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` -#eval do - let y <-- .ret (0: Nat) - let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide - let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ - .ret r - ----------------------- --- MACHINE INTEGERS -- ----------------------- - --- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., --- USize. They are generally defined in an idiomatic style, except that there is --- not a single type class to rule them all (more on that below). The absence of --- type class is intentional, and allows the Lean compiler to efficiently map --- them to machine integers during compilation. - --- USize is designed properly: you cannot reduce `getNumBits` using the --- simplifier, meaning that proofs do not depend on the compile-time value of --- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really --- support, at least officially, 16-bit microcontrollers, so this seems like a --- fine design decision for now.) - --- Note from Chris Bailey: "If there's more than one salient property of your --- definition then the subtyping strategy might get messy, and the property part --- of a subtype is less discoverable by the simplifier or tactics like --- library_search." So, we will not add refinements on the return values of the --- operations defined on Primitives, but will rather rely on custom lemmas to --- invert on possible return values of the primitive operations. - --- Machine integer constants, done via `ofNatCore`, which requires a proof that --- the `Nat` fits within the desired integer type. We provide a custom tactic. - -syntax "intlit" : tactic - -macro_rules - | `(tactic| intlit) => `(tactic| - match USize.size, usize_size_eq with - | _, Or.inl rfl => decide - | _, Or.inr rfl => decide) - --- This is how the macro is expected to be used -#eval USize.ofNatCore 0 (by intlit) - --- Also works for other integer types (at the expense of a needless disjunction) -#eval UInt32.ofNatCore 0 (by intlit) - --- The machine integer operations (e.g. sub) are always total, which is not what --- we want. We therefore define "checked" variants, below. Note that we add a --- tiny bit of complexity for the USize variant: we first check whether the --- result is < 2^32; if it is, we can compute the definition, rather than --- returning a term that is computationally stuck (the comparison to USize.size --- cannot reduce at compile-time, per the remark about regarding `getNumBits`). --- This is useful for the various #asserts that we want to reduce at --- type-checking time. - --- Further thoughts: look at what has been done here: --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean --- and --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean --- which both contain a fair amount of reasoning already! -def USize.checked_sub (n: USize) (m: USize): Result USize := - -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? - if n >= m then - let n' := USize.toNat n - let m' := USize.toNat n - let r := USize.ofNatCore (n' - m') (by - have h: n' - m' <= n' := by - apply Nat.sub_le_of_le_add - case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left - apply Nat.lt_of_le_of_lt h - apply n.val.isLt - ) - return r - else - fail integerOverflow - -@[simp] -theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := - match USize.size, usize_size_eq with - | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) - | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) - -def USize.checked_add (n: USize) (m: USize): Result USize := - if h: n.val + m.val < USize.size then - .ret ⟨ n.val + m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_rem (n: USize) (m: USize): Result USize := - if h: m > 0 then - .ret ⟨ n.val % m.val, by - have h1: ↑m.val < USize.size := m.val.isLt - have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h - apply Nat.lt_trans h2 h1 - ⟩ - else - .fail integerOverflow - -def USize.checked_mul (n: USize) (m: USize): Result USize := - if h: n.val * m.val < USize.size then - .ret ⟨ n.val * m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_div (n: USize) (m: USize): Result USize := - if m > 0 then - .ret ⟨ n.val / m.val, by - have h1: ↑n.val < USize.size := n.val.isLt - have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val - apply Nat.lt_of_le_of_lt h2 h1 - ⟩ - else - .fail integerOverflow - --- Test behavior... -#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 - -#eval USize.checked_sub 20 10 --- NOTE: compare with concrete behavior here, which I do not think we want -#eval USize.sub 0 1 -#eval UInt8.add 255 255 - --- We now define a type class that subsumes the various machine integer types, so --- as to write a concise definition for scalar_cast, rather than exhaustively --- enumerating all of the possible pairs. We remark that Rust has sane semantics --- and fails if a cast operation would involve a truncation or modulo. - -class MachineInteger (t: Type) where - size: Nat - val: t -> Fin size - ofNatCore: (n:Nat) -> LT.lt n size -> t - -set_option hygiene false in -run_cmd - for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do - Lean.Elab.Command.elabCommand (← `( - namespace $typeName - instance: MachineInteger $typeName where - size := size - val := val - ofNatCore := ofNatCore - end $typeName - )) - --- Aeneas only instantiates the destination type (`src` is implicit). We rely on --- Lean to infer `src`. - -def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := - if h: MachineInteger.val x < MachineInteger.size dst then - .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) - else - .fail integerOverflow - -------------- --- VECTORS -- -------------- - --- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) --- rather than maximum values (usize_max). -def Vec (α : Type u) := { l : List α // List.length l < USize.size } - -def vec_new (α : Type u): Vec α := ⟨ [], by { - match USize.size, usize_size_eq with - | _, Or.inl rfl => simp - | _, Or.inr rfl => simp - } ⟩ - -#check vec_new - -def vec_len (α : Type u) (v : Vec α) : USize := - let ⟨ v, l ⟩ := v - USize.ofNatCore (List.length v) l - -#eval vec_len Nat (vec_new Nat) - -def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () - --- NOTE: old version trying to use a subtype notation, but probably better to --- leave Result elimination to auxiliary lemmas with suitable preconditions --- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one --- make the proof work in that case? Probably need to import tactics from --- mathlib to deal with inequalities... would love to see an example. -def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // - match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} - := - if h : List.length v.val + 1 < USize.size then - ⟨ return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩, by simp ⟩ - else - ⟨ fail maximumSizeExceeded, by simp ⟩ - -#eval do - -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with - -- fields val and property. However, Lean's elaborator can automatically - -- select the `val` field if the context provides a type annotation. We - -- annotate `x`, which relieves us of having to write `.val` on the right-hand - -- side of the monadic let. - let v := vec_new Nat - let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? - -- TODO: strengthen post-condition above and do a demo to show that we can - -- safely eliminate the `fail` case - return (vec_len Nat x) - -def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) - := - if h : List.length v.val + 1 <= 4294967295 then - return ⟨ List.concat v.val x, - by - rw [List.length_concat] - have h': 4294967295 < USize.size := by intlit - apply Nat.lt_of_le_of_lt h h' - ⟩ - else if h: List.length v.val + 1 < USize.size then - return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩ - else - fail maximumSizeExceeded - -def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - -def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - ----------- --- MISC -- ----------- - -def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := - x - -def mem_replace_back (a : Type) (_ : a) (y : a) : a := - y - -/-- Aeneas-translated function -- useful to reduce non-recursive definitions. - Use with `simp [ aeneas ]` -/ -register_simp_attr aeneas - --------------------- --- ASSERT COMMAND -- --------------------- - -open Lean Elab Command Term Meta - -syntax (name := assert) "#assert" term: command - -@[command_elab assert] -unsafe -def assertImpl : CommandElab := fun (_stx: Syntax) => do - runTermElabM (fun _ => do - let r ← evalTerm Bool (mkConst ``Bool) _stx[1] - if not r then - logInfo "Assertion failed for: " - logInfo _stx[1] - logError "Expression reduced to false" - pure ()) - -#eval 2 == 2 -#assert (2 == 2) - -------------------- --- SANITY CHECKS -- -------------------- - --- TODO: add more once we have signed integers - -#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc/loops/Loops/Clauses/Clauses.lean b/tests/lean/misc/loops/Loops/Clauses/Clauses.lean deleted file mode 100644 index 5ddb65ca..00000000 --- a/tests/lean/misc/loops/Loops/Clauses/Clauses.lean +++ /dev/null @@ -1,209 +0,0 @@ --- [loops]: decreases clauses -import Base.Primitives -import Loops.Types - -/- [loops::sum]: termination measure -/ -@[simp] -def sum_loop_terminates (max : UInt32) (i : UInt32) (s : UInt32) := (max, i, s) - -syntax "sum_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| sum_loop_decreases $max $i $s) =>`(tactic| sorry) - -/- [loops::sum_with_mut_borrows]: termination measure -/ -@[simp] -def sum_with_mut_borrows_loop_terminates (max : UInt32) (mi : UInt32) - (ms : UInt32) := - (max, mi, ms) - -syntax "sum_with_mut_borrows_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| sum_with_mut_borrows_loop_decreases $max $mi $ms) =>`(tactic| sorry) - -/- [loops::sum_with_shared_borrows]: termination measure -/ -@[simp] -def sum_with_shared_borrows_loop_terminates (max : UInt32) (i : UInt32) - (s : UInt32) := - (max, i, s) - -syntax "sum_with_shared_borrows_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| sum_with_shared_borrows_loop_decreases $max $i $s) =>`(tactic| sorry) - -/- [loops::clear]: termination measure -/ -@[simp] def clear_loop_terminates (v : vec UInt32) (i : USize) := (v, i) - -syntax "clear_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| clear_loop_decreases $v $i) =>`(tactic| sorry) - -/- [loops::list_mem]: termination measure -/ -@[simp] -def list_mem_loop_terminates (x : UInt32) (ls : list_t UInt32) := (x, ls) - -syntax "list_mem_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_mem_loop_decreases $x $ls) =>`(tactic| sorry) - -/- [loops::list_nth_mut_loop]: termination measure -/ -@[simp] -def list_nth_mut_loop_loop_terminates (T : Type) (ls : list_t T) (i : UInt32) - := - (ls, i) - -syntax "list_nth_mut_loop_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_mut_loop_loop_decreases $ls $i) =>`(tactic| sorry) - -/- [loops::list_nth_shared_loop]: termination measure -/ -@[simp] -def list_nth_shared_loop_loop_terminates (T : Type) (ls : list_t T) - (i : UInt32) := - (ls, i) - -syntax "list_nth_shared_loop_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_shared_loop_loop_decreases $ls $i) =>`(tactic| sorry) - -/- [loops::get_elem_mut]: termination measure -/ -@[simp] -def get_elem_mut_loop_terminates (x : USize) (ls : list_t USize) := (x, ls) - -syntax "get_elem_mut_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| get_elem_mut_loop_decreases $x $ls) =>`(tactic| sorry) - -/- [loops::get_elem_shared]: termination measure -/ -@[simp] -def get_elem_shared_loop_terminates (x : USize) (ls : list_t USize) := (x, ls) - -syntax "get_elem_shared_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| get_elem_shared_loop_decreases $x $ls) =>`(tactic| sorry) - -/- [loops::list_nth_mut_loop_with_id]: termination measure -/ -@[simp] -def list_nth_mut_loop_with_id_loop_terminates (T : Type) (i : UInt32) - (ls : list_t T) := - (i, ls) - -syntax "list_nth_mut_loop_with_id_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_mut_loop_with_id_loop_decreases $i $ls) =>`(tactic| sorry) - -/- [loops::list_nth_shared_loop_with_id]: termination measure -/ -@[simp] -def list_nth_shared_loop_with_id_loop_terminates (T : Type) (i : UInt32) - (ls : list_t T) := - (i, ls) - -syntax "list_nth_shared_loop_with_id_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_shared_loop_with_id_loop_decreases $i $ls) =>`(tactic| sorry) - -/- [loops::list_nth_mut_loop_pair]: termination measure -/ -@[simp] -def list_nth_mut_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -syntax "list_nth_mut_loop_pair_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_mut_loop_pair_loop_decreases $ls0 $ls1 $i) =>`(tactic| sorry) - -/- [loops::list_nth_shared_loop_pair]: termination measure -/ -@[simp] -def list_nth_shared_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -syntax "list_nth_shared_loop_pair_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_shared_loop_pair_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_mut_loop_pair_merge]: termination measure -/ -@[simp] -def list_nth_mut_loop_pair_merge_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -syntax "list_nth_mut_loop_pair_merge_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_mut_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_shared_loop_pair_merge]: termination measure -/ -@[simp] -def list_nth_shared_loop_pair_merge_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -syntax "list_nth_shared_loop_pair_merge_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_shared_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_mut_shared_loop_pair]: termination measure -/ -@[simp] -def list_nth_mut_shared_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -syntax "list_nth_mut_shared_loop_pair_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_mut_shared_loop_pair_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_mut_shared_loop_pair_merge]: termination measure -/ -@[simp] -def list_nth_mut_shared_loop_pair_merge_loop_terminates (T : Type) - (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -syntax "list_nth_mut_shared_loop_pair_merge_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_mut_shared_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_shared_mut_loop_pair]: termination measure -/ -@[simp] -def list_nth_shared_mut_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -syntax "list_nth_shared_mut_loop_pair_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_shared_mut_loop_pair_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_shared_mut_loop_pair_merge]: termination measure -/ -@[simp] -def list_nth_shared_mut_loop_pair_merge_loop_terminates (T : Type) - (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -syntax "list_nth_shared_mut_loop_pair_merge_loop_decreases" term+ : tactic - -macro_rules -| `(tactic| list_nth_shared_mut_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - diff --git a/tests/lean/misc/loops/Loops/Clauses/Template.lean b/tests/lean/misc/loops/Loops/Clauses/Template.lean deleted file mode 100644 index d1e72d65..00000000 --- a/tests/lean/misc/loops/Loops/Clauses/Template.lean +++ /dev/null @@ -1,210 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [loops]: templates for the decreases clauses -import Base.Primitives -import Loops.Types - -/- [loops::sum]: termination measure -/ -@[simp] -def sum_loop_terminates (max : UInt32) (i : UInt32) (s : UInt32) := (max, i, s) - -/- [loops::sum]: decreases_by tactic -/ -syntax "sum_loop_decreases" term+ : tactic -macro_rules -| `(tactic| sum_loop_decreases $max $i $s) =>`(tactic| sorry) - -/- [loops::sum_with_mut_borrows]: termination measure -/ -@[simp] -def sum_with_mut_borrows_loop_terminates (max : UInt32) (mi : UInt32) - (ms : UInt32) := - (max, mi, ms) - -/- [loops::sum_with_mut_borrows]: decreases_by tactic -/ -syntax "sum_with_mut_borrows_loop_decreases" term+ : tactic -macro_rules -| `(tactic| sum_with_mut_borrows_loop_decreases $max $mi $ms) =>`(tactic| sorry) - -/- [loops::sum_with_shared_borrows]: termination measure -/ -@[simp] -def sum_with_shared_borrows_loop_terminates (max : UInt32) (i : UInt32) - (s : UInt32) := - (max, i, s) - -/- [loops::sum_with_shared_borrows]: decreases_by tactic -/ -syntax "sum_with_shared_borrows_loop_decreases" term+ : tactic -macro_rules -| `(tactic| sum_with_shared_borrows_loop_decreases $max $i $s) =>`(tactic| sorry) - -/- [loops::clear]: termination measure -/ -@[simp] def clear_loop_terminates (v : Vec UInt32) (i : USize) := (v, i) - -/- [loops::clear]: decreases_by tactic -/ -syntax "clear_loop_decreases" term+ : tactic -macro_rules -| `(tactic| clear_loop_decreases $v $i) =>`(tactic| sorry) - -/- [loops::list_mem]: termination measure -/ -@[simp] -def list_mem_loop_terminates (x : UInt32) (ls : list_t UInt32) := (x, ls) - -/- [loops::list_mem]: decreases_by tactic -/ -syntax "list_mem_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_mem_loop_decreases $x $ls) =>`(tactic| sorry) - -/- [loops::list_nth_mut_loop]: termination measure -/ -@[simp] -def list_nth_mut_loop_loop_terminates (T : Type) (ls : list_t T) (i : UInt32) - := - (ls, i) - -/- [loops::list_nth_mut_loop]: decreases_by tactic -/ -syntax "list_nth_mut_loop_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_mut_loop_loop_decreases $ls $i) =>`(tactic| sorry) - -/- [loops::list_nth_shared_loop]: termination measure -/ -@[simp] -def list_nth_shared_loop_loop_terminates (T : Type) (ls : list_t T) - (i : UInt32) := - (ls, i) - -/- [loops::list_nth_shared_loop]: decreases_by tactic -/ -syntax "list_nth_shared_loop_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_shared_loop_loop_decreases $ls $i) =>`(tactic| sorry) - -/- [loops::get_elem_mut]: termination measure -/ -@[simp] -def get_elem_mut_loop_terminates (x : USize) (ls : list_t USize) := (x, ls) - -/- [loops::get_elem_mut]: decreases_by tactic -/ -syntax "get_elem_mut_loop_decreases" term+ : tactic -macro_rules -| `(tactic| get_elem_mut_loop_decreases $x $ls) =>`(tactic| sorry) - -/- [loops::get_elem_shared]: termination measure -/ -@[simp] -def get_elem_shared_loop_terminates (x : USize) (ls : list_t USize) := (x, ls) - -/- [loops::get_elem_shared]: decreases_by tactic -/ -syntax "get_elem_shared_loop_decreases" term+ : tactic -macro_rules -| `(tactic| get_elem_shared_loop_decreases $x $ls) =>`(tactic| sorry) - -/- [loops::list_nth_mut_loop_with_id]: termination measure -/ -@[simp] -def list_nth_mut_loop_with_id_loop_terminates (T : Type) (i : UInt32) - (ls : list_t T) := - (i, ls) - -/- [loops::list_nth_mut_loop_with_id]: decreases_by tactic -/ -syntax "list_nth_mut_loop_with_id_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_mut_loop_with_id_loop_decreases $i $ls) =>`(tactic| sorry) - -/- [loops::list_nth_shared_loop_with_id]: termination measure -/ -@[simp] -def list_nth_shared_loop_with_id_loop_terminates (T : Type) (i : UInt32) - (ls : list_t T) := - (i, ls) - -/- [loops::list_nth_shared_loop_with_id]: decreases_by tactic -/ -syntax "list_nth_shared_loop_with_id_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_shared_loop_with_id_loop_decreases $i $ls) =>`(tactic| sorry) - -/- [loops::list_nth_mut_loop_pair]: termination measure -/ -@[simp] -def list_nth_mut_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -/- [loops::list_nth_mut_loop_pair]: decreases_by tactic -/ -syntax "list_nth_mut_loop_pair_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_mut_loop_pair_loop_decreases $ls0 $ls1 $i) =>`(tactic| sorry) - -/- [loops::list_nth_shared_loop_pair]: termination measure -/ -@[simp] -def list_nth_shared_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -/- [loops::list_nth_shared_loop_pair]: decreases_by tactic -/ -syntax "list_nth_shared_loop_pair_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_shared_loop_pair_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_mut_loop_pair_merge]: termination measure -/ -@[simp] -def list_nth_mut_loop_pair_merge_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -/- [loops::list_nth_mut_loop_pair_merge]: decreases_by tactic -/ -syntax "list_nth_mut_loop_pair_merge_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_mut_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_shared_loop_pair_merge]: termination measure -/ -@[simp] -def list_nth_shared_loop_pair_merge_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -/- [loops::list_nth_shared_loop_pair_merge]: decreases_by tactic -/ -syntax "list_nth_shared_loop_pair_merge_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_shared_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_mut_shared_loop_pair]: termination measure -/ -@[simp] -def list_nth_mut_shared_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -/- [loops::list_nth_mut_shared_loop_pair]: decreases_by tactic -/ -syntax "list_nth_mut_shared_loop_pair_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_mut_shared_loop_pair_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_mut_shared_loop_pair_merge]: termination measure -/ -@[simp] -def list_nth_mut_shared_loop_pair_merge_loop_terminates (T : Type) - (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -/- [loops::list_nth_mut_shared_loop_pair_merge]: decreases_by tactic -/ -syntax "list_nth_mut_shared_loop_pair_merge_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_mut_shared_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_shared_mut_loop_pair]: termination measure -/ -@[simp] -def list_nth_shared_mut_loop_pair_loop_terminates (T : Type) (ls0 : list_t T) - (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -/- [loops::list_nth_shared_mut_loop_pair]: decreases_by tactic -/ -syntax "list_nth_shared_mut_loop_pair_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_shared_mut_loop_pair_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - -/- [loops::list_nth_shared_mut_loop_pair_merge]: termination measure -/ -@[simp] -def list_nth_shared_mut_loop_pair_merge_loop_terminates (T : Type) - (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) := - (ls0, ls1, i) - -/- [loops::list_nth_shared_mut_loop_pair_merge]: decreases_by tactic -/ -syntax "list_nth_shared_mut_loop_pair_merge_loop_decreases" term+ : tactic -macro_rules -| `(tactic| list_nth_shared_mut_loop_pair_merge_loop_decreases $ls0 $ls1 $i) => - `(tactic| sorry) - diff --git a/tests/lean/misc/loops/Loops/Funs.lean b/tests/lean/misc/loops/Loops/Funs.lean deleted file mode 100644 index 5a81ebff..00000000 --- a/tests/lean/misc/loops/Loops/Funs.lean +++ /dev/null @@ -1,740 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [loops]: function definitions -import Base.Primitives -import Loops.Types -import Loops.Clauses.Clauses - -/- [loops::sum] -/ -def sum_loop_fwd (max : UInt32) (i : UInt32) (s : UInt32) : (Result UInt32) := - if h: i < max - then - do - let s0 ← UInt32.checked_add s i - let i0 ← UInt32.checked_add i (UInt32.ofNatCore 1 (by intlit)) - sum_loop_fwd max i0 s0 - else UInt32.checked_mul s (UInt32.ofNatCore 2 (by intlit)) -termination_by sum_loop_fwd max i s => sum_loop_terminates max i s -decreasing_by sum_loop_decreases max i s - -/- [loops::sum] -/ -def sum_fwd (max : UInt32) : Result UInt32 := - sum_loop_fwd max (UInt32.ofNatCore 0 (by intlit)) - (UInt32.ofNatCore 0 (by intlit)) - -/- [loops::sum_with_mut_borrows] -/ -def sum_with_mut_borrows_loop_fwd - (max : UInt32) (mi : UInt32) (ms : UInt32) : (Result UInt32) := - if h: mi < max - then - do - let ms0 ← UInt32.checked_add ms mi - let mi0 ← UInt32.checked_add mi (UInt32.ofNatCore 1 (by intlit)) - sum_with_mut_borrows_loop_fwd max mi0 ms0 - else UInt32.checked_mul ms (UInt32.ofNatCore 2 (by intlit)) -termination_by sum_with_mut_borrows_loop_fwd max mi ms => - sum_with_mut_borrows_loop_terminates max mi ms -decreasing_by sum_with_mut_borrows_loop_decreases max mi ms - -/- [loops::sum_with_mut_borrows] -/ -def sum_with_mut_borrows_fwd (max : UInt32) : Result UInt32 := - sum_with_mut_borrows_loop_fwd max (UInt32.ofNatCore 0 (by intlit)) - (UInt32.ofNatCore 0 (by intlit)) - -/- [loops::sum_with_shared_borrows] -/ -def sum_with_shared_borrows_loop_fwd - (max : UInt32) (i : UInt32) (s : UInt32) : (Result UInt32) := - if h: i < max - then - do - let i0 ← UInt32.checked_add i (UInt32.ofNatCore 1 (by intlit)) - let s0 ← UInt32.checked_add s i0 - sum_with_shared_borrows_loop_fwd max i0 s0 - else UInt32.checked_mul s (UInt32.ofNatCore 2 (by intlit)) -termination_by sum_with_shared_borrows_loop_fwd max i s => - sum_with_shared_borrows_loop_terminates max i s -decreasing_by sum_with_shared_borrows_loop_decreases max i s - -/- [loops::sum_with_shared_borrows] -/ -def sum_with_shared_borrows_fwd (max : UInt32) : Result UInt32 := - sum_with_shared_borrows_loop_fwd max (UInt32.ofNatCore 0 (by intlit)) - (UInt32.ofNatCore 0 (by intlit)) - -/- [loops::clear] -/ -def clear_loop_fwd_back (v : Vec UInt32) (i : USize) : (Result (Vec UInt32)) := - let i0 := vec_len UInt32 v - if h: i < i0 - then - do - let i1 ← USize.checked_add i (USize.ofNatCore 1 (by intlit)) - let v0 ← vec_index_mut_back UInt32 v i (UInt32.ofNatCore 0 (by intlit)) - clear_loop_fwd_back v0 i1 - else Result.ret v -termination_by clear_loop_fwd_back v i => clear_loop_terminates v i -decreasing_by clear_loop_decreases v i - -/- [loops::clear] -/ -def clear_fwd_back (v : Vec UInt32) : Result (Vec UInt32) := - clear_loop_fwd_back v (USize.ofNatCore 0 (by intlit)) - -/- [loops::list_mem] -/ -def list_mem_loop_fwd (x : UInt32) (ls : list_t UInt32) : (Result Bool) := - match h: ls with - | list_t.ListCons y tl => - if h: y = x - then Result.ret true - else list_mem_loop_fwd x tl - | list_t.ListNil => Result.ret false -termination_by list_mem_loop_fwd x ls => list_mem_loop_terminates x ls -decreasing_by list_mem_loop_decreases x ls - -/- [loops::list_mem] -/ -def list_mem_fwd (x : UInt32) (ls : list_t UInt32) : Result Bool := - list_mem_loop_fwd x ls - -/- [loops::list_nth_mut_loop] -/ -def list_nth_mut_loop_loop_fwd - (T : Type) (ls : list_t T) (i : UInt32) : (Result T) := - match h: ls with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret x - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_mut_loop_loop_fwd T tl i0 - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_loop_fwd ls i => - list_nth_mut_loop_loop_terminates T ls i -decreasing_by list_nth_mut_loop_loop_decreases ls i - -/- [loops::list_nth_mut_loop] -/ -def list_nth_mut_loop_fwd (T : Type) (ls : list_t T) (i : UInt32) : Result T := - list_nth_mut_loop_loop_fwd T ls i - -/- [loops::list_nth_mut_loop] -/ -def list_nth_mut_loop_loop_back - (T : Type) (ls : list_t T) (i : UInt32) (ret0 : T) : (Result (list_t T)) := - match h: ls with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl0 ← list_nth_mut_loop_loop_back T tl i0 ret0 - Result.ret (list_t.ListCons x tl0) - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_loop_back ls i ret0 => - list_nth_mut_loop_loop_terminates T ls i -decreasing_by list_nth_mut_loop_loop_decreases ls i - -/- [loops::list_nth_mut_loop] -/ -def list_nth_mut_loop_back - (T : Type) (ls : list_t T) (i : UInt32) (ret0 : T) : Result (list_t T) := - list_nth_mut_loop_loop_back T ls i ret0 - -/- [loops::list_nth_shared_loop] -/ -def list_nth_shared_loop_loop_fwd - (T : Type) (ls : list_t T) (i : UInt32) : (Result T) := - match h: ls with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret x - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_shared_loop_loop_fwd T tl i0 - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_shared_loop_loop_fwd ls i => - list_nth_shared_loop_loop_terminates T ls i -decreasing_by list_nth_shared_loop_loop_decreases ls i - -/- [loops::list_nth_shared_loop] -/ -def list_nth_shared_loop_fwd - (T : Type) (ls : list_t T) (i : UInt32) : Result T := - list_nth_shared_loop_loop_fwd T ls i - -/- [loops::get_elem_mut] -/ -def get_elem_mut_loop_fwd (x : USize) (ls : list_t USize) : (Result USize) := - match h: ls with - | list_t.ListCons y tl => - if h: y = x - then Result.ret y - else get_elem_mut_loop_fwd x tl - | list_t.ListNil => Result.fail Error.panic -termination_by get_elem_mut_loop_fwd x ls => get_elem_mut_loop_terminates x ls -decreasing_by get_elem_mut_loop_decreases x ls - -/- [loops::get_elem_mut] -/ -def get_elem_mut_fwd (slots : Vec (list_t USize)) (x : USize) : Result USize := - do - let l ← - vec_index_mut_fwd (list_t USize) slots (USize.ofNatCore 0 (by intlit)) - get_elem_mut_loop_fwd x l - -/- [loops::get_elem_mut] -/ -def get_elem_mut_loop_back - (x : USize) (ls : list_t USize) (ret0 : USize) : (Result (list_t USize)) := - match h: ls with - | list_t.ListCons y tl => - if h: y = x - then Result.ret (list_t.ListCons ret0 tl) - else - do - let tl0 ← get_elem_mut_loop_back x tl ret0 - Result.ret (list_t.ListCons y tl0) - | list_t.ListNil => Result.fail Error.panic -termination_by get_elem_mut_loop_back x ls ret0 => - get_elem_mut_loop_terminates x ls -decreasing_by get_elem_mut_loop_decreases x ls - -/- [loops::get_elem_mut] -/ -def get_elem_mut_back - (slots : Vec (list_t USize)) (x : USize) (ret0 : USize) : - Result (Vec (list_t USize)) - := - do - let l ← - vec_index_mut_fwd (list_t USize) slots (USize.ofNatCore 0 (by intlit)) - let l0 ← get_elem_mut_loop_back x l ret0 - vec_index_mut_back (list_t USize) slots (USize.ofNatCore 0 (by intlit)) l0 - -/- [loops::get_elem_shared] -/ -def get_elem_shared_loop_fwd - (x : USize) (ls : list_t USize) : (Result USize) := - match h: ls with - | list_t.ListCons y tl => - if h: y = x - then Result.ret y - else get_elem_shared_loop_fwd x tl - | list_t.ListNil => Result.fail Error.panic -termination_by get_elem_shared_loop_fwd x ls => - get_elem_shared_loop_terminates x ls -decreasing_by get_elem_shared_loop_decreases x ls - -/- [loops::get_elem_shared] -/ -def get_elem_shared_fwd - (slots : Vec (list_t USize)) (x : USize) : Result USize := - do - let l ← - vec_index_fwd (list_t USize) slots (USize.ofNatCore 0 (by intlit)) - get_elem_shared_loop_fwd x l - -/- [loops::id_mut] -/ -def id_mut_fwd (T : Type) (ls : list_t T) : Result (list_t T) := - Result.ret ls - -/- [loops::id_mut] -/ -def id_mut_back - (T : Type) (ls : list_t T) (ret0 : list_t T) : Result (list_t T) := - Result.ret ret0 - -/- [loops::id_shared] -/ -def id_shared_fwd (T : Type) (ls : list_t T) : Result (list_t T) := - Result.ret ls - -/- [loops::list_nth_mut_loop_with_id] -/ -def list_nth_mut_loop_with_id_loop_fwd - (T : Type) (i : UInt32) (ls : list_t T) : (Result T) := - match h: ls with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret x - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_mut_loop_with_id_loop_fwd T i0 tl - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_with_id_loop_fwd i ls => - list_nth_mut_loop_with_id_loop_terminates T i ls -decreasing_by list_nth_mut_loop_with_id_loop_decreases i ls - -/- [loops::list_nth_mut_loop_with_id] -/ -def list_nth_mut_loop_with_id_fwd - (T : Type) (ls : list_t T) (i : UInt32) : Result T := - do - let ls0 ← id_mut_fwd T ls - list_nth_mut_loop_with_id_loop_fwd T i ls0 - -/- [loops::list_nth_mut_loop_with_id] -/ -def list_nth_mut_loop_with_id_loop_back - (T : Type) (i : UInt32) (ls : list_t T) (ret0 : T) : (Result (list_t T)) := - match h: ls with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl0 ← list_nth_mut_loop_with_id_loop_back T i0 tl ret0 - Result.ret (list_t.ListCons x tl0) - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_with_id_loop_back i ls ret0 => - list_nth_mut_loop_with_id_loop_terminates T i ls -decreasing_by list_nth_mut_loop_with_id_loop_decreases i ls - -/- [loops::list_nth_mut_loop_with_id] -/ -def list_nth_mut_loop_with_id_back - (T : Type) (ls : list_t T) (i : UInt32) (ret0 : T) : Result (list_t T) := - do - let ls0 ← id_mut_fwd T ls - let l ← list_nth_mut_loop_with_id_loop_back T i ls0 ret0 - id_mut_back T ls l - -/- [loops::list_nth_shared_loop_with_id] -/ -def list_nth_shared_loop_with_id_loop_fwd - (T : Type) (i : UInt32) (ls : list_t T) : (Result T) := - match h: ls with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret x - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_shared_loop_with_id_loop_fwd T i0 tl - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_shared_loop_with_id_loop_fwd i ls => - list_nth_shared_loop_with_id_loop_terminates T i ls -decreasing_by list_nth_shared_loop_with_id_loop_decreases i ls - -/- [loops::list_nth_shared_loop_with_id] -/ -def list_nth_shared_loop_with_id_fwd - (T : Type) (ls : list_t T) (i : UInt32) : Result T := - do - let ls0 ← id_shared_fwd T ls - list_nth_shared_loop_with_id_loop_fwd T i ls0 - -/- [loops::list_nth_mut_loop_pair] -/ -def list_nth_mut_loop_pair_loop_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - (Result (T × T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (x0, x1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_mut_loop_pair_loop_fwd T tl0 tl1 i0 - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_pair_loop_fwd ls0 ls1 i => - list_nth_mut_loop_pair_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_loop_pair_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_loop_pair] -/ -def list_nth_mut_loop_pair_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - Result (T × T) - := - list_nth_mut_loop_pair_loop_fwd T ls0 ls1 i - -/- [loops::list_nth_mut_loop_pair] -/ -def list_nth_mut_loop_pair_loop_back'a - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - (Result (list_t T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl0) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl00 ← list_nth_mut_loop_pair_loop_back'a T tl0 tl1 i0 ret0 - Result.ret (list_t.ListCons x0 tl00) - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_pair_loop_back'a ls0 ls1 i ret0 => - list_nth_mut_loop_pair_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_loop_pair_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_loop_pair] -/ -def list_nth_mut_loop_pair_back'a - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - Result (list_t T) - := - list_nth_mut_loop_pair_loop_back'a T ls0 ls1 i ret0 - -/- [loops::list_nth_mut_loop_pair] -/ -def list_nth_mut_loop_pair_loop_back'b - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - (Result (list_t T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl10 ← list_nth_mut_loop_pair_loop_back'b T tl0 tl1 i0 ret0 - Result.ret (list_t.ListCons x1 tl10) - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_pair_loop_back'b ls0 ls1 i ret0 => - list_nth_mut_loop_pair_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_loop_pair_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_loop_pair] -/ -def list_nth_mut_loop_pair_back'b - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - Result (list_t T) - := - list_nth_mut_loop_pair_loop_back'b T ls0 ls1 i ret0 - -/- [loops::list_nth_shared_loop_pair] -/ -def list_nth_shared_loop_pair_loop_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - (Result (T × T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (x0, x1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_shared_loop_pair_loop_fwd T tl0 tl1 i0 - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_shared_loop_pair_loop_fwd ls0 ls1 i => - list_nth_shared_loop_pair_loop_terminates T ls0 ls1 i -decreasing_by list_nth_shared_loop_pair_loop_decreases ls0 ls1 i - -/- [loops::list_nth_shared_loop_pair] -/ -def list_nth_shared_loop_pair_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - Result (T × T) - := - list_nth_shared_loop_pair_loop_fwd T ls0 ls1 i - -/- [loops::list_nth_mut_loop_pair_merge] -/ -def list_nth_mut_loop_pair_merge_loop_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - (Result (T × T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (x0, x1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_mut_loop_pair_merge_loop_fwd T tl0 tl1 i0 - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_pair_merge_loop_fwd ls0 ls1 i => - list_nth_mut_loop_pair_merge_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_loop_pair_merge_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_loop_pair_merge] -/ -def list_nth_mut_loop_pair_merge_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - Result (T × T) - := - list_nth_mut_loop_pair_merge_loop_fwd T ls0 ls1 i - -/- [loops::list_nth_mut_loop_pair_merge] -/ -def list_nth_mut_loop_pair_merge_loop_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : (T × T)) : - (Result ((list_t T) × (list_t T))) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then - let (t, t0) := ret0 - Result.ret (list_t.ListCons t tl0, list_t.ListCons t0 tl1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let (tl00, tl10) ← - list_nth_mut_loop_pair_merge_loop_back T tl0 tl1 i0 ret0 - Result.ret (list_t.ListCons x0 tl00, list_t.ListCons x1 tl10) - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_loop_pair_merge_loop_back ls0 ls1 i ret0 => - list_nth_mut_loop_pair_merge_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_loop_pair_merge_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_loop_pair_merge] -/ -def list_nth_mut_loop_pair_merge_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : (T × T)) : - Result ((list_t T) × (list_t T)) - := - list_nth_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0 - -/- [loops::list_nth_shared_loop_pair_merge] -/ -def list_nth_shared_loop_pair_merge_loop_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - (Result (T × T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (x0, x1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_shared_loop_pair_merge_loop_fwd T tl0 tl1 i0 - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_shared_loop_pair_merge_loop_fwd ls0 ls1 i => - list_nth_shared_loop_pair_merge_loop_terminates T ls0 ls1 i -decreasing_by list_nth_shared_loop_pair_merge_loop_decreases ls0 ls1 i - -/- [loops::list_nth_shared_loop_pair_merge] -/ -def list_nth_shared_loop_pair_merge_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - Result (T × T) - := - list_nth_shared_loop_pair_merge_loop_fwd T ls0 ls1 i - -/- [loops::list_nth_mut_shared_loop_pair] -/ -def list_nth_mut_shared_loop_pair_loop_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - (Result (T × T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (x0, x1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_mut_shared_loop_pair_loop_fwd T tl0 tl1 i0 - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_shared_loop_pair_loop_fwd ls0 ls1 i => - list_nth_mut_shared_loop_pair_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_shared_loop_pair_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_shared_loop_pair] -/ -def list_nth_mut_shared_loop_pair_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - Result (T × T) - := - list_nth_mut_shared_loop_pair_loop_fwd T ls0 ls1 i - -/- [loops::list_nth_mut_shared_loop_pair] -/ -def list_nth_mut_shared_loop_pair_loop_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - (Result (list_t T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl0) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl00 ← - list_nth_mut_shared_loop_pair_loop_back T tl0 tl1 i0 ret0 - Result.ret (list_t.ListCons x0 tl00) - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_shared_loop_pair_loop_back ls0 ls1 i ret0 => - list_nth_mut_shared_loop_pair_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_shared_loop_pair_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_shared_loop_pair] -/ -def list_nth_mut_shared_loop_pair_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - Result (list_t T) - := - list_nth_mut_shared_loop_pair_loop_back T ls0 ls1 i ret0 - -/- [loops::list_nth_mut_shared_loop_pair_merge] -/ -def list_nth_mut_shared_loop_pair_merge_loop_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - (Result (T × T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (x0, x1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_mut_shared_loop_pair_merge_loop_fwd T tl0 tl1 i0 - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_shared_loop_pair_merge_loop_fwd ls0 ls1 i => - list_nth_mut_shared_loop_pair_merge_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_shared_loop_pair_merge_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_shared_loop_pair_merge] -/ -def list_nth_mut_shared_loop_pair_merge_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - Result (T × T) - := - list_nth_mut_shared_loop_pair_merge_loop_fwd T ls0 ls1 i - -/- [loops::list_nth_mut_shared_loop_pair_merge] -/ -def list_nth_mut_shared_loop_pair_merge_loop_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - (Result (list_t T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl0) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl00 ← - list_nth_mut_shared_loop_pair_merge_loop_back T tl0 tl1 i0 ret0 - Result.ret (list_t.ListCons x0 tl00) - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_mut_shared_loop_pair_merge_loop_back ls0 ls1 i ret0 => - list_nth_mut_shared_loop_pair_merge_loop_terminates T ls0 ls1 i -decreasing_by list_nth_mut_shared_loop_pair_merge_loop_decreases ls0 ls1 i - -/- [loops::list_nth_mut_shared_loop_pair_merge] -/ -def list_nth_mut_shared_loop_pair_merge_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - Result (list_t T) - := - list_nth_mut_shared_loop_pair_merge_loop_back T ls0 ls1 i ret0 - -/- [loops::list_nth_shared_mut_loop_pair] -/ -def list_nth_shared_mut_loop_pair_loop_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - (Result (T × T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (x0, x1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_shared_mut_loop_pair_loop_fwd T tl0 tl1 i0 - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_shared_mut_loop_pair_loop_fwd ls0 ls1 i => - list_nth_shared_mut_loop_pair_loop_terminates T ls0 ls1 i -decreasing_by list_nth_shared_mut_loop_pair_loop_decreases ls0 ls1 i - -/- [loops::list_nth_shared_mut_loop_pair] -/ -def list_nth_shared_mut_loop_pair_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - Result (T × T) - := - list_nth_shared_mut_loop_pair_loop_fwd T ls0 ls1 i - -/- [loops::list_nth_shared_mut_loop_pair] -/ -def list_nth_shared_mut_loop_pair_loop_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - (Result (list_t T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl10 ← - list_nth_shared_mut_loop_pair_loop_back T tl0 tl1 i0 ret0 - Result.ret (list_t.ListCons x1 tl10) - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_shared_mut_loop_pair_loop_back ls0 ls1 i ret0 => - list_nth_shared_mut_loop_pair_loop_terminates T ls0 ls1 i -decreasing_by list_nth_shared_mut_loop_pair_loop_decreases ls0 ls1 i - -/- [loops::list_nth_shared_mut_loop_pair] -/ -def list_nth_shared_mut_loop_pair_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - Result (list_t T) - := - list_nth_shared_mut_loop_pair_loop_back T ls0 ls1 i ret0 - -/- [loops::list_nth_shared_mut_loop_pair_merge] -/ -def list_nth_shared_mut_loop_pair_merge_loop_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - (Result (T × T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (x0, x1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_shared_mut_loop_pair_merge_loop_fwd T tl0 tl1 i0 - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_shared_mut_loop_pair_merge_loop_fwd ls0 ls1 i => - list_nth_shared_mut_loop_pair_merge_loop_terminates T ls0 ls1 i -decreasing_by list_nth_shared_mut_loop_pair_merge_loop_decreases ls0 ls1 i - -/- [loops::list_nth_shared_mut_loop_pair_merge] -/ -def list_nth_shared_mut_loop_pair_merge_fwd - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) : - Result (T × T) - := - list_nth_shared_mut_loop_pair_merge_loop_fwd T ls0 ls1 i - -/- [loops::list_nth_shared_mut_loop_pair_merge] -/ -def list_nth_shared_mut_loop_pair_merge_loop_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - (Result (list_t T)) - := - match h: ls0 with - | list_t.ListCons x0 tl0 => - match h: ls1 with - | list_t.ListCons x1 tl1 => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl1) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl10 ← - list_nth_shared_mut_loop_pair_merge_loop_back T tl0 tl1 i0 ret0 - Result.ret (list_t.ListCons x1 tl10) - | list_t.ListNil => Result.fail Error.panic - | list_t.ListNil => Result.fail Error.panic -termination_by list_nth_shared_mut_loop_pair_merge_loop_back ls0 ls1 i ret0 => - list_nth_shared_mut_loop_pair_merge_loop_terminates T ls0 ls1 i -decreasing_by list_nth_shared_mut_loop_pair_merge_loop_decreases ls0 ls1 i - -/- [loops::list_nth_shared_mut_loop_pair_merge] -/ -def list_nth_shared_mut_loop_pair_merge_back - (T : Type) (ls0 : list_t T) (ls1 : list_t T) (i : UInt32) (ret0 : T) : - Result (list_t T) - := - list_nth_shared_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0 - diff --git a/tests/lean/misc/loops/Loops/Types.lean b/tests/lean/misc/loops/Loops/Types.lean deleted file mode 100644 index f4b6809e..00000000 --- a/tests/lean/misc/loops/Loops/Types.lean +++ /dev/null @@ -1,9 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [loops]: type definitions -import Base.Primitives - -/- [loops::List] -/ -inductive list_t (T : Type) := -| ListCons : T -> list_t T -> list_t T -| ListNil : list_t T - diff --git a/tests/lean/misc/loops/lakefile.lean b/tests/lean/misc/loops/lakefile.lean deleted file mode 100644 index 0d20ba1f..00000000 --- a/tests/lean/misc/loops/lakefile.lean +++ /dev/null @@ -1,18 +0,0 @@ -import Lake -open Lake DSL - -require mathlib from git - "https://github.com/leanprover-community/mathlib4.git" - -package «loops» { - -- add package configuration options here -} - -lean_lib «Base» { - -- add library configuration options here -} - -lean_lib «Loops» { - -- add library configuration options here -} - diff --git a/tests/lean/misc/no_nested_borrows/Base/Primitives.lean b/tests/lean/misc/no_nested_borrows/Base/Primitives.lean deleted file mode 100644 index 5b64e908..00000000 --- a/tests/lean/misc/no_nested_borrows/Base/Primitives.lean +++ /dev/null @@ -1,392 +0,0 @@ -import Lean -import Lean.Meta.Tactic.Simp -import Init.Data.List.Basic -import Mathlib.Tactic.RunCmd - -------------- --- PRELUDE -- -------------- - --- Results & monadic combinators - -inductive Error where - | assertionFailure: Error - | integerOverflow: Error - | arrayOutOfBounds: Error - | maximumSizeExceeded: Error - | panic: Error -deriving Repr, BEq - -open Error - -inductive Result (α : Type u) where - | ret (v: α): Result α - | fail (e: Error): Result α -deriving Repr, BEq - -open Result - -/- HELPERS -/ - -def ret? {α: Type} (r: Result α): Bool := - match r with - | Result.ret _ => true - | Result.fail _ => false - -def massert (b:Bool) : Result Unit := - if b then .ret () else fail assertionFailure - -def eval_global {α: Type} (x: Result α) (_: ret? x): α := - match x with - | Result.fail _ => by contradiction - | Result.ret x => x - -/- DO-DSL SUPPORT -/ - -def bind (x: Result α) (f: α -> Result β) : Result β := - match x with - | ret v => f v - | fail v => fail v - --- Allows using Result in do-blocks -instance : Bind Result where - bind := bind - --- Allows using return x in do-blocks -instance : Pure Result where - pure := fun x => ret x - -/- CUSTOM-DSL SUPPORT -/ - --- Let-binding the Result of a monadic operation is oftentimes not sufficient, --- because we may need a hypothesis for equational reasoning in the scope. We --- rely on subtype, and a custom let-binding operator, in effect recreating our --- own variant of the do-dsl - -def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := - match o with - | .ret x => .ret ⟨x, rfl⟩ - | .fail e => .fail e - -macro "let" e:term " ⟵ " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- TODO: any way to factorize both definitions? -macro "let" e:term " <-- " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- We call the hypothesis `h`, in effect making it unavailable to the user --- (because too much shadowing). But in practice, once can use the French single --- quote notation (input with f< and f>), where `‹ h ›` finds a suitable --- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` -#eval do - let y <-- .ret (0: Nat) - let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide - let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ - .ret r - ----------------------- --- MACHINE INTEGERS -- ----------------------- - --- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., --- USize. They are generally defined in an idiomatic style, except that there is --- not a single type class to rule them all (more on that below). The absence of --- type class is intentional, and allows the Lean compiler to efficiently map --- them to machine integers during compilation. - --- USize is designed properly: you cannot reduce `getNumBits` using the --- simplifier, meaning that proofs do not depend on the compile-time value of --- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really --- support, at least officially, 16-bit microcontrollers, so this seems like a --- fine design decision for now.) - --- Note from Chris Bailey: "If there's more than one salient property of your --- definition then the subtyping strategy might get messy, and the property part --- of a subtype is less discoverable by the simplifier or tactics like --- library_search." So, we will not add refinements on the return values of the --- operations defined on Primitives, but will rather rely on custom lemmas to --- invert on possible return values of the primitive operations. - --- Machine integer constants, done via `ofNatCore`, which requires a proof that --- the `Nat` fits within the desired integer type. We provide a custom tactic. - -syntax "intlit" : tactic - -macro_rules - | `(tactic| intlit) => `(tactic| - match USize.size, usize_size_eq with - | _, Or.inl rfl => decide - | _, Or.inr rfl => decide) - --- This is how the macro is expected to be used -#eval USize.ofNatCore 0 (by intlit) - --- Also works for other integer types (at the expense of a needless disjunction) -#eval UInt32.ofNatCore 0 (by intlit) - --- The machine integer operations (e.g. sub) are always total, which is not what --- we want. We therefore define "checked" variants, below. Note that we add a --- tiny bit of complexity for the USize variant: we first check whether the --- result is < 2^32; if it is, we can compute the definition, rather than --- returning a term that is computationally stuck (the comparison to USize.size --- cannot reduce at compile-time, per the remark about regarding `getNumBits`). --- This is useful for the various #asserts that we want to reduce at --- type-checking time. - --- Further thoughts: look at what has been done here: --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean --- and --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean --- which both contain a fair amount of reasoning already! -def USize.checked_sub (n: USize) (m: USize): Result USize := - -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? - if n >= m then - let n' := USize.toNat n - let m' := USize.toNat n - let r := USize.ofNatCore (n' - m') (by - have h: n' - m' <= n' := by - apply Nat.sub_le_of_le_add - case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left - apply Nat.lt_of_le_of_lt h - apply n.val.isLt - ) - return r - else - fail integerOverflow - -@[simp] -theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := - match USize.size, usize_size_eq with - | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) - | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) - -def USize.checked_add (n: USize) (m: USize): Result USize := - if h: n.val + m.val < USize.size then - .ret ⟨ n.val + m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_rem (n: USize) (m: USize): Result USize := - if h: m > 0 then - .ret ⟨ n.val % m.val, by - have h1: ↑m.val < USize.size := m.val.isLt - have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h - apply Nat.lt_trans h2 h1 - ⟩ - else - .fail integerOverflow - -def USize.checked_mul (n: USize) (m: USize): Result USize := - if h: n.val * m.val < USize.size then - .ret ⟨ n.val * m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_div (n: USize) (m: USize): Result USize := - if m > 0 then - .ret ⟨ n.val / m.val, by - have h1: ↑n.val < USize.size := n.val.isLt - have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val - apply Nat.lt_of_le_of_lt h2 h1 - ⟩ - else - .fail integerOverflow - --- Test behavior... -#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 - -#eval USize.checked_sub 20 10 --- NOTE: compare with concrete behavior here, which I do not think we want -#eval USize.sub 0 1 -#eval UInt8.add 255 255 - --- We now define a type class that subsumes the various machine integer types, so --- as to write a concise definition for scalar_cast, rather than exhaustively --- enumerating all of the possible pairs. We remark that Rust has sane semantics --- and fails if a cast operation would involve a truncation or modulo. - -class MachineInteger (t: Type) where - size: Nat - val: t -> Fin size - ofNatCore: (n:Nat) -> LT.lt n size -> t - -set_option hygiene false in -run_cmd - for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do - Lean.Elab.Command.elabCommand (← `( - namespace $typeName - instance: MachineInteger $typeName where - size := size - val := val - ofNatCore := ofNatCore - end $typeName - )) - --- Aeneas only instantiates the destination type (`src` is implicit). We rely on --- Lean to infer `src`. - -def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := - if h: MachineInteger.val x < MachineInteger.size dst then - .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) - else - .fail integerOverflow - -------------- --- VECTORS -- -------------- - --- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) --- rather than maximum values (usize_max). -def Vec (α : Type u) := { l : List α // List.length l < USize.size } - -def vec_new (α : Type u): Vec α := ⟨ [], by { - match USize.size, usize_size_eq with - | _, Or.inl rfl => simp - | _, Or.inr rfl => simp - } ⟩ - -#check vec_new - -def vec_len (α : Type u) (v : Vec α) : USize := - let ⟨ v, l ⟩ := v - USize.ofNatCore (List.length v) l - -#eval vec_len Nat (vec_new Nat) - -def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () - --- NOTE: old version trying to use a subtype notation, but probably better to --- leave Result elimination to auxiliary lemmas with suitable preconditions --- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one --- make the proof work in that case? Probably need to import tactics from --- mathlib to deal with inequalities... would love to see an example. -def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // - match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} - := - if h : List.length v.val + 1 < USize.size then - ⟨ return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩, by simp ⟩ - else - ⟨ fail maximumSizeExceeded, by simp ⟩ - -#eval do - -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with - -- fields val and property. However, Lean's elaborator can automatically - -- select the `val` field if the context provides a type annotation. We - -- annotate `x`, which relieves us of having to write `.val` on the right-hand - -- side of the monadic let. - let v := vec_new Nat - let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? - -- TODO: strengthen post-condition above and do a demo to show that we can - -- safely eliminate the `fail` case - return (vec_len Nat x) - -def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) - := - if h : List.length v.val + 1 <= 4294967295 then - return ⟨ List.concat v.val x, - by - rw [List.length_concat] - have h': 4294967295 < USize.size := by intlit - apply Nat.lt_of_le_of_lt h h' - ⟩ - else if h: List.length v.val + 1 < USize.size then - return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩ - else - fail maximumSizeExceeded - -def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - -def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - ----------- --- MISC -- ----------- - -def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := - x - -def mem_replace_back (a : Type) (_ : a) (y : a) : a := - y - -/-- Aeneas-translated function -- useful to reduce non-recursive definitions. - Use with `simp [ aeneas ]` -/ -register_simp_attr aeneas - --------------------- --- ASSERT COMMAND -- --------------------- - -open Lean Elab Command Term Meta - -syntax (name := assert) "#assert" term: command - -@[command_elab assert] -unsafe -def assertImpl : CommandElab := fun (_stx: Syntax) => do - runTermElabM (fun _ => do - let r ← evalTerm Bool (mkConst ``Bool) _stx[1] - if not r then - logInfo "Assertion failed for: " - logInfo _stx[1] - logError "Expression reduced to false" - pure ()) - -#eval 2 == 2 -#assert (2 == 2) - -------------------- --- SANITY CHECKS -- -------------------- - --- TODO: add more once we have signed integers - -#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc/no_nested_borrows/NoNestedBorrows.lean b/tests/lean/misc/no_nested_borrows/NoNestedBorrows.lean deleted file mode 100644 index a20ee9fd..00000000 --- a/tests/lean/misc/no_nested_borrows/NoNestedBorrows.lean +++ /dev/null @@ -1,556 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [no_nested_borrows] -import Base.Primitives - -structure OpaqueDefs where - - /- [no_nested_borrows::Pair] -/ - structure pair_t (T1 T2 : Type) where pair_x : T1 pair_y : T2 - - /- [no_nested_borrows::List] -/ - inductive list_t (T : Type) := - | ListCons : T -> list_t T -> list_t T - | ListNil : list_t T - - /- [no_nested_borrows::One] -/ - inductive one_t (T1 : Type) := | OneOne : T1 -> one_t T1 - - /- [no_nested_borrows::EmptyEnum] -/ - inductive empty_enum_t := | EmptyEnumEmpty : empty_enum_t - - /- [no_nested_borrows::Enum] -/ - inductive enum_t := | EnumVariant1 : enum_t | EnumVariant2 : enum_t - - /- [no_nested_borrows::EmptyStruct] -/ - structure empty_struct_t where - - /- [no_nested_borrows::Sum] -/ - inductive sum_t (T1 T2 : Type) := - | SumLeft : T1 -> sum_t T1 T2 - | SumRight : T2 -> sum_t T1 T2 - - /- [no_nested_borrows::neg_test] -/ - def neg_test_fwd (x : Int32) : Result Int32 := - Int32.checked_neg x - - /- [no_nested_borrows::add_test] -/ - def add_test_fwd (x : UInt32) (y : UInt32) : Result UInt32 := - UInt32.checked_add x y - - /- [no_nested_borrows::subs_test] -/ - def subs_test_fwd (x : UInt32) (y : UInt32) : Result UInt32 := - UInt32.checked_sub x y - - /- [no_nested_borrows::div_test] -/ - def div_test_fwd (x : UInt32) (y : UInt32) : Result UInt32 := - UInt32.checked_div x y - - /- [no_nested_borrows::div_test1] -/ - def div_test1_fwd (x : UInt32) : Result UInt32 := - UInt32.checked_div x (UInt32.ofNatCore 2 (by intlit)) - - /- [no_nested_borrows::rem_test] -/ - def rem_test_fwd (x : UInt32) (y : UInt32) : Result UInt32 := - UInt32.checked_rem x y - - /- [no_nested_borrows::cast_test] -/ - def cast_test_fwd (x : UInt32) : Result Int32 := - scalar_cast Int32 x - - /- [no_nested_borrows::test2] -/ - def test2_fwd : Result Unit := - do - let _ ← UInt32.checked_add (UInt32.ofNatCore 23 (by intlit)) - (UInt32.ofNatCore 44 (by intlit)) - Result.ret () - - /- Unit test for [no_nested_borrows::test2] -/ - #assert (test2_fwd == .ret ()) - - /- [no_nested_borrows::get_max] -/ - def get_max_fwd (x : UInt32) (y : UInt32) : Result UInt32 := - if h: x >= y - then Result.ret x - else Result.ret y - - /- [no_nested_borrows::test3] -/ - def test3_fwd : Result Unit := - do - let x ← - get_max_fwd (UInt32.ofNatCore 4 (by intlit)) - (UInt32.ofNatCore 3 (by intlit)) - let y ← - get_max_fwd (UInt32.ofNatCore 10 (by intlit)) - (UInt32.ofNatCore 11 (by intlit)) - let z ← UInt32.checked_add x y - if h: not (z = (UInt32.ofNatCore 15 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::test3] -/ - #assert (test3_fwd == .ret ()) - - /- [no_nested_borrows::test_neg1] -/ - def test_neg1_fwd : Result Unit := - do - let y ← Int32.checked_neg (Int32.ofNatCore 3 (by intlit)) - if h: not (y = (Int32.ofNatCore -3 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::test_neg1] -/ - #assert (test_neg1_fwd == .ret ()) - - /- [no_nested_borrows::refs_test1] -/ - def refs_test1_fwd : Result Unit := - if h: not ((Int32.ofNatCore 1 (by intlit)) = - (Int32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::refs_test1] -/ - #assert (refs_test1_fwd == .ret ()) - - /- [no_nested_borrows::refs_test2] -/ - def refs_test2_fwd : Result Unit := - if h: not ((Int32.ofNatCore 2 (by intlit)) = - (Int32.ofNatCore 2 (by intlit))) - then Result.fail Error.panic - else - if h: not ((Int32.ofNatCore 0 (by intlit)) = - (Int32.ofNatCore 0 (by intlit))) - then Result.fail Error.panic - else - if h: not ((Int32.ofNatCore 2 (by intlit)) = - (Int32.ofNatCore 2 (by intlit))) - then Result.fail Error.panic - else - if h: not ((Int32.ofNatCore 2 (by intlit)) = - (Int32.ofNatCore 2 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::refs_test2] -/ - #assert (refs_test2_fwd == .ret ()) - - /- [no_nested_borrows::test_list1] -/ - def test_list1_fwd : Result Unit := - Result.ret () - - /- Unit test for [no_nested_borrows::test_list1] -/ - #assert (test_list1_fwd == .ret ()) - - /- [no_nested_borrows::test_box1] -/ - def test_box1_fwd : Result Unit := - let b := (Int32.ofNatCore 1 (by intlit)) - let x := b - if h: not (x = (Int32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::test_box1] -/ - #assert (test_box1_fwd == .ret ()) - - /- [no_nested_borrows::copy_int] -/ - def copy_int_fwd (x : Int32) : Result Int32 := - Result.ret x - - /- [no_nested_borrows::test_unreachable] -/ - def test_unreachable_fwd (b : Bool) : Result Unit := - if h: b - then Result.fail Error.panic - else Result.ret () - - /- [no_nested_borrows::test_panic] -/ - def test_panic_fwd (b : Bool) : Result Unit := - if h: b - then Result.fail Error.panic - else Result.ret () - - /- [no_nested_borrows::test_copy_int] -/ - def test_copy_int_fwd : Result Unit := - do - let y ← copy_int_fwd (Int32.ofNatCore 0 (by intlit)) - if h: not ((Int32.ofNatCore 0 (by intlit)) = y) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::test_copy_int] -/ - #assert (test_copy_int_fwd == .ret ()) - - /- [no_nested_borrows::is_cons] -/ - def is_cons_fwd (T : Type) (l : list_t T) : Result Bool := - match h: l with - | list_t.ListCons t l0 => Result.ret true - | list_t.ListNil => Result.ret false - - /- [no_nested_borrows::test_is_cons] -/ - def test_is_cons_fwd : Result Unit := - do - let l := list_t.ListNil - let b ← - is_cons_fwd Int32 (list_t.ListCons (Int32.ofNatCore 0 (by intlit)) l) - if h: not b - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::test_is_cons] -/ - #assert (test_is_cons_fwd == .ret ()) - - /- [no_nested_borrows::split_list] -/ - def split_list_fwd (T : Type) (l : list_t T) : Result (T × (list_t T)) := - match h: l with - | list_t.ListCons hd tl => Result.ret (hd, tl) - | list_t.ListNil => Result.fail Error.panic - - /- [no_nested_borrows::test_split_list] -/ - def test_split_list_fwd : Result Unit := - do - let l := list_t.ListNil - let p ← - split_list_fwd Int32 (list_t.ListCons (Int32.ofNatCore 0 (by intlit)) - l) - let (hd, _) := p - if h: not (hd = (Int32.ofNatCore 0 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::test_split_list] -/ - #assert (test_split_list_fwd == .ret ()) - - /- [no_nested_borrows::choose] -/ - def choose_fwd (T : Type) (b : Bool) (x : T) (y : T) : Result T := - if h: b - then Result.ret x - else Result.ret y - - /- [no_nested_borrows::choose] -/ - def choose_back - (T : Type) (b : Bool) (x : T) (y : T) (ret0 : T) : Result (T × T) := - if h: b - then Result.ret (ret0, y) - else Result.ret (x, ret0) - - /- [no_nested_borrows::choose_test] -/ - def choose_test_fwd : Result Unit := - do - let z ← - choose_fwd Int32 true (Int32.ofNatCore 0 (by intlit)) - (Int32.ofNatCore 0 (by intlit)) - let z0 ← Int32.checked_add z (Int32.ofNatCore 1 (by intlit)) - if h: not (z0 = (Int32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else - do - let (x, y) ← - choose_back Int32 true (Int32.ofNatCore 0 (by intlit)) - (Int32.ofNatCore 0 (by intlit)) z0 - if h: not (x = (Int32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else - if h: not (y = (Int32.ofNatCore 0 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::choose_test] -/ - #assert (choose_test_fwd == .ret ()) - - /- [no_nested_borrows::test_char] -/ - def test_char_fwd : Result Char := - Result.ret 'a' - - /- [no_nested_borrows::NodeElem] -/ - mutual inductive node_elem_t (T : Type) := - | NodeElemCons : tree_t T -> node_elem_t T -> node_elem_t T - | NodeElemNil : node_elem_t T - - /- [no_nested_borrows::Tree] -/ - inductive tree_t (T : Type) := - | TreeLeaf : T -> tree_t T - | TreeNode : T -> node_elem_t T -> tree_t T -> tree_t T - - /- [no_nested_borrows::list_length] -/ - def list_length_fwd (T : Type) (l : list_t T) : Result UInt32 := - match h: l with - | list_t.ListCons t l1 => - do - let i ← list_length_fwd T l1 - UInt32.checked_add (UInt32.ofNatCore 1 (by intlit)) i - | list_t.ListNil => Result.ret (UInt32.ofNatCore 0 (by intlit)) - - /- [no_nested_borrows::list_nth_shared] -/ - def list_nth_shared_fwd (T : Type) (l : list_t T) (i : UInt32) : Result T := - match h: l with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret x - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_shared_fwd T tl i0 - | list_t.ListNil => Result.fail Error.panic - - /- [no_nested_borrows::list_nth_mut] -/ - def list_nth_mut_fwd (T : Type) (l : list_t T) (i : UInt32) : Result T := - match h: l with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret x - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_mut_fwd T tl i0 - | list_t.ListNil => Result.fail Error.panic - - /- [no_nested_borrows::list_nth_mut] -/ - def list_nth_mut_back - (T : Type) (l : list_t T) (i : UInt32) (ret0 : T) : Result (list_t T) := - match h: l with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl0 ← list_nth_mut_back T tl i0 ret0 - Result.ret (list_t.ListCons x tl0) - | list_t.ListNil => Result.fail Error.panic - - /- [no_nested_borrows::list_rev_aux] -/ - def list_rev_aux_fwd - (T : Type) (li : list_t T) (lo : list_t T) : Result (list_t T) := - match h: li with - | list_t.ListCons hd tl => list_rev_aux_fwd T tl (list_t.ListCons hd lo) - | list_t.ListNil => Result.ret lo - - /- [no_nested_borrows::list_rev] -/ - def list_rev_fwd_back (T : Type) (l : list_t T) : Result (list_t T) := - let li := mem_replace_fwd (list_t T) l list_t.ListNil - list_rev_aux_fwd T li list_t.ListNil - - /- [no_nested_borrows::test_list_functions] -/ - def test_list_functions_fwd : Result Unit := - do - let l := list_t.ListNil - let l0 := list_t.ListCons (Int32.ofNatCore 2 (by intlit)) l - let l1 := list_t.ListCons (Int32.ofNatCore 1 (by intlit)) l0 - let i ← - list_length_fwd Int32 (list_t.ListCons (Int32.ofNatCore 0 (by intlit)) - l1) - if h: not (i = (UInt32.ofNatCore 3 (by intlit))) - then Result.fail Error.panic - else - do - let i0 ← - list_nth_shared_fwd Int32 (list_t.ListCons - (Int32.ofNatCore 0 (by intlit)) l1) - (UInt32.ofNatCore 0 (by intlit)) - if h: not (i0 = (Int32.ofNatCore 0 (by intlit))) - then Result.fail Error.panic - else - do - let i1 ← - list_nth_shared_fwd Int32 (list_t.ListCons - (Int32.ofNatCore 0 (by intlit)) l1) - (UInt32.ofNatCore 1 (by intlit)) - if h: not (i1 = (Int32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else - do - let i2 ← - list_nth_shared_fwd Int32 (list_t.ListCons - (Int32.ofNatCore 0 (by intlit)) l1) - (UInt32.ofNatCore 2 (by intlit)) - if h: not (i2 = (Int32.ofNatCore 2 (by intlit))) - then Result.fail Error.panic - else - do - let ls ← - list_nth_mut_back Int32 (list_t.ListCons - (Int32.ofNatCore 0 (by intlit)) l1) - (UInt32.ofNatCore 1 (by intlit)) - (Int32.ofNatCore 3 (by intlit)) - let i3 ← - list_nth_shared_fwd Int32 ls - (UInt32.ofNatCore 0 (by intlit)) - if h: not (i3 = (Int32.ofNatCore 0 (by intlit))) - then Result.fail Error.panic - else - do - let i4 ← - list_nth_shared_fwd Int32 ls - (UInt32.ofNatCore 1 (by intlit)) - if h: not (i4 = (Int32.ofNatCore 3 (by intlit))) - then Result.fail Error.panic - else - do - let i5 ← - list_nth_shared_fwd Int32 ls - (UInt32.ofNatCore 2 (by intlit)) - if h: not (i5 = (Int32.ofNatCore 2 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::test_list_functions] -/ - #assert (test_list_functions_fwd == .ret ()) - - /- [no_nested_borrows::id_mut_pair1] -/ - def id_mut_pair1_fwd (T1 T2 : Type) (x : T1) (y : T2) : Result (T1 × T2) := - Result.ret (x, y) - - /- [no_nested_borrows::id_mut_pair1] -/ - def id_mut_pair1_back - (T1 T2 : Type) (x : T1) (y : T2) (ret0 : (T1 × T2)) : Result (T1 × T2) := - let (t, t0) := ret0 - Result.ret (t, t0) - - /- [no_nested_borrows::id_mut_pair2] -/ - def id_mut_pair2_fwd (T1 T2 : Type) (p : (T1 × T2)) : Result (T1 × T2) := - let (t, t0) := p - Result.ret (t, t0) - - /- [no_nested_borrows::id_mut_pair2] -/ - def id_mut_pair2_back - (T1 T2 : Type) (p : (T1 × T2)) (ret0 : (T1 × T2)) : Result (T1 × T2) := - let (t, t0) := ret0 - Result.ret (t, t0) - - /- [no_nested_borrows::id_mut_pair3] -/ - def id_mut_pair3_fwd (T1 T2 : Type) (x : T1) (y : T2) : Result (T1 × T2) := - Result.ret (x, y) - - /- [no_nested_borrows::id_mut_pair3] -/ - def id_mut_pair3_back'a - (T1 T2 : Type) (x : T1) (y : T2) (ret0 : T1) : Result T1 := - Result.ret ret0 - - /- [no_nested_borrows::id_mut_pair3] -/ - def id_mut_pair3_back'b - (T1 T2 : Type) (x : T1) (y : T2) (ret0 : T2) : Result T2 := - Result.ret ret0 - - /- [no_nested_borrows::id_mut_pair4] -/ - def id_mut_pair4_fwd (T1 T2 : Type) (p : (T1 × T2)) : Result (T1 × T2) := - let (t, t0) := p - Result.ret (t, t0) - - /- [no_nested_borrows::id_mut_pair4] -/ - def id_mut_pair4_back'a - (T1 T2 : Type) (p : (T1 × T2)) (ret0 : T1) : Result T1 := - Result.ret ret0 - - /- [no_nested_borrows::id_mut_pair4] -/ - def id_mut_pair4_back'b - (T1 T2 : Type) (p : (T1 × T2)) (ret0 : T2) : Result T2 := - Result.ret ret0 - - /- [no_nested_borrows::StructWithTuple] -/ - structure struct_with_tuple_t (T1 T2 : Type) where - - struct_with_tuple_p : (T1 × T2) - - - /- [no_nested_borrows::new_tuple1] -/ - def new_tuple1_fwd : Result (struct_with_tuple_t UInt32 UInt32) := - Result.ret - { - struct_with_tuple_p := ((UInt32.ofNatCore 1 (by intlit)), - (UInt32.ofNatCore 2 (by intlit))) - } - - /- [no_nested_borrows::new_tuple2] -/ - def new_tuple2_fwd : Result (struct_with_tuple_t Int16 Int16) := - Result.ret - { - struct_with_tuple_p := ((Int16.ofNatCore 1 (by intlit)), - (Int16.ofNatCore 2 (by intlit))) - } - - /- [no_nested_borrows::new_tuple3] -/ - def new_tuple3_fwd : Result (struct_with_tuple_t UInt64 Int64) := - Result.ret - { - struct_with_tuple_p := ((UInt64.ofNatCore 1 (by intlit)), - (Int64.ofNatCore 2 (by intlit))) - } - - /- [no_nested_borrows::StructWithPair] -/ - structure struct_with_pair_t (T1 T2 : Type) where - - struct_with_pair_p : pair_t T1 T2 - - - /- [no_nested_borrows::new_pair1] -/ - def new_pair1_fwd : Result (struct_with_pair_t UInt32 UInt32) := - Result.ret - { - struct_with_pair_p := { - pair_x := (UInt32.ofNatCore 1 (by intlit)), - pair_y := (UInt32.ofNatCore 2 (by intlit)) - } - } - - /- [no_nested_borrows::test_constants] -/ - def test_constants_fwd : Result Unit := - do - let swt ← new_tuple1_fwd - let (i, _) := swt.struct_with_tuple_p - if h: not (i = (UInt32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else - do - let swt0 ← new_tuple2_fwd - let (i0, _) := swt0.struct_with_tuple_p - if h: not (i0 = (Int16.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else - do - let swt1 ← new_tuple3_fwd - let (i1, _) := swt1.struct_with_tuple_p - if h: not (i1 = (UInt64.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else - do - let swp ← new_pair1_fwd - if h: not (swp.struct_with_pair_p.pair_x = - (UInt32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [no_nested_borrows::test_constants] -/ - #assert (test_constants_fwd == .ret ()) - - /- [no_nested_borrows::test_weird_borrows1] -/ - def test_weird_borrows1_fwd : Result Unit := - Result.ret () - - /- Unit test for [no_nested_borrows::test_weird_borrows1] -/ - #assert (test_weird_borrows1_fwd == .ret ()) - - /- [no_nested_borrows::test_mem_replace] -/ - def test_mem_replace_fwd_back (px : UInt32) : Result UInt32 := - let y := mem_replace_fwd UInt32 px (UInt32.ofNatCore 1 (by intlit)) - if h: not (y = (UInt32.ofNatCore 0 (by intlit))) - then Result.fail Error.panic - else Result.ret (UInt32.ofNatCore 2 (by intlit)) - - /- [no_nested_borrows::test_shared_borrow_bool1] -/ - def test_shared_borrow_bool1_fwd (b : Bool) : Result UInt32 := - if h: b - then Result.ret (UInt32.ofNatCore 0 (by intlit)) - else Result.ret (UInt32.ofNatCore 1 (by intlit)) - - /- [no_nested_borrows::test_shared_borrow_bool2] -/ - def test_shared_borrow_bool2_fwd : Result UInt32 := - Result.ret (UInt32.ofNatCore 0 (by intlit)) - - /- [no_nested_borrows::test_shared_borrow_enum1] -/ - def test_shared_borrow_enum1_fwd (l : list_t UInt32) : Result UInt32 := - match h: l with - | list_t.ListCons i l0 => Result.ret (UInt32.ofNatCore 1 (by intlit)) - | list_t.ListNil => Result.ret (UInt32.ofNatCore 0 (by intlit)) - - /- [no_nested_borrows::test_shared_borrow_enum2] -/ - def test_shared_borrow_enum2_fwd : Result UInt32 := - Result.ret (UInt32.ofNatCore 0 (by intlit)) - diff --git a/tests/lean/misc/no_nested_borrows/lakefile.lean b/tests/lean/misc/no_nested_borrows/lakefile.lean deleted file mode 100644 index e4460813..00000000 --- a/tests/lean/misc/no_nested_borrows/lakefile.lean +++ /dev/null @@ -1,18 +0,0 @@ -import Lake -open Lake DSL - -require mathlib from git - "https://github.com/leanprover-community/mathlib4.git" - -package «no_nested_borrows» { - -- add package configuration options here -} - -lean_lib «Base» { - -- add library configuration options here -} - -lean_lib «NoNestedBorrows» { - -- add library configuration options here -} - diff --git a/tests/lean/misc/paper/Base/Primitives.lean b/tests/lean/misc/paper/Base/Primitives.lean deleted file mode 100644 index 5b64e908..00000000 --- a/tests/lean/misc/paper/Base/Primitives.lean +++ /dev/null @@ -1,392 +0,0 @@ -import Lean -import Lean.Meta.Tactic.Simp -import Init.Data.List.Basic -import Mathlib.Tactic.RunCmd - -------------- --- PRELUDE -- -------------- - --- Results & monadic combinators - -inductive Error where - | assertionFailure: Error - | integerOverflow: Error - | arrayOutOfBounds: Error - | maximumSizeExceeded: Error - | panic: Error -deriving Repr, BEq - -open Error - -inductive Result (α : Type u) where - | ret (v: α): Result α - | fail (e: Error): Result α -deriving Repr, BEq - -open Result - -/- HELPERS -/ - -def ret? {α: Type} (r: Result α): Bool := - match r with - | Result.ret _ => true - | Result.fail _ => false - -def massert (b:Bool) : Result Unit := - if b then .ret () else fail assertionFailure - -def eval_global {α: Type} (x: Result α) (_: ret? x): α := - match x with - | Result.fail _ => by contradiction - | Result.ret x => x - -/- DO-DSL SUPPORT -/ - -def bind (x: Result α) (f: α -> Result β) : Result β := - match x with - | ret v => f v - | fail v => fail v - --- Allows using Result in do-blocks -instance : Bind Result where - bind := bind - --- Allows using return x in do-blocks -instance : Pure Result where - pure := fun x => ret x - -/- CUSTOM-DSL SUPPORT -/ - --- Let-binding the Result of a monadic operation is oftentimes not sufficient, --- because we may need a hypothesis for equational reasoning in the scope. We --- rely on subtype, and a custom let-binding operator, in effect recreating our --- own variant of the do-dsl - -def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } := - match o with - | .ret x => .ret ⟨x, rfl⟩ - | .fail e => .fail e - -macro "let" e:term " ⟵ " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- TODO: any way to factorize both definitions? -macro "let" e:term " <-- " f:term : doElem => - `(doElem| let ⟨$e, h⟩ ← Result.attach $f) - --- We call the hypothesis `h`, in effect making it unavailable to the user --- (because too much shadowing). But in practice, once can use the French single --- quote notation (input with f< and f>), where `‹ h ›` finds a suitable --- hypothesis in the context, this is equivalent to `have x: h := by assumption in x` -#eval do - let y <-- .ret (0: Nat) - let _: y = 0 := by cases ‹ ret 0 = ret y › ; decide - let r: { x: Nat // x = 0 } := ⟨ y, by assumption ⟩ - .ret r - ----------------------- --- MACHINE INTEGERS -- ----------------------- - --- NOTE: we reuse the fixed-width integer types from prelude.lean: UInt8, ..., --- USize. They are generally defined in an idiomatic style, except that there is --- not a single type class to rule them all (more on that below). The absence of --- type class is intentional, and allows the Lean compiler to efficiently map --- them to machine integers during compilation. - --- USize is designed properly: you cannot reduce `getNumBits` using the --- simplifier, meaning that proofs do not depend on the compile-time value of --- USize.size. (Lean assumes 32 or 64-bit platforms, and Rust doesn't really --- support, at least officially, 16-bit microcontrollers, so this seems like a --- fine design decision for now.) - --- Note from Chris Bailey: "If there's more than one salient property of your --- definition then the subtyping strategy might get messy, and the property part --- of a subtype is less discoverable by the simplifier or tactics like --- library_search." So, we will not add refinements on the return values of the --- operations defined on Primitives, but will rather rely on custom lemmas to --- invert on possible return values of the primitive operations. - --- Machine integer constants, done via `ofNatCore`, which requires a proof that --- the `Nat` fits within the desired integer type. We provide a custom tactic. - -syntax "intlit" : tactic - -macro_rules - | `(tactic| intlit) => `(tactic| - match USize.size, usize_size_eq with - | _, Or.inl rfl => decide - | _, Or.inr rfl => decide) - --- This is how the macro is expected to be used -#eval USize.ofNatCore 0 (by intlit) - --- Also works for other integer types (at the expense of a needless disjunction) -#eval UInt32.ofNatCore 0 (by intlit) - --- The machine integer operations (e.g. sub) are always total, which is not what --- we want. We therefore define "checked" variants, below. Note that we add a --- tiny bit of complexity for the USize variant: we first check whether the --- result is < 2^32; if it is, we can compute the definition, rather than --- returning a term that is computationally stuck (the comparison to USize.size --- cannot reduce at compile-time, per the remark about regarding `getNumBits`). --- This is useful for the various #asserts that we want to reduce at --- type-checking time. - --- Further thoughts: look at what has been done here: --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/Fin/Basic.lean --- and --- https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Data/UInt.lean --- which both contain a fair amount of reasoning already! -def USize.checked_sub (n: USize) (m: USize): Result USize := - -- NOTE: the test USize.toNat n - m >= 0 seems to always succeed? - if n >= m then - let n' := USize.toNat n - let m' := USize.toNat n - let r := USize.ofNatCore (n' - m') (by - have h: n' - m' <= n' := by - apply Nat.sub_le_of_le_add - case h => rewrite [ Nat.add_comm ]; apply Nat.le_add_left - apply Nat.lt_of_le_of_lt h - apply n.val.isLt - ) - return r - else - fail integerOverflow - -@[simp] -theorem usize_fits (n: Nat) (h: n <= 4294967295): n < USize.size := - match USize.size, usize_size_eq with - | _, Or.inl rfl => Nat.lt_of_le_of_lt h (by decide) - | _, Or.inr rfl => Nat.lt_of_le_of_lt h (by decide) - -def USize.checked_add (n: USize) (m: USize): Result USize := - if h: n.val + m.val < USize.size then - .ret ⟨ n.val + m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_rem (n: USize) (m: USize): Result USize := - if h: m > 0 then - .ret ⟨ n.val % m.val, by - have h1: ↑m.val < USize.size := m.val.isLt - have h2: n.val.val % m.val.val < m.val.val := @Nat.mod_lt n.val m.val h - apply Nat.lt_trans h2 h1 - ⟩ - else - .fail integerOverflow - -def USize.checked_mul (n: USize) (m: USize): Result USize := - if h: n.val * m.val < USize.size then - .ret ⟨ n.val * m.val, h ⟩ - else - .fail integerOverflow - -def USize.checked_div (n: USize) (m: USize): Result USize := - if m > 0 then - .ret ⟨ n.val / m.val, by - have h1: ↑n.val < USize.size := n.val.isLt - have h2: n.val.val / m.val.val <= n.val.val := @Nat.div_le_self n.val m.val - apply Nat.lt_of_le_of_lt h2 h1 - ⟩ - else - .fail integerOverflow - --- Test behavior... -#eval assert! USize.checked_sub 10 20 == fail integerOverflow; 0 - -#eval USize.checked_sub 20 10 --- NOTE: compare with concrete behavior here, which I do not think we want -#eval USize.sub 0 1 -#eval UInt8.add 255 255 - --- We now define a type class that subsumes the various machine integer types, so --- as to write a concise definition for scalar_cast, rather than exhaustively --- enumerating all of the possible pairs. We remark that Rust has sane semantics --- and fails if a cast operation would involve a truncation or modulo. - -class MachineInteger (t: Type) where - size: Nat - val: t -> Fin size - ofNatCore: (n:Nat) -> LT.lt n size -> t - -set_option hygiene false in -run_cmd - for typeName in [`UInt8, `UInt16, `UInt32, `UInt64, `USize].map Lean.mkIdent do - Lean.Elab.Command.elabCommand (← `( - namespace $typeName - instance: MachineInteger $typeName where - size := size - val := val - ofNatCore := ofNatCore - end $typeName - )) - --- Aeneas only instantiates the destination type (`src` is implicit). We rely on --- Lean to infer `src`. - -def scalar_cast { src: Type } (dst: Type) [ MachineInteger src ] [ MachineInteger dst ] (x: src): Result dst := - if h: MachineInteger.val x < MachineInteger.size dst then - .ret (MachineInteger.ofNatCore (MachineInteger.val x).val h) - else - .fail integerOverflow - -------------- --- VECTORS -- -------------- - --- Note: unlike F*, Lean seems to use strict upper bounds (e.g. USize.size) --- rather than maximum values (usize_max). -def Vec (α : Type u) := { l : List α // List.length l < USize.size } - -def vec_new (α : Type u): Vec α := ⟨ [], by { - match USize.size, usize_size_eq with - | _, Or.inl rfl => simp - | _, Or.inr rfl => simp - } ⟩ - -#check vec_new - -def vec_len (α : Type u) (v : Vec α) : USize := - let ⟨ v, l ⟩ := v - USize.ofNatCore (List.length v) l - -#eval vec_len Nat (vec_new Nat) - -def vec_push_fwd (α : Type u) (_ : Vec α) (_ : α) : Unit := () - --- NOTE: old version trying to use a subtype notation, but probably better to --- leave Result elimination to auxiliary lemmas with suitable preconditions --- TODO: I originally wrote `List.length v.val < USize.size - 1`; how can one --- make the proof work in that case? Probably need to import tactics from --- mathlib to deal with inequalities... would love to see an example. -def vec_push_back_old (α : Type u) (v : Vec α) (x : α) : { res: Result (Vec α) // - match res with | fail _ => True | ret v' => List.length v'.val = List.length v.val + 1} - := - if h : List.length v.val + 1 < USize.size then - ⟨ return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩, by simp ⟩ - else - ⟨ fail maximumSizeExceeded, by simp ⟩ - -#eval do - -- NOTE: the // notation is syntactic sugar for Subtype, a refinement with - -- fields val and property. However, Lean's elaborator can automatically - -- select the `val` field if the context provides a type annotation. We - -- annotate `x`, which relieves us of having to write `.val` on the right-hand - -- side of the monadic let. - let v := vec_new Nat - let x: Vec Nat ← (vec_push_back_old Nat v 1: Result (Vec Nat)) -- WHY do we need the type annotation here? - -- TODO: strengthen post-condition above and do a demo to show that we can - -- safely eliminate the `fail` case - return (vec_len Nat x) - -def vec_push_back (α : Type u) (v : Vec α) (x : α) : Result (Vec α) - := - if h : List.length v.val + 1 <= 4294967295 then - return ⟨ List.concat v.val x, - by - rw [List.length_concat] - have h': 4294967295 < USize.size := by intlit - apply Nat.lt_of_le_of_lt h h' - ⟩ - else if h: List.length v.val + 1 < USize.size then - return ⟨List.concat v.val x, - by - rw [List.length_concat] - assumption - ⟩ - else - fail maximumSizeExceeded - -def vec_insert_fwd (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_insert_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - -def vec_index_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_back (α : Type u) (v: Vec α) (i: USize) (_: α): Result Unit := - if i.val < List.length v.val then - .ret () - else - .fail arrayOutOfBounds - -def vec_index_mut_fwd (α : Type u) (v: Vec α) (i: USize): Result α := - if h: i.val < List.length v.val then - .ret (List.get v.val ⟨i.val, h⟩) - else - .fail arrayOutOfBounds - -def vec_index_mut_back (α : Type u) (v: Vec α) (i: USize) (x: α): Result (Vec α) := - if i.val < List.length v.val then - .ret ⟨ List.set v.val i.val x, by - have h: List.length v.val < USize.size := v.property - rewrite [ List.length_set v.val i.val x ] - assumption - ⟩ - else - .fail arrayOutOfBounds - ----------- --- MISC -- ----------- - -def mem_replace_fwd (a : Type) (x : a) (_ : a) : a := - x - -def mem_replace_back (a : Type) (_ : a) (y : a) : a := - y - -/-- Aeneas-translated function -- useful to reduce non-recursive definitions. - Use with `simp [ aeneas ]` -/ -register_simp_attr aeneas - --------------------- --- ASSERT COMMAND -- --------------------- - -open Lean Elab Command Term Meta - -syntax (name := assert) "#assert" term: command - -@[command_elab assert] -unsafe -def assertImpl : CommandElab := fun (_stx: Syntax) => do - runTermElabM (fun _ => do - let r ← evalTerm Bool (mkConst ``Bool) _stx[1] - if not r then - logInfo "Assertion failed for: " - logInfo _stx[1] - logError "Expression reduced to false" - pure ()) - -#eval 2 == 2 -#assert (2 == 2) - -------------------- --- SANITY CHECKS -- -------------------- - --- TODO: add more once we have signed integers - -#assert (USize.checked_rem 1 2 == .ret 1) diff --git a/tests/lean/misc/paper/Paper.lean b/tests/lean/misc/paper/Paper.lean deleted file mode 100644 index 4faf36ee..00000000 --- a/tests/lean/misc/paper/Paper.lean +++ /dev/null @@ -1,128 +0,0 @@ --- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS --- [paper] -import Base.Primitives - -structure OpaqueDefs where - - /- [paper::ref_incr] -/ - def ref_incr_fwd_back (x : Int32) : Result Int32 := - Int32.checked_add x (Int32.ofNatCore 1 (by intlit)) - - /- [paper::test_incr] -/ - def test_incr_fwd : Result Unit := - do - let x ← ref_incr_fwd_back (Int32.ofNatCore 0 (by intlit)) - if h: not (x = (Int32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [paper::test_incr] -/ - #assert (test_incr_fwd == .ret ()) - - /- [paper::choose] -/ - def choose_fwd (T : Type) (b : Bool) (x : T) (y : T) : Result T := - if h: b - then Result.ret x - else Result.ret y - - /- [paper::choose] -/ - def choose_back - (T : Type) (b : Bool) (x : T) (y : T) (ret0 : T) : Result (T × T) := - if h: b - then Result.ret (ret0, y) - else Result.ret (x, ret0) - - /- [paper::test_choose] -/ - def test_choose_fwd : Result Unit := - do - let z ← - choose_fwd Int32 true (Int32.ofNatCore 0 (by intlit)) - (Int32.ofNatCore 0 (by intlit)) - let z0 ← Int32.checked_add z (Int32.ofNatCore 1 (by intlit)) - if h: not (z0 = (Int32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else - do - let (x, y) ← - choose_back Int32 true (Int32.ofNatCore 0 (by intlit)) - (Int32.ofNatCore 0 (by intlit)) z0 - if h: not (x = (Int32.ofNatCore 1 (by intlit))) - then Result.fail Error.panic - else - if h: not (y = (Int32.ofNatCore 0 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [paper::test_choose] -/ - #assert (test_choose_fwd == .ret ()) - - /- [paper::List] -/ - inductive list_t (T : Type) := - | ListCons : T -> list_t T -> list_t T - | ListNil : list_t T - - /- [paper::list_nth_mut] -/ - def list_nth_mut_fwd (T : Type) (l : list_t T) (i : UInt32) : Result T := - match h: l with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret x - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - list_nth_mut_fwd T tl i0 - | list_t.ListNil => Result.fail Error.panic - - /- [paper::list_nth_mut] -/ - def list_nth_mut_back - (T : Type) (l : list_t T) (i : UInt32) (ret0 : T) : Result (list_t T) := - match h: l with - | list_t.ListCons x tl => - if h: i = (UInt32.ofNatCore 0 (by intlit)) - then Result.ret (list_t.ListCons ret0 tl) - else - do - let i0 ← UInt32.checked_sub i (UInt32.ofNatCore 1 (by intlit)) - let tl0 ← list_nth_mut_back T tl i0 ret0 - Result.ret (list_t.ListCons x tl0) - | list_t.ListNil => Result.fail Error.panic - - /- [paper::sum] -/ - def sum_fwd (l : list_t Int32) : Result Int32 := - match h: l with - | list_t.ListCons x tl => do - let i ← sum_fwd tl - Int32.checked_add x i - | list_t.ListNil => Result.ret (Int32.ofNatCore 0 (by intlit)) - - /- [paper::test_nth] -/ - def test_nth_fwd : Result Unit := - do - let l := list_t.ListNil - let l0 := list_t.ListCons (Int32.ofNatCore 3 (by intlit)) l - let l1 := list_t.ListCons (Int32.ofNatCore 2 (by intlit)) l0 - let x ← - list_nth_mut_fwd Int32 (list_t.ListCons (Int32.ofNatCore 1 (by intlit)) - l1) (UInt32.ofNatCore 2 (by intlit)) - let x0 ← Int32.checked_add x (Int32.ofNatCore 1 (by intlit)) - let l2 ← - list_nth_mut_back Int32 (list_t.ListCons - (Int32.ofNatCore 1 (by intlit)) l1) (UInt32.ofNatCore 2 (by intlit)) - x0 - let i ← sum_fwd l2 - if h: not (i = (Int32.ofNatCore 7 (by intlit))) - then Result.fail Error.panic - else Result.ret () - - /- Unit test for [paper::test_nth] -/ - #assert (test_nth_fwd == .ret ()) - - /- [paper::call_choose] -/ - def call_choose_fwd (p : (UInt32 × UInt32)) : Result UInt32 := - do - let (px, py) := p - let pz ← choose_fwd UInt32 true px py - let pz0 ← UInt32.checked_add pz (UInt32.ofNatCore 1 (by intlit)) - let (px0, _) ← choose_back UInt32 true px py pz0 - Result.ret px0 - diff --git a/tests/lean/misc/paper/lakefile.lean b/tests/lean/misc/paper/lakefile.lean deleted file mode 100644 index d8affff8..00000000 --- a/tests/lean/misc/paper/lakefile.lean +++ /dev/null @@ -1,18 +0,0 @@ -import Lake -open Lake DSL - -require mathlib from git - "https://github.com/leanprover-community/mathlib4.git" - -package «paper» { - -- add package configuration options here -} - -lean_lib «Base» { - -- add library configuration options here -} - -lean_lib «Paper» { - -- add library configuration options here -} - -- cgit v1.2.3