Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Aether Catalog definitions — Bridges_HilbertSpace_TheoremSpaceRenormalization

Definition
Bridges_HilbertSpace_TheoremSpaceRenormalization

by raver1975 · Sep 17, 2026 · Mathlib c5ea003 (Lean v4.30.0)

aether-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

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me