| /- |
| Copyright (c) 2026 R.W. Yett. Released under Apache 2.0. |
|
|
| Constructed initial algebra for one polynomial functor. |
|
|
| F X = Shape α X has two constructors: nil, and cons of a head in α with a tail in X. |
| The inductive type List α is the carrier. inn and out are defined by the constructors |
| and proved inverse. fold is the catamorphism, and it is proved unique. |
| eval is inn. It is proved to be the two-sided inverse of out. |
|
|
| This file does not assume an InitialFAlgebra. It does not construct a final |
| coalgebra of infinite lists. It does not identify this functor with a physical tensor. |
| -/ |
|
|
| namespace ResNova.Foundations.ListInitialAlgebra |
|
|
| inductive Shape (α : Type) (x : Type) where |
| | nil |
| | cons (head : α) (tail : x) |
| deriving DecidableEq |
|
|
| def mapShape {α x y : Type} (f : x → y) : Shape α x → Shape α y |
| | .nil => .nil |
| | .cons h t => .cons h (f t) |
|
|
| theorem mapShape_id {α x : Type} (s : Shape α x) : mapShape (id : x → x) s = s := by |
| cases s <;> rfl |
|
|
| theorem mapShape_comp {α x y z : Type} (f : x → y) (g : y → z) (s : Shape α x) : |
| mapShape (g ∘ f) s = mapShape g (mapShape f s) := by |
| cases s <;> rfl |
|
|
| def inn {α : Type} : Shape α (List α) → List α |
| | .nil => [] |
| | .cons h t => h :: t |
|
|
| def out {α : Type} : List α → Shape α (List α) |
| | [] => .nil |
| | h :: t => .cons h t |
|
|
| theorem out_inn {α : Type} (s : Shape α (List α)) : out (inn s) = s := by |
| cases s <;> rfl |
|
|
| theorem inn_out {α : Type} (xs : List α) : inn (out xs) = xs := by |
| cases xs <;> rfl |
|
|
| / |
| def eval {α : Type} : Shape α (List α) → List α := |
| inn |
|
|
| theorem eval_out_left {α : Type} (s : Shape α (List α)) : out (eval s) = s := |
| out_inn s |
|
|
| theorem eval_out_right {α : Type} (xs : List α) : eval (out xs) = xs := |
| inn_out xs |
|
|
| def fold {α β : Type} (alg : Shape α β → β) : List α → β |
| | [] => alg .nil |
| | h :: t => alg (.cons h (fold alg t)) |
|
|
| theorem fold_step {α β : Type} (alg : Shape α β → β) (s : Shape α (List α)) : |
| fold alg (inn s) = alg (mapShape (fold alg) s) := by |
| cases s <;> rfl |
|
|
| theorem fold_unique {α β : Type} (alg : Shape α β → β) (h : List α → β) |
| (comm : ∀ s : Shape α (List α), h (inn s) = alg (mapShape h s)) : |
| ∀ xs : List α, h xs = fold alg xs := by |
| intro xs |
| induction xs with |
| | nil => |
| have hc := comm .nil |
| simpa [inn, mapShape, fold] using hc |
| | cons a t ih => |
| have hc := comm (.cons a t) |
| have hc' : h (a :: t) = alg (.cons a (h t)) := by |
| simpa [inn, mapShape] using hc |
| rw [hc', ih] |
| rfl |
|
|
| / |
| theorem fold_inn_id {α : Type} (xs : List α) : fold inn xs = xs := by |
| induction xs with |
| | nil => rfl |
| | cons _ _ ih => |
| simp [fold, inn, ih] |
|
|
| theorem fold_eval_id {α : Type} (xs : List α) : fold (eval (α := α)) xs = xs := by |
| simpa [eval] using fold_inn_id xs |
|
|
| / |
| theorem execute_unique {α β : Type} (alg : Shape α β → β) (h : List α → β) |
| (comm : ∀ s : Shape α (List α), h (inn s) = alg (mapShape h s)) : |
| h = fold alg := by |
| funext xs |
| exact fold_unique alg h comm xs |
|
|
| def execute {α β : Type} (alg : Shape α β → β) : List α → β := |
| fold alg |
|
|
| theorem execute_step {α β : Type} (alg : Shape α β → β) (s : Shape α (List α)) : |
| execute alg (eval s) = alg (mapShape (execute alg) s) := |
| fold_step alg s |
|
|
| end ResNova.Foundations.ListInitialAlgebra |
|
|
