08eb78a5b2
This PR sets up the new integrated test/bench suite. It then migrates all benchmarks and some related tests to the new suite. There's also some documentation and some linting. For now, a lot of the old tests are left alone so this PR doesn't become even larger than it already is. Eventually, all tests should be migrated to the new suite though so there isn't a confusing mix of two systems.
104 lines
3.4 KiB
Text
104 lines
3.4 KiB
Text
inductive Tree where | node : List Tree → Tree
|
||
|
||
mutual
|
||
def Tree.size : Tree → Nat
|
||
| node ts => list_size ts
|
||
|
||
def Tree.list_size : List Tree → Nat
|
||
| [] => 0
|
||
| t::ts => t.size + list_size ts
|
||
end
|
||
|
||
example : Tree.list_size (t :: ts) = t.size + Tree.list_size ts := rfl
|
||
|
||
-- If we only look at the nested type at a finite depth we don't need an auxiliary definition:
|
||
|
||
def Tree.isList : Tree → Bool
|
||
| .node [] => true
|
||
| .node [t] => t.isList
|
||
| .node _ => false
|
||
|
||
|
||
-- A nested inductive type
|
||
-- the `Bool → RTree α` prevents well-founded recursion and
|
||
-- tests support for reflexive types
|
||
|
||
inductive RTree (α : Type u) : Type u
|
||
| node : α → (Bool → RTree α) → List (RTree α) → RTree α
|
||
|
||
-- only recurse on the non-nested component
|
||
def RTree.simple_size : RTree α → Nat
|
||
| .node _x t _ts => 1 + (t true).simple_size + (t false).simple_size
|
||
|
||
/--
|
||
info: @[defeq] theorem RTree.simple_size.eq_1.{u_1} : ∀ {α : Type u_1} (_x : α) (t : Bool → RTree α) (_ts : List (RTree α)),
|
||
(RTree.node _x t _ts).simple_size = 1 + (t true).simple_size + (t false).simple_size :=
|
||
fun {α} _x t _ts => Eq.refl (RTree.node _x t _ts).simple_size
|
||
-/
|
||
#guard_msgs in
|
||
#print RTree.simple_size.eq_1
|
||
|
||
-- set_option trace.Elab.definition.structural true
|
||
|
||
-- also recurse on the nested components
|
||
#guard_msgs in
|
||
mutual
|
||
def RTree.size : RTree α → Nat
|
||
| .node _ t ts => 1 + (t true).size + (t false).size + aux_size ts
|
||
def RTree.aux_size : List (RTree α) → Nat
|
||
| [] => 0
|
||
| t::ts => t.size + aux_size ts
|
||
end
|
||
|
||
/--
|
||
info: @[defeq] theorem RTree.aux_size.eq_2.{u_1} : ∀ {α : Type u_1} (t : RTree α) (ts : List (RTree α)),
|
||
RTree.aux_size (t :: ts) = t.size + RTree.aux_size ts :=
|
||
fun {α} t ts => Eq.refl (RTree.aux_size (t :: ts))
|
||
-/
|
||
#guard_msgs in
|
||
#print RTree.aux_size.eq_2
|
||
|
||
mutual
|
||
def RTree.map (f : α → β) : RTree α → RTree β
|
||
| .node x t ts => .node (f x) (fun b => (t b).map f) (map_aux f ts)
|
||
def RTree.map_aux (f : α → β) : List (RTree α) → List (RTree β)
|
||
| [] => []
|
||
| t::ts => t.map f :: map_aux f ts
|
||
end
|
||
|
||
/--
|
||
info: @[defeq] theorem RTree.map_aux.eq_2.{u_1, u_2} : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (t : RTree α)
|
||
(ts : List (RTree α)), RTree.map_aux f (t :: ts) = RTree.map f t :: RTree.map_aux f ts :=
|
||
fun {α} {β} f t ts => Eq.refl (RTree.map_aux f (t :: ts))
|
||
-/
|
||
#guard_msgs in
|
||
#print RTree.map_aux.eq_2
|
||
|
||
|
||
inductive Vec (α : Type u) : Nat → Bool → Type u where
|
||
| empty : Vec α 0 false
|
||
| succ : α → Vec α n b → Vec α (n + 1) true
|
||
|
||
-- Now an example with indices all over the place
|
||
|
||
inductive VTree (α : Type u) : Bool → Nat → Type u
|
||
| node (b : Bool) (n : Nat) : α → (List Bool → List Nat → Vec (VTree α true 5) n b) → VTree α (!b) (n+1)
|
||
|
||
mutual
|
||
def VTree.size : VTree α b n → Nat
|
||
| .node _ _ _ f => 1 + vec_size (f [] [])
|
||
-- We have to write `VTree α true 5` here, and cannot write `VTree α b' n'` here.
|
||
-- This seems to be reasonable, cf. the type of the motives of `VTree.rec`
|
||
def VTree.vec_size : Vec (VTree α true 5) n b → Nat
|
||
| .empty => 0
|
||
| .succ t ts => t.size + vec_size ts
|
||
end
|
||
|
||
/--
|
||
info: @[defeq] theorem VTree.size.eq_1.{u_1} : ∀ {α : Type u_1} (b_2 : Bool) (n_2 : Nat) (a : α)
|
||
(f : List Bool → List Nat → Vec (VTree α true 5) n_2 b_2),
|
||
(VTree.node b_2 n_2 a f).size = 1 + VTree.vec_size (f [] []) :=
|
||
fun {α} b_2 n_2 a f => Eq.refl (VTree.node b_2 n_2 a f).size
|
||
-/
|
||
#guard_msgs in
|
||
#print VTree.size.eq_1
|