Aether Catalog definitions — Bridges_HilbertSpace_TheoremSpaceRenormalization
DefinitionBridges_HilbertSpace_TheoremSpaceRenormalizationaether-catalogbridges
Definition bundle for the Aether Catalog module Bridges.HilbertSpace.TheoremSpaceRenormalization, transplanted by skeleton subtraction; supplies the types and constants the catalog's theorems import.
Definition code
-- Def bundle generated from Bridges/HilbertSpace/TheoremSpaceRenormalization.lean by skeleton subtraction
import Mathlib
/-
Copyright (c) 2025 Harmonic. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
# Renormalization of Theorem Space: Universality Classes of Mathematical Theories
We formalize a mathematical framework for studying universality classes of
proof dependency structures through renormalization group (RG) flow. The central
objects are "strict depth flows" — dynamical systems with a well-founded depth
measure guaranteeing convergence — and "flow morphisms" that transfer universality
structure between systems.
## Main Definitions
* `StrictDepthFlow` — A self-map with a depth function that strictly decreases
at each non-fixed step, guaranteeing convergence.
* `FlowMorphism` — A structure-preserving map between two dynamical systems
that intertwines their step functions.
* `CoarseGraining` — A surjective flow morphism representing the passage from
a fine-grained to a coarse-grained description.
* `EventualEq` — Two points are eventually equal if their iterates agree from
some point onward; this defines universality classes.
## Main Results
* `sdf_fixed_after_depth` — In a strict depth flow, every point reaches a
fixed point within `depth(x)` iteration steps. (Convergence theorem)
* `flow_morphism_preserves_eventual_eq` — Flow morphisms preserve the eventual
equality relation, hence map universality classes to universality classes.
* `coarse_graining_class_surjection` — Coarse-graining induces a surjection on
universality classes, proving classes can only merge, never split.
* `finite_flow_class_count_bound` — For a finite type with n elements, the
number of fixed points (hence universality classes for strict depth flows)
is at most n.
* `depth_flow_morphism_composition` — Flow morphisms compose, showing that
iterated coarse-graining is itself a coarse-graining.
-/
namespace TheoremSpaceRG
/-! ## Section 1: Strict Depth Flows
A strict depth flow is a dynamical system `(α, step)` equipped with a natural
number-valued "depth" function that strictly decreases at each non-fixed step.
This guarantees that every orbit reaches a fixed point in finitely many steps,
with the convergence time bounded by the initial depth.
This models the renormalization of proof dependency structures: each coarse-graining
step reduces the "complexity depth" of the dependency graph until reaching an
irreducible fixed-point structure — the universality class signature.
-/
/-- A strict depth flow: a self-map with a depth function that strictly decreases
at non-fixed points, guaranteeing finite-time convergence to fixed points. -/
structure StrictDepthFlow (α : Type*) where
/-- The step function (renormalization operator) -/
step : α → α
/-- The depth measure (complexity of the state) -/
depth : α → ℕ
/-- Depth strictly decreases at non-fixed points -/
depth_decrease : ∀ x, step x ≠ x → depth (step x) < depth x
/-- Iteration of a strict depth flow's step function. -/
def sdfIterate {α : Type*} (f : StrictDepthFlow α) : ℕ → α → α
| 0, x => x
| n + 1, x => f.step (sdfIterate f n x)
/-
**Convergence Theorem**: In a strict depth flow, iterating `depth(x)` times
always produces a fixed point. This is the key quantitative bound showing that
renormalization terminates with convergence time controlled by initial complexity.
-/
/-
The depth of iterates is non-increasing.
-/
/-
Once a fixed point is reached, all subsequent iterates are the same.
-/
/-
The fixed point reached by iterating is unique: it doesn't depend on
how many extra steps we take beyond `depth(x)`.
-/
/-! ## Section 2: Flow Morphisms
A flow morphism between two dynamical systems `(α, f)` and `(β, g)` is a map
`φ : α → β` that intertwines the dynamics: `φ ∘ f = g ∘ φ`.
Flow morphisms are the natural notion of "structure-preserving map" between
renormalization flows. They transfer all dynamical information — fixed points,
periodic orbits, universality classes — from one system to another.
-/
/-- A flow morphism intertwines the dynamics of two systems. -/
structure FlowMorphism (α β : Type*) (f : α → α) (g : β → β) where
/-- The underlying map -/
toFun : α → β
/-- The intertwining condition -/
commutes : ∀ x, toFun (f x) = g (toFun x)
/-
Flow morphisms commute with iteration.
-/
theorem flow_morphism_iterate_commutes {α β : Type*} {f : α → α} {g : β → β}
(φ : FlowMorphism α β f g) (n : ℕ) (x : α) :
φ.toFun (f^[n] x) = g^[n] (φ.toFun x) := by
induction' n with n ih generalizing x <;> simp_all +decide [ Function.iterate_succ_apply' ];
rw [ ← ih, φ.commutes ]
/-- Eventual equality: two points are eventually equal if their orbits
eventually merge. This is the equivalence relation whose classes are
the universality classes. -/
def EventualEq {α : Type*} (f : α → α) (x y : α) : Prop :=
∃ N : ℕ, ∀ n, N ≤ n → f^[n] x = f^[n] y
theorem eventualEq_refl {α : Type*} (f : α → α) (x : α) : EventualEq f x x :=
⟨0, fun _ _ => rfl⟩
theorem eventualEq_symm {α : Type*} {f : α → α} {x y : α}
(h : EventualEq f x y) : EventualEq f y x :=
let ⟨N, hN⟩ := h; ⟨N, fun n hn => (hN n hn).symm⟩
theorem eventualEq_trans {α : Type*} {f : α → α} {x y z : α}
(hxy : EventualEq f x y) (hyz : EventualEq f y z) : EventualEq f x z := by
obtain ⟨N₁, hN₁⟩ := hxy; obtain ⟨N₂, hN₂⟩ := hyz
exact ⟨max N₁ N₂, fun n hn => by
rw [hN₁ n (le_of_max_le_left hn), hN₂ n (le_of_max_le_right hn)]⟩
/-- The eventual equality setoid on a type with a self-map. -/
def eventualSetoid (α : Type*) (f : α → α) : Setoid α where
r := EventualEq f
iseqv := ⟨eventualEq_refl f, fun h => eventualEq_symm h,
fun h₁ h₂ => eventualEq_trans h₁ h₂⟩
/-
**Transfer Theorem**: Flow morphisms preserve eventual equality, hence map
universality classes to universality classes. This is the formal content of
"universality" — structural properties that persist across coarse-grainings.
-/
theorem flow_morphism_preserves_eventual_eq {α β : Type*} {f : α → α} {g : β → β}
(φ : FlowMorphism α β f g) {x y : α}
(h : EventualEq f x y) : EventualEq g (φ.toFun x) (φ.toFun y) := by
exact ⟨ h.choose, fun n hn => by rw [ ← flow_morphism_iterate_commutes, ← flow_morphism_iterate_commutes, h.choose_spec n hn ] ⟩
/-! ## Section 3: Coarse-Graining
A coarse-graining is a surjective flow morphism. Surjectivity ensures that
the coarser system doesn't introduce "phantom" states with no fine-grained
counterpart. The key structural result is that coarse-graining can only
merge universality classes, never split them.
-/
/-- A coarse-graining is a surjective flow morphism. -/
structure CoarseGraining (α β : Type*) (f : α → α) (g : β → β) extends
FlowMorphism α β f g where
surjective : Function.Surjective toFun
/-- Coarse-graining induces a well-defined map on universality class quotients. -/
noncomputable def coarseGrainingQuotientMap {α β : Type*} {f : α → α} {g : β → β}
(cg : CoarseGraining α β f g) :
Quotient (eventualSetoid α f) → Quotient (eventualSetoid β g) :=
Quotient.map cg.toFun
(fun _ _ h => flow_morphism_preserves_eventual_eq cg.toFlowMorphism h)
/-
**Class Surjection Theorem**: Coarse-graining induces a surjection on
universality class quotients. Classes can only merge, never split.
-/
/-! ## Section 4: Finite Flow Theory
For flows on finite types, we obtain stronger results: explicit bounds on
the number of universality classes, and the guarantee that coarse-graining
strictly reduces this count (unless the flow is already at a fixed point).
-/
/-- For a finite type, the set of fixed points is a Finset. -/
noncomputable def fixedPointFinset {α : Type*} [Fintype α] [DecidableEq α] (f : α → α) : Finset α :=
Finset.univ.filter (fun x => f x = x)
/-
In a strict depth flow on a finite type, every element eventually
reaches a fixed point.
-/
/-
**Finite Orbit Theorem**: For any function on a finite type, the orbit of any
element eventually enters a cycle.
-/
/-! ## Section 5: Depth Spectrum and Critical Exponents
The depth spectrum of a strict depth flow captures the distribution of
convergence times across all states. Critical exponents characterize
how the spectrum scales under coarse-graining.
-/
/-- The maximum depth in a finite strict depth flow. -/
noncomputable def maxDepth {α : Type*} [Fintype α] [Nonempty α] (f : StrictDepthFlow α) : ℕ :=
Finset.sup' Finset.univ Finset.univ_nonempty f.depth
/-
All elements stabilize within the maximum depth.
-/
/-! ## Section 6: Constructive Examples -/
/-- The truncation flow on ℕ: sends n to min(n, K).
Models a "complexity ceiling" renormalization where
all states above threshold K collapse to K. -/
def truncationFlow (K : ℕ) : StrictDepthFlow ℕ where
step := fun n => min n K
depth := fun n => if n ≤ K then 0 else n - K
depth_decrease := fun x hx => by
simp only [Nat.min_def] at hx ⊢
by_cases h : x ≤ K
· simp [h] at hx
· simp [h]; omega
/-! ## Section 7: Falsifiable Conjecture
**Spectral Rigidity Conjecture**: For strict depth flows on finite types,
the depth spectrum (as a multiset) determines the number of universality
classes (= number of fixed points).
This is falsifiable: construct two flows with the same depth spectrum
but different numbers of fixed points to disprove it.
-/
/-
The conjecture holds when all elements have depth 0 (all fixed).
-/
end TheoremSpaceRG