introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
22.3 kB
import OAI.Combinatorics.CompleteCrossing.Drawing
import Mathlib.Dynamics.PeriodicPts.Lemmas
import Mathlib.LinearAlgebra.Span.Defs
import Mathlib.Logic.Equiv.Fin.Rotate
import Mathlib.Tactic
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring
namespace OAI
/-! Cycle-space spanning, flows, simple cycles, and oriented darts. -/
section
/-! Linear properties of actual oriented simple cycles. -/
noncomputable section
open scoped BigOperators Classical
namespace Paper170
variable {V E : Type} {G : Graph V E}
namespace SimpleCycle
def next (C : SimpleCycle G) (i : Fin C.length) : Fin C.length :=
⟨(i.val+1)%C.length, Nat.mod_lt _ (by have := C.three_le; omega)⟩
theorem follows_next (C : SimpleCycle G) (i : Fin C.length) :
(G.src (C.edge i)=C.vertex i ∧ G.dst (C.edge i)=C.vertex (C.next i)) ∨
(G.dst (C.edge i)=C.vertex i ∧ G.src (C.edge i)=C.vertex (C.next i)) := C.follows i
theorem next_eq_finRotate (C : SimpleCycle G) : C.next = finRotate C.length := by
funext i
apply Fin.ext
have hL : 1 < C.length := by have := C.three_le; omega
simp [next, finRotate_apply, Fin.val_add, Nat.mod_eq_of_lt hL]
theorem next_val (C : SimpleCycle G) (i : Fin C.length) :
(C.next i).val = if i.val+1<C.length then i.val+1 else 0 := by
change (i.val+1)%C.length = _
by_cases h : i.val+1<C.length
· simp [h, Nat.mod_eq_of_lt h]
· have he : i.val+1=C.length := by omega
simp [he]
theorem next_ne_self (C : SimpleCycle G) (i : Fin C.length) : C.next i≠i := by
intro h
have he := congrArg Fin.val h
rw [next_val] at he
have := C.three_le
split_ifs at he <;> omega
theorem next_next_ne_self (C : SimpleCycle G) (i : Fin C.length) : C.next (C.next i)≠i := by
intro h
have he := congrArg Fin.val h
simp only [next_val] at he
have := C.three_le
split_ifs at he <;> omega
theorem edge_injective (C : SimpleCycle G) : Function.Injective C.edge := by
intro i j hij
have hi := C.follows_next i
have hj := C.follows_next j
rw [hij] at hi
rcases hi with hi | hi <;> rcases hj with hj | hj
· exact C.vertex_injective (hi.1.symm.trans hj.1)
· have h1 := C.vertex_injective (hi.1.symm.trans hj.2)
have h2 := C.vertex_injective (hi.2.symm.trans hj.1)
exact False.elim (C.next_next_ne_self j (by rw [← h1,h2]))
· have h1 := C.vertex_injective (hi.1.symm.trans hj.2)
have h2 := C.vertex_injective (hi.2.symm.trans hj.1)
exact False.elim (C.next_next_ne_self j (by rw [← h1,h2]))
· exact C.vertex_injective (hi.1.symm.trans hj.1)
theorem edgeChain_at_edge (C : SimpleCycle G) (i : Fin C.length) :
C.edgeChain (C.edge i) = if G.src (C.edge i)=C.vertex i then 1 else -1 := by
classical
simp only [edgeChain, C.edge_injective.eq_iff]
simp
theorem edgeChain_at_edge_ne_zero (C : SimpleCycle G) (i : Fin C.length) :
C.edgeChain (C.edge i) ≠ 0 := by
rw [edgeChain_at_edge]
split_ifs <;> norm_num
theorem edgeChain_eq_zero_of_not_mem_range (C : SimpleCycle G) {e : E}
(he : e∉Set.range C.edge) : C.edgeChain e=0 := by
classical
apply Finset.sum_eq_zero
intro i _
rw [ite_eq_right (fun h => he ⟨i,h⟩)]
theorem edgeChain_support (C : SimpleCycle G) (e : E) :
C.edgeChain e≠0 ↔ e∈Set.range C.edge := by
constructor
· exact fun h => Classical.byContradiction (fun he => h (C.edgeChain_eq_zero_of_not_mem_range he))
· rintro ⟨i,rfl⟩
exact C.edgeChain_at_edge_ne_zero i
theorem signed_boundary_step (C : SimpleCycle G) (i : Fin C.length) (v : V) :
(if G.src (C.edge i)=C.vertex i then (1:ℝ) else -1) *
((if G.dst (C.edge i)=v then 1 else 0)-(if G.src (C.edge i)=v then 1 else 0)) =
(if C.vertex (C.next i)=v then 1 else 0)-(if C.vertex i=v then 1 else 0) := by
classical
rcases C.follows_next i with h | h
· simp [h.1,h.2]
· have hn : C.vertex (C.next i)≠C.vertex i := fun h => C.next_ne_self i (C.vertex_injective h)
simp only [h.1,h.2,ite_eq_right hn]
ring
theorem boundary_edgeChain [Fintype E] (C : SimpleCycle G) (v : V) : boundary G C.edgeChain v=0 := by
classical
unfold boundary edgeChain
simp only [Finset.sum_mul]
rw [Finset.sum_comm]
have hi (i : Fin C.length) :
(∑e, (if C.edge i=e then (if G.src e=C.vertex i then (1:ℝ) else -1) else 0) *
((if G.dst e=v then 1 else 0)-(if G.src e=v then 1 else 0))) =
(if C.vertex (C.next i)=v then 1 else 0)-(if C.vertex i=v then 1 else 0) := by
rw [Finset.sum_eq_single (C.edge i)]
· simpa using C.signed_boundary_step i v
· intro e _ he
simp [Ne.symm he]
· simp
simp_rw [hi]
rw [Finset.sum_sub_distrib, next_eq_finRotate]
exact sub_eq_zero.mpr (Equiv.sum_comp (finRotate C.length)
(fun i => if C.vertex i=v then (1:ℝ) else 0))
end SimpleCycle
end Paper170
end
end
section
noncomputable section
open scoped BigOperators Classical
namespace Paper170
variable {V E : Type} [Fintype V] [Fintype E] (G : Graph V E)
omit [Fintype V] in
lemma incoming_has_outgoing (z : E → ℝ) (hz : ∀ v, boundary G z v = 0)
(v : V) (e : E)
(he : (G.dst e = v ∧ 0 < z e) ∨ (G.src e = v ∧ z e < 0)) :
∃ f, ((G.src f = v ∧ 0 < z f) ∨ (G.dst f = v ∧ z f < 0)) := by
by_contra hn
have hn' (f : E) : ¬ ((G.src f = v ∧ 0 < z f) ∨ (G.dst f = v ∧ z f < 0)) := fun hf => hn ⟨f, hf⟩
let term := fun f : E => z f * ((if G.dst f = v then 1 else 0) -
(if G.src f = v then 1 else 0))
have hnonneg (f : E) : 0 ≤ term f := by
by_cases hdst : G.dst f = v
· by_cases hsrc : G.src f = v
· exact (G.loopless f (hsrc.trans hdst.symm)).elim
· have hf : 0 ≤ z f := by
by_contra! h
exact hn' f (Or.inr ⟨hdst, h⟩)
simpa [term, hdst, hsrc] using hf
· by_cases hsrc : G.src f = v
· have hf : z f ≤ 0 := by
by_contra! h
exact hn' f (Or.inl ⟨hsrc, h⟩)
simpa [term, hdst, hsrc] using neg_nonneg.mpr hf
· simp [term, hdst, hsrc]
have hpos : 0 < term e := by
rcases he with ⟨hdst, he⟩ | ⟨hsrc, he⟩
· have hsrc : G.src e ≠ v := fun h => G.loopless e (h.trans hdst.symm)
simpa [term, hdst, hsrc] using he
· have hdst : G.dst e ≠ v := fun h => G.loopless e (hsrc.trans h.symm)
simpa [term, hdst, hsrc] using neg_pos.mpr he
have ht : 0 < ∑ f, term f := Finset.sum_pos' (fun f _ => hnonneg f)
⟨e, Finset.mem_univ e, hpos⟩
have hzero : (∑ f, term f) = 0 := hz v
linarith
abbrev FlowVertex (z : E → ℝ) := {v : V // ∃ e, ((G.src e = v ∧ 0 < z e) ∨ (G.dst e = v ∧ z e < 0))}
omit [Fintype V] in
lemma flow_successor_exists (z : E → ℝ) (hz : ∀ v, boundary G z v = 0)
(v : FlowVertex G z) : ∃ w : FlowVertex G z, ∃ e, ((G.src e = v.val ∧ G.dst e = w.val ∧ 0 < z e) ∨
(G.dst e = v.val ∧ G.src e = w.val ∧ z e < 0)) := by
obtain ⟨e, he⟩ := v.property
rcases he with ⟨hsrc, he⟩ | ⟨hdst, he⟩
· refine ⟨⟨G.dst e, incoming_has_outgoing G z hz (G.dst e) e (Or.inl ⟨rfl, he⟩)⟩,
e, Or.inl ⟨hsrc, rfl, he⟩⟩
· refine ⟨⟨G.src e, incoming_has_outgoing G z hz (G.src e) e (Or.inr ⟨rfl, he⟩)⟩,
e, Or.inr ⟨hdst, rfl, he⟩⟩
def flowNext (z : E → ℝ) (hz : ∀ v, boundary G z v = 0) (v : FlowVertex G z) :
FlowVertex G z := (flow_successor_exists G z hz v).choose
def flowEdge (z : E → ℝ) (hz : ∀ v, boundary G z v = 0) (v : FlowVertex G z) : E :=
(flow_successor_exists G z hz v).choose_spec.choose
omit [Fintype V] in
lemma flowEdge_spec (z : E → ℝ) (hz : ∀ v, boundary G z v = 0) (v : FlowVertex G z) :
((G.src (flowEdge G z hz v) = v.val ∧ G.dst (flowEdge G z hz v) = (flowNext G z hz v).val ∧ 0 < z (flowEdge G z hz v)) ∨
(G.dst (flowEdge G z hz v) = v.val ∧ G.src (flowEdge G z hz v) = (flowNext G z hz v).val ∧ z (flowEdge G z hz v) < 0)) :=
(flow_successor_exists G z hz v).choose_spec.choose_spec
omit [Fintype V] [Fintype E] in
lemma flowArc_irrefl (z : E → ℝ) (v : V) (e : E) : ¬ ((G.src e = v ∧ G.dst e = v ∧ 0 < z e) ∨
(G.dst e = v ∧ G.src e = v ∧ z e < 0)) := by
rintro (⟨hs, hd, _⟩ | ⟨hd, hs, _⟩) <;> exact G.loopless e (hs.trans hd.symm)
omit [Fintype V] [Fintype E] in
lemma flowArc_not_reverse (z : E → ℝ) (v w : V) (e f : E)
(he : ((G.src e = v ∧ G.dst e = w ∧ 0 < z e) ∨
(G.dst e = v ∧ G.src e = w ∧ z e < 0))) (hf : ((G.src f = w ∧ G.dst f = v ∧ 0 < z f) ∨
(G.dst f = w ∧ G.src f = v ∧ z f < 0))) : False := by
have hef : e = f := by
apply G.simple e f
rcases he with ⟨he1, he2, _⟩ | ⟨he1, he2, _⟩ <;>
rcases hf with ⟨hf1, hf2, _⟩ | ⟨hf1, hf2, _⟩
· exact Or.inr ⟨he1.trans hf2.symm, he2.trans hf1.symm⟩
· exact Or.inl ⟨he1.trans hf2.symm, he2.trans hf1.symm⟩
· exact Or.inl ⟨he2.trans hf1.symm, he1.trans hf2.symm⟩
· exact Or.inr ⟨he2.trans hf1.symm, he1.trans hf2.symm⟩
subst f
rcases he with ⟨he1, he2, hp⟩ | ⟨he1, he2, hp⟩ <;>
rcases hf with ⟨hf1, hf2, hq⟩ | ⟨hf1, hf2, hq⟩
· exact G.loopless e (he1.trans hf2.symm)
· linarith
· linarith
· exact G.loopless e (hf2.trans he1.symm)
lemma exists_positive_period {α : Type*} [Finite α] [Nonempty α] (f : α → α) :
∃ a, 0 < Function.minimalPeriod f a := by
let x : α := Classical.arbitrary α
obtain ⟨m, n, hne, heq⟩ := Finite.exists_ne_map_eq_of_infinite (fun i : ℕ => f^[i] x)
have helper {m n : ℕ} (hmn : m < n) (h : f^[m] x = f^[n] x) :
∃ a, 0 < Function.minimalPeriod f a := by
have hperiod : Function.IsPeriodicPt f (n - m) (f^[m] x) := by
change f^[n-m] (f^[m] x) = f^[m] x
rw [← Function.iterate_add_apply, Nat.sub_add_cancel hmn.le]
exact h.symm
exact ⟨f^[m] x, hperiod.minimalPeriod_pos (Nat.sub_pos_of_lt hmn)⟩
rcases lt_or_gt_of_ne hne with hlt | hlt
· exact helper hlt heq
· exact helper hlt heq.symm
end Paper170
end
end
section
/-! Directed traversals of the fixed edges of an arbitrary finite simple graph. -/
noncomputable section
namespace Paper170Geometry
open Paper170 (Graph)
variable {V E : Type} {G : Graph V E}
structure OrientedDart (G : Graph V E) where
edge : E
forward : Bool
namespace OrientedDart
def fst (d : OrientedDart G) : V := if d.forward then G.src d.edge else G.dst d.edge
def snd (d : OrientedDart G) : V := if d.forward then G.dst d.edge else G.src d.edge
def symm (d : OrientedDart G) : OrientedDart G := ⟨d.edge,!d.forward⟩
@[simp] theorem symm_fst (d : OrientedDart G) : d.symm.fst = d.snd := by
cases d with | mk e b => cases b <;> rfl
@[simp] theorem symm_snd (d : OrientedDart G) : d.symm.snd = d.fst := by
cases d with | mk e b => cases b <;> rfl
@[simp] theorem symm_symm (d : OrientedDart G) : d.symm.symm = d := by
cases d with | mk e b => cases b <;> rfl
theorem fst_ne_snd (d : OrientedDart G) : d.fst ≠ d.snd := by
cases d with
| mk e b =>
cases b
· exact (G.loopless e).symm
· exact G.loopless e
end OrientedDart
def forwardDart (G : Graph V E) (e : E) : OrientedDart G := ⟨e,true⟩
def backwardDart (G : Graph V E) (e : E) : OrientedDart G := ⟨e,false⟩
def dartSign (d : OrientedDart G) : ℝ := if d.forward then 1 else -1
theorem orientedDart_cases (d : OrientedDart G) :
(∃ e, d = forwardDart G e) ∨ (∃ e, d = backwardDart G e) := by
cases d with
| mk e b =>
cases b
· exact Or.inr ⟨e,rfl⟩
· exact Or.inl ⟨e,rfl⟩
theorem dart_source_incident (d : OrientedDart G) :
d.fst = G.src d.edge ∨ d.fst = G.dst d.edge := by
cases d with
| mk e b =>
cases b
· exact Or.inr rfl
· exact Or.inl rfl
theorem dart_target_incident (d : OrientedDart G) :
d.snd = G.src d.edge ∨ d.snd = G.dst d.edge := by
cases d with
| mk e b =>
cases b
· exact Or.inl rfl
· exact Or.inr rfl
@[simp] theorem dartSign_symm (d : OrientedDart G) : dartSign d.symm = -dartSign d := by
cases d with | mk e b => cases b <;> norm_num [dartSign,OrientedDart.symm]
end Paper170Geometry
end
end
section
/-! Support reduction spans the real kernel of the graph boundary map by simple cycles. -/
noncomputable section
open scoped BigOperators Classical
namespace Paper170
variable {V E : Type} [Fintype E] (G : Graph V E)
def boundaryLinear : (E → ℝ) →ₗ[ℝ] (V → ℝ) where
toFun z := boundary G z
map_add' z w := by
funext v
simp [boundary, add_mul, Finset.sum_add_distrib]
map_smul' a z := by
funext v
simp [boundary, mul_assoc, Finset.mul_sum]
def chainSupport (z : E → ℝ) : Finset E := Finset.univ.filter fun e => z e≠0
theorem mem_chainSupport (z : E → ℝ) (e : E) : e∈chainSupport z ↔ z e≠0 := by
simp [chainSupport]
theorem simple_cycles_balanced (z : E → ℝ)
(hz : z∈Submodule.span ℝ (Set.range (fun C : SimpleCycle G => C.edgeChain))) :
∀v, boundary G z v=0 := by
have hle : Submodule.span ℝ (Set.range (fun C : SimpleCycle G => C.edgeChain)) ≤
LinearMap.ker (boundaryLinear G) := by
rw [Submodule.span_le]
rintro _ ⟨C,rfl⟩
exact funext C.boundary_edgeChain
exact fun v => congrFun (hle hz) v
theorem simple_cycles_span_of_supported_cycle
(hex : ∀z : E → ℝ, (∀v, boundary G z v=0) → z≠0 →
∃C : SimpleCycle G, ∀i, z (C.edge i)≠0) (z : E → ℝ) :
(∀v, boundary G z v=0) ↔ z∈Submodule.span ℝ (Set.range (fun C : SimpleCycle G => C.edgeChain)) := by
constructor
· intro hz
suffices h : ∀m (w : E → ℝ), (chainSupport w).card=m → (∀v, boundary G w v=0) →
w∈Submodule.span ℝ (Set.range (fun C : SimpleCycle G => C.edgeChain)) from
h _ z rfl hz
intro m
induction m using Nat.strong_induction_on with
| h m ih =>
intro w hm hw
by_cases hw0 : w=0
· simp [hw0]
obtain ⟨C,hC⟩ := hex w hw hw0
let i : Fin C.length := ⟨0,by have := C.three_le; omega⟩
let e := C.edge i
have hc : C.edgeChain e≠0 := C.edgeChain_at_edge_ne_zero i
let a := w e / C.edgeChain e
let w' := w-a • C.edgeChain
have hw' : ∀v, boundary G w' v=0 := by
have hmapw : boundaryLinear G w=0 := funext hw
have hmapC : boundaryLinear G C.edgeChain=0 := funext C.boundary_edgeChain
have hmap : boundaryLinear G w'=0 := by
simp only [w',map_sub,map_smul,hmapw,hmapC,smul_zero,sub_self]
exact fun v => congrFun hmap v
have he0 : w' e=0 := by
change w e-(w e/C.edgeChain e)*C.edgeChain e=0
rw [div_mul_cancel₀ _ hc,sub_self]
have hsub : chainSupport w' ⊆ chainSupport w := by
intro f hf
rw [mem_chainSupport] at hf ⊢
by_contra hwf
have hCf : C.edgeChain f=0 := by
by_contra hh
obtain ⟨j,hj⟩ := (C.edgeChain_support f).mp hh
exact hC j (hj ▸ hwf)
apply hf
change w f-a*C.edgeChain f=0
rw [hwf,hCf,mul_zero,sub_self]
have hproper : chainSupport w' ⊂ chainSupport w := by
apply Finset.ssubset_iff_subset_ne.mpr
refine ⟨hsub,?_⟩
intro heq
have hew : e∈chainSupport w := (mem_chainSupport w e).mpr (hC i)
rw [← heq,mem_chainSupport] at hew
exact hew he0
have hcard : (chainSupport w').card<m := by
rw [← hm]
exact Finset.card_lt_card hproper
have hind := ih _ hcard w' rfl hw'
have hchain : C.edgeChain∈Submodule.span ℝ (Set.range (fun C : SimpleCycle G => C.edgeChain)) :=
Submodule.subset_span ⟨C,rfl⟩
have hsum := (Submodule.span ℝ (Set.range (fun C : SimpleCycle G => C.edgeChain))).add_mem
hind ((Submodule.span ℝ (Set.range (fun C : SimpleCycle G => C.edgeChain))).smul_mem a hchain)
simpa only [w',sub_add_cancel] using hsum
· exact simple_cycles_balanced G z
end Paper170
end
end
section
noncomputable section
open scoped Classical
namespace Paper170
variable {V E : Type} [Fintype V] [Fintype E] (G : Graph V E)
omit [Fintype V] in
lemma flow_period_three (z : E → ℝ) (hz : ∀ v, boundary G z v = 0)
(a : FlowVertex G z) (hp : 0 < Function.minimalPeriod (flowNext G z hz) a) :
3 ≤ Function.minimalPeriod (flowNext G z hz) a := by
let f := flowNext G z hz
have hone : Function.minimalPeriod f a ≠ 1 := by
intro h
have heq : f a = a := by
simpa [h] using (Function.iterate_minimalPeriod (f := f) (x := a))
have hs := flowEdge_spec G z hz a
change ((G.src (flowEdge G z hz a) = a.val ∧ G.dst (flowEdge G z hz a) = (f a).val ∧ 0 < z (flowEdge G z hz a)) ∨
(G.dst (flowEdge G z hz a) = a.val ∧ G.src (flowEdge G z hz a) = (f a).val ∧ z (flowEdge G z hz a) < 0)) at hs
rw [heq] at hs
exact flowArc_irrefl G z a.val _ hs
have htwo : Function.minimalPeriod f a ≠ 2 := by
intro h
have heq : f (f a) = a := by
simpa [h, Function.iterate_succ_apply'] using
(Function.iterate_minimalPeriod (f := f) (x := a))
have hs := flowEdge_spec G z hz (f a)
change ((G.src (flowEdge G z hz (f a)) = (f a).val ∧ G.dst (flowEdge G z hz (f a)) = (f (f a)).val ∧ 0 < z (flowEdge G z hz (f a))) ∨
(G.dst (flowEdge G z hz (f a)) = (f a).val ∧ G.src (flowEdge G z hz (f a)) = (f (f a)).val ∧ z (flowEdge G z hz (f a)) < 0)) at hs
rw [heq] at hs
exact flowArc_not_reverse G z a.val (f a).val _ _ (flowEdge_spec G z hz a) hs
change 0 < Function.minimalPeriod f a at hp
change 3 ≤ Function.minimalPeriod f a
omega
theorem exists_supported_simple_cycle (z : E → ℝ) (hz : ∀ v, boundary G z v = 0)
(hne : z ≠ 0) : ∃ C : SimpleCycle G, ∀ i, z (C.edge i) ≠ 0 := by
obtain ⟨e, he⟩ : ∃ e, z e ≠ 0 := by
by_contra! h
exact hne (funext h)
have hnonempty : Nonempty (FlowVertex G z) := by
rcases lt_or_gt_of_ne he with h | h
· exact ⟨⟨G.dst e, e, Or.inr ⟨rfl, h⟩⟩⟩
· exact ⟨⟨G.src e, e, Or.inl ⟨rfl, h⟩⟩⟩
let := hnonempty
let f := flowNext G z hz
obtain ⟨a, ha⟩ := exists_positive_period f
let n := Function.minimalPeriod f a
have hn : 3 ≤ n := flow_period_three G z hz a ha
have hstep (i : Fin n) :
f^[((i.val + 1) % n)] a = f (f^[i.val] a) := by
rw [Function.iterate_mod_minimalPeriod_eq]
exact Function.iterate_succ_apply' _ _ _
let C : SimpleCycle G :=
{ length := n
three_le := hn
vertex := fun i => (f^[i.val] a).val
vertex_injective := by
intro i j hij
apply Fin.ext
exact Function.iterate_injOn_Iio_minimalPeriod i.isLt j.isLt (Subtype.ext hij)
edge := fun i => flowEdge G z hz (f^[i.val] a)
follows := by
intro i
change (G.src (flowEdge G z hz (f^[i.val] a)) = (f^[i.val] a).val ∧
G.dst (flowEdge G z hz (f^[i.val] a)) = (f^[((i.val + 1) % n)] a).val) ∨
(G.dst (flowEdge G z hz (f^[i.val] a)) = (f^[i.val] a).val ∧
G.src (flowEdge G z hz (f^[i.val] a)) = (f^[((i.val + 1) % n)] a).val)
rw [hstep]
rcases flowEdge_spec G z hz (f^[i.val] a) with ⟨hs, hd, _⟩ | ⟨hd, hs, _⟩
· exact Or.inl ⟨hs, hd⟩
· exact Or.inr ⟨hd, hs⟩ }
refine ⟨C, ?_⟩
intro i
rcases flowEdge_spec G z hz (f^[i.val] a) with ⟨_, _, hp⟩ | ⟨_, _, hn⟩
· exact ne_of_gt hp
· exact ne_of_lt hn
end Paper170
end
end
section
/-! A frozen simple cycle gives a periodic sequence of actual oriented edge traversals. -/
noncomputable section
open scoped Classical
namespace Paper170.SimpleCycle
open Paper170Geometry
variable {V E : Type} {G : Graph V E}
def dart (C : SimpleCycle G) (i : Fin C.length) : OrientedDart G :=
⟨C.edge i,decide (G.src (C.edge i)=C.vertex i)⟩
theorem dart_fst (C : SimpleCycle G) (i : Fin C.length) : (C.dart i).fst = C.vertex i := by
rcases C.follows_next i with h | h
· simp [dart,OrientedDart.fst,h.1]
· have hn : G.src (C.edge i) ≠ C.vertex i := by
rw [h.2]
exact fun he => C.next_ne_self i (C.vertex_injective he)
simp [dart,OrientedDart.fst,hn,h.1]
theorem dart_snd (C : SimpleCycle G) (i : Fin C.length) : (C.dart i).snd = C.vertex (C.next i) := by
rcases C.follows_next i with h | h
· simp [dart,OrientedDart.snd,h.1,h.2]
· have hn : G.src (C.edge i) ≠ C.vertex i := by
rw [h.2]
exact fun he => C.next_ne_self i (C.vertex_injective he)
simpa only [dart,OrientedDart.snd,decide_eq_true_eq,ite_eq_right hn] using h.2
theorem dart_edge (C : SimpleCycle G) (i : Fin C.length) : (C.dart i).edge = C.edge i := rfl
theorem dart_sign (C : SimpleCycle G) (i : Fin C.length) :
dartSign (C.dart i) = if G.src (C.edge i)=C.vertex i then 1 else -1 := by
simp [dart,dartSign]
def modIndex (C : SimpleCycle G) (i : ℕ) : Fin C.length :=
⟨i % C.length,Nat.mod_lt _ (by have := C.three_le; omega)⟩
theorem modIndex_succ (C : SimpleCycle G) (i : ℕ) : C.modIndex (i+1)=C.next (C.modIndex i) := by
apply Fin.ext
simp [modIndex,next,Nat.add_mod]
theorem modIndex_period (C : SimpleCycle G) : C.modIndex C.length=C.modIndex 0 := by
apply Fin.ext
simp [modIndex]
def cyclicDart (C : SimpleCycle G) (i : ℕ) : OrientedDart G := C.dart (C.modIndex i)
theorem cyclicDart_seam (C : SimpleCycle G) (i : ℕ) :
(C.cyclicDart i).snd = (C.cyclicDart (i+1)).fst := by
simp only [cyclicDart,dart_snd,dart_fst,modIndex_succ]
theorem cyclicDart_period (C : SimpleCycle G) : C.cyclicDart C.length = C.cyclicDart 0 := by
rw [cyclicDart,cyclicDart,modIndex_period]
theorem cyclicDart_next_edge_ne (C : SimpleCycle G) (i : ℕ) :
(C.cyclicDart (i+1)).edge ≠ (C.cyclicDart i).edge := by
simp only [cyclicDart,dart_edge,modIndex_succ]
exact fun he => C.next_ne_self _ (C.edge_injective he)
end Paper170.SimpleCycle
end
end
section
/-! The real cycle space of an arbitrary finite simple graph. -/
noncomputable section
namespace Paper170
variable {V E : Type} [Fintype V] [Fintype E] (G : Graph V E)
theorem simple_cycles_span (z : E → ℝ) :
(∀v, boundary G z v=0) ↔
z∈Submodule.span ℝ (Set.range (fun C : SimpleCycle G => C.edgeChain)) :=
simple_cycles_span_of_supported_cycle G (exists_supported_simple_cycle G) z
end Paper170
end
end
end OAI