| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Graphs.Cycle |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Transport |
| variable {V E : Type*} [Fintype V] [DecidableEq V] [DecidableEq E] |
| variable {inc : E → V → Prop} |
| namespace PatternCode |
|
|
| variable (x : PatternCode inc) |
|
|
| def through : Finset E := x.val.1 |
|
|
| def closed : Finset E := x.val.2 |
|
|
| def total : Finset E := x.through ∪ x.closed |
|
|
| noncomputable def ofPath (p : OddPath inc) (chord : E) (hlong : 3 ≤ p.length) |
| (hc : ∀ v, inc chord v ↔ v = p.vertex 0 ∨ v = p.vertex p.length) : PatternCode inc := |
| ⟨(p.through,p.closed chord),p.closedCycle chord hlong hc, |
| p.closedCycle_parity_zero chord hlong hc,p.closedCycle_parity_one chord hlong hc⟩ |
|
|
| omit [DecidableEq V] in |
| lemma activated {A B : Finset E} |
| (hA : MatchingOn inc A Finset.univ) (hB : MatchingOn inc B Finset.univ) |
| (hT : x.through ⊆ A) (hC : x.closed ⊆ B) : |
| x.total ∈ components (inc := inc) (A ∪ B) ∧ |
| A ∩ x.total = x.through ∧ B ∩ x.total = x.closed := by |
| obtain ⟨c,ht,hc⟩ := x.property |
| have heq : c.edgeSet = x.total := by |
| rw [c.edgeSet_eq_parity_union,ht,hc] |
| rfl |
| have hU : ∀ i, c.edgeAt i ∈ A ∪ B := by |
| intro i |
| have he := c.edgeAt_mem_edgeSet i |
| rw [heq] at he |
| rcases Finset.mem_union.mp he with he | he |
| · exact Finset.mem_union_left _ (hT he) |
| · exact Finset.mem_union_right _ (hC he) |
| have hz : c.edgeAt 0 ∈ A := hT (by change c.edgeAt 0 ∈ x.val.1; rw [← ht]; exact c.zero_mem_parity) |
| have hzn : c.edgeAt 0 ∉ B := fun hb => ((c.cycle_edge_mem_complement hA hB hU 0).mp hb) hz |
| have hUr : ∀ i, c.edgeAt i ∈ B ∪ A := by simpa only [Finset.union_comm] using hU |
| refine ⟨heq ▸ c.edgeSet_mem_components hA hB hU,?_,?_⟩ |
| · have h := c.inter_edgeSet_parity hA hB hU |
| simpa only [ite_eq_left hz,heq,ht,through] using h |
| · have h := c.inter_edgeSet_parity hB hA hUr |
| simpa only [ite_eq_right hzn,heq,hc,closed] using h |
|
|
| omit [DecidableEq V] in |
| lemma activated_injective {A B : Finset E} |
| (hA : MatchingOn inc A Finset.univ) (hB : MatchingOn inc B Finset.univ) : |
| Set.InjOn (fun x : PatternCode inc => x.total) |
| {x | x.through ⊆ A ∧ x.closed ⊆ B} := by |
| intro x hx y hy he |
| change x.total = y.total at he |
| have hxx := x.activated hA hB hx.1 hx.2 |
| have hyy := y.activated hA hB hy.1 hy.2 |
| apply Subtype.ext |
| apply Prod.ext |
| · change x.through = y.through |
| rw [← hxx.2.1,← hyy.2.1,he] |
| · change x.closed = y.closed |
| rw [← hxx.2.2,← hyy.2.2,he] |
|
|
| omit [DecidableEq V] in |
| lemma activated_derivative {A B : Finset E} |
| (hA : MatchingOn inc A Finset.univ) (hB : MatchingOn inc B Finset.univ) |
| (hT : x.through ⊆ A) (hC : x.closed ⊆ B) |
| (f g : Finset E → ℝ) : |
| (f ((A \ x.through) ∪ x.through) - f ((A \ x.through) ∪ x.closed)) - |
| (g ((B \ x.closed) ∪ x.through) - g ((B \ x.closed) ∪ x.closed)) = |
| (f A + g B) - (f (exchange A B x.total) + g (exchange B A x.total)) := by |
| have hx := x.activated hA hB hT hC |
| have hAT : A \ x.through = A \ x.total := by rw [← hx.2.1]; ext e; simp |
| have hBC : B \ x.closed = B \ x.total := by rw [← hx.2.2]; ext e; simp |
| rw [Finset.sdiff_union_of_subset hT,Finset.sdiff_union_of_subset hC,hAT,hBC] |
| simp only [exchange,hx.2.1,hx.2.2] |
| ring |
| |
| variable [Fintype E] |
| |
| noncomputable instance : Fintype (PatternCode inc) := Fintype.ofFinite _ |
|
|
| omit [DecidableEq V] in |
| theorem activated_sum_le {A B : Finset E} |
| (hA : MatchingOn inc A Finset.univ) (hB : MatchingOn inc B Finset.univ) |
| (f g : Finset E → ℝ) : |
| (∑ x : PatternCode inc, if x.through ⊆ A ∧ x.closed ⊆ B then |
| ((f ((A \ x.through) ∪ x.through) - f ((A \ x.through) ∪ x.closed)) - |
| (g ((B \ x.closed) ∪ x.through) - g ((B \ x.closed) ∪ x.closed)))^2 else 0) |
| ≤ ∑ S ∈ components (inc := inc) (A ∪ B), |
| ((f A + g B) - (f (exchange A B S) + g (exchange B A S)))^2 := by |
| classical |
| rw [← Finset.sum_filter] |
| let active : Finset (PatternCode inc) := Finset.univ.filter (fun x => x.through ⊆ A ∧ x.closed ⊆ B) |
| let cost : Finset E → ℝ := fun S => |
| ((f A + g B) - (f (exchange A B S) + g (exchange B A S)))^2 |
| change (∑ x ∈ active, _) ≤ ∑ S ∈ components (inc := inc) (A ∪ B), cost S |
| have hinj : Set.InjOn (fun x : PatternCode inc => x.total) (active : Set (PatternCode inc)) := by |
| intro x hx y hy h |
| exact activated_injective hA hB (Finset.mem_filter.mp hx).2 (Finset.mem_filter.mp hy).2 h |
| calc |
| _ = ∑ x ∈ active, cost x.total := by |
| apply Finset.sum_congr rfl |
| intro x hx |
| have hh := (Finset.mem_filter.mp hx).2 |
| rw [x.activated_derivative hA hB hh.1 hh.2 f g] |
| _ = ∑ S ∈ active.image (fun x => x.total), cost S := (Finset.sum_image hinj).symm |
| _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (by |
| intro S hS |
| obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hS |
| have hh := (Finset.mem_filter.mp hx).2 |
| exact (x.activated hA hB hh.1 hh.2).1) (fun S _ _ => sq_nonneg _) |
|
|
| end PatternCode |
|
|
| end MatchingFPRAS.Transport |
|
|
| namespace MatchingFPRAS.PairEnergy |
|
|
| open scoped BigOperators |
|
|
| structure Law (Ω : Type*) [Fintype Ω] where |
| weight : Ω → ℝ |
| nonneg : ∀ x, 0 ≤ weight x |
| total : ∑ x, weight x = 1 |
|
|
| variable {ι Ω Δ : Type*} [Fintype ι] [Fintype Ω] [Fintype Δ] |
|
|
| noncomputable def guideMass (π : Law Ω) (closed : ι → Finset Ω) (X : ι) : ℝ := |
| ∑ B ∈ closed X, π.weight B |
|
|
| noncomputable def guideMean (π : Law Ω) (closed : ι → Finset Ω) |
| (derivative : ι → Ω → ℝ) (X : ι) : ℝ := |
| (∑ B ∈ closed X, π.weight B * derivative X B) / guideMass π closed X |
|
|
| noncomputable def contextMass (ρ : Δ → ℝ) (arc : Δ → ι) (context : Δ → Ω) |
| (X : ι) (A : Ω) : ℝ := by |
| classical |
| exact ∑ d with arc d = X ∧ context d = A, ρ d |
|
|
| noncomputable def swapSum (π : Law Ω) (through closed : ι → Finset Ω) |
| (d₁ d₂ : ι → Ω → ℝ) : ℝ := |
| ∑ X, ∑ A ∈ through X, ∑ B ∈ closed X, |
| π.weight A * π.weight B * (d₁ X A - d₂ X B) ^ 2 |
|
|
| omit [Fintype Ω] in |
| lemma weighted_jensen (s : Finset Ω) (w b : Ω → ℝ) (a : ℝ) |
| (hw : ∀ i ∈ s, 0 ≤ w i) : |
| (∑ i ∈ s, w i) * (a - (∑ i ∈ s, w i * b i) / (∑ i ∈ s, w i)) ^ 2 ≤ |
| ∑ i ∈ s, w i * (a - b i) ^ 2 := by |
| have hm : 0 ≤ ∑ i ∈ s, w i := Finset.sum_nonneg hw |
| obtain hm0 | hmpos := hm.eq_or_lt |
| · rw [← hm0, zero_mul] |
| exact Finset.sum_nonneg fun i hi => mul_nonneg (hw i hi) (sq_nonneg _) |
| · have hc := Finset.sum_sq_le_sum_mul_sum_of_sq_le_mul s |
| (r := fun i => w i * (a - b i)) |
| (f := w) (g := fun i => w i * (a - b i) ^ 2) |
| hw (fun i hi => mul_nonneg (hw i hi) (sq_nonneg _)) |
| (fun i hi => by nlinarith [sq_nonneg (w i * (a - b i))]) |
| have heq : (∑ i ∈ s, w i * (a - b i)) = |
| (∑ i ∈ s, w i) * |
| (a - (∑ i ∈ s, w i * b i) / (∑ i ∈ s, w i)) := by |
| simp_rw [mul_sub, Finset.sum_sub_distrib, ← Finset.sum_mul] |
| rw [mul_div_cancel₀ _ (ne_of_gt hmpos)] |
| rw [heq, mul_pow] at hc |
| apply (mul_le_mul_iff_right₀ hmpos).mp |
| nlinarith [hc] |
|
|
| omit [Fintype Ω] in |
| lemma sum_contextMass (ρ : Δ → ℝ) (arc : Δ → ι) (context : Δ → Ω) |
| (through : ι → Finset Ω) (hcontext : ∀ d, context d ∈ through (arc d)) |
| (h : ι → Ω → ℝ) : |
| (∑ d, ρ d * h (arc d) (context d)) = |
| ∑ X, ∑ A ∈ through X, contextMass ρ arc context X A * h X A := by |
| classical |
| symm |
| simp only [contextMass, Finset.sum_mul] |
| calc |
| _ = ∑ X, ∑ A ∈ through X, |
| ∑ d with arc d = X ∧ context d = A, ρ d * h (arc d) (context d) := by |
| apply Finset.sum_congr rfl |
| intro X _ |
| apply Finset.sum_congr rfl |
| intro A _ |
| apply Finset.sum_congr rfl |
| intro d hd |
| obtain ⟨hX, hA⟩ := (Finset.mem_filter.mp hd).2 |
| rw [hX, hA] |
| _ = ∑ X, ∑ d with arc d = X, ρ d * h (arc d) (context d) := by |
| apply Finset.sum_congr rfl |
| intro X _ |
| have ht : ∀ d ∈ Finset.univ.filter (fun d => arc d = X), context d ∈ through X := by |
| intro d hd |
| simpa only [(Finset.mem_filter.mp hd).2] using hcontext d |
| simpa only [Finset.filter_filter] using |
| Finset.sum_fiberwise_of_maps_to ht (fun d => ρ d * h (arc d) (context d)) |
| _ = ∑ d, ρ d * h (arc d) (context d) := Finset.sum_fiberwise _ arc _ |
|
|
| omit [Fintype ι] in |
| lemma tagged_context_bound {Tag : Type*} [Fintype Tag] |
| (π : Law Ω) (closed : ι → Finset Ω) (ρ : Δ → ℝ) |
| (arc : Δ → ι) (context guide : Δ → Ω) (tag : Δ → Tag) (C : ℝ) |
| (hC : 0 ≤ C) |
| (hguide : ∀ d, guide d ∈ closed (arc d)) |
| (hinj : Function.Injective fun d => (context d, guide d, tag d)) |
| (hweight : ∀ d, ρ d ≤ C * π.weight (context d) * π.weight (guide d)) |
| (X : ι) (A : Ω) : |
| contextMass ρ arc context X A ≤ |
| (C * Fintype.card Tag) * π.weight A * guideMass π closed X := by |
| classical |
| let s : Finset Δ := Finset.univ.filter (fun d => arc d = X ∧ context d = A) |
| have hmaps : ∀ d ∈ s, guide d ∈ closed X := by |
| intro d hd |
| have hX := (Finset.mem_filter.mp hd).2.1 |
| simpa only [hX] using hguide d |
| have hfiber (B : Ω) : (s.filter (fun d => guide d = B)).card ≤ Fintype.card Tag := by |
| apply Finset.card_le_card_of_injOn tag (t := Finset.univ) |
| · intro d hd |
| exact Finset.mem_univ _ |
| · intro d hd e he heq |
| apply hinj |
| have hd' := (Finset.mem_filter.mp (Finset.mem_filter.mp hd).1).2 |
| have he' := (Finset.mem_filter.mp (Finset.mem_filter.mp he).1).2 |
| have hdB := (Finset.mem_filter.mp hd).2 |
| have heB := (Finset.mem_filter.mp he).2 |
| exact Prod.ext (hd'.2.trans he'.2.symm) (Prod.ext (hdB.trans heB.symm) heq) |
| change (∑ d ∈ s, ρ d) ≤ _ |
| rw [← Finset.sum_fiberwise_of_maps_to hmaps ρ] |
| calc |
| _ ≤ ∑ B ∈ closed X, (Fintype.card Tag : ℝ) * (C * π.weight A * π.weight B) := by |
| apply Finset.sum_le_sum |
| intro B hB |
| calc |
| _ ≤ ∑ d ∈ s with guide d = B, C * π.weight A * π.weight B := by |
| apply Finset.sum_le_sum |
| intro d hd |
| have hdA := (Finset.mem_filter.mp (Finset.mem_filter.mp hd).1).2.2 |
| have hdB := (Finset.mem_filter.mp hd).2 |
| simpa only [hdA, hdB] using hweight d |
| _ = ((s.filter (fun d => guide d = B)).card : ℝ) * |
| (C * π.weight A * π.weight B) := by simp |
| _ ≤ _ := mul_le_mul_of_nonneg_right (by exact_mod_cast hfiber B) |
| (mul_nonneg (mul_nonneg hC (π.nonneg A)) (π.nonneg B)) |
| _ = _ := by |
| simp only [guideMass, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro B hB |
| ring |
|
|
| theorem error_demand_load |
| (π : Law Ω) (through closed : ι → Finset Ω) (d₁ d₂ : ι → Ω → ℝ) |
| (ρ : Δ → ℝ) (arc : Δ → ι) (c₀ c₁ : Δ → Ω) (C : ℝ) |
| (hρ : ∀ d, 0 ≤ ρ d) (hC : 0 ≤ C) |
| (hc₀ : ∀ d, c₀ d ∈ through (arc d)) |
| (hc₁ : ∀ d, c₁ d ∈ through (arc d)) |
| (hm₀ : ∀ X A, contextMass ρ arc c₀ X A ≤ C * π.weight A * guideMass π closed X) |
| (hm₁ : ∀ X A, contextMass ρ arc c₁ X A ≤ C * π.weight A * guideMass π closed X) : |
| (∑ d, ρ d * (d₁ (arc d) (c₁ d) - d₁ (arc d) (c₀ d)) ^ 2) ≤ |
| 4 * C * swapSum π through closed d₁ d₂ := by |
| classical |
| let μ := guideMean π closed d₂ |
| have hcontext (c : Δ → Ω) (hc : ∀ d, c d ∈ through (arc d)) |
| (hm : ∀ X A, contextMass ρ arc c X A ≤ C * π.weight A * guideMass π closed X) : |
| (∑ d, ρ d * (d₁ (arc d) (c d) - μ (arc d)) ^ 2) ≤ |
| C * swapSum π through closed d₁ d₂ := by |
| rw [sum_contextMass ρ arc c through hc (fun X A => (d₁ X A - μ X) ^ 2)] |
| calc |
| _ ≤ ∑ X, ∑ A ∈ through X, |
| C * π.weight A * guideMass π closed X * (d₁ X A - μ X) ^ 2 := by |
| apply Finset.sum_le_sum |
| intro X _ |
| exact Finset.sum_le_sum fun A _ => |
| mul_le_mul_of_nonneg_right (hm X A) (sq_nonneg _) |
| _ ≤ ∑ X, ∑ A ∈ through X, C * π.weight A * |
| (∑ B ∈ closed X, π.weight B * (d₁ X A - d₂ X B) ^ 2) := by |
| apply Finset.sum_le_sum |
| intro X _ |
| apply Finset.sum_le_sum |
| intro A _ |
| have hj := weighted_jensen (closed X) π.weight (d₂ X) (d₁ X A) |
| (fun B _ => π.nonneg B) |
| change guideMass π closed X * (d₁ X A - μ X) ^ 2 ≤ _ at hj |
| convert mul_le_mul_of_nonneg_left hj (mul_nonneg hC (π.nonneg A)) using 1 |
| ring |
| _ = C * swapSum π through closed d₁ d₂ := by |
| simp only [swapSum, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro X _ |
| apply Finset.sum_congr rfl |
| intro A _ |
| apply Finset.sum_congr rfl |
| intro B _ |
| ring |
| have h₀ := hcontext c₀ hc₀ hm₀ |
| have h₁ := hcontext c₁ hc₁ hm₁ |
| calc |
| _ ≤ ∑ d, (2 * (ρ d * (d₁ (arc d) (c₁ d) - μ (arc d)) ^ 2) + |
| 2 * (ρ d * (d₁ (arc d) (c₀ d) - μ (arc d)) ^ 2)) := by |
| apply Finset.sum_le_sum |
| intro d _ |
| nlinarith [mul_nonneg (hρ d) |
| (sq_nonneg (d₁ (arc d) (c₁ d) + d₁ (arc d) (c₀ d) - 2 * μ (arc d)))] |
| _ = 2 * (∑ d, ρ d * (d₁ (arc d) (c₁ d) - μ (arc d)) ^ 2) + |
| 2 * (∑ d, ρ d * (d₁ (arc d) (c₀ d) - μ (arc d)) ^ 2) := by |
| rw [Finset.sum_add_distrib, ← Finset.mul_sum, ← Finset.mul_sum] |
| _ ≤ 4 * C * swapSum π through closed d₁ d₂ := by linarith |
|
|
| end MatchingFPRAS.PairEnergy |
|
|
| namespace MatchingFPRAS.Transport |
|
|
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] |
|
|
| variable {inc : E → V → Prop} |
|
|
| noncomputable instance instFintypePM : Fintype (PM inc) := Fintype.ofFinite _ |
|
|
| noncomputable def gibbsLaw (w : E → ℝ) (hw : ∀ e, 0 < w e) (M : PM inc) : |
| MatchingFPRAS.PairEnergy.Law (PM inc) where |
| weight := gibbs w |
| nonneg := fun A => le_of_lt (gibbs_pos w hw A) |
| total := gibbs_sum w hw M |
|
|
| namespace PatternCode |
|
|
| noncomputable def throughStates (x : PatternCode inc) : Finset (PM inc) := by |
| classical |
| exact Finset.univ.filter (fun A => x.through ⊆ A.val) |
|
|
| noncomputable def closedStates (x : PatternCode inc) : Finset (PM inc) := by |
| classical |
| exact Finset.univ.filter (fun A => x.closed ⊆ A.val) |
|
|
| omit [DecidableEq V] in |
| lemma mem_throughStates (x : PatternCode inc) (A : PM inc) : |
| A ∈ x.throughStates ↔ x.through ⊆ A.val := by |
| classical |
| simp [throughStates] |
|
|
| omit [DecidableEq V] in |
| lemma mem_closedStates (x : PatternCode inc) (A : PM inc) : |
| A ∈ x.closedStates ↔ x.closed ⊆ A.val := by |
| classical |
| simp [closedStates] |
|
|
| def firstDerivative (f : Finset E → ℝ) (x : PatternCode inc) (A : PM inc) : ℝ := |
| f A.val - f ((A.val \ x.through) ∪ x.closed) |
|
|
| def secondDerivative (g : Finset E → ℝ) (x : PatternCode inc) (B : PM inc) : ℝ := |
| g ((B.val \ x.closed) ∪ x.through) - g B.val |
|
|
| end PatternCode |
|
|
| end MatchingFPRAS.Transport |
|
|
| namespace MatchingFPRAS.Transport.CellDemands |
|
|
| variable {V L : Type*} [Fintype V] [DecidableEq V] [Fintype L] [DecidableEq L] |
|
|
| variable {bags : V → Finset L} {G : SimpleGraph L} |
|
|
| noncomputable local instance : Fintype (BagEdge bags) := Fintype.ofFinite _ |
|
|
| variable {hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b} |
|
|
| variable {hG : G.IsAcyclic} |
|
|
| namespace ErrorDemand |
|
|
| variable (e : ErrorDemand hbags hG) |
|
|
| omit [Fintype L] in |
| lemma X_long : 3 ≤ (e.demand.paths.side e.X).length := by |
| have hp := (e.demand.paths.side e.X).positive |
| have ho := (e.demand.paths.side e.X).odd |
| have hn := e.property e.X e.X_bit |
| change (e.demand.paths.side e.X).length ≠ 1 at hn |
| omega |
|
|
| noncomputable def pattern : PatternCode (BagEdge.Incident (bags := bags)) := |
| PatternCode.ofPath (e.demand.paths.side e.X) (e.demand.paths.chord e.X) e.X_long |
| (e.demand.paths.chord_incidence e.X) |
|
|
| variable (height : L → ℝ) (hheight : ∀ l, 0 < height l) |
|
|
| variable (hstep : ∀ a b, G.Adj a b → height a ≤ 2 * height b) |
|
|
| variable (D : ℝ) (hD : 1 ≤ D) (w : BagEdge bags → ℝ) |
|
|
| variable (hw : ∀ e, height e.color / D ≤ w e ∧ w e ≤ 3 * height e.color) |
|
|
| variable (lo hi : ℝ) (hlo : 0 < lo) (hlohi : lo ≤ hi) |
|
|
| noncomputable def choice (j : Bool) : DemandEncoding BagEdge.Incident e.raw := |
| if j then e.errorOne height hheight hstep D hD w hw lo hi hlo hlohi |
| else e.errorZero height hheight hstep D hD w hw lo hi hlo hlohi |
|
|
| lemma choice_spec (j : Bool) : |
| let enc := e.choice height hheight hstep D hD w hw lo hi hlo hlohi j |
| enc.first.val = e.demand.outside ∪ |
| (if j then e.demand.paths.contextOne e.bit e.Y else e.demand.paths.orientation e.bit) ∧ |
| e.pattern.closed ⊆ enc.second.val ∧ |
| gibbs (fun e => max lo (min hi (w e))) e.demand.1.1 * |
| gibbs (fun e => max lo (min hi (w e))) e.demand.1.2 ≤ |
| (1000*D)^4 * gibbs (fun e => max lo (min hi (w e))) enc.first * |
| gibbs (fun e => max lo (min hi (w e))) enc.second := by |
| have h := (e.exists_errors height hheight hstep D hD w hw lo hi hlo hlohi).choose_spec.choose_spec |
| change _ ∧ _ ∧ _ ∧ _ ∧ _ ∧ _ at h |
| cases j |
| · exact ⟨h.1,h.2.2.1,h.2.2.2.2.1⟩ |
| · exact ⟨h.2.1,h.2.2.2.1,h.2.2.2.2.2⟩ |
|
|
| lemma choice_injective (j : Bool) : Function.Injective (fun e : ErrorDemand hbags hG => |
| (e.choice height hheight hstep D hD w hw lo hi hlo hlohi j).finiteCode) := by |
| intro e f h |
| exact raw_injective (DemandEncoding.finiteCode_recovers _ _ h) |
|
|
| lemma choice_through (j : Bool) : |
| (e.choice height hheight hstep D hD w hw lo hi hlo hlohi j).first ∈ e.pattern.throughStates := by |
| apply (e.pattern.mem_throughStates _).mpr |
| rw [(e.choice_spec height hheight hstep D hD w hw lo hi hlo hlohi j).1] |
| change (e.demand.paths.side e.X).through ⊆ _ |
| apply Finset.Subset.trans _ (Finset.subset_union_right) |
| cases j |
| · exact e.demand.paths.through_subset_orientation e.bit e.X e.X_bit |
| · exact e.demand.paths.through_subset_contextOne e.bit e.X e.Y e.X_bit e.Y_bit e.X_ne_Y |
| BagEdge.exists_incident |
|
|
| theorem context_load (M : PM (BagEdge.Incident (bags := bags))) (j : Bool) |
| (X : PatternCode (BagEdge.Incident (bags := bags))) (A : PM BagEdge.Incident) : |
| let wt := fun e => max lo (min hi (w e)) |
| let π := gibbsLaw wt (fun _ => lt_of_lt_of_le hlo (le_max_left _ _)) M |
| let ρ := fun e : ErrorDemand hbags hG => gibbs wt e.demand.1.1 * gibbs wt e.demand.1.2 |
| let enc := fun e : ErrorDemand hbags hG => e.choice height hheight hstep D hD w hw lo hi hlo hlohi j |
| MatchingFPRAS.PairEnergy.contextMass ρ pattern (fun e => (enc e).first) X A ≤ |
| ((1000*D)^4 * Fintype.card (DemandTag (V := V) (E := BagEdge bags))) * |
| π.weight A * MatchingFPRAS.PairEnergy.guideMass π PatternCode.closedStates X := by |
| dsimp only |
| apply MatchingFPRAS.PairEnergy.tagged_context_bound |
| (guide := fun e => (e.choice height hheight hstep D hD w hw lo hi hlo hlohi j).second) |
| (tag := fun e => (e.choice height hheight hstep D hD w hw lo hi hlo hlohi j).tag) |
| · positivity |
| · intro e |
| exact (e.pattern.mem_closedStates _).mpr |
| (e.choice_spec height hheight hstep D hD w hw lo hi hlo hlohi j).2.1 |
| · exact choice_injective height hheight hstep D hD w hw lo hi hlo hlohi j |
| · intro e |
| exact (e.choice_spec height hheight hstep D hD w hw lo hi hlo hlohi j).2.2 |
|
|
| end ErrorDemand |
|
|
| end MatchingFPRAS.Transport.CellDemands |
|
|
| end OAI |
|
|
