Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Neutral winding proto-clock core

Definition
WindingDynamics_NeutralClockCoreV1

by lisamegawatts · Sep 18, 2026 · Mathlib c5ea003 (Lean v4.30.0)

universal-coverwinding-dynamicswinding-prototime

Defines a parameter-neutral lifted phase reading, principal representative and integer sheet, affine origin and global deck actions, orientation reversal, an endpoint-to-winding adapter, and the scalar remaining-scale power-law budget. The event carrier has no built-in physical time.

Definition code
import Mathlib.Analysis.SpecialFunctions.Integrability.Basic
import Mathlib.Analysis.SpecialFunctions.Complex.Circle

noncomputable section

namespace WindingDynamics

open Set MeasureTheory

abbrev ClockLift (Event : Type*) := Event → ℝ

noncomputable def clockPhase {Event : Type*}
    (reading : ClockLift Event) (event : Event) : Circle :=
  Circle.exp (reading event)

noncomputable def clockPrincipal {Event : Type*}
    (cut : ℝ) (reading : ClockLift Event) (event : Event) : ℝ :=
  toIocMod Real.two_pi_pos cut (reading event)

noncomputable def clockTurn {Event : Type*}
    (cut : ℝ) (reading : ClockLift Event) (event : Event) : ℤ :=
  toIocDiv Real.two_pi_pos cut (reading event)

noncomputable def reconstructedReading {Event : Type*}
    (cut : ℝ) (reading : ClockLift Event) (event : Event) : ℝ :=
  clockPrincipal cut reading event +
    (clockTurn cut reading event : ℝ) * (2 * Real.pi)

def ClockPrecedes {Event : Type*}
    (reading : ClockLift Event) (first second : Event) : Prop :=
  reading first < reading second

def deckShift {Event : Type*}
    (turn : ℤ) (reading : ClockLift Event) : ClockLift Event :=
  fun event ↦ reading event + (turn : ℝ) * (2 * Real.pi)

def originShift {Event : Type*}
    (offset : ℝ) (reading : ClockLift Event) : ClockLift Event :=
  fun event ↦ reading event + offset

def SameIncrements {Event : Type*}
    (first second : ClockLift Event) : Prop :=
  ∀ initial final : Event,
    second final - second initial = first final - first initial

def reverseReading {Event : Type*}
    (reading : ClockLift Event) : ClockLift Event :=
  fun event ↦ -reading event

noncomputable def principalEdgeTurn (base difference : ℝ) : ℤ :=
  -toIocDiv Real.two_pi_pos (base - Real.pi) (base + difference)

noncomputable def powerLawFrequency (exponent remainingScale : ℝ) : ℝ :=
  remainingScale ^ (-exponent)

def FiniteWindingBudget (exponent : ℝ) : Prop :=
  IntegrableOn (powerLawFrequency exponent) (Set.Ioo (0 : ℝ) 1)

def PrincipalLedgerReconstructionGate : Prop :=
  (∀ (Event : Type) (cut : ℝ) (reading : ClockLift Event) (event : Event),
    cut < clockPrincipal cut reading event ∧
      clockPrincipal cut reading event ≤ cut + 2 * Real.pi) ∧
  (∀ (Event : Type) (cut : ℝ) (reading : ClockLift Event) (event : Event),
    reconstructedReading cut reading event = reading event) ∧
  (∀ (Event : Type) (firstCut secondCut : ℝ)
      (reading : ClockLift Event) (event : Event),
    reconstructedReading firstCut reading event =
      reconstructedReading secondCut reading event ∧
    Circle.exp (clockPrincipal firstCut reading event) =
      Circle.exp (clockPrincipal secondCut reading event)) ∧
  (∀ (Event : Type) (reading : ClockLift Event) (event : Event),
    clockTurn (-Real.pi) reading event =
      -principalEdgeTurn 0 (reading event))

def InducedClockOrderGate : Prop :=
  (∀ (Event : Type) (reading : ClockLift Event),
    (∀ event : Event, ¬ClockPrecedes reading event event) ∧
      (∀ first second third : Event,
        ClockPrecedes reading first second →
          ClockPrecedes reading second third →
            ClockPrecedes reading first third)) ∧
  (∀ (Event : Type) (reading : ClockLift Event),
    Function.Injective reading →
      ∀ first second : Event,
        first ≠ second →
          ClockPrecedes reading first second ∨
            ClockPrecedes reading second first) ∧
  (∀ (Event : Type) (_ : LinearOrder Event) (reading : ClockLift Event),
    StrictMono reading →
      ∀ first second : Event,
        ClockPrecedes reading first second ↔ first < second) ∧
  (∃ reading : ClockLift (Fin 3),
    reading 0 = 0 ∧
      reading 1 = 4 * Real.pi ∧
      reading 2 = 2 * Real.pi ∧
      reading 2 - reading 0 = 2 * Real.pi ∧
      ¬StrictMono reading)

def DeckOriginFreedomGate : Prop :=
  (∀ (Event : Type) (reading : ClockLift Event),
    originShift 0 reading = reading) ∧
  (∀ (Event : Type) (firstOffset secondOffset : ℝ)
      (reading : ClockLift Event),
    originShift (firstOffset + secondOffset) reading =
      originShift firstOffset (originShift secondOffset reading)) ∧
  (∀ (Event : Type) (offset : ℝ) (reading : ClockLift Event)
      (first second : Event),
    originShift offset reading second - originShift offset reading first =
      reading second - reading first ∧
    (ClockPrecedes (originShift offset reading) first second ↔
      ClockPrecedes reading first second)) ∧
  (∀ (Event : Type) (_ : Nonempty Event)
      (first second : ClockLift Event),
    SameIncrements first second →
      ∃! offset : ℝ, second = originShift offset first) ∧
  (∀ (Event : Type) (reading : ClockLift Event),
    deckShift 0 reading = reading) ∧
  (∀ (Event : Type) (firstTurn secondTurn : ℤ)
      (reading : ClockLift Event),
    deckShift (firstTurn + secondTurn) reading =
      deckShift firstTurn (deckShift secondTurn reading)) ∧
  (∀ (Event : Type) (turn : ℤ) (reading : ClockLift Event) (event : Event),
    clockPhase (deckShift turn reading) event = clockPhase reading event) ∧
  (∀ (Event : Type) (turn : ℤ) (reading : ClockLift Event)
      (first second : Event),
    ClockPrecedes (deckShift turn reading) first second ↔
      ClockPrecedes reading first second) ∧
  (∀ (Event : Type) (_ : Nonempty Event) (turn : ℤ)
      (reading : ClockLift Event),
    deckShift turn reading = reading ↔ turn = 0)

def OrientationReversalGate : Prop :=
  (∀ (Event : Type) (reading : ClockLift Event) (event : Event),
    clockPhase (reverseReading reading) event =
      (clockPhase reading event)⁻¹) ∧
  (∀ (Event : Type) (reading : ClockLift Event) (first second : Event),
    ClockPrecedes (reverseReading reading) first second ↔
      ClockPrecedes reading second first) ∧
  (∀ (Event : Type) (turn : ℤ) (reading : ClockLift Event),
    reverseReading (deckShift turn reading) =
      deckShift (-turn) (reverseReading reading))

def LandedWindingClockGate : Prop :=
  (∀ (endpoint : ℝ) (winding : ℤ),
    endpoint = (winding : ℝ) * (2 * Real.pi) →
      clockTurn (-Real.pi) (fun _ : Unit ↦ endpoint) () = winding) ∧
  (∀ winding : ℤ,
    clockTurn (-Real.pi)
      (fun _ : Unit ↦ (winding : ℝ) * (2 * Real.pi)) () = winding)

def PowerLawWindingBudgetGate : Prop :=
  (∀ exponent : ℝ, FiniteWindingBudget exponent ↔ exponent < 1) ∧
  (∀ h : ℝ, 0 ≤ h → ¬FiniteWindingBudget (1 + h))

def ClaimBoundary : Prop :=
  PrincipalLedgerReconstructionGate ∧
    InducedClockOrderGate ∧
    DeckOriginFreedomGate ∧
    OrientationReversalGate ∧
    LandedWindingClockGate ∧
    PowerLawWindingBudgetGate

end WindingDynamics
Source
MonumentalSystems/LeanProofs, WindingProtoTimeP01CorrectedV1Targets.lean and P01 corrective audit, 2026-09-18.
Read-back

What the Lean code literally says, in plain math · gpt-5.6-sol

This defines a proposition as the conjunction of the following six groups of assertions. Write a clock reading on an event type EEE as a function r:E→Rr:E\to\mathbb Rr:E→R; write Pc(x)P_c(x)Pc​(x) for the representative of xxx modulo 2π2\pi2π in the left-open, right-closed interval (c,c+2π](c,c+2\pi](c,c+2π], and Qc(x)∈ZQ_c(x)\in\mathbb ZQc​(x)∈Z for the corresponding quotient, so that x=Pc(x)+Qc(x) 2πx=P_c(x)+Q_c(x)\,2\pix=Pc​(x)+Qc​(x)2π; write θr(e)=Circle.exp⁡(r(e))\theta_r(e)=\operatorname{Circle.exp}(r(e))θr​(e)=Circle.exp(r(e)), e≺rfe\prec_r fe≺r​f for r(e)<r(f)r(e)<r(f)r(e)<r(f), Oa(r)(e)=r(e)+aO_a(r)(e)=r(e)+aOa​(r)(e)=r(e)+a, Dk(r)(e)=r(e)+k 2πD_k(r)(e)=r(e)+k\,2\piDk​(r)(e)=r(e)+k2π, and R(r)(e)=−r(e)R(r)(e)=-r(e)R(r)(e)=−r(e). First, for every small type EEE, every c∈Rc\in\mathbb Rc∈R, every r:E→Rr:E\to\mathbb Rr:E→R, and every e∈Ee\in Ee∈E, one has c<Pc(r(e))≤c+2πc<P_c(r(e))\le c+2\pic<Pc​(r(e))≤c+2π and Pc(r(e))+Qc(r(e)) 2π=r(e)P_c(r(e))+Q_c(r(e))\,2\pi=r(e)Pc​(r(e))+Qc​(r(e))2π=r(e); for every two cuts c1,c2c_1,c_2c1​,c2​, both reconstructed values are equal and Circle.exp⁡(Pc1(r(e)))=Circle.exp⁡(Pc2(r(e)))\operatorname{Circle.exp}(P_{c_1}(r(e)))=\operatorname{Circle.exp}(P_{c_2}(r(e)))Circle.exp(Pc1​​(r(e)))=Circle.exp(Pc2​​(r(e))); and Q−π(r(e))=−(−Q−π(r(e)))Q_{-\pi}(r(e))=-(-Q_{-\pi}(r(e)))Q−π​(r(e))=−(−Q−π​(r(e))), because the custom “principal edge turn” at base 000 and difference r(e)r(e)r(e) is defined as −Q−π(r(e))-Q_{-\pi}(r(e))−Q−π​(r(e)). Second, for every E,rE,rE,r, ≺r\prec_r≺r​ is irreflexive and transitive; if rrr is injective, every two distinct events are comparable in one direction; if EEE carries a linear order and rrr is strictly increasing for that order, then e≺rfe\prec_r fe≺r​f iff e<fe<fe<f; and there exists r:Fin⁡3→Rr:\operatorname{Fin}3\to\mathbb Rr:Fin3→R with r(0)=0r(0)=0r(0)=0, r(1)=4πr(1)=4\pir(1)=4π, r(2)=2πr(2)=2\pir(2)=2π, r(2)−r(0)=2πr(2)-r(0)=2\pir(2)−r(0)=2π, and rrr not strictly increasing in the canonical order on Fin⁡3\operatorname{Fin}3Fin3. Third, for every E,rE,rE,r, O0(r)=rO_0(r)=rO0​(r)=r; Oa+b(r)=Oa(Ob(r))O_{a+b}(r)=O_a(O_b(r))Oa+b​(r)=Oa​(Ob​(r)); for all events e,fe,fe,f, Oa(r)(f)−Oa(r)(e)=r(f)−r(e)O_a(r)(f)-O_a(r)(e)=r(f)-r(e)Oa​(r)(f)−Oa​(r)(e)=r(f)−r(e) and e≺Oa(r)fe\prec_{O_a(r)}fe≺Oa​(r)​f iff e≺rfe\prec_r fe≺r​f; whenever EEE is nonempty and two readings r,sr,sr,s satisfy s(f)−s(e)=r(f)−r(e)s(f)-s(e)=r(f)-r(e)s(f)−s(e)=r(f)−r(e) for every e,fe,fe,f, there exists a unique a∈Ra\in\mathbb Ra∈R with s=Oa(r)s=O_a(r)s=Oa​(r); D0(r)=rD_0(r)=rD0​(r)=r; Dk+ℓ(r)=Dk(Dℓ(r))D_{k+\ell}(r)=D_k(D_\ell(r))Dk+ℓ​(r)=Dk​(Dℓ​(r)); θDk(r)(e)=θr(e)\theta_{D_k(r)}(e)=\theta_r(e)θDk​(r)​(e)=θr​(e); e≺Dk(r)fe\prec_{D_k(r)}fe≺Dk​(r)​f iff e≺rfe\prec_r fe≺r​f; and, when EEE is nonempty, Dk(r)=rD_k(r)=rDk​(r)=r iff k=0k=0k=0. Fourth, for every E,r,e,f,kE,r,e,f,kE,r,e,f,k, θR(r)(e)=θr(e)−1\theta_{R(r)}(e)=\theta_r(e)^{-1}θR(r)​(e)=θr​(e)−1, e≺R(r)fe\prec_{R(r)}fe≺R(r)​f iff f≺ref\prec_r ef≺r​e, and R(Dk(r))=D−k(R(r))R(D_k(r))=D_{-k}(R(r))R(Dk​(r))=D−k​(R(r)). Fifth, for every x∈Rx\in\mathbb Rx∈R and n∈Zn\in\mathbb Zn∈Z, if x=n 2πx=n\,2\pix=n2π, then applying Q−πQ_{-\pi}Q−π​ to the value of the constant reading xxx on the sole element of Unit⁡\operatorname{Unit}Unit gives nnn; and, separately, the same equality is asserted directly for the constant value n 2πn\,2\pin2π for every integer nnn. Sixth, if B(α)B(\alpha)B(α) means Lebesgue integrability on the open interval (0,1)(0,1)(0,1) of the real-power function x↦x−αx\mapsto x^{-\alpha}x↦x−α, then for every α∈R\alpha\in\mathbb Rα∈R, B(α)B(\alpha)B(α) iff α<1\alpha<1α<1, and for every h≥0h\ge0h≥0, including h=0h=0h=0, B(1+h)B(1+h)B(1+h) is false. All unrestricted assertions over EEE include the empty type, where event-indexed universal clauses and equalities between readings may be vacuous; nonemptiness is imposed only in the two explicitly stated origin/deck uniqueness clauses.

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