math / data /lean /OAI /Probability /FKMaps /CornerInverse.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
31 kB
import OAI.Probability.FKMaps.CornerInsertion
namespace OAI
noncomputable section
open Equiv Equiv.Perm
namespace FKCRT.Chords
variable {N K : ℕ}
/-- Transport a core matching through its strictly increasing position map. -/
def openerEmbedding (a : Perm (Fin N)) (b : Perm (Fin K))
(e : Fin K ↪o Fin N) (h : ∀ i,a (e i)=e (b i)) : Opener b ↪ Opener a where
toFun x := ⟨e x.val,by rw [h]; exact e.strictMono x.property⟩
inj' := by intro x y hxy; exact Subtype.ext (e.injective (congrArg Subtype.val hxy))
lemma cross_embedding (a : Perm (Fin N)) (b : Perm (Fin K))
(e : Fin K ↪o Fin N) (h : ∀ i,a (e i)=e (b i)) (x y : Opener b) :
Cross a (openerEmbedding a b e h x) (openerEmbedding a b e h y) ↔ Cross b x y := by
change ((e x.val<e y.val ∧ e y.val<a (e x.val) ∧ a (e x.val)<a (e y.val)) ∨
(e y.val<e x.val ∧ e x.val<a (e y.val) ∧ a (e y.val)<a (e x.val))) ↔ _
simp only [h,e.lt_iff_lt,Cross]
def graphHom (a : Perm (Fin N)) (b : Perm (Fin K))
(e : Fin K ↪o Fin N) (h : ∀ i,a (e i)=e (b i)) : graph b →g graph a where
toFun := openerEmbedding a b e h
map_rel' := fun hx => (cross_embedding a b e h _ _).mpr hx
lemma opener_range (a : Perm (Fin N)) (b : Perm (Fin K))
(e : Fin K ↪o Fin N) (h : ∀ i,a (e i)=e (b i)) (x : Opener a)
(hx : x.val∈Set.range e) : ∃ y : Opener b,openerEmbedding a b e h y=x := by
obtain ⟨i,hi⟩ := hx
have hp : i<b i := by
apply e.lt_iff_lt.mp
rw [← h,hi]
exact x.property
exact ⟨⟨i,hp⟩,Subtype.ext hi⟩
/-- Once every unmarked interval is matched internally, the core mask is
also matched internally; this is forced by the actual involution. -/
lemma core_closed_of_chunks (a : Perm (Fin N)) (ha : Function.Involutive a)
(p : Fin N→Bool) (hN : 0<N) (hp : p ⟨0,hN⟩=true)
(hchunks : ∀ x∈(CornerSplit.split p (List.finRange N)).2,∀ d∈x.2,a d∈x.2) :
∀ d,p (a d)=p d := by
have hunmarked : ∀ d,p d=false → p (a d)=false := by
intro d hd
obtain ⟨x,hx,hdx⟩ := unmarked_in_chunk p hN hp hd
exact (CornerSplit.marked_corners p (List.finRange N) x hx).2 _ (hchunks x hx d hdx)
intro d
cases hd : p d with
| false => exact hunmarked d hd
| true =>
cases had : p (a d) with
| true => rfl
| false =>
have hh := hunmarked (a d) had
rw [ha,hd] at hh
cases hh
/-- Inserting internally matched words in the corners of a connected core
leaves precisely that core as the root crossing component. -/
theorem root_component_insertion (a : Perm (Fin N)) (ha : Function.Involutive a)
(hf : ∀ d,a d≠d) (b : Perm (Fin K)) (e : Fin K ↪o Fin N)
(hmatch : ∀ i,a (e i)=e (b i)) (r : Opener b) (hr : (e r.val).val=0)
(hconnected : ∀ x : Opener b,(graph b).Reachable r x)
(hchunks : ∀ x∈(CornerSplit.split (fun d => decide (d∈Set.range e)) (List.finRange N)).2,
∀ d∈x.2,a d∈x.2) :
componentDarts a (openerEmbedding a b e hmatch r)=Finset.univ.filter (fun d => d∈Set.range e) := by
classical
let p : Fin N→Bool := fun d => decide (d∈Set.range e)
have hp : p (e r.val)=true := decide_eq_true (Set.mem_range_self _)
have hN : 0<N := (e r.val).pos
have hp0 : p ⟨0,hN⟩=true := by
have he : (⟨0,hN⟩ : Fin N)=e r.val := Fin.ext hr.symm
rw [he]; exact hp
have hcore := core_closed_of_chunks a ha p hN hp0 hchunks
have he := root_component_of_core a ha hf p (openerEmbedding a b e hmatch r) hr hp hcore hchunks
(by
intro x hx
obtain ⟨y,rfl⟩ := opener_range a b e hmatch x (of_decide_eq_true hx)
exact (hconnected y).map (graphHom a b e hmatch))
simpa only [p,decide_eq_true_eq] using he
end FKCRT.Chords
end
noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.CornerSplit
lemma skeleton_sublist {α : Type*} (l : List (α×List α)) :
(l.map Prod.fst).Sublist (join l) := by
induction l with
| nil => exact .refl _
| cons x l ih =>
change (x.1::l.map Prod.fst).Sublist (x.1::(x.2++join l))
exact (ih.trans (List.sublist_append_right _ _)).cons_cons _
end FKCRT.CornerSplit
namespace FKCRT.MapCycles
variable {α : Type*}
lemma scanArches_corners_subset (f : α→Option Bool) (l : List (α×List α))
(G : α×List α→List (α×α))
(hg : ∀ x∈l,∀ S,scanArches f x.2 S=some (S,G x))
{E F : List (α×α)}
(hcore : scanArches f (l.map Prod.fst) []=some ([],E))
(hfull : scanArches f (CornerSplit.join l) []=some ([],F)) :
∀ e∈E,e∈F := by
obtain ⟨H,hH,hperm⟩ := scanArches_corners f l G hg hcore
have he : H=F := congrArg Prod.snd (Option.some.inj (hH.symm.trans hfull))
rw [he] at hperm
intro e he
exact hperm.mem_iff.mpr (List.mem_append_left _ he)
end FKCRT.MapCycles
namespace FKCRT.Inventory
open MapCycles
variable {α : Type*} [DecidableEq α]
lemma typed_corner_scans (w : α→TypedLetter) (l : List (α×List α))
(hn : (CornerSplit.join l).Nodup)
(hw : ∀ x∈l,stackTypedRun (x.2.map w) []=some []) (c : Bool) :
∃ G : α×List α→List (α×α),
∀ x∈l,∀ S,scanArches (fun a => colorInstruction c (w a)) x.2 S=some (S,G x) := by
have hex : ∀ x∈l,∃ E,∀ S,scanArches (fun a => colorInstruction c (w a)) x.2 S=some (S,E) := by
intro x hx
have hxnodup : x.2.Nodup := (List.nodup_cons.mp ((List.nodup_flatMap.mp hn).1 x hx)).2
obtain ⟨E,hE,_⟩ := empty_typed_scan w x.2 hxnodup (hw x hx) c
exact ⟨E,hE⟩
classical
let G := fun x => if hx : x∈l then Classical.choose (hex x hx) else []
refine ⟨G,?_⟩
intro x hx S
simpa only [G,dite_eq_left hx] using (Classical.choose_spec (hex x hx)) S
/-- Actual core pairs remain the same pairs after inserting *arbitrary*
successful corner words. This controls the adaptive matching itself. -/
theorem corner_core_pairs (w : α→TypedLetter) (l : List (α×List α))
(hn : (CornerSplit.join l).Nodup)
(hw : ∀ x∈l,stackTypedRun (x.2.map w) []=some [])
(E F C D : List (α×α))
(hE : Arches (CornerSplit.join l) E) (hF : Arches (CornerSplit.join l) F)
(hc : (endpoints (E++F)).Perm (CornerSplit.join l))
(htE : ∀ e∈E,w e.1=.burger true ∧ w e.2=.order true)
(htF : ∀ e∈F,w e.1=.burger false ∧ w e.2=.order false)
(hC : Arches (l.map Prod.fst) C) (hD : Arches (l.map Prod.fst) D)
(hd : (endpoints (C++D)).Perm (l.map Prod.fst))
(htC : ∀ e∈C,w e.1=.burger true ∧ w e.2=.order true)
(htD : ∀ e∈D,w e.1=.burger false ∧ w e.2=.order false) :
(∀ e∈C,e∈E) ∧ (∀ e∈D,e∈F) := by
have hfull := matching_color_coverage w (CornerSplit.join l) E F hc htE htF
have hcore := matching_color_coverage w (l.map Prod.fst) C D hd htC htD
have hncore := hn.sublist (CornerSplit.skeleton_sublist l)
constructor
· obtain ⟨G,hG⟩ := typed_corner_scans w l hn hw true
obtain ⟨Ec,hEc,hEcC⟩ := hC.scan hncore (fun x => colorInstruction true (w x))
(fun e he => by simp [colorInstruction,(htC e he).1,(htC e he).2]) hcore.1 []
obtain ⟨Ef,hEf,hEfE⟩ := hE.scan hn (fun x => colorInstruction true (w x))
(fun e he => by simp [colorInstruction,(htE e he).1,(htE e he).2]) hfull.1 []
intro e he
exact hEfE.mem_iff.mp (scanArches_corners_subset _ l G hG hEc hEf e (hEcC.mem_iff.mpr he))
· obtain ⟨G,hG⟩ := typed_corner_scans w l hn hw false
obtain ⟨Dc,hDc,hDcD⟩ := hD.scan hncore (fun x => colorInstruction false (w x))
(fun e he => by simp [colorInstruction,(htD e he).1,(htD e he).2]) hcore.2 []
obtain ⟨Df,hDf,hDfF⟩ := hF.scan hn (fun x => colorInstruction false (w x))
(fun e he => by simp [colorInstruction,(htF e he).1,(htF e he).2]) hfull.2 []
intro e he
exact hDfF.mem_iff.mp (scanArches_corners_subset _ l G hG hDc hDf e (hDcD.mem_iff.mpr he))
/-- The exact matching restriction, stated on every actual core endpoint. -/
theorem corner_core_turns (w : α→TypedLetter) (l : List (α×List α))
(hn : (CornerSplit.join l).Nodup)
(hw : ∀ x∈l,stackTypedRun (x.2.map w) []=some [])
(E F C D : List (α×α))
(hE : Arches (CornerSplit.join l) E) (hF : Arches (CornerSplit.join l) F)
(hc : (endpoints (E++F)).Perm (CornerSplit.join l))
(htE : ∀ e∈E,w e.1=.burger true ∧ w e.2=.order true)
(htF : ∀ e∈F,w e.1=.burger false ∧ w e.2=.order false)
(hC : Arches (l.map Prod.fst) C) (hD : Arches (l.map Prod.fst) D)
(hd : (endpoints (C++D)).Perm (l.map Prod.fst))
(htC : ∀ e∈C,w e.1=.burger true ∧ w e.2=.order true)
(htD : ∀ e∈D,w e.1=.burger false ∧ w e.2=.order false) :
∀ a∈l.map Prod.fst,turns (E++F) a=turns (C++D) a := by
obtain ⟨hCE,hDF⟩ := corner_core_pairs w l hn hw E F C D hE hF hc htE htF hC hD hd htC htD
have hsub : ∀ e∈C++D,e∈E++F := by
intro e he
rcases List.mem_append.mp he with he|he
· exact List.mem_append_left _ (hCE e he)
· exact List.mem_append_right _ (hDF e he)
have hnp := hc.nodup_iff.mpr hn
have hncore : (endpoints (C++D)).Nodup :=
hd.nodup_iff.mpr (hn.sublist (CornerSplit.skeleton_sublist l))
intro a ha
obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp (hd.mem_iff.mpr ha)
· rw [(turns_pair hnp e (hsub e he)).1,(turns_pair hncore e he).1]
· rw [(turns_pair hnp e (hsub e he)).2,(turns_pair hncore e he).2]
end FKCRT.Inventory
end
noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.CornerSplit
variable {α : Type*}
lemma join_perm_parts (l : List (α×List α)) :
(join l).Perm (l.map Prod.fst++l.flatMap Prod.snd) := by
induction l with
| nil => exact .refl _
| cons x l ih =>
change (x.1::(x.2++join l)).Perm (x.1::(l.map Prod.fst++(x.2++l.flatMap Prod.snd)))
apply List.Perm.cons
apply (ih.append_left x.2).trans
simpa only [List.append_assoc] using
(List.perm_append_comm (l₁:=x.2) (l₂:=l.map Prod.fst)).append_right (l.flatMap Prod.snd)
lemma own_mask {α : Type*} [DecidableEq α] (l : List (α×List α)) (hn : (join l).Nodup) :
∀ x∈l,decide (x.1∈l.map Prod.fst)=true ∧
∀ d∈x.2,decide (d∈l.map Prod.fst)=false := by
have hh := (join_perm_parts l).nodup_iff.mp hn
intro x hx
refine ⟨decide_eq_true (List.mem_map.mpr ⟨x,hx,rfl⟩),?_⟩
intro d hd
apply decide_eq_false
intro hm
exact (List.nodup_append.mp hh).2.2 d hm d (List.mem_flatMap.mpr ⟨x,hx,hd⟩) rfl
end FKCRT.CornerSplit
namespace FKCRT.Chords
variable {N : ℕ}
def partialOpener (a b : Perm (Fin N)) (p : Fin N→Bool)
(hsupport : ∀ d,b d≠d → p d=true)
(hmatch : ∀ d,p d=true → a d=b d) (x : Opener b) : Opener a :=
⟨x.val,by rw [hmatch _ (hsupport _ (ne_of_gt x.property))];exact x.property⟩
def partialGraphHom (a b : Perm (Fin N)) (p : Fin N→Bool)
(hsupport : ∀ d,b d≠d → p d=true)
(hmatch : ∀ d,p d=true → a d=b d) : graph b →g graph a where
toFun := partialOpener a b p hsupport hmatch
map_rel' := by
intro x y h
change Cross a (partialOpener a b p hsupport hmatch x) (partialOpener a b p hsupport hmatch y)
change (x.val<y.val ∧ y.val<a x.val ∧ a x.val<a y.val) ∨
(y.val<x.val ∧ x.val<a y.val ∧ a y.val<a x.val)
rw [hmatch _ (hsupport _ (ne_of_gt x.property)),hmatch _ (hsupport _ (ne_of_gt y.property))]
exact h
theorem root_component_partial (a b : Perm (Fin N)) (ha : Function.Involutive a)
(hf : ∀ d,a d≠d) (p : Fin N→Bool)
(hsupport : ∀ d,b d≠d → p d=true) (hmatch : ∀ d,p d=true → a d=b d)
(r : Opener b) (hr : r.val.val=0)
(hconnected : ∀ x : Opener b,(graph b).Reachable r x)
(hchunks : ∀ x∈(CornerSplit.split p (List.finRange N)).2,∀ d∈x.2,a d∈x.2) :
componentDarts a (partialOpener a b p hsupport hmatch r)=Finset.univ.filter (fun d => p d=true) := by
have hp := hsupport r.val (ne_of_gt r.property)
have hN : 0<N := r.val.pos
have hp0 : p ⟨0,hN⟩=true := by
have he : (⟨0,hN⟩ : Fin N)=r.val := Fin.ext hr.symm
rw [he];exact hp
apply root_component_of_core a ha hf p (partialOpener a b p hsupport hmatch r) hr hp
(core_closed_of_chunks a ha p hN hp0 hchunks) hchunks
intro x hx
let y : Opener b := ⟨x.val,by rw [← hmatch _ hx];exact x.property⟩
exact (hconnected y).map (partialGraphHom a b p hsupport hmatch)
end FKCRT.Chords
namespace FKCRT.Inventory
open MapCycles Chords
variable {N : ℕ}
/-- Exact inverse of root-component extraction. Connectivity here specifies
which finite words are cores; all corner matching and separation facts are
proved from the original stack algorithm. -/
theorem connected_corner_inverse (w : Fin N→TypedLetter)
(l : List (Fin N×List (Fin N))) (hjoin : CornerSplit.join l=List.finRange N)
(hw : ∀ x∈l,stackTypedRun (x.2.map w) []=some [])
(E F C D : List (Fin N×Fin N))
(hE : Arches (List.finRange N) E) (hF : Arches (List.finRange N) F)
(hc : (endpoints (E++F)).Perm (List.finRange N))
(htE : ∀ e∈E,w e.1=.burger true ∧ w e.2=.order true)
(htF : ∀ e∈F,w e.1=.burger false ∧ w e.2=.order false)
(hC : Arches (l.map Prod.fst) C) (hD : Arches (l.map Prod.fst) D)
(hd : (endpoints (C++D)).Perm (l.map Prod.fst))
(htC : ∀ e∈C,w e.1=.burger true ∧ w e.2=.order true)
(htD : ∀ e∈D,w e.1=.burger false ∧ w e.2=.order false)
(r : Opener (turns (C++D))) (hr : r.val.val=0)
(hconnected : ∀ x : Opener (turns (C++D)),(Chords.graph (turns (C++D))).Reachable r x) :
∃ R : Opener (turns (E++F)),R.val=r.val ∧ rootSplit (turns (E++F)) R=l := by
classical
let a := turns (E++F)
let b := turns (C++D)
let p : Fin N→Bool := fun d => decide (d∈l.map Prod.fst)
have hn : (CornerSplit.join l).Nodup := hjoin.symm ▸ List.nodup_finRange N
have hnp : (endpoints (E++F)).Nodup := hc.nodup_iff.mpr (List.nodup_finRange N)
have hnc : (endpoints (C++D)).Nodup := hd.nodup_iff.mpr (hn.sublist (CornerSplit.skeleton_sublist l))
have hs : CornerSplit.split p (List.finRange N)=([],l) := by
rw [← hjoin];exact CornerSplit.split_join p l (CornerSplit.own_mask l hn)
have hmatch : ∀ d,p d=true → a d=b d := by
intro d hd'
exact corner_core_turns w l hn hw E F C D (hjoin.symm ▸ hE) (hjoin.symm ▸ hF)
(hjoin.symm ▸ hc) htE htF hC hD hd htC htD d (of_decide_eq_true hd')
have hsupport : ∀ d,b d≠d → p d=true := by
intro d hbd
apply decide_eq_true
apply hd.mem_iff.mp
by_contra hh
exact hbd (turns_fixed_of_notMem hh)
have hchunks : ∀ x∈(CornerSplit.split p (List.finRange N)).2,∀ d∈x.2,a d∈x.2 := by
intro x hx
have hxl : x∈l := by simpa only [hs] using hx
obtain ⟨u,v,he,_⟩ := CornerSplit.located p (List.finRange N) x hx
have he' : List.finRange N=(u++[x.1])++(x.2++v) := by simpa only [List.append_assoc,List.singleton_append] using he
exact empty_interval_matching_closed w (u++[x.1]) x.2 v
(he' ▸ List.nodup_finRange N) E F (he' ▸ hE) (he' ▸ hF) (he' ▸ hc) htE htF (hw x hxl)
have hf : ∀ d,a d≠d := by
intro d hh
exact (turns_eq_self_iff hnp d).mp hh (hc.mem_iff.mpr (List.mem_finRange d))
let R := partialOpener a b p hsupport hmatch r
have hcomp := root_component_partial a b (turns_involutive hnp) hf p hsupport hmatch r hr hconnected hchunks
refine ⟨R,rfl,?_⟩
have hmask : (fun d => decide (d∈componentDarts a R))=p := by
funext d
rw [hcomp]
simp only [Finset.mem_filter,Finset.mem_univ,true_and,Bool.decide_eq_true]
change (CornerSplit.split (fun d => decide (d∈componentDarts a R)) (List.finRange N)).2=l
rw [hmask,hs]
end FKCRT.Inventory
end
noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.MapCycles
variable {α β : Type*}
lemma Arches.map {l : List α} {E : List (α×α)} (h : Arches l E) (f : α→β) :
Arches (l.map f) (E.map (Prod.map f f)) := by
induction h with
| nil => exact .nil
| skip a h ih => exact .skip (f a) ih
| pair a b hL hR ihL ihR =>
simpa only [List.map_cons,List.map_append,Prod.map_apply] using Arches.pair (f a) (f b) ihL ihR
lemma endpoints_map (f : α→β) (E : List (α×α)) :
endpoints (E.map (Prod.map f f))=(endpoints E).map f := by
induction E with
| nil => rfl
| cons e E ih =>
rcases e with ⟨a,b⟩
simp only [List.map_cons,endpoints_cons,Prod.map_apply,ih]
lemma Arches.filter {l : List α} {E : List (α×α)} (h : Arches l E) (p : α→Bool)
(hp : ∀ e∈E,p e.1=p e.2) :
Arches (l.filter p) (E.filter (fun e => p e.1)) := by
induction h with
| nil => exact .nil
| @skip a l E h ih =>
cases ha : p a with
| true => simpa only [List.filter_cons,ha,ite_true] using Arches.skip a (ih hp)
| false => simpa only [List.filter_cons,ha,Bool.false_eq_true,ite_false] using ih hp
| @pair a b L R E F hL hR ihL ihR =>
have hab := hp (a,b) (List.mem_cons_self)
have hE := ihL (fun e he => hp e (List.mem_cons_of_mem _ (List.mem_append_left _ he)))
have hF := ihR (fun e he => hp e (List.mem_cons_of_mem _ (List.mem_append_right _ he)))
cases ha : p a with
| true =>
have hb : p b=true := hab.symm.trans ha
simpa only [List.filter_cons,List.filter_append,ha,hb,ite_true] using Arches.pair a b hE hF
| false =>
have hb : p b=false := hab.symm.trans ha
simpa only [List.filter_cons,List.filter_append,ha,hb,Bool.false_eq_true,ite_false] using hE.append hF
lemma endpoints_filter (p : α→Bool) (E : List (α×α))
(hp : ∀ e∈E,p e.1=p e.2) :
endpoints (E.filter (fun e => p e.1))=(endpoints E).filter p := by
induction E with
| nil => rfl
| cons e E ih =>
have he := hp e (List.mem_cons_self)
have hh := ih (fun f hf => hp f (List.mem_cons_of_mem _ hf))
cases ha : p e.1 <;> have hb := he.symm.trans ha <;>
simp only [List.filter_cons,endpoints_cons,ha,hb,Bool.false_eq_true,ite_true,ite_false,hh]
end FKCRT.MapCycles
namespace FKCRT.Inventory
open MapCycles
variable {α : Type*} [DecidableEq α]
/-- Restrict the actual successful word to any union of its matched pairs.
This includes both its root component and each real corner interval. -/
theorem matching_subword_empty (w : α→TypedLetter) (l : List α) (hn : l.Nodup)
(E F : List (α×α)) (hE : Arches l E) (hF : Arches l F)
(hc : (endpoints (E++F)).Perm l)
(htE : ∀ e∈E,w e.1=.burger true ∧ w e.2=.order true)
(htF : ∀ e∈F,w e.1=.burger false ∧ w e.2=.order false)
(p : α→Bool) (hp : ∀ d∈l,p (turns (E++F) d)=p d) :
stackTypedRun ((l.filter p).map w) []=some [] := by
have hnp := hc.nodup_iff.mpr hn
have heq : ∀ e∈E++F,p e.1=p e.2 := by
intro e he
have hm : e.1∈l := hc.mem_iff.mp (mem_endpoints.mpr ⟨e,he,Or.inl rfl⟩)
have hh := hp e.1 hm
rw [(turns_pair hnp e he).1] at hh
exact hh.symm
have he : ∀ e∈E,p e.1=p e.2 := fun e he => heq e (List.mem_append_left _ he)
have hf : ∀ e∈F,p e.1=p e.2 := fun e he => heq e (List.mem_append_right _ he)
apply typedRun_of_matchings w (l.filter p) (hn.filter _)
(E.filter (fun e => p e.1)) (F.filter (fun e => p e.1)) (hE.filter p he) (hF.filter p hf)
· rw [← List.filter_append,endpoints_filter p (E++F) heq]
exact hc.filter p
· intro e he';exact htE e (List.mem_filter.mp he').1
· intro e he';exact htF e (List.mem_filter.mp he').1
end FKCRT.Inventory
end
noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.MapCycles
variable {α β : Type*} [DecidableEq α] [DecidableEq β]
lemma turns_map_on (f : α→β) (hf : Function.Injective f) (E : List (α×α))
(hn : (endpoints E).Nodup) (i : α) (hi : i∈endpoints E) :
turns (E.map (Prod.map f f)) (f i)=f (turns E i) := by
have hn' : (endpoints (E.map (Prod.map f f))).Nodup := by
rw [endpoints_map];exact hn.map hf
obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp hi
· have hh := (turns_pair hn' (Prod.map f f e) (List.mem_map.mpr ⟨e,he,rfl⟩)).1
simpa only [Prod.map_fst,Prod.map_snd,(turns_pair hn e he).1] using hh
· have hh := (turns_pair hn' (Prod.map f f e) (List.mem_map.mpr ⟨e,he,rfl⟩)).2
simpa only [Prod.map_fst,Prod.map_snd,(turns_pair hn e he).2] using hh
end FKCRT.MapCycles
namespace FKCRT.Inventory
open MapCycles Chords
variable {α β : Type*}
/-- A certificate for the actual two stack matchings of a finite typed word.
The matching uniqueness theorem makes its induced mate choice-independent. -/
structure StackMatching (w : α→TypedLetter) (l : List α) where
first : List (α×α)
second : List (α×α)
first_arches : Arches l first
second_arches : Arches l second
covers : (endpoints (first++second)).Perm l
first_types : ∀ e∈first,w e.1=.burger true ∧ w e.2=.order true
second_types : ∀ e∈second,w e.1=.burger false ∧ w e.2=.order false
namespace StackMatching
variable {w : α→TypedLetter} {l : List α}
def ofEmpty (hw : stackTypedRun (l.map w) []=some []) : StackMatching w l :=
let h := ordered_matchings w l hw
⟨h.choose,h.choose_spec.choose,h.choose_spec.choose_spec.1,
h.choose_spec.choose_spec.2.1,h.choose_spec.choose_spec.2.2.1,
h.choose_spec.choose_spec.2.2.2.1,h.choose_spec.choose_spec.2.2.2.2⟩
def mate [DecidableEq α] (M : StackMatching w l) : Perm α := turns (M.first++M.second)
lemma empty [DecidableEq α] (M : StackMatching w l) (hn : l.Nodup) :
stackTypedRun (l.map w) []=some [] :=
typedRun_of_matchings w l hn M.first M.second M.first_arches M.second_arches
M.covers M.first_types M.second_types
lemma unique_mate [DecidableEq α] (M P : StackMatching w l) (hn : l.Nodup) : M.mate=P.mate := by
obtain ⟨hE,hF⟩ := typed_matchings_unique w l hn M.first M.second P.first P.second
M.first_arches M.second_arches P.first_arches P.second_arches M.covers P.covers
M.first_types M.second_types P.first_types P.second_types
exact turns_perm (hE.append hF) (M.covers.nodup_iff.mpr hn)
lemma involutive [DecidableEq α] (M : StackMatching w l) (hn : l.Nodup) :
Function.Involutive M.mate := turns_involutive (M.covers.nodup_iff.mpr hn)
lemma no_fixed [DecidableEq α] (M : StackMatching w l) (hn : l.Nodup) (i : α) (hi : i∈l) :
M.mate i≠i := by
intro hh
exact (turns_eq_self_iff (M.covers.nodup_iff.mpr hn) i).mp hh (M.covers.mem_iff.mpr hi)
lemma endpoints_mem (M : StackMatching w l) (e : α×α) (he : e∈M.first++M.second) :
e.1∈l ∧ e.2∈l :=
⟨M.covers.mem_iff.mp (mem_endpoints.mpr ⟨e,he,Or.inl rfl⟩),
M.covers.mem_iff.mp (mem_endpoints.mpr ⟨e,he,Or.inr rfl⟩)⟩
def map (M : StackMatching w l) (f : α→β) (v : β→TypedLetter)
(hv : ∀ i∈l,v (f i)=w i) : StackMatching v (l.map f) where
first := M.first.map (Prod.map f f)
second := M.second.map (Prod.map f f)
first_arches := M.first_arches.map f
second_arches := M.second_arches.map f
covers := by rw [← List.map_append,endpoints_map];exact M.covers.map f
first_types := by
intro e he
obtain ⟨x,hx,rfl⟩ := List.mem_map.mp he
have hh := M.endpoints_mem x (List.mem_append_left _ hx)
simpa only [Prod.map_fst,Prod.map_snd,hv _ hh.1,hv _ hh.2] using M.first_types x hx
second_types := by
intro e he
obtain ⟨x,hx,rfl⟩ := List.mem_map.mp he
have hh := M.endpoints_mem x (List.mem_append_right _ hx)
simpa only [Prod.map_fst,Prod.map_snd,hv _ hh.1,hv _ hh.2] using M.second_types x hx
lemma map_mate [DecidableEq α] [DecidableEq β] (M : StackMatching w l)
(hn : l.Nodup) (f : α→β) (hf : Function.Injective f) (v : β→TypedLetter)
(hv : ∀ i∈l,v (f i)=w i) (i : α) (hi : i∈l) :
(M.map f v hv).mate (f i)=f (M.mate i) := by
change turns (List.map (Prod.map f f) M.first++List.map (Prod.map f f) M.second) (f i)=_
rw [← List.map_append]
exact turns_map_on f hf _ (M.covers.nodup_iff.mpr hn) i (M.covers.mem_iff.mpr hi)
lemma cast_mate [DecidableEq α] {l' : List α} (h : l=l') (M : StackMatching w l) :
(h ▸ M).mate=M.mate := by cases h; rfl
end StackMatching
variable [LinearOrder α]
/-- The literal increasing compression map, not a fresh random matching. -/
def positionEmbedding (l : List α) (hs : l.Pairwise (·<·)) : Fin l.length ↪o α :=
OrderEmbedding.ofStrictMono l.get (fun _ _ h => hs.rel_get_of_lt h)
omit [LinearOrder α] in
lemma positions_word (w : α→TypedLetter) (l : List α) :
(List.finRange l.length).map (w ∘ l.get)=l.map w := by
rw [← List.map_map,List.map_get_finRange]
/-- Normalization preserves the actual mate permutation on all positions. -/
theorem normalized_matching_mate (w : α→TypedLetter) (l : List α) (hs : l.Pairwise (·<·))
(M : StackMatching w l) :
∃ P : StackMatching (w ∘ l.get) (List.finRange l.length),
∀ i,M.mate (l.get i)=l.get (P.mate i) := by
have hn : l.Nodup := hs.nodup
have hw : stackTypedRun ((List.finRange l.length).map (w ∘ l.get)) []=some [] := by
rw [positions_word];exact M.empty hn
let P := StackMatching.ofEmpty hw
let Q := P.map l.get w (fun _ _ => rfl)
have hQ : (List.finRange l.length).map l.get=l := List.map_get_finRange l
let R : StackMatching w l := hQ ▸ Q
have hmate := M.unique_mate R hn
refine ⟨P,fun i => ?_⟩
rw [hmate]
have hR : R.mate=Q.mate := StackMatching.cast_mate hQ Q
rw [hR]
exact P.map_mate (List.nodup_finRange _) l.get (List.nodup_iff_injective_get.mp hn)
w (fun _ _ => rfl) i (List.mem_finRange i)
end FKCRT.Inventory
end
noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.MapCycles
variable {α : Type*} [DecidableEq α]
lemma turns_sublist_preserves {E F : List (α×α)} (hn : (endpoints F).Nodup)
(hEF : E<+F) {S : Set α} (hF : ∀ d∈S,turns F d∈S) :
∀ d,turns E d∈S ↔ d∈S := by
have he : (endpoints E).Nodup := hn.sublist (hEF.flatMap _)
have hf (d : α) (hd : d∈S) : turns E d∈S := by
by_cases hx : d∈endpoints E
· rw [turns_sublist_apply hn hEF hx]
exact hF d hd
· simpa only [turns_fixed_of_notMem hx] using hd
intro d
constructor
· intro hd
simpa only [turns_involutive he d] using hf (turns E d) hd
· exact hf d
end FKCRT.MapCycles
namespace FKCRT.Inventory
open MapCycles PermutationWedge
variable {α : Type*} [DecidableEq α] [Fintype α]
omit [Fintype α] in
lemma StackMatching.empty_prefix_preserves {w : α→TypedLetter} {v z : List α}
(M : StackMatching w (v++z)) (hn : (v++z).Nodup)
(hv : stackTypedRun (v.map w) []=some []) :
(∀ d,M.mate d∈v ↔ d∈v) ∧ (∀ d,turns M.first d∈v ↔ d∈v) := by
have hm (d : α) (hd : d∈v) : turns (M.first++M.second) d∈v := by
exact empty_interval_matching_closed w [] v z (by simpa using hn)
M.first M.second (by simpa using M.first_arches) (by simpa using M.second_arches)
(by simpa using M.covers) M.first_types M.second_types hv d hd
have hn' : (endpoints (M.first++M.second)).Nodup := M.covers.nodup_iff.mpr hn
exact ⟨turns_sublist_preserves hn' (List.Sublist.refl _) hm,
turns_sublist_preserves hn' (List.sublist_append_left _ _) hm⟩
/-- A genuine successful inserted interval of the actual typed matching
creates a one-vertex union for the full, all-edge map graph. The local graph
metric conclusions now follow unconditionally from `GraphWedge.Data`. -/
def StackMatching.empty_prefix_wedge {w : α→TypedLetter} (a b : α) (L R : List α)
(M : StackMatching w ((a::L)++(b::R))) (hn : ((a::L)++(b::R)).Nodup)
(hv : stackTypedRun ((a::L).map w) []=some []) :
let p := (a::L).formPerm*(b::R).formPerm*turns M.first
let S : Set α := {d | d∈a::L}
GraphWedge.Data (sideGraph M.mate p S (M.empty_prefix_preserves hn hv).1)
(sideGraph M.mate p Sᶜ (fun d => not_congr ((M.empty_prefix_preserves hn hv).1 d)))
(dartGraph M.mate (swap a b*p)) := by
let S : Set α := {d | d∈a::L}
let p := (a::L).formPerm*(b::R).formPerm*turns M.first
have hpres := M.empty_prefix_preserves hn hv
have hd : (a::L).Disjoint (b::R) := List.disjoint_iff_ne.mpr (List.nodup_append.mp hn).2.2
have hp : ∀ d,p d∈S ↔ d∈S := by
intro d
simp only [p,S,Set.mem_ofPred_eq,mul_apply,List.formPerm_mem_iff_mem,
formPerm_other_mem_iff hd,hpres.2]
have ha : a∈S := by simp [S]
have hb : b∉S := fun h => List.disjoint_left.mp hd h (by simp)
exact PermutationWedge.data hp ha hb hpres.1
/-- Literal all-edge distance preservation for actual typed insertion,
not merely the selected spanning tree or a replacement metric. -/
theorem StackMatching.empty_prefix_distance {w : α→TypedLetter} (a b : α) (L R : List α)
(M : StackMatching w ((a::L)++(b::R))) (hn : ((a::L)++(b::R)).Nodup)
(hv : stackTypedRun ((a::L).map w) []=some []) (x y : α)
(hx : x∈a::L) (hy : y∈a::L) :
let p := (a::L).formPerm*(b::R).formPerm*turns M.first
let s := ((a::L)++(b::R)).formPerm*turns M.first
let S : Set α := {d | d∈a::L}
(dartGraph M.mate s).edist (vertex s x) (vertex s y)=
(sideGraph M.mate p S (M.empty_prefix_preserves hn hv).1).edist
(sideMk p S x hx) (sideMk p S y hy) := by
dsimp only
have hj := (contour_vertex_join a b L R (by simpa only [List.cons_append] using hn)
(turns M.first) (M.empty_prefix_preserves hn hv).2).1
have hj' : ((a::L)++(b::R)).formPerm*turns M.first=
swap a b*((a::L).formPerm*(b::R).formPerm*turns M.first) := by
simpa only [List.cons_append] using hj
rw [hj']
exact (M.empty_prefix_wedge a b L R hn hv).edist_left
(sideMk _ _ x hx) (sideMk _ _ y hy)
/-- Cross-block distances in the original all-edge map add through the
unique identified vertex. This includes coincident poles and loop edges. -/
theorem StackMatching.empty_prefix_cross_distance {w : α→TypedLetter} (a b : α) (L R : List α)
(M : StackMatching w ((a::L)++(b::R))) (hn : ((a::L)++(b::R)).Nodup)
(hv : stackTypedRun ((a::L).map w) []=some []) (x y : α)
(hx : x∈a::L) (hy : y∉a::L) :
let p := (a::L).formPerm*(b::R).formPerm*turns M.first
let s := ((a::L)++(b::R)).formPerm*turns M.first
let S : Set α := {d | d∈a::L}
(dartGraph M.mate s).edist (vertex s x) (vertex s y)=
(sideGraph M.mate p S (M.empty_prefix_preserves hn hv).1).edist
(sideMk p S x hx) (sideMk p S a (by simp [S]))+
(sideGraph M.mate p Sᶜ (fun d => not_congr ((M.empty_prefix_preserves hn hv).1 d))).edist
(sideMk p Sᶜ b (fun hb => List.disjoint_left.mp
(List.disjoint_iff_ne.mpr (List.nodup_append.mp hn).2.2) hb (by simp)))
(sideMk p Sᶜ y hy) := by
dsimp only
have hj := (contour_vertex_join a b L R (by simpa only [List.cons_append] using hn)
(turns M.first) (M.empty_prefix_preserves hn hv).2).1
have hj' : ((a::L)++(b::R)).formPerm*turns M.first=
swap a b*((a::L).formPerm*(b::R).formPerm*turns M.first) := by
simpa only [List.cons_append] using hj
rw [hj']
exact (M.empty_prefix_wedge a b L R hn hv).edist_cross
(sideMk _ _ x hx) (sideMk _ _ y hy)
end FKCRT.Inventory
end
end OAI