77 lines
2.7 KiB
Lean4
77 lines
2.7 KiB
Lean4
|
/-
|
|||
|
|
Port of `Lattice/IterProd.agda`: the `k`-fold product `A × (A × ⋯ × B)`.
|
|||
|
|
|
|||
|
|
With propositional equality and typeclasses, the Agda `Everything` record
|
|||
|
|
(which threaded the lattice operations and the conditional fixed-height proof
|
|||
|
|
through one recursion, so that the operations built by separate recursions
|
|||
|
|
would agree) is no longer needed: the `Lattice` instance is one recursive
|
|||
|
|
definition, and the fixed-height structure is another recursion over it.
|
|||
|
|
|
|||
|
|
Correspondence:
|
|||
|
|
IterProd ↦ Spa.IterProd
|
|||
|
|
build ↦ Spa.IterProd.build
|
|||
|
|
isLattice/lattice ↦ instance Spa.IterProd.instLattice
|
|||
|
|
fixedHeight,
|
|||
|
|
isFiniteHeightLattice,
|
|||
|
|
finiteHeightLattice ↦ Spa.IterProd.fixedHeight (+ FiniteHeightLattice instance)
|
|||
|
|
⊥-built ↦ Spa.IterProd.bot_fixedHeight
|
|||
|
|
-/
|
|||
|
|
import Spa.Lattice.Prod
|
|||
|
|
import Spa.Lattice.Unit
|
|||
|
|
import Mathlib.Tactic.Ring
|
|||
|
|
|
|||
|
|
namespace Spa
|
|||
|
|
|
|||
|
|
universe u
|
|||
|
|
|
|||
|
|
/-- Agda: `IterProd k = iterate k (A × ·) B`. (As in the Agda module, `A` and
|
|||
|
|
`B` are constrained to the same universe to keep the recursion simple.) -/
|
|||
|
|
def IterProd (A B : Type u) : ℕ → Type u
|
|||
|
|
| 0 => B
|
|||
|
|
| k + 1 => A × IterProd A B k
|
|||
|
|
|
|||
|
|
namespace IterProd
|
|||
|
|
|
|||
|
|
variable {A B : Type u}
|
|||
|
|
|
|||
|
|
instance instLattice [Lattice A] [Lattice B] :
|
|||
|
|
∀ k, Lattice (IterProd A B k)
|
|||
|
|
| 0 => inferInstanceAs (Lattice B)
|
|||
|
|
| k + 1 => @Prod.instLattice A (IterProd A B k) _ (instLattice k)
|
|||
|
|
|
|||
|
|
instance instDecidableEq [DecidableEq A] [DecidableEq B] :
|
|||
|
|
∀ k, DecidableEq (IterProd A B k)
|
|||
|
|
| 0 => inferInstanceAs (DecidableEq B)
|
|||
|
|
| k + 1 => @instDecidableEqProd A (IterProd A B k) _ (instDecidableEq k)
|
|||
|
|
|
|||
|
|
/-- Agda: `build`. -/
|
|||
|
|
def build (a : A) (b : B) : (k : ℕ) → IterProd A B k
|
|||
|
|
| 0 => b
|
|||
|
|
| k + 1 => (a, build a b k)
|
|||
|
|
|
|||
|
|
variable [Lattice A] [Lattice B]
|
|||
|
|
|
|||
|
|
/-- Agda: `fixedHeight` (the `isFiniteHeightIfSupported` recursion). -/
|
|||
|
|
def fixedHeight {hA hB : ℕ} (fhA : FixedHeight A hA) (fhB : FixedHeight B hB) :
|
|||
|
|
(k : ℕ) → FixedHeight (IterProd A B k) (k * hA + hB)
|
|||
|
|
| 0 => fhB.cast (by ring)
|
|||
|
|
| k + 1 => (fhA.prod (fixedHeight fhA fhB k)).cast (by ring)
|
|||
|
|
|
|||
|
|
/-- Agda: `⊥-built` — the bottom of the iterated product is built from the
|
|||
|
|
component bottoms. -/
|
|||
|
|
theorem bot_fixedHeight {hA hB : ℕ} (fhA : FixedHeight A hA) (fhB : FixedHeight B hB) :
|
|||
|
|
∀ k, (fixedHeight fhA fhB k).bot = build fhA.bot fhB.bot k
|
|||
|
|
| 0 => rfl
|
|||
|
|
| k + 1 => by
|
|||
|
|
show (fhA.bot, (fixedHeight fhA fhB k).bot) = (fhA.bot, build fhA.bot fhB.bot k)
|
|||
|
|
rw [bot_fixedHeight fhA fhB k]
|
|||
|
|
|
|||
|
|
instance [IA : FiniteHeightLattice A] [IB : FiniteHeightLattice B] (k : ℕ) :
|
|||
|
|
FiniteHeightLattice (IterProd A B k) where
|
|||
|
|
height := k * IA.height + IB.height
|
|||
|
|
fixedHeight := fixedHeight IA.fixedHeight IB.fixedHeight k
|
|||
|
|
|
|||
|
|
end IterProd
|
|||
|
|
|
|||
|
|
end Spa
|