Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Actual Covering-Fiber Transport and Naturality

Definition
Monodromy_Covering

by Xiaoyang Liu · Nov 5, 2026 · Mathlib 0df444a (Lean v4.33.1)

computabilitycovering-spacesmonodromy-computation

Defines a carried state as a point of an actual covering fiber and transport as the endpoint of Mathlib’s continuous path lift. Establishes lift realization and uniqueness, concatenation, homotopy invariance, reversal, fiber equivalences and naturality under continuous maps commuting with the covering projections.

Definition code
-- Generated by Lean-fact skeleton subtraction; original source is frozen in imports/monodromy/source.
module
public import Definitions.Def_Monodromy_PlatformCompatibility
public import Mathlib.Logic.Function.Conjugate
public import Mathlib.Tactic.FunProp
public import Mathlib.Topology.Homotopy.Lifting

@[expose] public section


@[expose] public section

/-!
# Transport from actual continuous covering-space lifts

The state is a point of an actual fiber of `p : E → X`. Transport is the
endpoint of mathlib's continuous path lift, not an independently axiomatized
endpoint function. Composition and homotopy invariance consequently depend on
the covering-space lifting theorems imported above.

The hypothesis `IsCoveringMap p` is explicit. This file does not establish that
a particular polynomial family is a covering, that its fibers are finite, or
that a numerical continuation algorithm computes these ideal lifts.
-/


namespace Monodromy.Transport

open unitInterval

universe u v w

variable {E : Type u} {X : Type v}
variable [TopologicalSpace E] [TopologicalSpace X]
variable {p : E → X}

/-- A persistent state over a specified control point. -/
abbrev Fiber (p : E → X) (x : X) := p ⁻¹' {x}

/-- The endpoint of the actual continuous lift of a based or open path. -/
noncomputable def transport (cov : IsCoveringMap p) {x y : X}
    (γ : Path x y) : Fiber p x → Fiber p y :=
  cov.monodromy (Path.Homotopic.Quotient.mk γ)







/-- Serial path execution: the first path acts first, then the second path. -/
theorem transport_trans (cov : IsCoveringMap p) {x y z : X}
    (γ : Path x y) (δ : Path y z) (e : Fiber p x) :
    transport cov (γ.trans δ) e = transport cov δ (transport cov γ e) := by
  exact cov.monodromy_trans_apply (Path.Homotopic.Quotient.mk γ)
    (Path.Homotopic.Quotient.mk δ) e

/-- Endpoint-fixed path homotopy preserves the transported state. -/
theorem transport_homotopic (cov : IsCoveringMap p) {x y : X}
    {γ δ : Path x y} (homotopy : γ.Homotopic δ) (e : Fiber p x) :
    transport cov γ e = transport cov δ e := by
  exact congrArg (fun q : Path.Homotopic.Quotient x y => cov.monodromy q e)
    (Quotient.sound homotopy)

/-- The constant path retains the actual state. -/
@[simp] theorem transport_refl (cov : IsCoveringMap p) {x : X} (e : Fiber p x) :
    transport cov (Path.refl x) e = e := by
  change cov.monodromy (Path.Homotopic.Quotient.refl x) e = e
  exact congrFun (cov.monodromy_refl (x := x)) e

/-- Executing a path and then its reverse restores the ideal carried state. -/
@[simp] theorem transport_reverse (cov : IsCoveringMap p) {x y : X}
    (γ : Path x y) (e : Fiber p x) :
    transport cov γ.symm (transport cov γ e) = e := by
  calc
    transport cov γ.symm (transport cov γ e) =
        transport cov (γ.trans γ.symm) e := (transport_trans cov γ γ.symm e).symm
    _ = transport cov (Path.refl x) e :=
      transport_homotopic cov (Path.Homotopic.trans_symm γ) e
    _ = e := transport_refl cov e

/-- Reverse execution followed by forward execution also restores the state. -/
@[simp] theorem reverse_transport (cov : IsCoveringMap p) {x y : X}
    (γ : Path x y) (e : Fiber p y) :
    transport cov γ (transport cov γ.symm e) = e := by
  calc
    transport cov γ (transport cov γ.symm e) =
        transport cov (γ.symm.trans γ) e := (transport_trans cov γ.symm γ e).symm
    _ = transport cov (Path.refl y) e :=
      transport_homotopic cov (Path.Homotopic.symm_trans γ) e
    _ = e := transport_refl cov e

/-- Open-path transport is a fiber equivalence; loops specialize to permutations. -/
noncomputable def transportEquiv (cov : IsCoveringMap p) {x y : X}
    (γ : Path x y) : Fiber p x ≃ Fiber p y where
  toFun := transport cov γ
  invFun := transport cov γ.symm
  left_inv := transport_reverse cov γ
  right_inv := reverse_transport cov γ

section Naturality

variable {E' : Type w} [TopologicalSpace E'] {q : E' → X}

/-- A commuting map of total spaces restricts to a map of each actual fiber. -/
def mapFiber (h : E → E') (square : q ∘ h = p) {x : X} :
    Fiber p x → Fiber q x :=
  fun e => ⟨h e, (congrFun square e).trans e.2⟩







/-- An actual covering isomorphism gives a specified identification of fibers. -/
def fiberEquiv (h : E ≃ₜ E') (square : q ∘ h = p) (x : X) :
    Fiber p x ≃ Fiber q x where
  toFun := mapFiber h square
  invFun e := ⟨h.symm e, by
    calc
      p (h.symm e) = q (h (h.symm e)) := (congrFun square (h.symm e)).symm
      _ = q e := congrArg q (h.apply_symm_apply e)
      _ = x := e.2⟩
  left_inv e := Subtype.ext (h.symm_apply_apply e)
  right_inv e := Subtype.ext (h.apply_symm_apply e)



end Naturality

end Monodromy.Transport

/-! Coverings are preserved by continuous pullback and finite product. -/

namespace Monodromy.CoverPullback

variable {E X B : Type*} [TopologicalSpace E] [TopologicalSpace X] [TopologicalSpace B]

abbrev Space (p : E → X) (g : B → X) := {pair : B × E // p pair.2 = g pair.1}

def projection (p : E → X) (g : B → X) (state : Space p g) : B := state.val.1

set_option backward.isDefEq.respectTransparency false in
theorem covering {p : E → X} (cover : IsCoveringMap p) {g : B → X}
    (continuous_g : Continuous g) : IsCoveringMap (projection p g) := by
  intro point
  let I := p ⁻¹' {g point}
  obtain ⟨discrete, V, in_V, open_V, _, H, over⟩ := cover (g point)
  let U : Set B := g ⁻¹' V
  let forward : (projection p g) ⁻¹' U → U × I := fun state =>
    (⟨state.val.val.1, state.property⟩,
     (H ⟨state.val.val.2, by
       change p state.val.val.2 ∈ V
       rw [state.val.property]
       exact state.property⟩).2)
  let backward : U × I → (projection p g) ⁻¹' U := fun coordinates =>
    let old := H.symm (⟨g coordinates.1.val, coordinates.1.property⟩, coordinates.2)
    ⟨⟨(coordinates.1.val, old.val),
      (over old).symm.trans (by simp [old])⟩, coordinates.1.property⟩
  have left_inverse : Function.LeftInverse backward forward := by
    intro state
    apply Subtype.ext
    apply Subtype.ext
    apply Prod.ext
    · rfl
    · let old : p ⁻¹' V := ⟨state.val.val.2, by
        change p state.val.val.2 ∈ V
        rw [state.val.property]
        exact state.property⟩
      have same : (⟨g state.val.val.1, state.property⟩, (H old).2) = H old := by
        apply Prod.ext
        · apply Subtype.ext
          exact state.val.property.symm.trans (over old).symm
        · rfl
      change (H.symm (⟨g state.val.val.1, state.property⟩, (H old).2)).val = state.val.val.2
      rw [same, H.symm_apply_apply]
  have right_inverse : Function.RightInverse backward forward := by
    intro coordinates
    apply Prod.ext
    · apply Subtype.ext
      rfl
    · change (H (H.symm (⟨g coordinates.1.val, coordinates.1.property⟩, coordinates.2))).2 = coordinates.2
      rw [H.apply_symm_apply]
  let localHomeomorph : (projection p g) ⁻¹' U ≃ₜ U × I :=
    { toFun := forward
      invFun := backward
      left_inv := left_inverse
      right_inv := right_inverse
      continuous_toFun := by dsimp [forward]; fun_prop
      continuous_invFun := by dsimp [backward]; fun_prop }
  apply IsEvenlyCovered.to_isEvenlyCovered_preimage (I := I)
  refine ⟨discrete, U, in_V, open_V.preimage continuous_g, ?_, localHomeomorph, ?_⟩
  · exact (open_V.preimage continuous_g).preimage (continuous_fst.comp continuous_subtype_val)
  · intro state
    rfl

end Monodromy.CoverPullback

namespace Monodromy.CoverPullback

variable {E X F Y : Type*}
  [TopologicalSpace E] [TopologicalSpace X] [TopologicalSpace F] [TopologicalSpace Y]

set_option backward.isDefEq.respectTransparency false in
theorem prodMap {f : E → X} {g : F → Y} (first : IsCoveringMap f) (second : IsCoveringMap g) :
    IsCoveringMap (Prod.map f g) := by
  intro point
  obtain ⟨first_discrete, U, in_U, open_U, _, H, over_H⟩ := first point.1
  obtain ⟨second_discrete, V, in_V, open_V, _, K, over_K⟩ := second point.2
  let I := f ⁻¹' {point.1}
  let J := g ⁻¹' {point.2}
  let : DiscreteTopology I := first_discrete
  let : DiscreteTopology J := second_discrete
  have source_eq : (Prod.map f g) ⁻¹' (U ×ˢ V) = (f ⁻¹' U) ×ˢ (g ⁻¹' V) := rfl
  let localHomeomorph : (Prod.map f g) ⁻¹' (U ×ˢ V) ≃ₜ (U ×ˢ V) × (I × J) :=
    (Homeomorph.setCongr source_eq).trans ((Homeomorph.Set.prod (f ⁻¹' U) (g ⁻¹' V)).trans
      ((H.prodCongr K).trans ((Homeomorph.prodProdProdComm U I V J).trans
        ((Homeomorph.Set.prod U V).symm.prodCongr (Homeomorph.refl (I × J))))))
  apply IsEvenlyCovered.to_isEvenlyCovered_preimage (I := I × J)
  refine ⟨inferInstance, U ×ˢ V, ⟨in_U, in_V⟩, open_U.prod open_V,
    (open_U.prod open_V).preimage (first.continuous.prodMap second.continuous), localHomeomorph, ?_⟩
  intro state
  exact Prod.ext (over_H _) (over_K _)

end Monodromy.CoverPullback

namespace Monodromy.CoverPullback

variable {X : Type*} [TopologicalSpace X]

theorem identity : IsCoveringMap (id : X → X) := by
  intro point
  let U : Set X := Set.univ
  let H : U ≃ₜ U × Unit :=
    { toFun := fun value => (value, ())
      invFun := Prod.fst
      left_inv := fun _ => rfl
      right_inv := fun _ => Prod.ext rfl (Subsingleton.elim _ _)
      continuous_toFun := by fun_prop
      continuous_invFun := continuous_fst }
  apply IsEvenlyCovered.to_isEvenlyCovered_preimage (I := Unit)
  exact ⟨inferInstance, Set.univ, trivial, isOpen_univ, by simp, H, fun _ => rfl⟩

end Monodromy.CoverPullback
Source
Authoritative local working-tree snapshot SHA-256 e03ce2d08e07ee663140bec213fb21e995f44153a3c556c908fcf1c8d6fefe6c; repository https://github.com/ERHUTUZI123/monodromy. The remote Git base is incomplete and is not asserted to contain these declarations. src/Monodromy/Covering.lean (file SHA-256 aefdaceefa095ff0e469f6766ca5bf2502b71b887c244e8f6be18ed5d8448b0c): Monodromy.Transport.Fiber at L33-L34 [UTF-8 910:1018]. Monodromy.Transport.transport at L36-L39 [UTF-8 1020:1253]. Monodromy.Transport.transport_trans at L65-L70 [UTF-8 2500:2876]. Monodromy.Transport.transport_homotopic at L72-L77 [UTF-8 2878:3234]. Monodromy.Transport.transport_refl at L79-L83 [UTF-8 3236:3522]. Monodromy.Transport.transport_reverse at L85-L94 [UTF-8 3524:4045]. Monodromy.Transport.reverse_transport at L96-L105 [UTF-8 4047:4569]. Monodromy.Transport.transportEquiv at L107-L113 [UTF-8 4571:4915]. Monodromy.Transport.mapFiber at L119-L122 [UTF-8 4998:5221]. Monodromy.Transport.fiberEquiv at L163-L173 [UTF-8 7052:7552]. Monodromy.CoverPullback.Space at L194-L194 [UTF-8 8301:8383]. Monodromy.CoverPullback.projection at L196-L196 [UTF-8 8385:8466]. Monodromy.CoverPullback.covering at L198-L250 [UTF-8 8468:10850]. Monodromy.CoverPullback.prodMap at L259-L278 [UTF-8 11030:12278]. Monodromy.CoverPullback.identity at L286-L297 [UTF-8 12387:12907].
Read-back

What the Lean code literally says, in plain math · OpenAI Codex (independent agent)

For arbitrary topological spaces E,XE,XE,X and a map p:E→Xp:E\to Xp:E→X, the fiber at xxx is the subtype Fp(x)={e∈E:p(e)=x}F_p(x)=\{e\in E:p(e)=x\}Fp​(x)={e∈E:p(e)=x}. Given an explicit covering-map hypothesis on ppp and a continuous path γ:[0,1]→X\gamma:[0,1]\to Xγ:[0,1]→X from xxx to yyy, the noncomputable map Tγ:Fp(x)→Fp(y)T_\gamma:F_p(x)\to F_p(y)Tγ​:Fp​(x)→Fp​(y) is defined as the covering monodromy of the endpoint-fixed homotopy class of γ\gammaγ, hence by the endpoint of its covering-space path lift. The bundle asserts, for every composable pair of paths γ:x→y\gamma:x\to yγ:x→y, δ:y→z\delta:y\to zδ:y→z and every starting fiber point, Tγ∗δ=Tδ∘TγT_{\gamma*\delta}=T_\delta\circ T_\gammaTγ∗δ​=Tδ​∘Tγ​; for homotopic endpoint-fixed paths their transports agree pointwise; constant-path transport is the identity; reverse-path transport after forward transport is the identity on Fp(x)F_p(x)Fp​(x), and forward transport after reverse transport is the identity on Fp(y)F_p(y)Fp​(y). It packages these two transport maps as mutually inverse functions in an equivalence of fibers. For an additional topological space E′E'E′, a map q:E′→Xq:E'\to Xq:E′→X and any function h:E→E′h:E\to E'h:E→E′ satisfying q∘h=pq\circ h=pq∘h=p, it defines the fiber map e↦h(e)e\mapsto h(e)e↦h(e), with no continuity hypothesis on hhh required by that definition; when hhh is a homeomorphism with that same commuting equation it defines a fiber equivalence using hhh and h−1h^{-1}h−1. For arbitrary topological spaces E,X,BE,X,BE,X,B, it defines the pullback P(p,g)={(b,e)∈B×E:p(e)=g(b)}P(p,g)=\{(b,e)\in B\times E:p(e)=g(b)\}P(p,g)={(b,e)∈B×E:p(e)=g(b)} and projection (b,e)↦b(b,e)\mapsto b(b,e)↦b, and asserts that this projection is a covering map if ppp is a covering map and g:B→Xg:B\to Xg:B→X is continuous. For arbitrary topological spaces E,X,F,YE,X,F,YE,X,F,Y it asserts that (e,f)↦(p(e),q(f))(e,f)\mapsto(p(e),q(f))(e,f)↦(p(e),q(f)) is a covering map whenever p:E→Xp:E\to Xp:E→X and q:F→Yq:F\to Yq:F→Y are covering maps; for every topological XXX it also asserts the identity of XXX is a covering map. No finiteness, inhabitedness or connectedness hypotheses are imposed on these spaces or fibers, and all pointwise transport equations quantify only over the fiber points supplied.

Human review
  • Endorsed by marwahaha · Nov 6, 2026

  • Endorsed by Xiaoyang Liu · Nov 6, 2026

    Confirmed by the mission captain (proposal self-audit).

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