Lean migration: Phases 0-2 (core lattice/chain, fixpoint, transport)
- lean/ lake project pinned to Lean v4.17.0 + mathlib v4.17.0 - Spa.Lattice: fold monotonicity, FixedHeight/BoundedChains (LTSeries-based), FiniteHeightLattice, chain-bottom-is-least; the rest of Lattice.agda, Chain.agda and Equivalence.agda lift into mathlib (see LEAN_MIGRATION.md) - Spa.Fixedpoint: gas-based least-fixpoint computation (doStep/fix/aFix) - Spa.Isomorphism: FixedHeight transport along monotone inverse pairs Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
75
lean/Spa/Fixedpoint.lean
Normal file
75
lean/Spa/Fixedpoint.lean
Normal file
@@ -0,0 +1,75 @@
|
||||
/-
|
||||
Port of `Fixedpoint.agda`.
|
||||
|
||||
Same gas-based algorithm: iterate `f` starting at the chain-bottom `⊥`; since
|
||||
the lattice has fixed height `h`, a fixed point must be reached within `h + 1`
|
||||
steps, or we would build a `<`-chain longer than the longest one. We
|
||||
deliberately do *not* use mathlib's `OrderHom.lfp` (different proof approach,
|
||||
and not computable).
|
||||
|
||||
Correspondence:
|
||||
doStep ↦ Spa.Fixedpoint.doStep (the chain argument now carries
|
||||
`a₁ = ⊥` and its length in the
|
||||
`LTSeries` structure itself)
|
||||
fix ↦ Spa.Fixedpoint.fix
|
||||
aᶠ ↦ Spa.Fixedpoint.aFix
|
||||
aᶠ≈faᶠ ↦ Spa.Fixedpoint.aFix_eq
|
||||
stepPreservesLess ↦ Spa.Fixedpoint.doStep_le
|
||||
aᶠ≼ ↦ Spa.Fixedpoint.aFix_le
|
||||
-/
|
||||
import Spa.Lattice
|
||||
|
||||
namespace Spa.Fixedpoint
|
||||
|
||||
variable {α : Type*} [Lattice α] [DecidableEq α] {h : ℕ}
|
||||
|
||||
/-- Agda: `doStep`. `g` is gas; the invariant `c.length + g = h + 1` guarantees
|
||||
that when gas runs out the chain contradicts boundedness. -/
|
||||
def doStep (fh : FixedHeight α h) (f : α → α) (hf : Monotone f) :
|
||||
∀ (g : ℕ) (c : LTSeries α), c.length + g = h + 1 →
|
||||
c.last ≤ f c.last → {a : α // a = f a}
|
||||
| 0, c, hlen, _ =>
|
||||
absurd (fh.bounded c) (by omega)
|
||||
| g + 1, c, hlen, hle =>
|
||||
if heq : c.last = f c.last then
|
||||
⟨c.last, heq⟩
|
||||
else
|
||||
doStep fh f hf g (c.snoc (f c.last) (lt_of_le_of_ne hle heq))
|
||||
(by simp [RelSeries.snoc]; omega)
|
||||
(by rw [RelSeries.last_snoc]; exact hf hle)
|
||||
|
||||
/-- Agda: `fix`. Start iterating from `⊥`. -/
|
||||
def fix (fh : FixedHeight α h) (f : α → α) (hf : Monotone f) : {a : α // a = f a} :=
|
||||
doStep fh f hf (h + 1) (RelSeries.singleton _ fh.bot)
|
||||
(by simp)
|
||||
(by simpa [RelSeries.last_singleton] using fh.bot_le (f fh.bot))
|
||||
|
||||
/-- Agda: `aᶠ`. -/
|
||||
def aFix (fh : FixedHeight α h) (f : α → α) (hf : Monotone f) : α :=
|
||||
(fix fh f hf).1
|
||||
|
||||
/-- Agda: `aᶠ≈faᶠ`. -/
|
||||
theorem aFix_eq (fh : FixedHeight α h) (f : α → α) (hf : Monotone f) :
|
||||
aFix fh f hf = f (aFix fh f hf) :=
|
||||
(fix fh f hf).2
|
||||
|
||||
/-- Agda: `stepPreservesLess` — iteration stays below any fixed point. -/
|
||||
theorem doStep_le (fh : FixedHeight α h) (f : α → α) (hf : Monotone f)
|
||||
{b : α} (hb : b = f b) :
|
||||
∀ (g : ℕ) (c : LTSeries α) (hlen : c.length + g = h + 1)
|
||||
(hle : c.last ≤ f c.last), c.last ≤ b →
|
||||
(doStep fh f hf g c hlen hle : α) ≤ b
|
||||
| 0, c, hlen, _ => fun _ => absurd (fh.bounded c) (by omega)
|
||||
| g + 1, c, hlen, hle => fun hcb => by
|
||||
rw [doStep]
|
||||
split
|
||||
· exact hcb
|
||||
· exact doStep_le fh f hf hb g _ _ _
|
||||
(by rw [RelSeries.last_snoc]; exact le_of_le_of_eq (hf hcb) hb.symm)
|
||||
|
||||
/-- Agda: `aᶠ≼` — `aFix` is below every fixed point of `f`. -/
|
||||
theorem aFix_le (fh : FixedHeight α h) (f : α → α) (hf : Monotone f)
|
||||
{a : α} (ha : a = f a) : aFix fh f hf ≤ a :=
|
||||
doStep_le fh f hf ha _ _ _ _ (by simpa using fh.bot_le a)
|
||||
|
||||
end Spa.Fixedpoint
|
||||
58
lean/Spa/Isomorphism.lean
Normal file
58
lean/Spa/Isomorphism.lean
Normal file
@@ -0,0 +1,58 @@
|
||||
/-
|
||||
Port of `Isomorphism.agda` (`TransportFiniteHeight`).
|
||||
|
||||
With propositional equality this module shrinks dramatically: the Agda
|
||||
hypotheses `f-preserves-≈`, `g-preserves-≈` are free, and `f-⊔-distr` /
|
||||
`g-⊔-distr` (which in the setoid world encoded monotonicity of `f` and `g`
|
||||
w.r.t. the derived order) become plain `Monotone` hypotheses. The chain
|
||||
transport `portChain₁` / `portChain₂` is mathlib's `LTSeries.map`, using that
|
||||
a monotone injective map between partial orders is strictly monotone.
|
||||
|
||||
Correspondence:
|
||||
IsInverseˡ / IsInverseʳ ↦ explicit inverse hypotheses `hfg` / `hgf`
|
||||
f-Injective / g-Injective ↦ local `Function.LeftInverse.injective`
|
||||
portChain₁ / portChain₂ ↦ LTSeries.map
|
||||
instance fixedHeight ↦ Spa.FixedHeight.transport
|
||||
isFiniteHeightLattice,
|
||||
finiteHeightLattice ↦ Spa.FiniteHeightLattice.transport
|
||||
-/
|
||||
import Spa.Lattice
|
||||
|
||||
namespace Spa
|
||||
|
||||
namespace FixedHeight
|
||||
|
||||
variable {α β : Type*} [PartialOrder α] [PartialOrder β] {h : ℕ}
|
||||
|
||||
/-- Agda: `TransportFiniteHeight.fixedHeight`. Transport a `FixedHeight`
|
||||
structure along a monotone inverse pair `f : α → β`, `g : β → α`. -/
|
||||
def transport (fh : FixedHeight α h) (f : α → β) (g : β → α)
|
||||
(hf : Monotone f) (hg : Monotone g)
|
||||
(hgf : ∀ a, g (f a) = a) (hfg : ∀ b, f (g b) = b) :
|
||||
FixedHeight β h where
|
||||
bot := f fh.bot
|
||||
top := f fh.top
|
||||
longestChain :=
|
||||
fh.longestChain.map f
|
||||
(hf.strictMono_of_injective (Function.LeftInverse.injective hgf))
|
||||
head_longestChain := by
|
||||
rw [LTSeries.head_map, fh.head_longestChain]
|
||||
last_longestChain := by
|
||||
rw [LTSeries.last_map, fh.last_longestChain]
|
||||
length_longestChain := fh.length_longestChain
|
||||
bounded := fun c =>
|
||||
fh.bounded
|
||||
(c.map g (hg.strictMono_of_injective (Function.LeftInverse.injective hfg)))
|
||||
|
||||
end FixedHeight
|
||||
|
||||
/-- Agda: `TransportFiniteHeight.finiteHeightLattice`. -/
|
||||
def FiniteHeightLattice.transport {α β : Type*} [Lattice α] [Lattice β]
|
||||
(I : FiniteHeightLattice α) (f : α → β) (g : β → α)
|
||||
(hf : Monotone f) (hg : Monotone g)
|
||||
(hgf : ∀ a, g (f a) = a) (hfg : ∀ b, f (g b) = b) :
|
||||
FiniteHeightLattice β where
|
||||
height := I.height
|
||||
fixedHeight := I.fixedHeight.transport f g hf hg hgf hfg
|
||||
|
||||
end Spa
|
||||
138
lean/Spa/Lattice.lean
Normal file
138
lean/Spa/Lattice.lean
Normal file
@@ -0,0 +1,138 @@
|
||||
/-
|
||||
Port of `Lattice.agda`.
|
||||
|
||||
Most of the Agda module is *lifted* into mathlib, since we now work with
|
||||
propositional equality instead of a setoid:
|
||||
|
||||
IsSemilattice A _≈_ _⊔_ ↦ SemilatticeSup α
|
||||
IsLattice A _≈_ _⊔_ _⊓_ ↦ Lattice α
|
||||
_≼_ (a ⊔ b ≈ b) ↦ a ≤ b (bridge: `sup_eq_right`)
|
||||
_≺_ ↦ a < b
|
||||
Monotonic ↦ Monotone
|
||||
⊔-assoc/⊔-comm/⊔-idemp ↦ sup_assoc/sup_comm/sup_idem
|
||||
absorb-⊔-⊓/absorb-⊓-⊔ ↦ sup_inf_self/inf_sup_self
|
||||
≼-refl/≼-trans/≼-antisym ↦ le_refl/le_trans/le_antisymm
|
||||
x≼x⊔y ↦ le_sup_left
|
||||
⊔-Monotonicˡ/ʳ ↦ sup_le_sup_left/sup_le_sup_right
|
||||
id-Mono/const-Mono ↦ monotone_id/monotone_const
|
||||
IsDecidable ↦ DecidableEq (kept only where computation needs it)
|
||||
Chain (Chain.agda) ↦ LTSeries (chains of `<`); concat ↦ RelSeries.smash
|
||||
ChainMapping.Chain-map ↦ LTSeries.map (Monotone + Injective ⇒ StrictMono)
|
||||
|
||||
What remains custom is exactly what mathlib does not have:
|
||||
* monotonicity of folds over pairwise-related lists (foldr-Mono & friends),
|
||||
* the fixed-height machinery (Chain.Height ↦ FixedHeight, Bounded),
|
||||
* the proof that the bottom of the longest chain is a least element (⊥≼).
|
||||
-/
|
||||
import Mathlib.Order.Lattice
|
||||
import Mathlib.Order.RelSeries
|
||||
|
||||
namespace Spa
|
||||
|
||||
/-! ### Monotonicity helpers (Lattice.agda, `Monotonic₂` and fold lemmas) -/
|
||||
|
||||
/-- Agda: `Monotonic₂` (a pair of one-sided monotonicity proofs). -/
|
||||
def Monotone₂ {α β γ : Type*} [Preorder α] [Preorder β] [Preorder γ]
|
||||
(f : α → β → γ) : Prop :=
|
||||
(∀ b, Monotone fun a => f a b) ∧ (∀ a, Monotone (f a))
|
||||
|
||||
section Folds
|
||||
|
||||
variable {α β : Type*} [Preorder α] [Preorder β]
|
||||
|
||||
/-- Agda: `foldr-Mono`. `Pairwise _≼₁_` becomes `List.Forall₂ (· ≤ ·)`. -/
|
||||
theorem foldr_mono {l₁ l₂ : List α} (f : α → β → β) {b₁ b₂ : β}
|
||||
(hl : List.Forall₂ (· ≤ ·) l₁ l₂) (hb : b₁ ≤ b₂)
|
||||
(hf₁ : ∀ b, Monotone fun a => f a b) (hf₂ : ∀ a, Monotone (f a)) :
|
||||
l₁.foldr f b₁ ≤ l₂.foldr f b₂ := by
|
||||
induction hl with
|
||||
| nil => exact hb
|
||||
| cons hxy _ ih =>
|
||||
exact le_trans (hf₁ _ hxy) (hf₂ _ ih)
|
||||
|
||||
/-- Agda: `foldl-Mono`. -/
|
||||
theorem foldl_mono {l₁ l₂ : List α} (f : β → α → β) {b₁ b₂ : β}
|
||||
(hl : List.Forall₂ (· ≤ ·) l₁ l₂) (hb : b₁ ≤ b₂)
|
||||
(hf₁ : ∀ a, Monotone fun b => f b a) (hf₂ : ∀ b, Monotone (f b)) :
|
||||
l₁.foldl f b₁ ≤ l₂.foldl f b₂ := by
|
||||
induction hl generalizing b₁ b₂ with
|
||||
| nil => exact hb
|
||||
| cons hxy _ ih =>
|
||||
exact ih (le_trans (hf₁ _ hb) (hf₂ _ hxy))
|
||||
|
||||
omit [Preorder α] in
|
||||
/-- Agda: `foldr-Mono'` (fixed list, varying accumulator). -/
|
||||
theorem foldr_mono' (l : List α) (f : α → β → β)
|
||||
(hf : ∀ a, Monotone (f a)) : Monotone fun b => l.foldr f b := by
|
||||
intro b₁ b₂ hb
|
||||
induction l with
|
||||
| nil => exact hb
|
||||
| cons x xs ih => exact hf x ih
|
||||
|
||||
omit [Preorder α] in
|
||||
/-- Agda: `foldl-Mono'`. -/
|
||||
theorem foldl_mono' (l : List α) (f : β → α → β)
|
||||
(hf : ∀ a, Monotone fun b => f b a) : Monotone fun b => l.foldl f b := by
|
||||
intro b₁ b₂ hb
|
||||
induction l generalizing b₁ b₂ with
|
||||
| nil => exact hb
|
||||
| cons x xs ih => exact ih (hf x hb)
|
||||
|
||||
end Folds
|
||||
|
||||
/-! ### Fixed height (Chain.agda `Bounded`/`Height`, Lattice.agda `FixedHeight`) -/
|
||||
|
||||
/-- Agda: `Chain.Bounded`. Every `<`-chain has length at most `n`. -/
|
||||
def BoundedChains (α : Type*) [Preorder α] (n : ℕ) : Prop :=
|
||||
∀ c : LTSeries α, c.length ≤ n
|
||||
|
||||
/-- Agda: `Chain.Height` (with `FixedHeight h = Height h` from Lattice.agda).
|
||||
A longest chain runs from `⊥` to `⊤` and has length exactly `height`;
|
||||
no chain is longer. -/
|
||||
structure FixedHeight (α : Type*) [Preorder α] (height : ℕ) where
|
||||
bot : α
|
||||
top : α
|
||||
longestChain : LTSeries α
|
||||
head_longestChain : longestChain.head = bot
|
||||
last_longestChain : longestChain.last = top
|
||||
length_longestChain : longestChain.length = height
|
||||
bounded : BoundedChains α height
|
||||
|
||||
/-- Agda: `Chain.Bounded-suc-n` (a bounded order admits no chain one longer). -/
|
||||
theorem BoundedChains.no_longer {α : Type*} [Preorder α] {n : ℕ}
|
||||
(h : BoundedChains α n) (c : LTSeries α) : c.length ≠ n + 1 :=
|
||||
fun hc => absurd (h c) (by omega)
|
||||
|
||||
/-- Agda: `IsFiniteHeightLattice` / `FiniteHeightLattice` (bundled). -/
|
||||
class FiniteHeightLattice (α : Type*) [Lattice α] where
|
||||
height : ℕ
|
||||
fixedHeight : FixedHeight α height
|
||||
|
||||
namespace FixedHeight
|
||||
|
||||
variable {α : Type*} [Lattice α] {h : ℕ}
|
||||
|
||||
/-- Agda: `Known-⊥`. -/
|
||||
def KnownBot (fh : FixedHeight α h) : Prop := ∀ a : α, fh.bot ≤ a
|
||||
|
||||
/-- Agda: `Known-⊤`. -/
|
||||
def KnownTop (fh : FixedHeight α h) : Prop := ∀ a : α, a ≤ fh.top
|
||||
|
||||
/-- Agda: `⊥≼` — the bottom of the longest chain is a least element.
|
||||
Same proof: if `⊥ ⊓ a ≠ ⊥` then `⊥ ⊓ a < ⊥` prepends to the longest chain,
|
||||
contradicting boundedness. (The decidability hypothesis of the Agda proof is
|
||||
not needed classically.) -/
|
||||
theorem bot_le (fh : FixedHeight α h) : fh.KnownBot := by
|
||||
intro a
|
||||
by_cases heq : fh.bot ⊓ a = fh.bot
|
||||
· exact inf_eq_left.mp heq
|
||||
· exfalso
|
||||
have hlt : fh.bot ⊓ a < fh.bot :=
|
||||
lt_of_le_of_ne inf_le_left heq
|
||||
exact fh.bounded.no_longer
|
||||
(fh.longestChain.cons (fh.bot ⊓ a) (fh.head_longestChain ▸ hlt))
|
||||
(by simp [RelSeries.cons, fh.length_longestChain])
|
||||
|
||||
end FixedHeight
|
||||
|
||||
end Spa
|
||||
Reference in New Issue
Block a user