Power-Cover Roots as Finite Branch Observations
DefinitionMonodromy_RadixFor each positive degree, defines the power covering on the circle, its canonical roots of unity and readout of a retained logarithmic branch modulo that degree. Normalized kernels give exact finite root selection used by native path routing and stopping observations.
-- Generated by Lean-fact skeleton subtraction; original source is frozen in imports/monodromy/source.
module
public import Definitions.Def_Monodromy_Choice
public import Mathlib.Analysis.Analytic.Constructions
public import Mathlib.Analysis.Analytic.IsolatedZeros
public import Mathlib.Analysis.Calculus.DSlope
public import Mathlib.Analysis.Calculus.Deriv.Add
public import Mathlib.Analysis.Calculus.Deriv.Comp
public import Mathlib.Analysis.Calculus.Deriv.Mul
public import Mathlib.Analysis.Calculus.Deriv.Pow
public import Mathlib.Analysis.Complex.Basic
public import Mathlib.Analysis.Complex.CoveringMap
public import Mathlib.Analysis.SpecialFunctions.Complex.Circle
public import Mathlib.Data.Fin.Basic
public import Mathlib.Logic.Function.Conjugate
public import Mathlib.RingTheory.RootsOfUnity.Complex
public import Mathlib.Tactic.FieldSimp
public import Mathlib.Tactic.FunProp
public import Mathlib.Tactic.Ring
public import Mathlib.Topology.Homotopy.Lifting
@[expose] public section
/-!
# Finite-root observations
The power covering reads a finite residue of the retained logarithmic branch.
Normalized kernels select its regular roots; integer residues occur only in proofs.
-/
@[expose] public section
namespace Monodromy.Radix
variable (B : ℕ) [NeZero B]
noncomputable def omega (digit : Fin B) : Circle :=
Circle.exp (2 * Real.pi * (digit.val : ℝ) / (B : ℝ))
theorem primitive : IsPrimitiveRoot (Circle.exp (2 * Real.pi / (B : ℝ))) B := by
have complex : IsPrimitiveRoot ((Circle.exp (2 * Real.pi / (B : ℝ)) : Circle) : ℂ) B := by
convert Complex.isPrimitiveRoot_exp B (NeZero.ne B) using 1
simp only [Circle.coe_exp]
congr 1
push_cast
ring
exact complex.of_map_of_injective (f := Circle.coeHom) Subtype.val_injective
omit [NeZero B] in
theorem omega_eq_pow (digit : Fin B) :
omega B digit = Circle.exp (2 * Real.pi / (B : ℝ)) ^ digit.val := by
rw [← Circle.exp_natCast_mul]
unfold omega
congr 1
ring
theorem omega_injective : Function.Injective (omega B) := by
intro first second same
rw [omega_eq_pow, omega_eq_pow] at same
exact Fin.ext ((primitive B).pow_inj first.isLt second.isLt same)
theorem omega_pow (digit : Fin B) : omega B digit ^ B = 1 := by
rw [omega_eq_pow, ← pow_mul, Nat.mul_comm digit.val B, pow_mul,
(primitive B).pow_eq_one, one_pow]
theorem omega_complex_pow (digit : Fin B) : (omega B digit : ℂ) ^ B = 1 := by
simpa only [Circle.coe_pow, Circle.coe_one] using
congrArg (fun point : Circle => (point : ℂ)) (omega_pow B digit)
/-- The logarithmic lift factors the exponential through the finite power cover. -/
noncomputable def readRoot (x : ℝ) : Circle := Circle.exp (x / (B : ℝ))
/-- The finite root reads the lowest radix digit, without a modulus in its definition. -/
theorem readRoot_digit (n : ℤ) (digit : Fin B) :
readRoot B ((2 * Real.pi) * (((B : ℤ) * n + digit.val : ℤ) : ℝ)) = omega B digit := by
have split :
(2 * Real.pi) * (((B : ℤ) * n + digit.val : ℤ) : ℝ) / (B : ℝ) =
(n : ℝ) * (2 * Real.pi) + 2 * Real.pi * (digit.val : ℝ) / (B : ℝ) := by
push_cast
field_simp [show (B : ℝ) ≠ 0 by exact_mod_cast NeZero.ne B]
unfold readRoot
rw [split, Circle.exp_add, Circle.exp_int_mul_two_pi, one_mul]
rfl
theorem omega_regular (digit : Fin B) :
deriv (fun z : ℂ => z ^ B) (omega B digit : ℂ) ≠ 0 := by
rw [deriv_pow_field]
exact mul_ne_zero (by exact_mod_cast NeZero.ne B)
(pow_ne_zero _ (omega B digit).coe_ne_zero)
end Monodromy.Radix
namespace Monodromy.Radix.Tower
abbrev Punctured := {z : ℂ // z ≠ 0}
def power (degree : ℕ) (point : Punctured) : Punctured :=
⟨point.val ^ degree, pow_ne_zero degree point.property⟩
def one : Punctured := ⟨1, one_ne_zero⟩
abbrev Roots (degree : ℕ) := Transport.Fiber (power degree) one
end Monodromy.Radix.Tower
Read-back
What the Lean code literally says, in plain math · OpenAI Codex (independent agent)
For a natural base and digit , define the unit-circle point , and for every real define on the unit circle. For every positive , the bundle asserts that is a primitive th root, that is injective, that both in the circle group and after its inclusion into , and that the complex derivative of at is nonzero. For every natural and every digit , including the vacuous digit domain at , it asserts . For every positive , integer and digit , it asserts ; negative integers , and digit are included. The functions themselves use total real division, so and the digit domain for is empty; the primitive-root, nonzero-derivative and residue-readout assertions assume . Separately, on it defines, for every natural degree , the map , the distinguished point , and the root type as the actual fiber of . This latter degree has no nonzero hypothesis: at degree the power map is the constant and every point of lies in its root fiber.
Confirmed by the mission captain (proposal self-audit).