Download data/lean/OAI/Algebra/GroupRing/ComparisonCoding.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/GroupRing/ComparisonCoding.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algebra/GroupRing/ComparisonCoding.lean
-
curl -L -o ComparisonCoding.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/GroupRing/ComparisonCoding.lean
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 | |