| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Graphs.LabelCycle |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Transport |
|
|
| section |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq E] |
|
|
| variable (inc : E → V → Prop) |
|
|
| abbrev PM := {M : Finset E // MatchingOn inc M Finset.univ} |
|
|
| @[ext] structure RawDemand where |
| first : PM inc |
| second : PM inc |
| anchor : E |
| corners : Fin 4 → V |
| flags : Fin 64 |
|
|
| structure DemandEncoding (d : RawDemand inc) where |
| first : PM inc |
| second : PM inc |
| added : Multiset E |
| dropped : Multiset E |
| added_card : added.card ≤ 4 |
| dropped_card : dropped.card ≤ 4 |
| conservation : d.first.val.val + d.second.val.val + added = |
| first.val.val + second.val.val + dropped |
| outside : ∀ e ∈ d.first.val ∪ d.second.val, |
| ¬ (overlayLineGraph inc (d.first.val ∪ d.second.val)).Reachable d.anchor e → |
| (e ∈ d.first.val ↔ e ∈ first.val) |
|
|
| abbrev DemandTag := E × (Fin 4 → V) × Fin 64 × Bool × (Fin 4 → Option E) × (Fin 4 → Option E) |
|
|
| noncomputable def padOccurrences (m : Multiset E) : Fin 4 → Option E := |
| fun i => m.toList[i.val]? |
|
|
| omit [DecidableEq E] in |
| lemma padOccurrences_recovers {m n : Multiset E} (hm : m.card ≤ 4) (hn : n.card ≤ 4) |
| (h : padOccurrences m = padOccurrences n) : m = n := by |
| have hl : m.toList = n.toList := by |
| apply List.ext_getElem? |
| intro i |
| by_cases hi : i < 4 |
| · exact congrFun h ⟨i, hi⟩ |
| · have hm' : m.toList.length ≤ i := by rw [Multiset.length_toList]; omega |
| have hn' : n.toList.length ≤ i := by rw [Multiset.length_toList]; omega |
| rw [List.getElem?_eq_none hm', List.getElem?_eq_none hn'] |
| simpa only [Multiset.coe_toList] using congrArg (fun l : List E => (l : Multiset E)) hl |
|
|
| omit [DecidableEq E] in |
| lemma tag_card [Fintype E] : Fintype.card (DemandTag (V := V) (E := E)) = |
| Fintype.card E * Fintype.card V ^ 4 * 128 * (Fintype.card E + 1) ^ 8 := by |
| simp only [DemandTag, Fintype.card_prod, Fintype.card_fun, Fintype.card_fin, |
| Fintype.card_bool, Fintype.card_option] |
| ring |
|
|
| omit [DecidableEq E] in |
| lemma tag_card_bound [Fintype E] (N : ℕ) (hN : 2 ≤ N) (hV : Fintype.card V ≤ N) |
| (hE : Fintype.card E ≤ 2 * N^2) : |
| Fintype.card (DemandTag (V := V) (E := E)) ≤ (10*N)^30 := by |
| rw [tag_card] |
| have hp : 1 ≤ N^2 := Nat.one_le_pow 2 N (by omega) |
| have he : Fintype.card E + 1 ≤ 3 * N^2 := by omega |
| calc |
| _ ≤ (2*N^2) * N^4 * 128 * (3*N^2)^8 := by gcongr |
| _ = (2*128*3^8) * N^22 := by ring |
| _ ≤ 10^30 * N^30 := by |
| exact Nat.mul_le_mul (by norm_num) (Nat.pow_le_pow_right (by omega) (by omega)) |
| _ = _ := by ring |
|
|
| namespace DemandEncoding |
|
|
| variable {inc} |
|
|
| def code {d : RawDemand inc} (a : DemandEncoding inc d) := |
| (a.first, a.second, d.anchor, d.corners, d.flags, |
| decide (d.anchor ∈ d.first.val), a.added, a.dropped) |
|
|
| theorem code_recovers {d e : RawDemand inc} (a : DemandEncoding inc d) |
| (b : DemandEncoding inc e) (h : a.code = b.code) : d = e := by |
| simp only [code, Prod.mk.injEq] at h |
| obtain ⟨hf,hs,ha,hc,hfl,hbit,had,hdr⟩ := h |
| have hu : d.first.val.val + d.second.val.val = e.first.val.val + e.second.val.val := by |
| have hh := a.conservation |
| rw [hf, hs, hdr, ← b.conservation, ← had] at hh |
| exact add_right_cancel hh |
| have hunion := union_eq_of_multiset_union_eq hu |
| have hb : d.anchor ∈ d.first.val ↔ d.anchor ∈ e.first.val := by |
| rw [← ha] at hbit |
| exact decide_eq_decide.mp hbit |
| have hp := pair_reconstruction inc d.first.property d.second.property |
| e.first.property e.second.property hu d.anchor hb (fun f hfu hnr => by |
| have hm := a.outside f hfu hnr |
| have hn := b.outside f (hunion ▸ hfu) (by simpa only [← ha, ← hunion] using hnr) |
| rw [hf] at hm |
| exact hm.trans hn.symm) |
| exact RawDemand.ext (Subtype.ext hp.1) (Subtype.ext hp.2) ha hc hfl |
|
|
| noncomputable def tag {d : RawDemand inc} (a : DemandEncoding inc d) : DemandTag (V := V) (E := E) := |
| (d.anchor, d.corners, d.flags, decide (d.anchor ∈ d.first.val), |
| padOccurrences a.added, padOccurrences a.dropped) |
|
|
| noncomputable def finiteCode {d : RawDemand inc} (a : DemandEncoding inc d) := |
| (a.first, a.second, a.tag) |
|
|
| theorem finiteCode_recovers {d e : RawDemand inc} (a : DemandEncoding inc d) |
| (b : DemandEncoding inc e) (h : a.finiteCode = b.finiteCode) : d = e := by |
| simp only [finiteCode, tag, Prod.mk.injEq] at h |
| obtain ⟨hf,hs,ha,hc,hfl,hbit,had,hdr⟩ := h |
| apply code_recovers a b |
| simp only [code, Prod.mk.injEq] |
| exact ⟨hf,hs,ha,hc,hfl,hbit, |
| padOccurrences_recovers a.added_card b.added_card had, |
| padOccurrences_recovers a.dropped_card b.dropped_card hdr⟩ |
|
|
| theorem code_injective (P : RawDemand inc → Prop) |
| (encode : ∀ d : {d : RawDemand inc // P d}, DemandEncoding inc d.val) : |
| Function.Injective (fun d => (encode d).finiteCode) := by |
| intro d e h |
| exact Subtype.ext (finiteCode_recovers (encode d) (encode e) h) |
|
|
| end DemandEncoding |
|
|
| end |
|
|
| section |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq V] [DecidableEq E] |
|
|
| variable (inc : E → V → Prop) |
|
|
| structure EmbeddedCell (d : RawDemand inc) where |
| cell : CellPaths inc |
| orientation : Bool |
| first_pattern : cell.orientation orientation ⊆ d.first.val |
| second_pattern : cell.orientation (!orientation) ⊆ d.second.val |
| reach : ∀ e ∈ cell.orientation true ∪ cell.orientation false, |
| (overlayLineGraph inc (d.first.val ∪ d.second.val)).Reachable d.anchor e |
|
|
| namespace EmbeddedCell |
|
|
| variable {inc} {d : RawDemand inc} (c : EmbeddedCell inc d) |
|
|
| variable (hinc : ∀ e, ∃ v, inc e v) |
|
|
| def outsideFirst : Finset E := d.first.val \ c.cell.orientation c.orientation |
|
|
| def outsideSecond : Finset E := d.second.val \ c.cell.orientation (!c.orientation) |
|
|
| lemma outsideFirst_matching : MatchingOn inc c.outsideFirst (Finset.univ \ c.cell.vertices) := |
| d.first.property.sdiff (c.cell.orientation_matching c.orientation) c.first_pattern |
|
|
| lemma outsideSecond_matching : MatchingOn inc c.outsideSecond (Finset.univ \ c.cell.vertices) := |
| d.second.property.sdiff (c.cell.orientation_matching (!c.orientation)) c.second_pattern |
|
|
| lemma context_vertices_disjoint : Disjoint (Finset.univ \ c.cell.vertices) c.cell.vertices := |
| Finset.sdiff_disjoint |
|
|
| def attachFirst (p : Finset E) (hp : MatchingOn inc p c.cell.vertices) : PM inc := |
| ⟨c.outsideFirst ∪ p, by |
| have h := c.outsideFirst_matching.union hp c.context_vertices_disjoint |
| simpa only [Finset.sdiff_union_of_subset (Finset.subset_univ _)] using h⟩ |
|
|
| def attachSecond (p : Finset E) (hp : MatchingOn inc p c.cell.vertices) : PM inc := |
| ⟨c.outsideSecond ∪ p, by |
| have h := c.outsideSecond_matching.union hp c.context_vertices_disjoint |
| simpa only [Finset.sdiff_union_of_subset (Finset.subset_univ _)] using h⟩ |
|
|
| include hinc in |
| lemma attachFirst_val (p : Finset E) (hp : MatchingOn inc p c.cell.vertices) : |
| (c.attachFirst p hp).val.val = c.outsideFirst.val + p.val := |
| union_val_add (c.outsideFirst_matching.disjoint_edges hp hinc c.context_vertices_disjoint) |
|
|
| include hinc in |
| lemma attachSecond_val (p : Finset E) (hp : MatchingOn inc p c.cell.vertices) : |
| (c.attachSecond p hp).val.val = c.outsideSecond.val + p.val := |
| union_val_add (c.outsideSecond_matching.disjoint_edges hp hinc c.context_vertices_disjoint) |
|
|
| include hinc in |
| lemma source_first_val : d.first.val.val = |
| c.outsideFirst.val + (c.cell.orientation c.orientation).val := by |
| have h := c.attachFirst_val hinc _ (c.cell.orientation_matching c.orientation) |
| have he : (c.attachFirst _ (c.cell.orientation_matching c.orientation)).val = d.first.val := by |
| exact Finset.sdiff_union_of_subset c.first_pattern |
| rwa [he] at h |
|
|
| include hinc in |
| lemma source_second_val : d.second.val.val = |
| c.outsideSecond.val + (c.cell.orientation (!c.orientation)).val := by |
| have h := c.attachSecond_val hinc _ (c.cell.orientation_matching (!c.orientation)) |
| have he : (c.attachSecond _ (c.cell.orientation_matching (!c.orientation))).val = d.second.val := by |
| exact Finset.sdiff_union_of_subset c.second_pattern |
| rwa [he] at h |
|
|
| include hinc in |
| lemma attach_outside (p : Finset E) (hp : MatchingOn inc p c.cell.vertices) |
| (e : E) (he : e ∈ d.first.val ∪ d.second.val) |
| (hn : ¬ (overlayLineGraph inc (d.first.val ∪ d.second.val)).Reachable d.anchor e) : |
| e ∈ d.first.val ↔ e ∈ (c.attachFirst p hp).val := by |
| have hnot (b : Bool) : e ∉ c.cell.orientation b := by |
| intro hm |
| apply hn |
| apply c.reach e |
| cases b |
| · exact Finset.mem_union_right _ hm |
| · exact Finset.mem_union_left _ hm |
| have hnp : e ∉ p := by |
| intro hm |
| obtain ⟨v,hv⟩ := hinc e |
| have hvc := hp.1 e hm v hv |
| rcases Finset.mem_union.mp he with he | he |
| · exact hnot _ (d.first.property.edge_mem_of_incident |
| (c.cell.orientation_matching c.orientation) c.first_pattern he hvc hv) |
| · exact hnot _ (d.second.property.edge_mem_of_incident |
| (c.cell.orientation_matching (!c.orientation)) c.second_pattern he hvc hv) |
| change e ∈ d.first.val ↔ e ∈ c.outsideFirst ∪ p |
| simp only [outsideFirst, Finset.mem_union, Finset.mem_sdiff, hnot, hnp, not_false_eq_true, |
| and_true, or_false] |
|
|
| def encode (p q : Finset E) (hp : MatchingOn inc p c.cell.vertices) |
| (hq : MatchingOn inc q c.cell.vertices) (add drop : Multiset E) |
| (ha : add.card ≤ 4) (hd : drop.card ≤ 4) |
| (hcons : (c.cell.orientation true).val + (c.cell.orientation false).val + add = |
| p.val + q.val + drop) : DemandEncoding inc d where |
| first := c.attachFirst p hp |
| second := c.attachSecond q hq |
| added := add |
| dropped := drop |
| added_card := ha |
| dropped_card := hd |
| conservation := by |
| rw [c.source_first_val hinc, c.source_second_val hinc, |
| c.attachFirst_val hinc p hp, c.attachSecond_val hinc q hq] |
| have ho : (c.cell.orientation c.orientation).val + |
| (c.cell.orientation (!c.orientation)).val = |
| (c.cell.orientation true).val + (c.cell.orientation false).val := by |
| cases c.orientation <;> simp only [Bool.not_false, Bool.not_true] |
| ac_rfl |
| calc |
| _ = c.outsideFirst.val + c.outsideSecond.val + |
| ((c.cell.orientation c.orientation).val + (c.cell.orientation (!c.orientation)).val + add) := by ac_rfl |
| _ = c.outsideFirst.val + c.outsideSecond.val + (p.val + q.val + drop) := by rw [ho,hcons] |
| _ = _ := by ac_rfl |
| outside := c.attach_outside hinc p hp |
|
|
| def switchEncoding (b r : Bool) (repair : Fin 4 → E) (hr : c.cell.Repairs r repair) : |
| DemandEncoding inc d := |
| c.encode hinc (c.cell.switched b) (c.cell.repaired r repair) |
| (c.cell.switched_matching b) (c.cell.repaired_matching r repair hr) |
| (c.cell.additions b r repair) (c.cell.drops r) |
| (by rw [← (c.cell.modification_cards b r repair).1]; exact (c.cell.modification_cards b r repair).2) |
| (c.cell.modification_cards b r repair).2 |
| (c.cell.switch_conservation b r repair hr hinc) |
| |
| def errorZeroEncoding (b : Bool) (repair : Fin 4 → E) (hr : c.cell.Repairs b repair) : |
| DemandEncoding inc d := |
| c.encode hinc (c.cell.orientation b) (c.cell.guide b repair) |
| (c.cell.orientation_matching b) (c.cell.guide_matching b repair hr) |
| (c.cell.additions b b repair) (c.cell.drops b) |
| (by rw [← (c.cell.modification_cards b b repair).1]; exact (c.cell.modification_cards b b repair).2) |
| (c.cell.modification_cards b b repair).2 |
| (c.cell.guide_conservation b repair hr hinc) |
| |
| def errorOneEncoding (b : Bool) (repair : Fin 4 → E) (hr : c.cell.Repairs b repair) |
| (Y : Fin 4) (hY : CellPaths.sideBit Y = b) : DemandEncoding inc d := |
| c.encode hinc (c.cell.contextOne b Y) (c.cell.guideOne b repair Y) |
| (c.cell.context_one_properties b repair hr Y hY hinc).1 |
| (c.cell.context_one_properties b repair hr Y hY hinc).2.1 |
| (c.cell.additions b b repair) (c.cell.drops b) |
| (by rw [← (c.cell.modification_cards b b repair).1]; exact (c.cell.modification_cards b b repair).2) |
| (c.cell.modification_cards b b repair).2 (by |
| rw [(c.cell.context_one_properties b repair hr Y hY hinc).2.2] |
| exact c.cell.guide_conservation b repair hr hinc) |
| |
| lemma zero_guide_contains (b : Bool) (repair : Fin 4 → E) (hr : c.cell.Repairs b repair) |
| (X : Fin 4) (hX : CellPaths.sideBit X = b) : |
| (c.cell.side X).closed (c.cell.chord X) ⊆ |
| (c.errorZeroEncoding hinc b repair hr).second.val := by |
| intro e he |
| exact Finset.mem_union_right _ (c.cell.closed_subset_guide b repair X hX he) |
|
|
| lemma one_guide_contains (b : Bool) (repair : Fin 4 → E) (hr : c.cell.Repairs b repair) |
| (X Y : Fin 4) (hX : CellPaths.sideBit X = b) (hY : CellPaths.sideBit Y = b) |
| (hne : X ≠ Y) : |
| (c.cell.side X).closed (c.cell.chord X) ⊆ |
| (c.errorOneEncoding hinc b repair hr Y hY).second.val := by |
| intro e he |
| exact Finset.mem_union_right _ (c.cell.closed_subset_guide_one b repair X Y hX hY hne hinc he) |
|
|
| end EmbeddedCell |
|
|
| end |
|
|
| section |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] |
|
|
| variable {inc : E → V → Prop} |
|
|
| namespace IndexedCycle.Corners |
|
|
| variable {c : IndexedCycle inc} (k : c.Corners) |
|
|
| def rawDemand (M N : PM inc) (flags : Fin 64) : RawDemand inc := |
| ⟨M, N, c.edgeAt 0, (fun i => c.vertexAt (k.start i)), flags⟩ |
|
|
| noncomputable def embeddedPair (M N : PM inc) |
| (hU : ∀ i, c.edgeAt i ∈ M.val ∪ N.val) |
| (chord : Fin 4 → E) |
| (hc : ∀ i v, inc (chord i) v ↔ |
| v = (k.side i).vertex 0 ∨ v = (k.side i).vertex (k.side i).length) |
| (flags : Fin 64) : EmbeddedCell inc (k.rawDemand M N flags) := by |
| classical |
| let a : ℕ := if c.edgeAt 0 ∈ M.val then 0 else 1 |
| have ha : a < 2 := by dsimp [a]; split <;> omega |
| have hM : ∀ t, t % 2 = a → c.edgeAt t ∈ M.val := by |
| intro t ht |
| apply (c.cycle_edge_mem_parity M.property N.property hU t).mpr |
| dsimp [a] at ht |
| split_ifs at ht ⊢ <;> omega |
| have hN : ∀ t, t % 2 = 1-a → c.edgeAt t ∈ N.val := by |
| intro t ht |
| apply (c.cycle_edge_mem_complement M.property N.property hU t).mpr |
| rw [c.cycle_edge_mem_parity M.property N.property hU t] |
| dsimp [a] at ht |
| split_ifs at ht ⊢ <;> first | omega | tauto |
| have hb : decide (k.a₀ % 2 = 1-a) = !decide (k.a₀ % 2 = a) := by |
| by_cases h : k.a₀ % 2 = a |
| · have hn : k.a₀ % 2 ≠ 1-a := by omega |
| simp [h] |
| omega |
| · have hn : k.a₀ % 2 = 1-a := by omega |
| simp [hn] |
| omega |
| refine ⟨k.cellPaths chord hc, decide (k.a₀ % 2 = a), |
| k.cell_orientation_subset chord hc M.val a ha hM, ?_, ?_⟩ |
| · rw [← hb] |
| exact k.cell_orientation_subset chord hc N.val (1-a) (by omega) hN |
| · intro e he |
| rcases Finset.mem_union.mp he with he | he |
| · exact k.cell_orientation_reachable chord hc _ hU true e he |
| · exact k.cell_orientation_reachable chord hc _ hU false e he |
|
|
| end IndexedCycle.Corners |
|
|
| end |
|
|
| variable {V E : Type*} [Fintype V] |
|
|
| variable {inc : E → V → Prop} |
|
|
| noncomputable def matchingWeight (w : E → ℝ) (M : PM inc) : ℝ := ∏ e ∈ M.val, w e |
|
|
| lemma matchingWeight_pos (w : E → ℝ) (hw : ∀ e, 0 < w e) (M : PM inc) : |
| 0 < matchingWeight w M := Finset.prod_pos (fun e _ => hw e) |
|
|
| variable [Fintype E] |
|
|
| noncomputable def partition (w : E → ℝ) : ℝ := by |
| classical |
| exact ∑ M : PM inc, matchingWeight w M |
|
|
| lemma partition_pos (w : E → ℝ) (hw : ∀ e, 0 < w e) (M : PM inc) : |
| 0 < partition (inc := inc) w := by |
| classical |
| exact Finset.sum_pos' (fun A _ => le_of_lt (matchingWeight_pos w hw A)) |
| ⟨M, Finset.mem_univ _, matchingWeight_pos w hw M⟩ |
|
|
| noncomputable def gibbs (w : E → ℝ) (M : PM inc) : ℝ := |
| matchingWeight w M / partition (inc := inc) w |
|
|
| lemma gibbs_pos (w : E → ℝ) (hw : ∀ e, 0 < w e) (M : PM inc) : |
| 0 < gibbs w M := div_pos (matchingWeight_pos w hw M) (partition_pos w hw M) |
|
|
| lemma gibbs_sum (w : E → ℝ) (hw : ∀ e, 0 < w e) (M : PM inc) : |
| letI : Fintype (PM inc) := Fintype.ofFinite _ |
| ∑ A : PM inc, gibbs w A = 1 := by |
| classical |
| simp only [gibbs, ← Finset.sum_div] |
| have hp := ne_of_gt (partition_pos w hw M) |
| convert div_self hp using 1 |
| congr 1 |
| unfold partition |
| congr 1 |
| ext A |
| simp |
|
|
| end MatchingFPRAS.Transport |
|
|
| end OAI |
|
|
