| import OAI.Probability.FKMaps.GraphWedge |
| import OAI.Probability.FKMaps.WordMaps |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| namespace FKCRT.Inventory |
| variable {N : ℕ} |
|
|
| def liveAt (a : Perm (Fin N)) (k : ℕ) : List (Fin N) := |
| ((List.finRange N).filter (fun x => decide (x.val<k ∧ k≤(a x).val))).reverse |
|
|
| lemma mem_liveAt (a : Perm (Fin N)) (k : ℕ) (x : Fin N) : |
| x∈liveAt a k ↔ x.val<k ∧ k≤(a x).val := by simp [liveAt] |
|
|
| lemma liveAt_sorted (a : Perm (Fin N)) (k : ℕ) : (liveAt a k).Pairwise (·>·) := by |
| exact ((List.pairwise_lt_finRange N).filter _).reverse |
|
|
| lemma liveAt_zero (a : Perm (Fin N)) : liveAt a 0=[] := by simp [liveAt] |
| lemma liveAt_end (a : Perm (Fin N)) : liveAt a N=[] := by |
| apply List.eq_nil_iff_forall_not_mem.mpr |
| intro x hx |
| have := (mem_liveAt a N x).mp hx |
| omega |
|
|
| lemma liveAt_open (a : Perm (Fin N)) (ha : Function.Involutive a) (i : Fin N) |
| (hi : i < a i) : liveAt a (i.val+1)=i::liveAt a i.val := by |
| have hs : (i::liveAt a i.val).Pairwise (·>·) := |
| List.pairwise_cons.mpr ⟨fun x hx => (mem_liveAt a i.val x).mp hx |>.1,liveAt_sorted a _⟩ |
| apply List.Pairwise.eq_of_mem_iff (liveAt_sorted a _) hs |
| intro x |
| rw [mem_liveAt,List.mem_cons,mem_liveAt] |
| have hx : a x=i → x=a i := fun h => by rw [← h,ha] |
| constructor |
| · rintro ⟨h1,h2⟩ |
| by_cases hxi : x=i |
| · exact Or.inl hxi |
| · exact Or.inr ⟨by have := Fin.val_ne_of_ne hxi; omega,by omega⟩ |
| · rintro (rfl|⟨h1,h2⟩) |
| · exact ⟨by omega,hi⟩ |
| · refine ⟨by omega,?_⟩ |
| by_contra hh |
| have he : a x=i := Fin.ext (by omega) |
| have he' := hx he |
| subst x |
| have hi' : i.val<(a i).val := hi |
| omega |
|
|
| lemma liveAt_close (a : Perm (Fin N)) (ha : Function.Involutive a) (i : Fin N) |
| (hi : a i < i) : liveAt a (i.val+1)=(liveAt a i.val).erase (a i) := by |
| apply List.Pairwise.eq_of_mem_iff (liveAt_sorted a _) ((liveAt_sorted a _).sublist List.erase_sublist) |
| intro x |
| rw [mem_liveAt,(liveAt_sorted a _).nodup.mem_erase_iff,mem_liveAt] |
| have hx : x=a i ↔ a x=i := by |
| constructor |
| · intro h; rw [h,ha] |
| · intro h; rw [← h,ha] |
| have hi' : (a i).val < i.val := hi |
| constructor |
| · rintro ⟨h1,h2⟩ |
| refine ⟨?_,?_,by omega⟩ |
| · intro he; have := hx.mp he; subst x; rw [ha] at h2; omega |
| · by_contra h |
| have he : x=i := Fin.ext (by omega) |
| subst x |
| omega |
| · rintro ⟨h1,h2,h3⟩ |
| refine ⟨by omega,?_⟩ |
| by_contra h |
| have he : a x=i := Fin.ext (by omega) |
| exact h1 (hx.mpr he) |
|
|
| lemma liveAt_mate (a : Perm (Fin N)) (ha : Function.Involutive a) (i : Fin N) |
| (hi : a i < i) : a i∈liveAt a i.val := by rw [mem_liveAt,ha]; exact ⟨hi,le_rfl⟩ |
| |
| lemma pop_map_erase {α : Type*} [DecidableEq α] (c : α→Bool) (s : List α) (x : α) |
| (hx : x∈s) (hfirst : ∀ t u,s=t++x::u → ∀ y∈t,c y≠c x) : |
| pop (some (c x)) (s.map c)=some ((s.erase x).map c) := by |
| induction s with |
| | nil => simp at hx |
| | cons y s ih => |
| by_cases hy : y=x |
| · subst y; simp [pop,eligible] |
| · have hxs : x∈s := List.mem_of_ne_of_mem (Ne.symm hy) hx |
| obtain ⟨t,u,htu⟩ := List.mem_iff_append.mp hxs |
| have hcy := hfirst (y::t) u (by rw [htu]; rfl) y (by simp) |
| have hh := ih hxs (by |
| intro t u he z hz |
| exact hfirst (y::t) u (by rw [he]; rfl) z (List.mem_cons_of_mem y hz)) |
| simp [pop,eligible,Ne.symm hcy,hy,hh] |
| |
| /-- For noncrossing same-colour arcs, the literal typed stack is the list of |
| live openers in reverse chronological order. No choice of a stack matching |
| is assumed. -/ |
| lemma matching_step_live (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (hf : ∀ x,a x≠x) (c : Fin N→Bool) (hc : ∀ x,c (a x)=c x) |
| (hn : ∀ x y,c x=c y → x < y → y < a x → a x < a y → False) (i : Fin N) : |
| stackTypedStep ((liveAt a i.val).map c) |
| (if i < a i then .burger (c i) else .order (c i))= |
| some ((liveAt a (i.val+1)).map c) := by |
| by_cases hi : i < a i |
| · rw [ite_eq_left hi,liveAt_open a ha i hi] |
| rfl |
| · have hlt : a i < i := lt_of_le_of_ne (le_of_not_gt hi) (hf i) |
| rw [ite_eq_right hi,stackTypedStep,liveAt_close a ha i hlt,← hc i] |
| apply pop_map_erase c _ _ (liveAt_mate a ha i hlt) |
| intro t u he y hy hcy |
| have hs := liveAt_sorted a i.val |
| rw [he,List.pairwise_append] at hs |
| have hiy : a i<y := hs.2.2 y hy (a i) (by simp) |
| have hym : y∈liveAt a i.val := he ▸ List.mem_append_left _ hy |
| obtain ⟨hy1,hy2⟩ := (mem_liveAt a i.val y).mp hym |
| have hneq : a y≠i := fun hh => (ne_of_lt hiy) (by rw [← hh,ha]) |
| have hy3 : i < a y := by have := Fin.val_ne_of_ne hneq; change (i : ℕ)<(a y : ℕ); omega |
| exact hn (a i) y hcy.symm hiy (by rwa [ha]) (by rwa [ha]) |
| |
| end FKCRT.Inventory |
| end |
| |
| |
| noncomputable section |
| open List Equiv Equiv.Perm |
| namespace FKCRT.Inventory |
| variable {N : ℕ} |
|
|
| lemma liveAt_first_colour (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (c : Fin N→Bool) |
| (hn : ∀ x y,c x=c y → x < y → y < a x → a x < a y → False) |
| (i : Fin N) (_hi : a i < i) : |
| ∀ t u,liveAt a i.val=t++a i::u → ∀ y∈t,c y≠c (a i) := by |
| intro t u he y hy hcy |
| have hs := liveAt_sorted a i.val |
| rw [he,List.pairwise_append] at hs |
| have hiy : a i < y := hs.2.2 y hy (a i) (by simp) |
| have hym : y∈liveAt a i.val := he ▸ List.mem_append_left _ hy |
| obtain ⟨hy1,hy2⟩ := (mem_liveAt a i.val y).mp hym |
| have hneq : a y≠i := fun hh => (ne_of_lt hiy) (by rw [← hh,ha]) |
| have hy3 : i < a y := by have := Fin.val_ne_of_ne hneq; change (i : ℕ)<(a y : ℕ); omega |
| exact hn (a i) y hcy.symm hiy (by rwa [ha]) (by rwa [ha]) |
| |
| lemma head_map_eq_of_first {α : Type*} (c : α→Bool) (s : List α) (x : α) |
| (hx : x∈s) (hfirst : ∀ t u,s=t++x::u → ∀ y∈t,c y≠c x) : |
| (s.map c).head?=some (c x) ↔ s.head?=some x := by |
| obtain ⟨t,u,rfl⟩ := List.mem_iff_append.mp hx |
| cases t with |
| | nil => simp |
| | cons y t => |
| have hh := hfirst (y::t) u rfl y (by simp) |
| have hy : y≠x := fun he => hh (congrArg c he) |
| simp [hh,hy] |
|
|
| lemma head_eq_iff_greatest {α : Type*} [LinearOrder α] (s : List α) |
| (hs : s.Pairwise (·>·)) (x : α) (hx : x∈s) : |
| s.head?=some x ↔ ∀ y∈s,y≤x := by |
| cases s with |
| | nil => simp at hx |
| | cons z s => |
| simp only [List.head?_cons,Option.some.injEq] |
| constructor |
| · rintro rfl y hy |
| rcases List.mem_cons.mp hy with rfl|hy |
| · exact le_rfl |
| · exact ((List.pairwise_cons.mp hs).1 y hy).le |
| · intro hh |
| have hz := hh z (by simp) |
| rcases List.mem_cons.mp hx with rfl|hx |
| · rfl |
| · exact False.elim (not_lt_of_ge hz ((List.pairwise_cons.mp hs).1 x hx)) |
|
|
| /-- The source's flexible-mark obstruction, with the strict first-occurrence |
| order and both closing endpoints retained exactly. -/ |
| theorem flexibleClosing_iff_no_later_cross (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (c : Fin N→Bool) (hc : ∀ x,c (a x)=c x) |
| (hn : ∀ x y,c x=c y → x < y → y < a x → a x < a y → False) |
| (i : Fin N) (hi : a i < i) : |
| flexibleClosing ((liveAt a i.val).map c) (.order (c i)) ↔ |
| ¬∃ j : Fin N,a i < j ∧ j < i ∧ i < a j := by |
| change (List.map c (liveAt a i.val)).head?=some (c i) ↔ _ |
| rw [← hc i,head_map_eq_of_first c _ _ (liveAt_mate a ha i hi) |
| (liveAt_first_colour a ha c hn i hi), |
| head_eq_iff_greatest _ (liveAt_sorted a _) _ (liveAt_mate a ha i hi)] |
| constructor |
| · intro hh ⟨j,h1,h2,h3⟩ |
| exact not_lt_of_ge (hh j ((mem_liveAt a _ j).mpr ⟨h2,h3.le⟩)) h1 |
| · intro hh j hj |
| by_contra h |
| obtain ⟨h2,h3⟩ := (mem_liveAt a _ j).mp hj |
| have h1 : a i < j := lt_of_not_ge h |
| have hne : a j≠i := fun he => (ne_of_lt h1) (by rw [← he,ha]) |
| have h4 : i < a j := by have := Fin.val_ne_of_ne hne; change i.val<(a j).val; omega |
| exact hh ⟨j,h1,h2,h4⟩ |
| |
| end FKCRT.Inventory |
| end |
| |
| |
| noncomputable section |
| open List Equiv Equiv.Perm |
| open scoped BigOperators |
| namespace FKCRT.Inventory |
| attribute [local instance] Classical.propDecidable |
| |
| lemma flexibleCount_ofFn {N : ℕ} (w : Fin N→TypedLetter) (S : Fin (N+1)→List Bool) |
| (hs : ∀ i,stackTypedStep (S i.castSucc) (w i)=some (S i.succ)) : |
| flexibleCount (List.ofFn w) (S 0)= |
| ∑ i,if flexibleClosing (S i.castSucc) (w i) then 1 else 0 := by |
| induction N with |
| | zero => simp [flexibleCount] |
| | succ N ih => |
| have h0 := hs 0 |
| simp only [Fin.castSucc_zero] at h0 |
| rw [List.ofFn_succ,flexibleCount,h0,Fin.sum_univ_succ] |
| simp only [Fin.castSucc_zero] |
| congr 1 |
| exact ih (fun i => w i.succ) (fun i => S i.succ) (fun i => hs i.succ) |
|
|
| /-- The complete flexible exponent of the actual identified word is the |
| number of its matched pairs with no later-first crossing edge. -/ |
| theorem matching_flexibleCount {N : ℕ} (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (hf : ∀ x,a x≠x) (c : Fin N→Bool) (hc : ∀ x,c (a x)=c x) |
| (hn : ∀ x y,c x=c y → x < y → y < a x → a x < a y → False) : |
| flexibleCount (List.ofFn (fun i => if i<a i then .burger (c i) else .order (c i))) []= |
| ∑ i : Fin N,if a i < i ∧ ¬∃ j : Fin N,a i < j ∧ j < i ∧ i < a j then 1 else 0 := by |
| let w : Fin N→TypedLetter := fun i => if i<a i then .burger (c i) else .order (c i) |
| let S : Fin (N+1)→List Bool := fun i => (liveAt a i.val).map c |
| have hs : ∀ i,stackTypedStep (S i.castSucc) (w i)=some (S i.succ) := |
| matching_step_live a ha hf c hc hn |
| have hS : S 0=[] := by simp [S,liveAt_zero] |
| rw [← hS,flexibleCount_ofFn w S hs] |
| apply Finset.sum_congr rfl |
| intro i _ |
| by_cases hi : i<a i |
| · have hn' : ¬a i < i := not_lt_of_ge hi.le |
| simp [w,hi,flexibleClosing,hn'] |
| · have hlt : a i < i := lt_of_le_of_ne (le_of_not_gt hi) (hf i) |
| have hh := flexibleClosing_iff_no_later_cross a ha c hc hn i hlt |
| change (if flexibleClosing ((liveAt a i.val).map c) |
| (if i<a i then .burger (c i) else .order (c i)) then 1 else 0)=_ |
| simp only [ite_eq_right hi,hh,hlt,true_and] |
|
|
| end FKCRT.Inventory |
| end |
|
|
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| attribute [local instance] Classical.propDecidable |
| namespace FKCRT.Chords |
| variable {N : ℕ} |
|
|
| lemma componentDarts_mate (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (r : Opener a) (d : Fin N) : |
| a d∈componentDarts a r ↔ d∈componentDarts a r := by |
| have hd (i : Fin N) : i∈componentDarts a r → a i∈componentDarts a r := by |
| intro hi |
| obtain ⟨x,hx,rfl|rfl⟩ := (mem_componentDarts a r i).mp hi |
| · exact (mem_componentDarts a r _).mpr ⟨x,hx,Or.inr rfl⟩ |
| · rw [ha] |
| exact (mem_componentDarts a r _).mpr ⟨x,hx,Or.inl rfl⟩ |
| constructor |
| · intro h |
| have hh := hd (a d) h |
| rw [ha] at hh |
| exact hh |
| · exact hd d |
|
|
| def opener (a : Perm (Fin N)) (ha : Function.Involutive a) (hf : ∀ d,a d≠d) |
| (d : Fin N) : Opener a := |
| if h : d<a d then ⟨d,h⟩ else ⟨a d,by rw [ha]; exact lt_of_le_of_ne (le_of_not_gt h) (hf d)⟩ |
| |
| lemma opener_endpoints (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (hf : ∀ d,a d≠d) (d : Fin N) : |
| d=(opener a ha hf d).val ∨ d=a (opener a ha hf d).val := by |
| unfold opener |
| split_ifs |
| · exact Or.inl rfl |
| · exact Or.inr (ha d).symm |
|
|
| lemma gapIndex_mate (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (hf : ∀ d,a d≠d) (r : Opener a) (hr : r.val.val=0) |
| (d : Fin N) (hd : d∉componentDarts a r) : gapIndex a r (a d)=gapIndex a r d := by |
| let f := opener a ha hf d |
| have hroot : r.val≤f.val := by change r.val.val≤f.val.val; rw [hr]; omega |
| have he := opener_endpoints a ha hf d |
| have hn : ¬(graph a).Reachable r f := fun h => hd ((mem_componentDarts a r d).mpr ⟨f,h,he⟩) |
| have hh := exterior_same_gap a ha r f hroot hn |
| rcases he with he|he |
| · rw [he]; exact hh.symm |
| · rw [he,ha]; exact hh |
| |
| def cornerDarts (a : Perm (Fin N)) (r : Opener a) (k : ℕ) : Finset (Fin N) := |
| Finset.univ.filter (fun d => d∉componentDarts a r ∧ gapIndex a r d=k) |
|
|
| lemma cornerDarts_mate (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (hf : ∀ d,a d≠d) (r : Opener a) (hr : r.val.val=0) (d : Fin N) (k : ℕ) : |
| a d∈cornerDarts a r k ↔ d∈cornerDarts a r k := by |
| simp only [cornerDarts,Finset.mem_filter,Finset.mem_univ,true_and,componentDarts_mate a ha] |
| by_cases hd : d∈componentDarts a r |
| · simp [hd] |
| · simp only [gapIndex_mate a ha hf r hr d hd] |
|
|
| lemma component_card_even (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (hf : ∀ d,a d≠d) (S : Finset (Fin N)) (hS : ∀ d∈S,a d∈S) : |
| S.card=2*(S.filter (fun d => d<a d)).card := by |
| let O := S.filter (fun d => d<a d) |
| have he : S=O∪O.image a := by |
| ext d |
| simp only [Finset.mem_union,Finset.mem_image] |
| constructor |
| · intro hd |
| by_cases h : d<a d |
| · exact Or.inl (Finset.mem_filter.mpr ⟨hd,h⟩) |
| · refine Or.inr ⟨a d,?_,ha d⟩ |
| apply Finset.mem_filter.mpr |
| exact ⟨hS d hd,by rw [ha]; exact lt_of_le_of_ne (le_of_not_gt h) (hf d)⟩ |
| · rintro (hd|⟨i,hi,rfl⟩) |
| · exact Finset.mem_of_mem_filter _ hd |
| · exact hS i (Finset.mem_of_mem_filter _ hi) |
| have hd : Disjoint O (O.image a) := by |
| apply Finset.disjoint_left.mpr |
| intro d hd hd' |
| obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp hd' |
| have hi' := (Finset.mem_filter.mp hi).2 |
| have hd'' := (Finset.mem_filter.mp hd).2 |
| rw [ha] at hd'' |
| exact (not_lt_of_ge hi'.le) hd'' |
| calc |
| S.card=(O∪O.image a).card := congrArg Finset.card he |
| _=O.card+O.card := by rw [Finset.card_union_of_disjoint hd,Finset.card_image_of_injective _ a.injective] |
| _=2*O.card := by omega |
|
|
| end Chords |
| namespace Inventory |
| open MapCycles |
| variable {N : ℕ} |
|
|
| def pairWord (a : Perm (Fin N)) (c : Fin N→Bool) (i : Fin N) : TypedLetter := |
| if i<a i then .burger (c i) else .order (c i) |
|
|
| /-- Any pair-closed ordered subword of a two-colour noncrossing matching is |
| itself an actual successful inventory word. This applies both to a root |
| crossing component and to each of its corner intervals. -/ |
| theorem typedRun_closed_subword (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (hf : ∀ x,a x≠x) (c : Fin N→Bool) (hc : ∀ x,c (a x)=c x) |
| (hn : ∀ x y,c x=c y → x < y → y < a x → a x < a y → False) |
| (l : List (Fin N)) (hl : l.Pairwise (·<·)) (hclosed : ∀ x∈l,a x∈l) : |
| stackTypedRun (l.map (pairWord a c)) []=some [] := by |
| have hm (b : Bool) : ∃ E,Arches l E ∧ |
| (endpoints E).Perm (l.filter (fun i => decide (c i=b))) ∧ |
| ∀ e∈E,e.2=a e.1 ∧ c e.1=b := by |
| obtain ⟨E,hE,hcov,hp⟩ := arches_of_noncrossing a ha (fun i => decide (c i=b)) |
| (fun i => by rw [hc]) l hl (fun x hx _ => hclosed x hx) (fun x _ _ => hf x) |
| (by |
| intro x _ y _ hx hy hxy hyx hax |
| exact hn x y ((of_decide_eq_true hx).trans (of_decide_eq_true hy).symm) hxy hyx hax) |
| exact ⟨E,hE,hcov,fun e he => ⟨(hp e he).1,of_decide_eq_true (hp e he).2⟩⟩ |
| obtain ⟨E,hE,hce,hpe⟩ := hm true |
| obtain ⟨F,hF,hcf,hpf⟩ := hm false |
| have hcov : (endpoints (E++F)).Perm l := by |
| rw [endpoints_append] |
| apply (hce.append hcf).trans |
| simpa using List.filter_append_perm c l |
| have hlabel (b : Bool) (G : List (Fin N×Fin N)) (hG : Arches l G) |
| (hp : ∀ e∈G,e.2=a e.1 ∧ c e.1=b) : |
| ∀ e∈G,pairWord a c e.1=.burger b ∧ pairWord a c e.2=.order b := by |
| intro e he |
| obtain ⟨hpair,hcol⟩ := hp e he |
| have hlt := hG.increasing hl e he |
| have hmate : a e.2=e.1 := by rw [hpair,ha] |
| have hcol' : c e.2=b := by rw [hpair,hc,hcol] |
| simp only [pairWord,← hpair,hmate,ite_eq_left hlt,ite_eq_right (not_lt_of_ge hlt.le),hcol,hcol',and_self] |
| exact typedRun_of_matchings _ _ hl.nodup E F hE hF hcov (hlabel true E hE hpe) (hlabel false F hF hpf) |
|
|
| /-- Every root component and every one of its literal corner subwords reduce |
| empty. The conclusion uses the full ordered subword, not independent fresh |
| words postulated at a random cut. -/ |
| theorem component_and_corners_empty (a : Perm (Fin N)) (ha : Function.Involutive a) |
| (hf : ∀ x,a x≠x) (c : Fin N→Bool) (hc : ∀ x,c (a x)=c x) |
| (hn : ∀ x y,c x=c y → x < y → y < a x → a x < a y → False) |
| (r : Chords.Opener a) (hr : r.val.val=0) : |
| stackTypedRun (((List.finRange N).filter (fun d => decide (d∈Chords.componentDarts a r))).map |
| (pairWord a c)) []=some [] ∧ |
| ∀ k,stackTypedRun (((List.finRange N).filter (fun d => decide (d∈Chords.cornerDarts a r k))).map |
| (pairWord a c)) []=some [] := by |
| constructor |
| · apply typedRun_closed_subword a ha hf c hc hn _ ((List.pairwise_lt_finRange N).filter _) |
| intro x hx |
| simp only [List.mem_filter,List.mem_finRange,true_and,decide_eq_true_eq] at hx ⊢ |
| exact (Chords.componentDarts_mate a ha r x).mpr hx |
| · intro k |
| apply typedRun_closed_subword a ha hf c hc hn _ ((List.pairwise_lt_finRange N).filter _) |
| intro x hx |
| simp only [List.mem_filter,List.mem_finRange,true_and,decide_eq_true_eq] at hx ⊢ |
| exact (Chords.cornerDarts_mate a ha hf r hr x k).mpr hx |
|
|
| end Inventory |
| end FKCRT |
| end |
|
|
| end OAI |
|
|
