Logarithm Sheets and Nested Exponential Lift Execution
DefinitionMonodromy_LogarithmIdentifies the exponential circle fiber with integer sheet labels and defines loop transport as a common translation of those labels. Builds nested complex-exponential execution from two actual logarithmic lifts, including a fixed zero-conditional upper write, branch preparation, concatenation, reversal and the matching restricted pullback covering.
-- Generated by Lean-fact skeleton subtraction; original source is frozen in imports/monodromy/source.
module
public import Definitions.Def_Monodromy_Covering
public import Lean.Elab.Tactic.Omega
public import Mathlib.Analysis.Analytic.Constructions
public import Mathlib.Analysis.Complex.CoveringMap
public import Mathlib.Analysis.Real.Pi.Bounds
public import Mathlib.Analysis.SpecialFunctions.Complex.Circle
public import Mathlib.Logic.Function.Conjugate
public import Mathlib.Tactic.FunProp
public import Mathlib.Tactic.Linarith
public import Mathlib.Tactic.Ring
public import Mathlib.Topology.Homotopy.Lifting
@[expose] public section
/-!
# The branches of the logarithm
Restricting the exponential to imaginary arguments gives the circle covering.
Its fiber over one retains an integer. A loop transports every initial
branch by addition, proved from its actual continuous lift. Nested complex
exponentials supply a conditional upper write: the actual lower lift winds
around the upper logarithm's omitted point only on the zero branch.
-/
@[expose] public section
namespace Monodromy.Logarithm
open unitInterval
abbrev Memory := Transport.Fiber Circle.exp (1 : Circle)
noncomputable def sheet (k : ℤ) : Memory :=
⟨(k : ℝ) * (2 * Real.pi), Circle.exp_int_mul_two_pi k⟩
noncomputable def integers : ℤ ≃ Memory := Equiv.ofBijective sheet ⟨by
intro k n same
have values := congrArg Subtype.val same
change (k : ℝ) * (2 * Real.pi) = (n : ℝ) * (2 * Real.pi) at values
exact Int.cast_injective (mul_right_cancel₀
(mul_ne_zero two_ne_zero Real.pi_ne_zero) values), by
intro root
obtain ⟨k, same⟩ := Circle.exp_eq_one.mp root.2
exact ⟨k, Subtype.ext same.symm⟩⟩
noncomputable def turn (n : ℤ) : Path (1 : Circle) 1 where
toFun t := Circle.exp (((n : ℝ) * (t : ℝ)) * (2 * Real.pi))
continuous_toFun := Circle.exp.continuous.comp
((continuous_const.mul continuous_subtype_val).mul continuous_const)
source' := by simp
target' := by simp
noncomputable def lift (k n : ℤ) : C(I, ℝ) where
toFun t := ((k : ℝ) + (n : ℝ) * (t : ℝ)) * (2 * Real.pi)
continuous_toFun := (continuous_const.add
(continuous_const.mul continuous_subtype_val)).mul continuous_const
end Monodromy.Logarithm
/-! Two successive logarithmic lifts and their fixed-loop actions. -/
noncomputable section
namespace Monodromy.NestedContinuation
open unitInterval
abbrev Punctured := {z : ℂ // z ≠ 0}
def expCover (z : ℂ) : Punctured := ⟨Complex.exp z, Complex.exp_ne_zero z⟩
theorem covering : IsCoveringMap expCover := Complex.isCoveringMap_exp
def period (k : ℤ) : ℂ := (k : ℂ) * (2 * Real.pi * Complex.I)
theorem exp_period (k : ℤ) : Complex.exp (period k) = 1 :=
Complex.exp_eq_one_iff.mpr ⟨k, rfl⟩
def rotor (t : I) : ℂ := (Circle.exp ((2 * Real.pi) * (t : ℝ)) : ℂ)
theorem continuous_rotor : Continuous rotor := by unfold rotor; fun_prop
@[simp] theorem rotor_zero : rotor 0 = 1 := by simp [rotor]
@[simp] theorem rotor_one : rotor 1 = 1 := by simp [rotor]
theorem rotor_ne_zero (t : I) : rotor t ≠ 0 := (Circle.exp _).coe_ne_zero
theorem rotor_norm (t : I) : ‖rotor t‖ = 1 := (Circle.exp _).norm_coe
def firstRoot (k : ℤ) : ℂ := 1 + period k
theorem firstRoot_slit (k : ℤ) : firstRoot k ∈ Complex.slitPlane := by
left
simp [firstRoot, period]
theorem firstRoot_ne_zero (k : ℤ) : firstRoot k ≠ 0 :=
Complex.slitPlane_ne_zero (firstRoot_slit k)
def secondRoot (k m : ℤ) : ℂ := Complex.log (firstRoot k) + period m
theorem exp_secondRoot (k m : ℤ) : Complex.exp (secondRoot k m) = firstRoot k := by
rw [secondRoot, Complex.exp_add, exp_period, mul_one, Complex.exp_log (firstRoot_ne_zero k)]
def base : Punctured := expCover 1
theorem exp_firstRoot (k : ℤ) : expCover (firstRoot k) = base := by
apply Subtype.ext
change Complex.exp (1 + period k) = Complex.exp 1
rw [Complex.exp_add, exp_period, mul_one]
/-- One fixed base loop, independent of both branch indices. -/
def loop : Path base base where
toFun t := expCover (rotor t)
continuous_toFun := by unfold expCover rotor; fun_prop
source' := by simp [base]
target' := by simp [base]
/-- This is the actual first lift supplied by the covering, not a prescribed successor. -/
def firstLift (k : ℤ) : C(I, ℂ) :=
covering.liftPath loop (firstRoot k) (loop.source.trans (exp_firstRoot k).symm)
def firstWitness (k : ℤ) : C(I, ℂ) where
toFun t := rotor t + period k
continuous_toFun := continuous_rotor.add continuous_const
theorem firstWitness_projects (k : ℤ) : expCover ∘ firstWitness k = loop := by
funext t
apply Subtype.ext
change Complex.exp (rotor t + period k) = Complex.exp (rotor t)
rw [Complex.exp_add, exp_period, mul_one]
/-- The explicit circle is identified with the unique first lift only in the proof. -/
theorem firstLift_eq (k : ℤ) (t : I) : firstLift k t = rotor t + period k := by
have same : firstWitness k = firstLift k :=
(covering.eq_liftPath_iff' (loop.source.trans (exp_firstRoot k).symm)).mpr
⟨firstWitness_projects k, by simp [firstWitness, firstRoot]⟩
exact congrArg (fun curve : C(I, ℂ) => curve t) same.symm
/-- Every nonzero first-level index keeps its circle in one logarithm chart. -/
theorem firstLift_slit {k : ℤ} (nonzero : k ≠ 0) (t : I) :
firstLift k t ∈ Complex.slitPlane := by
rw [firstLift_eq]
apply Or.inr
have bound : |(rotor t).im| ≤ 1 := (Complex.abs_im_le_norm _).trans_eq (rotor_norm t)
have imag : (period k).im = (k : ℝ) * (2 * Real.pi) := by simp [period]
simp only [Complex.add_im, imag]
intro zero
rcases lt_or_gt_of_ne nonzero with negative | positive
· have integer : (k : ℝ) ≤ -1 := by exact_mod_cast (show k ≤ -1 by omega)
have lower : -1 ≤ (rotor t).im := (abs_le.mp bound).1
have upper : (rotor t).im ≤ 1 := (abs_le.mp bound).2
nlinarith [Real.pi_gt_three, Real.pi_pos]
· have integer : (1 : ℝ) ≤ k := by exact_mod_cast (show 1 ≤ k by omega)
have lower : -1 ≤ (rotor t).im := (abs_le.mp bound).1
have upper : (rotor t).im ≤ 1 := (abs_le.mp bound).2
nlinarith [Real.pi_gt_three, Real.pi_pos]
theorem firstLift_ne_zero (k : ℤ) (t : I) : firstLift k t ≠ 0 := by
by_cases zero : k = 0
· subst k
simpa [firstLift_eq, period] using rotor_ne_zero t
· exact Complex.slitPlane_ne_zero (firstLift_slit zero t)
/-- The next covering receives the actual first lift, preserving its nonzero values. -/
def firstPath (k : ℤ) : Path
(⟨firstRoot k, firstRoot_ne_zero k⟩ : Punctured)
⟨firstRoot k, firstRoot_ne_zero k⟩ where
toFun t := ⟨firstLift k t, firstLift_ne_zero k t⟩
continuous_toFun := (firstLift k).continuous.subtype_mk _
source' := by apply Subtype.ext; simp [firstLift_eq, firstRoot]
target' := by apply Subtype.ext; simp [firstLift_eq, firstRoot]
/-- The second lift is generated from the first actual lift and the initial branch alone. -/
def secondLift (k m : ℤ) : C(I, ℂ) :=
covering.liftPath (firstPath k) (secondRoot k m)
((firstPath k).source.trans (by apply Subtype.ext; exact (exp_secondRoot k m).symm))
def zeroWitness (m : ℤ) : C(I, ℂ) where
toFun t := ((2 * Real.pi) * (t : ℝ) : ℂ) * Complex.I + period m
continuous_toFun := by fun_prop
theorem zeroWitness_projects (m : ℤ) : expCover ∘ zeroWitness m = firstPath 0 := by
funext t
apply Subtype.ext
change Complex.exp (((2 * Real.pi) * (t : ℝ) : ℂ) * Complex.I + period m) = firstLift 0 t
rw [Complex.exp_add, exp_period, mul_one, firstLift_eq]
simp [period, rotor, Circle.coe_exp]
def nonzeroWitness (k m : ℤ) (nonzero : k ≠ 0) : C(I, ℂ) where
toFun t := Complex.log (firstLift k t) + period m
continuous_toFun := ((firstLift k).continuous.clog (firstLift_slit nonzero)).add continuous_const
theorem nonzeroWitness_projects (k m : ℤ) (nonzero : k ≠ 0) :
expCover ∘ nonzeroWitness k m nonzero = firstPath k := by
funext t
apply Subtype.ext
change Complex.exp (Complex.log (firstLift k t) + period m) = firstLift k t
rw [Complex.exp_add, exp_period, mul_one, Complex.exp_log (firstLift_ne_zero k t)]
/-- Native conditional execution comes from two actual lifts of one fixed loop. -/
theorem secondLift_end (k m : ℤ) :
secondLift k m 1 = secondRoot k (m + if k = 0 then 1 else 0) := by
by_cases zero : k = 0
· subst k
have same : zeroWitness m = secondLift 0 m :=
(covering.eq_liftPath_iff'
((firstPath 0).source.trans (by apply Subtype.ext; exact (exp_secondRoot 0 m).symm))).mpr
⟨zeroWitness_projects m, by simp [zeroWitness, secondRoot, firstRoot, period]⟩
rw [← same]
simp [zeroWitness, secondRoot, firstRoot, period]
ring
· have same : nonzeroWitness k m zero = secondLift k m :=
(covering.eq_liftPath_iff'
((firstPath k).source.trans (by apply Subtype.ext; exact (exp_secondRoot k m).symm))).mpr
⟨nonzeroWitness_projects k m zero, by simp [nonzeroWitness, firstLift_eq, secondRoot, firstRoot]⟩
rw [← same]
simp [nonzeroWitness, firstLift_eq, secondRoot, firstRoot, zero]
/-- The fixed base path avoids the second singular value. -/
theorem loop_avoids_one (t : I) : loop t ≠ (⟨1, one_ne_zero⟩ : Punctured) := by
intro same
have exponential : Complex.exp (rotor t) = 1 := congrArg Subtype.val same
obtain ⟨n, period_eq⟩ := Complex.exp_eq_one_iff.mp exponential
have zero : firstLift (-n) t = 0 := by
rw [firstLift_eq]
rw [show rotor t = period n from period_eq]
simp [period]
exact firstLift_ne_zero (-n) t zero
/-- A native state is the retained root value, with no integer indices in the runtime interface. -/
abbrev Memory := Transport.Fiber (fun z : ℂ => expCover (Complex.exp z)) base
def prepare (k m : ℤ) : Memory :=
⟨secondRoot k m, by
change expCover (Complex.exp (secondRoot k m)) = base
rw [exp_secondRoot, exp_firstRoot]⟩
/-- The first lift starts at the exponential of the retained root itself. -/
def firstRaw (path : Path base base) (state : Memory) : C(I, ℂ) :=
covering.liftPath path (Complex.exp state.val) (path.source.trans state.property.symm)
theorem firstRaw_projects (path : Path base base) (state : Memory) :
expCover ∘ firstRaw path state = path :=
covering.liftPath_lifts path (Complex.exp state.val) (path.source.trans state.property.symm)
theorem firstRaw_start (path : Path base base) (state : Memory) :
firstRaw path state 0 = Complex.exp state.val :=
covering.liftPath_zero path (Complex.exp state.val) (path.source.trans state.property.symm)
theorem firstRaw_ne_zero (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) (t : I) :
firstRaw path state t ≠ 0 := by
intro zero
have projects := congrFun (firstRaw_projects path state) t
apply avoids t
calc
path t = expCover (firstRaw path state t) := projects.symm
_ = expCover 0 := congrArg expCover zero
_ = (⟨1, one_ne_zero⟩ : Punctured) := Subtype.ext Complex.exp_zero
/-- The upper covering receives exactly the actual first lift. -/
def firstRawPath (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) :
Path (expCover state.val)
⟨firstRaw path state 1, firstRaw_ne_zero path avoids state 1⟩ where
toFun t := ⟨firstRaw path state t, firstRaw_ne_zero path avoids state t⟩
continuous_toFun := (firstRaw path state).continuous.subtype_mk _
source' := by apply Subtype.ext; exact firstRaw_start path state
target' := rfl
def secondRaw (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) : C(I, ℂ) :=
covering.liftPath (firstRawPath path avoids state) state.val (firstRawPath path avoids state).source
theorem secondRaw_exp (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) (t : I) :
Complex.exp (secondRaw path avoids state t) = firstRaw path state t := by
have projects := covering.liftPath_lifts (firstRawPath path avoids state) state.val
(firstRawPath path avoids state).source
exact congrArg Subtype.val (congrFun projects t)
theorem secondRaw_start (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) :
secondRaw path avoids state 0 = state.val :=
covering.liftPath_zero (firstRawPath path avoids state) state.val
(firstRawPath path avoids state).source
theorem secondRaw_projects (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) (t : I) :
expCover (Complex.exp (secondRaw path avoids state t)) = path t := by
rw [secondRaw_exp]
exact congrFun (firstRaw_projects path state) t
/-- Execution uses only the fixed path and the actual retained root. -/
def execute (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) : Memory :=
⟨secondRaw path avoids state 1, (secondRaw_projects path avoids state 1).trans path.target⟩
theorem firstRaw_prepare (k m : ℤ) : firstRaw loop (prepare k m) = firstLift k :=
(covering.eq_liftPath_iff' (loop.source.trans (exp_firstRoot k).symm)).mpr
⟨firstRaw_projects loop (prepare k m), by
rw [firstRaw_start]
exact exp_secondRoot k m⟩
theorem secondRaw_prepare (k m : ℤ) :
secondRaw loop loop_avoids_one (prepare k m) = secondLift k m := by
have projects : expCover ∘ secondRaw loop loop_avoids_one (prepare k m) = firstPath k := by
funext t
apply Subtype.ext
change Complex.exp (secondRaw loop loop_avoids_one (prepare k m) t) = firstLift k t
rw [secondRaw_exp, firstRaw_prepare]
exact (covering.eq_liftPath_iff'
((firstPath k).source.trans (by apply Subtype.ext; exact (exp_secondRoot k m).symm))).mpr
⟨projects, secondRaw_start loop loop_avoids_one (prepare k m)⟩
theorem execute_prepare (k m : ℤ) :
execute loop loop_avoids_one (prepare k m) = prepare k (m + if k = 0 then 1 else 0) := by
apply Subtype.ext
change secondRaw loop loop_avoids_one (prepare k m) 1 = _
rw [secondRaw_prepare, secondLift_end]
rfl
/-- A second fixed base loop uses the same two coverings. -/
def advanceLoop : Path base base where
toFun t := expCover (1 + (((2 * Real.pi) * (t : ℝ) : ℝ) : ℂ) * Complex.I)
continuous_toFun := by unfold expCover; fun_prop
source' := by apply Subtype.ext; simp [base, expCover]
target' := by
apply Subtype.ext
change Complex.exp (1 + (((2 * Real.pi) * (1 : ℝ) : ℝ) : ℂ) * Complex.I) = Complex.exp 1
have turn : (((2 * Real.pi) * (1 : ℝ) : ℝ) : ℂ) * Complex.I = period 1 := by simp [period]
rw [turn]
exact congrArg Subtype.val (exp_firstRoot 1)
theorem advanceLoop_avoids_one (t : I) : advanceLoop t ≠ (⟨1, one_ne_zero⟩ : Punctured) := by
intro same
have exponential : Complex.exp (1 + (((2 * Real.pi) * (t : ℝ) : ℝ) : ℂ) * Complex.I) = 1 :=
congrArg Subtype.val same
obtain ⟨n, period_eq⟩ := Complex.exp_eq_one_iff.mp exponential
have real_eq := congrArg Complex.re period_eq
simp at real_eq
def advanceWitness (k : ℤ) : C(I, ℂ) where
toFun t := firstRoot k + (((2 * Real.pi) * (t : ℝ) : ℝ) : ℂ) * Complex.I
continuous_toFun := by fun_prop
theorem advanceWitness_start (k : ℤ) : advanceWitness k 0 = firstRoot k := by
simp [advanceWitness]
theorem advanceWitness_end (k : ℤ) : advanceWitness k 1 = firstRoot (k + 1) := by
simp [advanceWitness, firstRoot, period]
ring
theorem advanceWitness_slit (k : ℤ) (t : I) : advanceWitness k t ∈ Complex.slitPlane := by
left
simp [advanceWitness, firstRoot, period]
theorem advanceWitness_projects (k : ℤ) : expCover ∘ advanceWitness k = advanceLoop := by
funext t
apply Subtype.ext
change Complex.exp (firstRoot k + (((2 * Real.pi) * (t : ℝ) : ℝ) : ℂ) * Complex.I) =
Complex.exp (1 + (((2 * Real.pi) * (t : ℝ) : ℝ) : ℂ) * Complex.I)
unfold firstRoot
rw [add_right_comm, Complex.exp_add, exp_period, mul_one]
theorem advance_firstRaw (k m : ℤ) : firstRaw advanceLoop (prepare k m) = advanceWitness k := by
have same : advanceWitness k = firstRaw advanceLoop (prepare k m) :=
(covering.eq_liftPath_iff' (advanceLoop.source.trans (prepare k m).property.symm)).mpr
⟨advanceWitness_projects k, by rw [advanceWitness_start]; exact (exp_secondRoot k m).symm⟩
exact same.symm
def advanceSecondWitness (k m : ℤ) : C(I, ℂ) where
toFun t := Complex.log (advanceWitness k t) + period m
continuous_toFun := ((advanceWitness k).continuous.clog (advanceWitness_slit k)).add continuous_const
theorem advance_secondRaw (k m : ℤ) :
secondRaw advanceLoop advanceLoop_avoids_one (prepare k m) = advanceSecondWitness k m := by
have projects : expCover ∘ advanceSecondWitness k m = firstRawPath advanceLoop advanceLoop_avoids_one (prepare k m) := by
funext t
apply Subtype.ext
change Complex.exp (Complex.log (advanceWitness k t) + period m) = firstRaw advanceLoop (prepare k m) t
rw [Complex.exp_add, exp_period, mul_one,
Complex.exp_log (Complex.slitPlane_ne_zero (advanceWitness_slit k t)), advance_firstRaw]
have same : advanceSecondWitness k m = secondRaw advanceLoop advanceLoop_avoids_one (prepare k m) :=
(covering.eq_liftPath_iff' (firstRawPath advanceLoop advanceLoop_avoids_one (prepare k m)).source).mpr
⟨projects, by
change Complex.log (advanceWitness k 0) + period m = secondRoot k m
rw [advanceWitness_start]
rfl⟩
exact same.symm
/-- The other fixed loop advances the lower branch, retaining the upper branch. -/
theorem execute_advance (k m : ℤ) :
execute advanceLoop advanceLoop_avoids_one (prepare k m) = prepare (k + 1) m := by
apply Subtype.ext
change secondRaw advanceLoop advanceLoop_avoids_one (prepare k m) 1 = secondRoot (k + 1) m
rw [advance_secondRaw]
change Complex.log (advanceWitness k 1) + period m = _
rw [advanceWitness_end]
rfl
end Monodromy.NestedContinuation
namespace Monodromy.NestedContinuation
theorem period_injective : Function.Injective period := by
intro first second same
have factor : (2 * Real.pi * Complex.I : ℂ) ≠ 0 :=
mul_ne_zero (mul_ne_zero (by norm_num) (by exact_mod_cast Real.pi_ne_zero)) Complex.I_ne_zero
unfold period at same
exact_mod_cast mul_right_cancel₀ factor same
theorem firstRoot_injective : Function.Injective firstRoot := by
intro first second same
exact period_injective (add_left_cancel same)
end Monodromy.NestedContinuation
namespace Monodromy.NestedContinuation
open unitInterval
/-- A composite program still avoids the excluded singular value. -/
theorem avoids_trans (first second : Path base base)
(first_avoids : ∀ t, first t ≠ (⟨1, one_ne_zero⟩ : Punctured))
(second_avoids : ∀ t, second t ≠ (⟨1, one_ne_zero⟩ : Punctured)) :
∀ t, (first.trans second) t ≠ (⟨1, one_ne_zero⟩ : Punctured) := by
intro t
rw [Path.trans_apply]
split_ifs
· exact first_avoids _
· exact second_avoids _
theorem avoids_symm (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) :
∀ t, path.symm t ≠ (⟨1, one_ne_zero⟩ : Punctured) := by
intro t
exact avoids (σ t)
/-- This path is the actual second lift itself, with its proved start and end. -/
def executionPath (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) :
Path state.val (execute path avoids state).val where
toFun := secondRaw path avoids state
continuous_toFun := (secondRaw path avoids state).continuous
source' := secondRaw_start path avoids state
target' := rfl
/-- Later execution begins at the actual retained endpoint of the preceding lift. -/
def sequentialPath (first second : Path base base)
(first_avoids : ∀ t, first t ≠ (⟨1, one_ne_zero⟩ : Punctured))
(second_avoids : ∀ t, second t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) :
Path state.val (execute second second_avoids (execute first first_avoids state)).val :=
(executionPath first first_avoids state).trans
(executionPath second second_avoids (execute first first_avoids state))
end Monodromy.NestedContinuation
namespace Monodromy.NestedContinuation
end Monodromy.NestedContinuation
namespace Monodromy.NestedContinuation
end Monodromy.NestedContinuation
namespace Monodromy.NestedContinuation
end Monodromy.NestedContinuation
namespace Monodromy.NestedRestricted
open unitInterval
noncomputable section
def baseSet : Set ℂ := {value | value ≠ 0 ∧ value ≠ 1}
def firstSet : Set ℂ := Complex.exp ⁻¹' baseSet
def secondSet : Set ℂ := Complex.exp ⁻¹' firstSet
def firstProjection : firstSet → baseSet := baseSet.restrictPreimage Complex.exp
def secondProjection : secondSet → firstSet := firstSet.restrictPreimage Complex.exp
theorem firstCovering : IsCoveringMap firstProjection :=
(Complex.isCoveringMapOn_exp.mono (by
intro value valid
exact valid.1)).isCoveringMap_restrictPreimage
theorem firstSet_nonzero {value : ℂ} (valid : value ∈ firstSet) : value ≠ 0 := by
intro zero
have avoids_one : Complex.exp value ≠ 1 := valid.2
apply avoids_one
simp [zero]
/-- The fixed admissible paths are paths in the common twice-punctured base. -/
def basePath {start finish : {value : ℂ // value ≠ 0}}
(path : Path start finish) (avoids_one : ∀ t : I, (path t : ℂ) ≠ 1) :
Path (⟨start.val, start.property, by simpa using avoids_one 0⟩ : baseSet)
⟨finish.val, finish.property, by simpa using avoids_one 1⟩ where
toFun t := ⟨path t, (path t).property, avoids_one t⟩
continuous_toFun := (path.continuous.subtype_val).subtype_mk _
source' := by
apply Subtype.ext
exact congrArg (fun value : {value : ℂ // value ≠ 0} => (value : ℂ)) path.source
target' := by
apply Subtype.ext
exact congrArg (fun value : {value : ℂ // value ≠ 0} => (value : ℂ)) path.target
end
end Monodromy.NestedRestricted
namespace Monodromy.NestedContinuation
open unitInterval
/-- The actual first lift stays in the total space of the first restricted cover. -/
theorem firstRaw_mem (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) (t : I) :
firstRaw path state t ∈ NestedRestricted.firstSet := by
change Complex.exp (firstRaw path state t) ≠ 0 ∧ Complex.exp (firstRaw path state t) ≠ 1
refine ⟨Complex.exp_ne_zero _, ?_⟩
intro one
apply avoids t
apply Subtype.ext
exact (congrArg Subtype.val (congrFun (firstRaw_projects path state) t)).symm.trans one
/-- The actual second lift stays in the total space of the second restricted cover. -/
theorem secondRaw_mem (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) (t : I) :
secondRaw path avoids state t ∈ NestedRestricted.secondSet := by
change Complex.exp (secondRaw path avoids state t) ∈ NestedRestricted.firstSet
rw [secondRaw_exp]
exact firstRaw_mem path avoids state t
def lowerCurve (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) :
C(I, NestedRestricted.firstSet) where
toFun t := ⟨firstRaw path state t, firstRaw_mem path avoids state t⟩
continuous_toFun := (firstRaw path state).continuous.subtype_mk _
def upperCurve (path : Path base base)
(avoids : ∀ t, path t ≠ (⟨1, one_ne_zero⟩ : Punctured)) (state : Memory) :
C(I, NestedRestricted.secondSet) where
toFun t := ⟨secondRaw path avoids state t, secondRaw_mem path avoids state t⟩
continuous_toFun := (secondRaw path avoids state).continuous.subtype_mk _
end Monodromy.NestedContinuation
Read-back
What the Lean code literally says, in plain math · OpenAI Codex (independent agent)
Put . In the real logarithmic construction the memory type is on the unit circle, the point called sheet is for , and a noncomputable equivalence between and that fiber is defined from the injectivity and surjectivity proofs of this sheet map. For each integer it defines the based circle path and for integers the continuous real curve . In the complex construction put , , , , , , and , using the principal complex logarithm. The bundle asserts that is a covering map, , is continuous with endpoints , nonzero values and norm , belongs to the principal slit plane and is nonzero, , and . It defines the loop based at , its covering lift starting at , and the witness , and asserts that the witness projects to and . For the whole lifted curve lies in the slit plane; for every integer it is nonzero, so it defines a loop in based at . The second lift is the covering lift of starting at . The zero-index witness is and the witness for is ; each is asserted to project to its corresponding , and the included endpoint equation is . The loop is asserted to avoid . The complex memory is the subtype , and preparation sends to . For every based path at and , the first raw curve is the covering lift of starting at ; it is asserted to project to and start at . If for all , it is nonzero, hence supplies a path in from to . The second raw curve is the lift of that path starting at ; its equations are , and . Execution is its endpoint . At prepared states and path , the first and second raw curves equal and and execution sends preparation to preparation . A second based loop is , asserted to avoid ; its first witness starts at , ends at , lies in the slit plane and projects to . At preparation the first raw curve equals that witness and the second equals , so execution along sends preparation to preparation . The maps and are asserted injective. Avoidance of is preserved under concatenation and reversal of based paths; for any admissible path and memory state an execution path in is defined to be its actual second raw curve, from the retained initial value to the executed endpoint, and a sequential path for two admissible paths is defined by concatenating their execution paths, the second starting from the first executed endpoint. Finally, put , and ; it defines restricted exponential projections and , asserts the first projection is a covering map and every element of is nonzero, and turns any path in avoiding into a path in with the same complex values. For every admissible based path and every memory state, the first and second raw curves are asserted to lie pointwise in and , respectively, and the corresponding continuous curves with those restricted codomains are defined. All branch parameters range over all integers, including zero and negative integers; generic execution requires the entire input path to avoid , and its definitions use covering lifts from the supplied retained value rather than selecting a new integer pair.
Confirmed by the mission captain (proposal self-audit).