Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Support realization of the bipartite double cover

Definition
AT260939824_DoubleCoverSupport

by username · Oct 19, 2026 · Mathlib c5ea003 (Lean v4.30.0)

arxiv-2609-39824-positivegraph-theorylean-formalizationtopological-dynamics

Given a graph HHH and a chosen adjacent neighbor at each vertex, the two copies of each vertex are represented by points in the support-pair space. Oriented edges are assigned paths and homotopy classes between these points. Reversing an edge reverses its class, and closed four-walks have trivial class. These certificates package an actual realization compatible with the defining reduced-walk relations.

Definition code
import Definitions.Def_AT260939824_Actions
import Definitions.Def_AT260939824_Probability
import Definitions.Def_AT260939824_ReducedWalks
import Definitions.Def_AT260939824_Rounding
import Definitions.Def_AT260939824_SupportGeometry
import Definitions.Def_AT260939824_SupportModel
import Definitions.Def_AT260939824_SupportPathClasses
import Definitions.Def_AT260939824_TopologicalWalks
import Init
import Lean.Elab.Tactic.Omega
import Mathlib.Algebra.Group.Action.Basic
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Algebra.Ring.Parity
import Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic
import Mathlib.Combinatorics.SimpleGraph.Basic
import Mathlib.Combinatorics.SimpleGraph.Bipartite
import Mathlib.Combinatorics.SimpleGraph.Maps
import Mathlib.Combinatorics.SimpleGraph.Walk.Maps
import Mathlib.Data.Finset.Max
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Real.Basic
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.Tactic.FunProp
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.NormNum
import Mathlib.Topology.Algebra.MulAction
import Mathlib.Topology.Compactness.Compact
import Mathlib.Topology.Constructions
import Mathlib.Topology.Homotopy.Path
import Mathlib.Topology.Instances.Real.Lemmas
import Mathlib.Topology.MetricSpace.Basic
import Mathlib.Topology.MetricSpace.Isometry
import Mathlib.Topology.MetricSpace.Polish
import Mathlib.Topology.MetricSpace.Pseudo.Pi
import Mathlib.Topology.Path
import Mathlib.Topology.Separation.Basic
import Mathlib.Topology.Separation.Profinite
import Mathlib.Topology.UniformSpace.HeineCantor
import Mathlib.Topology.UnitInterval

set_option autoImplicit false

/-!
# Realization of the graph double cover in the support complex

The chosen-neighbor edge routes of Lemma 6.2 respect spur and four-walk
cancellation.  This file constructs that realization and proves its
compatibility with the reduced graph-walk homotopy presentation.
-/

namespace AbelianTargets

noncomputable section

variable {V : Type*} [Fintype V] (H : SimpleGraph V)
  (s : V → V) (hs : ∀ v, H.Adj v (s v))

/-- The two lifts of a vertex are exchanged by the support-shore swap. -/
def doublePoint : V ⊕ V → SupportPair H
  | .inl v => SupportPair.vertex H (hs v)
  | .inr v => SupportPair.vertex H (hs v).symm

def doubleEdgeClass : EdgeClasses H.bipartiteDoubleCover (doublePoint H s hs)
  | .inl u, .inr v, h => SupportPair.doubleClass H (hs u) h (hs v).symm
  | .inr u, .inl v, h => Path.Homotopic.Quotient.symm
      (SupportPair.doubleClass H (hs v) h.symm (hs u).symm)
  | .inl _, .inl _, h => h.elim
  | .inr _, .inr _, h => h.elim

def doubleEdgePath : EdgePaths H.bipartiteDoubleCover (doublePoint H s hs)
  | .inl u, .inr v, h => SupportPair.doubleEdgePath H (hs u) h (hs v).symm
  | .inr u, .inl v, h => (SupportPair.doubleEdgePath H (hs v) h.symm (hs u).symm).symm
  | .inl _, .inl _, h => h.elim
  | .inr _, .inr _, h => h.elim





theorem doubleEdgeClass_reverse {a b : V ⊕ V} (h : H.bipartiteDoubleCover.Adj a b) :
    doubleEdgeClass H s hs h.symm = Path.Homotopic.Quotient.symm (doubleEdgeClass H s hs h) := by
  cases a <;> cases b
  · exact h.elim
  · rfl
  · exact (SupportPair.quotient_symm_symm _).symm
  · exact h.elim

 theorem symm_trans_assoc {X : Type*} [TopologicalSpace X] {a b c : X}
    (P : Path.Homotopic.Quotient a b) (R : Path.Homotopic.Quotient b c) :
    Path.Homotopic.Quotient.trans (Path.Homotopic.Quotient.symm P)
      (Path.Homotopic.Quotient.trans P R) = R := by
  rw [← Path.Homotopic.Quotient.trans_assoc, Path.Homotopic.Quotient.symm_trans,
    Path.Homotopic.Quotient.refl_trans]

 theorem opposite_square {X : Type*} [TopologicalSpace X] {a b c d : X}
    (A : Path.Homotopic.Quotient a b) (B : Path.Homotopic.Quotient c b)
    (C : Path.Homotopic.Quotient c d) (D : Path.Homotopic.Quotient a d)
    (h : Path.Homotopic.Quotient.trans A
      (Path.Homotopic.Quotient.trans (Path.Homotopic.Quotient.symm B)
        (Path.Homotopic.Quotient.trans C (Path.Homotopic.Quotient.symm D))) =
      Path.Homotopic.Quotient.refl a) :
    Path.Homotopic.Quotient.trans (Path.Homotopic.Quotient.symm A)
      (Path.Homotopic.Quotient.trans D
        (Path.Homotopic.Quotient.trans (Path.Homotopic.Quotient.symm C) B)) =
      Path.Homotopic.Quotient.refl b := by
  have hrot := congrArg (fun R => Path.Homotopic.Quotient.trans
    (Path.Homotopic.Quotient.symm A) (Path.Homotopic.Quotient.trans R A)) h
  simp only [Path.Homotopic.Quotient.trans_assoc, symm_trans_assoc,
    Path.Homotopic.Quotient.refl_trans, Path.Homotopic.Quotient.symm_trans] at hrot
  have hinv := congrArg Path.Homotopic.Quotient.symm hrot
  simpa only [SupportPair.quotient_symm_trans, SupportPair.quotient_symm_symm,
    SupportPair.quotient_refl_symm, Path.Homotopic.Quotient.trans_assoc] using hinv

theorem doubleEdgeClass_four {a : V ⊕ V} (p : H.bipartiteDoubleCover.Walk a a)
    (hp : p.length = 4) : walkClass H.bipartiteDoubleCover (doublePoint H s hs)
      (doubleEdgeClass H s hs) p = Path.Homotopic.Quotient.refl (doublePoint H s hs a) := by
  cases p with
  | nil => simp at hp
  | @cons a b _ hab p =>
    cases p with
    | nil => simp at hp
    | @cons _ c _ hbc p =>
      cases p with
      | nil => simp at hp
      | @cons _ d _ hcd p =>
        cases p with
        | nil => simp at hp
        | @cons _ e _ hde p =>
          cases p with
          | cons h p => simp only [SimpleGraph.Walk.length_cons] at hp; omega
          | nil =>
            cases a with
            | inl v =>
              cases b with
              | inl w => exact hab.elim
              | inr w =>
                cases c with
                | inr x => exact hbc.elim
                | inl x =>
                  cases d with
                  | inl y => exact hcd.elim
                  | inr y =>
                    simpa only [walkClass_cons, walkClass_nil, doubleEdgeClass, doublePoint,
                      Path.Homotopic.Quotient.trans_refl, Path.Homotopic.Quotient.trans_assoc]
                      using SupportPair.doubleCover_four_null H (hs v) (hs w) (hs x) (hs y)
                        hab hbc.symm hcd hde.symm
            | inr v =>
              cases b with
              | inr w => exact hab.elim
              | inl w =>
                cases c with
                | inl x => exact hbc.elim
                | inr x =>
                  cases d with
                  | inr y => exact hcd.elim
                  | inl y =>
                    have h := SupportPair.doubleCover_four_null H (hs w) (hs v) (hs y) (hs x)
                      hab.symm hde hcd.symm hbc
                    simp only [Path.Homotopic.Quotient.trans_assoc] at h
                    have h' := opposite_square _ _ _ _ h
                    simpa only [walkClass_cons, walkClass_nil, doubleEdgeClass, doublePoint,
                      Path.Homotopic.Quotient.trans_refl] using h'

/-- The actual support-space edge realization fills all defining reduced
homotopy relations of the bipartite graph double cover. -/
def doubleCoverReducedEdgeClasses :
    ReducedEdgeClasses H.bipartiteDoubleCover (doublePoint H s hs) where
  edge := doubleEdgeClass H s hs
  reverse := fun {_ _} h => doubleEdgeClass_reverse H s hs h
  four := fun {_} p hp => doubleEdgeClass_four H s hs p hp



end

end AbelianTargets
Source
Ruijun Wang, Continuous graph homomorphisms of higher dimensional abelian group actions, arXiv:2609.39824v1 (30 September 2026), Sections 2-7; https://arxiv.org/html/2609.39824v1. Formalization-specific infrastructure in the import closure of Theorem 1.4 and Proposition 7.1; individual helper assertions are not represented as separately numbered paper theorems. Original Lean module AbelianTargets/DoubleCoverSupport.lean, selected declaration lines 20-23, 25-30, 32-36, 57-63, 65-70, 72-89, 91-139, 141-147; SHA-256 2fca52e6371811b5905e2c27e18a049c2d11b2745429f7764c435715a4a4ee35. Selected spans are from the final generated manifest. The original source snapshot is local; no public repository URL or commit was available.

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