math / data /lean /OAI /Algebra /GroupRing /ComparisonCoding.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
18.4 kB
import Mathlib
import OAI.Algebra.GroupRing.Iso
namespace OAI
noncomputable section
namespace TorsionFreeZeroDivisors.ComparisonCoding
open scoped Classical
open PatternCoding
/-- Full integer affine comparison geometry. The offset uses [-2H,2H]. -/
structure Data (P E : Type*) (H : β„•) where
flip : E β†’ E
source : E β†’ P
lower : E β†’ Fin (H+1)
upper : E β†’ Fin (H+1)
reverse : E β†’ Bool
offset : E β†’ Fin (4*H+1)
abbrev Code (K I H : β„•) := (Fin I β†’ Fin I) Γ— (Fin I β†’ Fin K) Γ—
(Fin I β†’ Fin (H+1)) Γ— (Fin I β†’ Fin (H+1)) Γ—
(Fin I β†’ Bool) Γ— (Fin I β†’ Fin (4*H+1))
def coefficient (K I : β„•) := (8*I*K)^I
lemma card_code (K I H : β„•) : Fintype.card (Code K I H) =
I^I*K^I*(H+1)^(2*I)*2^I*(4*H+1)^I := by
simp only [Code,Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,Fintype.card_bool]
rw [show 2*I=I+I by omega, pow_add]
ring
lemma card_code_bound (K I H : β„•) : Fintype.card (Code K I H) ≀
coefficient K I*(H+1)^(3*I) := by
rw [card_code]
have h : (4*H+1)^I≀(4*(H+1))^I := Nat.pow_le_pow_left (by omega) I
apply le_trans (Nat.mul_le_mul_left _ h)
apply le_of_eq
simp only [coefficient,mul_pow,show 2*I=I+I by omega,
show 3*I=I+(I+I) by omega,pow_add]
rw [show (8:β„•)^I=2^I*4^I by rw [←mul_pow]; norm_num]
ring
variable {P E P' E' : Type*} [Fintype P] [Fintype E] [Fintype P'] [Fintype E']
(K I H : β„•) (hK : 0<K) (hI : 0<I)
(hP : Fintype.card P≀K) (hE : Fintype.card E≀I)
def encode (a : Data P E H) : Code K I H :=
(pad I hE ⟨0,hI⟩ (fun e => names I hE (a.flip e)),
pad I hE ⟨0,hK⟩ (fun e => names K hP (a.source e)),
pad I hE 0 a.lower,pad I hE 0 a.upper,
pad I hE false a.reverse,pad I hE 0 a.offset)
structure Isomorphism (a : Data P E H) (b : Data P' E' H) where
path : P ≃ P'
comparison : E ≃ E'
flip_eq : βˆ€ e,comparison (a.flip e)=b.flip (comparison e)
source_eq : βˆ€ e,path (a.source e)=b.source (comparison e)
lower_eq : βˆ€ e,a.lower e=b.lower (comparison e)
upper_eq : βˆ€ e,a.upper e=b.upper (comparison e)
reverse_eq : βˆ€ e,a.reverse e=b.reverse (comparison e)
offset_eq : βˆ€ e,a.offset e=b.offset (comparison e)
variable (hP' : Fintype.card P'≀K) (hE' : Fintype.card E'≀I)
theorem encode_complete (a : Data P E H) (b : Data P' E' H)
(cP : Fintype.card P=Fintype.card P') (cE : Fintype.card E=Fintype.card E')
(he : encode K I H hK hI hP hE a=encode K I H hK hI hP' hE' b) :
βˆƒ f : Isomorphism H a b, f.path=rename cP ∧ f.comparison=rename cE := by
simp only [encode,Prod.mk.injEq] at he
obtain ⟨hf,hs,hl,hu,hr,ho⟩ := he
have hflip (e : E) : rename cE (a.flip e)=b.flip (rename cE e) := by
apply names_injective hE'
rw [rename_names I hE hE']
exact same_pad I hE hE' cE (⟨0,hI⟩ : Fin I) _ _ hf e
have hsource (e : E) : rename cP (a.source e)=b.source (rename cE e) := by
apply names_injective hP'
rw [rename_names K hP hP']
exact same_pad I hE hE' cE (⟨0,hK⟩ : Fin K) _ _ hs e
exact ⟨⟨rename cP,rename cE,hflip,hsource,
same_pad I hE hE' cE 0 _ _ hl,same_pad I hE hE' cE 0 _ _ hu,
same_pad I hE hE' cE false _ _ hr,same_pad I hE hE' cE 0 _ _ ho⟩,rfl,rfl⟩
end TorsionFreeZeroDivisors.ComparisonCoding
namespace TorsionFreeZeroDivisors.SubdivisionIso
open scoped Classical
open ChainSubdivision PortSubdivision
variable {C V C' V' : Type*} (len : C β†’ β„•) (len' : C' β†’ β„•)
(first last : C β†’ V) (first' last' : C' β†’ V')
(eC : C ≃ C') (eV : V ≃ V') (hl : βˆ€ c,len c=len' (eC c))
def edge : Edge len ≃ Edge len' := Equiv.sigmaCongr eC (fun c => finCongr (hl c))
def interior : Interior len ≃ Interior len' := Equiv.sigmaCongr eC (fun c => finCongr (congrArg (fun n => n-1) (hl c)))
def vertex : Vertex len (V:=V) ≃ Vertex len' (V:=V') := Equiv.sumCongr eV (interior len len' eC hl)
def dart : Dart len ≃ Dart len' := Equiv.prodCongr (edge len len' eC hl) (Equiv.refl Bool)
variable (hf : βˆ€ c,eV (first c)=first' (eC c)) (ht : βˆ€ c,eV (last c)=last' (eC c))
include hf ht in
lemma point_eq (c : C) (k : Fin (len c+1)) :
vertex len len' eC eV hl (point len first last c k)=
point len' first' last' (eC c) ⟨k.val,by rw [←hl c]; exact k.isLt⟩ := by
by_cases hz : k.val=0
Β· simp [point,hz,vertex,hf]
Β· by_cases ht' : k.val=len c
Β· have hn : k.val=len' (eC c) := ht'.trans (hl c)
simp only [point,dite_eq_right hz,dite_eq_left ht',dite_eq_left hn]
exact congrArg Sum.inl (ht c)
Β· have hn : k.valβ‰ len' (eC c) := by rwa [←hl c]
simp only [point,dite_eq_right hz,dite_eq_right ht',dite_eq_right hn]
rfl
include hf ht in
lemma origin_eq (d : Dart len) :
vertex len len' eC eV hl ((graph len first last).origin d)=
(graph len' first' last').origin (dart len len' eC hl d) := by
exact point_eq len len' first last first' last' eC eV hl hf ht d.1.1 _
omit eV in
lemma reverse_eq (d : Dart len) :
dart len len' eC hl ((graph len first last).reverse d)=
(graph len' first' last').reverse (dart len len' eC hl d) := rfl
end TorsionFreeZeroDivisors.SubdivisionIso
namespace TorsionFreeZeroDivisors.RankedSuppressionIso
section
open scoped Classical
open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
variable {V D V' D' : Type*} [Fintype D] [Fintype D']
(Ξ“ : PortGraph V D) (mark : V β†’ Prop) (h2 : βˆ€ v,Β¬mark v β†’ (out Ξ“.origin v).card=2)
(Ξ“' : PortGraph V' D') (mark' : V' β†’ Prop) (h2' : βˆ€ v,Β¬mark' v β†’ (out Ξ“'.origin v).card=2)
def skeleton : PortGraph (Mark mark) {d : D // turn Ξ“.origin mark h2 d=d} where
origin d := βŸ¨Ξ“.origin d.val,(turn_fixed_iff Ξ“.origin mark h2 _).mp d.property⟩
reverse := (suppressed Ξ“ mark h2).reverse
reverse_reverse := (suppressed Ξ“ mark h2).reverse_reverse
reverse_ne := (suppressed Ξ“ mark h2).reverse_ne
local notation "S" => skeleton Ξ“ mark h2
local notation "S'" => skeleton Ξ“' mark' h2'
local notation "B" => {d : D // turn Ξ“.origin mark h2 d=d}
local notation "B'" => {d : D' // turn Ξ“'.origin mark' h2' d=d}
local notation "R" => Rep Ξ“ mark h2
local notation "R'" => Rep Ξ“' mark' h2'
lemma chosen_iff (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val) (d : B) : InvolutionOrientation.Chosen (S).reverse d ↔
InvolutionOrientation.Chosen (S').reverse (f.dart d) := by
unfold InvolutionOrientation.Chosen InvolutionOrientation.rank
change (Fintype.equivFin B d).val < (Fintype.equivFin B ((S).reverse d)).val ↔
(Fintype.equivFin B' (f.dart d)).val < (Fintype.equivFin B' ((S').reverse (f.dart d))).val
rw [←f.reverse_eq,hrank,hrank]
def rep (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val) : R ≃ R' :=
f.dart.subtypeEquiv (chosen_iff Ξ“ mark h2 Ξ“' mark' h2' f hrank)
lemma rep_length (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
(hlen : βˆ€ d,chainLength Ξ“ mark h2 d=chainLength Ξ“' mark' h2' (f.dart d)) (c : R) : repLength Ξ“ mark h2 c=
repLength Ξ“' mark' h2' (rep Ξ“ mark h2 Ξ“' mark' h2' f hrank c) := hlen c.val
lemma first_eq (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val) (c : R) : f.vertex (first Ξ“ mark h2 c)=
first Ξ“' mark' h2' (rep Ξ“ mark h2 Ξ“' mark' h2' f hrank c) := f.origin_eq c.val
lemma last_eq (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val) (c : R) : f.vertex (last Ξ“ mark h2 c)=
last Ξ“' mark' h2' (rep Ξ“ mark h2 Ξ“' mark' h2' f hrank c) := by
change f.vertex ((S).origin ((S).reverse c.val))=(S').origin ((S').reverse (f.dart c.val))
rw [f.origin_eq,f.reverse_eq]
/-- Exact canonical-rank suppression isomorphisms lift to actual subdivisions. -/
def subdivided (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
(hlen : βˆ€ d,chainLength Ξ“ mark h2 d=chainLength Ξ“' mark' h2' (f.dart d)) :
Iso (ChainSubdivision.graph (repLength Ξ“ mark h2) (first Ξ“ mark h2) (last Ξ“ mark h2))
(ChainSubdivision.graph (repLength Ξ“' mark' h2') (first Ξ“' mark' h2') (last Ξ“' mark' h2')) where
vertex := SubdivisionIso.vertex _ _ (rep Ξ“ mark h2 Ξ“' mark' h2' f hrank) f.vertex
(rep_length Ξ“ mark h2 Ξ“' mark' h2' f hrank hlen)
dart := SubdivisionIso.dart _ _ (rep Ξ“ mark h2 Ξ“' mark' h2' f hrank)
(rep_length Ξ“ mark h2 Ξ“' mark' h2' f hrank hlen)
origin_eq := SubdivisionIso.origin_eq _ _ _ _ _ _ _ _ _
(first_eq Ξ“ mark h2 Ξ“' mark' h2' f hrank) (last_eq Ξ“ mark h2 Ξ“' mark' h2' f hrank)
reverse_eq := SubdivisionIso.reverse_eq _ _ _ _ _ _ _ _
variable (hcovered : βˆ€ d,ChainCoverage.Covered Ξ“.reverse (turn Ξ“.origin mark h2)
Ξ“.reverse_reverse (turn_involutive Ξ“.origin mark h2) d)
(hcovered' : βˆ€ d,ChainCoverage.Covered Ξ“'.reverse (turn Ξ“'.origin mark' h2')
Ξ“'.reverse_reverse (turn_involutive Ξ“'.origin mark' h2') d)
def actual (hcovered : βˆ€ d,ChainCoverage.Covered Ξ“.reverse (turn Ξ“.origin mark h2)
Ξ“.reverse_reverse (turn_involutive Ξ“.origin mark h2) d) :
Iso (ChainSubdivision.graph (repLength Ξ“ mark h2) (first Ξ“ mark h2) (last Ξ“ mark h2)) Ξ“ where
vertex := vertexEquiv Ξ“ mark h2 hcovered
dart := dartEquiv Ξ“ mark h2 hcovered
origin_eq := origin_map Ξ“ mark h2
reverse_eq := dartMap_reverse Ξ“ mark h2
include hcovered hcovered' in
/-- No vertex or dart names survive, but all actual graph incidence does. -/
def full (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
(hlen : βˆ€ d,chainLength Ξ“ mark h2 d=chainLength Ξ“' mark' h2' (f.dart d)) : Iso Ξ“ Ξ“' :=
((actual Ξ“ mark h2 hcovered).symm.trans (subdivided Ξ“ mark h2 Ξ“' mark' h2' f hrank hlen)).trans
(actual Ξ“' mark' h2' hcovered')
end
section
open scoped Classical
open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
variable {V D V' D' : Type*} [Fintype D] [Fintype D']
(Ξ“ : PortGraph V D) (mark : V β†’ Prop) (h2 : βˆ€ v,Β¬mark v β†’ (out Ξ“.origin v).card=2)
(Ξ“' : PortGraph V' D') (mark' : V' β†’ Prop) (h2' : βˆ€ v,Β¬mark' v β†’ (out Ξ“'.origin v).card=2)
(hcovered : βˆ€ d,ChainCoverage.Covered Ξ“.reverse (turn Ξ“.origin mark h2)
Ξ“.reverse_reverse (turn_involutive Ξ“.origin mark h2) d)
(hcovered' : βˆ€ d,ChainCoverage.Covered Ξ“'.reverse (turn Ξ“'.origin mark' h2')
Ξ“'.reverse_reverse (turn_involutive Ξ“'.origin mark' h2') d)
local notation "S" => skeleton Ξ“ mark h2
local notation "S'" => skeleton Ξ“' mark' h2'
local notation "B" => {d : D // turn Ξ“.origin mark h2 d=d}
local notation "B'" => {d : D' // turn Ξ“'.origin mark' h2' d=d}
local notation "R" => Rep Ξ“ mark h2
local notation "F" => next Ξ“.reverse (turn Ξ“.origin mark h2)
local notation "F'" => next Ξ“'.reverse (turn Ξ“'.origin mark' h2')
local notation "len" => chainLength Ξ“ mark h2
local notation "len'" => chainLength Ξ“' mark' h2'
lemma full_dartMap (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
(hlen : βˆ€ d,len d=len' (f.dart d)) (d : ChainSubdivision.Dart (repLength Ξ“ mark h2)) :
(full Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen).dart (dartMap Ξ“ mark h2 d)=
dartMap Ξ“' mark' h2' ((subdivided Ξ“ mark h2 Ξ“' mark' h2' f hrank hlen).dart d) := by
change (dartEquiv Ξ“' mark' h2' hcovered')
((subdivided Ξ“ mark h2 Ξ“' mark' h2' f hrank hlen).dart
((dartEquiv Ξ“ mark h2 hcovered).symm ((dartEquiv Ξ“ mark h2 hcovered) d))) = _
rw [Equiv.symm_apply_apply]
rfl
lemma full_forward (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
(hlen : βˆ€ d,len d=len' (f.dart d)) (c : R) (i : Fin (len c.val)) :
(full Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen).dart (F^[i.val] c.val.val)=
F'^[i.val] (f.dart c.val).val :=
full_dartMap Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen (⟨c,i⟩,false)
lemma full_iter (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
(hlen : βˆ€ d,len d=len' (f.dart d)) (d : B) (i : β„•) (hi : i<len d) :
(full Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen).dart (F^[i] d.val)=
F'^[i] (f.dart d).val := by
rcases InvolutionOrientation.chosen_or_reverse (S).reverse (S).reverse_reverse (S).reverse_ne d with hd|hd
Β· exact full_forward Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen ⟨d,hd⟩ ⟨i,hi⟩
Β· have hj : len d-i-1<len ((S).reverse d) := by
change len d-i-1<len ((suppressed Ξ“ mark h2).reverse d)
rw [chainLength_reverse]
omega
have hj' : i<len' (f.dart d) := by rwa [←hlen d]
apply Ξ“'.reverse_reverse.injective
rw [←(full Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen).reverse_eq]
rw [←ChainChunkTransport.reverse_iter Ξ“ mark h2 d i hi,
←ChainChunkTransport.reverse_iter Ξ“' mark' h2' (f.dart d) i hj']
have h := full_forward Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen
⟨(S).reverse d,hd⟩ ⟨len d-i-1,hj⟩
have hrev : f.dart ((suppressed Ξ“ mark h2).reverse d)=
(suppressed Ξ“' mark' h2').reverse (f.dart d) := f.reverse_eq d
simpa only [skeleton,hlen d,hrev] using h
lemma full_word (f : Iso S S')
(hrank : βˆ€ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
(hlen : βˆ€ d,len d=len' (f.dart d)) (d : B) :
(word Ξ“ mark h2 d).map (full Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen).dart =
word Ξ“' mark' h2' (f.dart d) := by
rw [word_eq_range,word_eq_range,List.map_map,←hlen d]
apply List.map_congr_left
intro i hi
exact full_iter Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen d i (List.mem_range.mp hi)
end
open scoped Classical
open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
variable {V D V' D' : Type} [Fintype D] [Fintype D']
(Ξ“ : PortGraph V D) (mark : V β†’ Prop) (h2 : βˆ€ v,Β¬mark v β†’ (out Ξ“.origin v).card=2)
(Ξ“' : PortGraph V' D') (mark' : V' β†’ Prop) (h2' : βˆ€ v,Β¬mark' v β†’ (out Ξ“'.origin v).card=2)
(hcovered : βˆ€ d,ChainCoverage.Covered Ξ“.reverse (turn Ξ“.origin mark h2)
Ξ“.reverse_reverse (turn_involutive Ξ“.origin mark h2) d)
(hcovered' : βˆ€ d,ChainCoverage.Covered Ξ“'.reverse (turn Ξ“'.origin mark' h2')
Ξ“'.reverse_reverse (turn_involutive Ξ“'.origin mark' h2') d)
local notation "S" => skeleton Ξ“ mark h2
local notation "S'" => skeleton Ξ“' mark' h2'
local notation "B" => {d : D // turn Ξ“.origin mark h2 d=d}
local notation "B'" => {d : D' // turn Ξ“'.origin mark' h2' d=d}
local notation "len" => chainLength Ξ“ mark h2
local notation "len'" => chainLength Ξ“' mark' h2'
variable (f : Iso (skeleton Ξ“ mark h2) (skeleton Ξ“' mark' h2'))
(hrank : βˆ€ d,(Fintype.equivFin {d : D' // turn Ξ“'.origin mark' h2' d=d} (f.dart d)).val=
(Fintype.equivFin {d : D // turn Ξ“.origin mark h2 d=d} d).val)
(hlen : βˆ€ d,chainLength Ξ“ mark h2 d=chainLength Ξ“' mark' h2' (f.dart d))
local notation "F" => full Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen
lemma full_seed (d : B) : (F).dart d.val=(f.dart d).val :=
full_iter Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen d 0
(chainLength_pos Ξ“ mark h2 d)
lemma full_vertexMap (v : ChainSubdivision.Vertex (repLength Ξ“ mark h2) (V:=Mark mark)) :
(F).vertex (vertexMap Ξ“ mark h2 v)=vertexMap Ξ“' mark' h2'
((subdivided Ξ“ mark h2 Ξ“' mark' h2' f hrank hlen).vertex v) := by
change (vertexEquiv Ξ“' mark' h2' hcovered')
((subdivided Ξ“ mark h2 Ξ“' mark' h2' f hrank hlen).vertex
((vertexEquiv Ξ“ mark h2 hcovered).symm ((vertexEquiv Ξ“ mark h2 hcovered) v)))=_
rw [Equiv.symm_apply_apply]
rfl
variable (side : V β†’ Bool) (side' : V' β†’ Bool)
(hs : βˆ€ d,side (Ξ“.origin (Ξ“.reverse d))=side (Ξ“.origin d))
(hs' : βˆ€ d,side' (Ξ“'.origin (Ξ“'.reverse d))=side' (Ξ“'.origin d))
(hside : βˆ€ v : Mark mark,side v.val=side' (f.vertex v).val)
include hside hs hs' in
lemma full_side (v : V) : side v=side' ((F).vertex v) := by
obtain ⟨v,rfl⟩ := (vertexEquiv Ξ“ mark h2 hcovered).surjective v
change side (vertexMap Ξ“ mark h2 v)=side' ((F).vertex (vertexMap Ξ“ mark h2 v))
rw [full_vertexMap]
cases v with
| inl v => exact hside v
| inr v =>
rcases v with ⟨c,i⟩
change side (Ξ“.origin ((next Ξ“.reverse (turn Ξ“.origin mark h2))^[i.val+1] c.val.val))=
side' (Ξ“'.origin ((next Ξ“'.reverse (turn Ξ“'.origin mark' h2'))^[i.val+1] (f.dart c.val).val))
rw [ChainSide.iterate_side Ξ“ mark h2 side hs,ChainSide.iterate_side Ξ“' mark' h2' side' hs']
have he := congrArg (fun x : Mark mark' => side' x.val) (f.origin_eq c.val)
exact (hside ((S).origin c.val)).trans he
variable {P P' : Type} (paths : P β†’ List {d : D // turn Ξ“.origin mark h2 d=d})
(paths' : P' β†’ List {d : D' // turn Ξ“'.origin mark' h2' d=d})
(eP : P ≃ P') (hp : βˆ€ p,(paths p).map f.dart=paths' (eP p))
include hp in
lemma full_words (p : P) : ((paths p).flatMap (word Ξ“ mark h2)).map (F).dart =
(paths' (eP p)).flatMap (word Ξ“' mark' h2') := by
rw [List.map_flatMap,←hp,List.flatMap_map]
apply List.flatMap_congr
intro d _
exact full_word Ξ“ mark h2 Ξ“' mark' h2' hcovered hcovered' f hrank hlen d
variable (hne : βˆ€ p,paths pβ‰ []) (hne' : βˆ€ p,paths' pβ‰ [])
(root : Option P) (root' : Option P') (hroot : root.map eP=root')
include hp hroot in
lemma full_source : (StageRoot.source Ξ“ mark h2 paths hne root).map (F).vertex=
StageRoot.source Ξ“' mark' h2' paths' hne' root' := by
rw [←hroot]
cases root with
| none => rfl
| some p =>
simp only [StageRoot.source,Option.map_some]
apply congrArg some
change (F).vertex (Ξ“.origin ((paths p).head (hne p)).val)=
Ξ“'.origin ((paths' (eP p)).head (hne' _)).val
rw [(F).origin_eq,full_seed]
have hh := congrArg List.head? (hp p)
rw [List.head?_map,List.head?_eq_some_head (hne p),
List.head?_eq_some_head (hne' (eP p))] at hh
exact congrArg (fun d => Ξ“'.origin d.val) (Option.some.inj hh)
end TorsionFreeZeroDivisors.RankedSuppressionIso
end
end OAI