| import Mathlib |
| import OAI.Computability.MaxCut.Encoding.BitValue |
| import OAI.Computability.MaxCut.Estimates.Divides |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace OptimalMaxCut.CounterMachine.Expr |
| open scoped BigOperators |
| open Finset |
| attribute [local instance] Classical.propDecidable |
|
|
| def listSum {I : Type} (l : List I) (f : I → Expr) : Expr := |
| l.foldr (fun i s => .add (f i) s) (.const 0) |
| @[simp] theorem listSum_eval {I : Type} (l : List I) (f : I → Expr) |
| (input : List Bool) (args : ℕ → ℕ) : |
| (listSum l f).eval input args = (l.map (fun i => (f i).eval input args)).sum := by |
| induction l with |
| | nil => rfl |
| | cons i l ih => |
| change (f i).eval input args + (listSum l f).eval input args = _ |
| simp [ih] |
|
|
| noncomputable def finiteSum {I : Type} [Fintype I] (f : I → Expr) : Expr := |
| listSum Finset.univ.toList f |
| @[simp] theorem finiteSum_eval {I : Type} [Fintype I] (f : I → Expr) |
| (input : List Bool) (args : ℕ → ℕ) : |
| (finiteSum f).eval input args = ∑ i, (f i).eval input args := by |
| simp [finiteSum] |
|
|
| /-- First successful bounded index. All searches are expanded into finite |
| counter loops, so the certificate does not postulate a search operation. -/ |
| def least (bound predicate : Expr) : Expr := |
| .sum bound (.mul (.arg 0) (.mul (positive predicate) |
| (.zero (.sum (.arg 0) (positive (predicate.rename (fun |
| | 0 => 0 |
| | j+1 => j+2))))))) |
|
|
| theorem least_eval (bound predicate : Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (least bound predicate).eval input args = |
| ∑ i ∈ range (bound.eval input args), |
| if predicate.eval input (bind args i) ≠ 0 ∧ |
| ∀ j < i, predicate.eval input (bind args j) = 0 then i else 0 := by |
| have hb (i j : ℕ) : (fun k => bind (bind args i) j (match k with |
| | 0 => 0 |
| | k+1 => k+2)) = bind args j := by |
| funext k; cases k <;> rfl |
| simp only [least, eval, positive_eval, rename_eval, hb] |
| apply sum_congr rfl |
| intro i hi |
| have hz : (∑ j ∈ range i, |
| if predicate.eval input (bind args j) ≠ 0 then (1:ℕ) else 0) = 0 ↔ |
| ∀ j < i, predicate.eval input (bind args j)=0 := by |
| simp only [sum_eq_zero_iff_of_nonneg (fun _ _ => Nat.zero_le _), mem_range] |
| simp |
| change i * ((if predicate.eval input (bind args i) ≠ 0 then 1 else 0) * |
| (if (∑ j ∈ range i, if predicate.eval input (bind args j) ≠ 0 then (1:ℕ) else 0)=0 then 1 else 0)) = _ |
| simp only [hz] |
| rw [indicator_and] |
| split_ifs <;> simp |
|
|
| end OptimalMaxCut.CounterMachine.Expr |
|
|
| namespace OptimalMaxCut.CounterMachine.Expr |
| open scoped BigOperators |
| open Finset |
| attribute [local instance] Classical.propDecidable |
|
|
| theorem least_eq (bound predicate : Expr) (input : List Bool) (args : ℕ → ℕ) (k : ℕ) |
| (hk : k < bound.eval input args) |
| (hp : predicate.eval input (bind args k) ≠ 0) |
| (he : ∀ j < k, predicate.eval input (bind args j) = 0) : |
| (least bound predicate).eval input args = k := by |
| rw [least_eval, sum_eq_single_of_mem k (mem_range.mpr hk)] |
| · exact ite_eq_left ⟨hp, he⟩ |
| · intro j hj hne |
| by_cases h : j < k |
| · simp [he j h] |
| · have hkj : k < j := by omega |
| split_ifs with hgood |
| · exact False.elim (hp (hgood.2 k hkj)) |
| · rfl |
|
|
| end OptimalMaxCut.CounterMachine.Expr |
| namespace OptimalMaxCut.CounterMachine.Expr |
| open scoped BigOperators |
| open Finset |
| attribute [local instance] Classical.propDecidable |
|
|
| def Represented (f : List Bool → (ℕ → ℕ) → ℕ) : Prop := |
| ∃ e : Expr, ∀ input args, e.eval input args = f input args |
|
|
| namespace Represented |
| variable {f g h : List Bool → (ℕ → ℕ) → ℕ} |
| theorem const (n : ℕ) : Represented (fun _ _ => n) := ⟨.const n, by intros; rfl⟩ |
| theorem arg (k : ℕ) : Represented (fun _ a => a k) := ⟨.arg k, by intros; rfl⟩ |
| theorem word (hf : Represented f) : Represented (fun s a => wordValue s (f s a)) := by |
| obtain ⟨e,he⟩ := hf; exact ⟨Expr.word e, by intros; simp [he]⟩ |
| theorem add (hf : Represented f) (hg : Represented g) : Represented (fun s a => f s a+g s a) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg; exact ⟨.add e d, by intros; simp [eval,he,hd]⟩ |
| theorem sub (hf : Represented f) (hg : Represented g) : Represented (fun s a => f s a-g s a) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg; exact ⟨.sub e d, by intros; simp [eval,he,hd]⟩ |
| theorem mul (hf : Represented f) (hg : Represented g) : Represented (fun s a => f s a*g s a) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg; exact ⟨.mul e d, by intros; simp [eval,he,hd]⟩ |
| theorem div (hf : Represented f) (hg : Represented g) : Represented (fun s a => f s a/g s a) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg; exact ⟨quotient e d, by intros; simp [he,hd]⟩ |
| theorem mod (hf : Represented f) (hg : Represented g) : Represented (fun s a => f s a%g s a) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg; exact ⟨remainder e d, by intros; simp [he,hd]⟩ |
| theorem pow (hf : Represented f) (n : ℕ) : Represented (fun s a => f s a^n) := by |
| obtain ⟨e,he⟩ := hf; exact ⟨power e n, by intros; simp [he]⟩ |
| theorem eq (hf : Represented f) (hg : Represented g) : |
| Represented (fun s a => if f s a=g s a then 1 else 0) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg; exact ⟨equal e d, by intros; simp [he,hd]⟩ |
| theorem lt (hf : Represented f) (hg : Represented g) : |
| Represented (fun s a => if f s a<g s a then 1 else 0) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg; exact ⟨Expr.lt e d, by intros; simp [he,hd]⟩ |
| theorem cond (hf : Represented f) (hg : Represented g) (hh : Represented h) : |
| Represented (fun s a => if f s a ≠ 0 then g s a else h s a) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg; obtain ⟨c,hc⟩ := hh |
| exact ⟨Expr.cond e d c, by intros; simp [he,hd,hc]⟩ |
| theorem sum (hf : Represented f) (hg : Represented g) : |
| Represented (fun s a => ∑ i ∈ range (f s a), g s (bind a i)) := by |
| obtain ⟨e,he⟩ := hf; obtain ⟨d,hd⟩ := hg |
| exact ⟨.sum e d, by intros; simp [eval,he,hd]⟩ |
| theorem finiteSum {I : Type} [Fintype I] {f : I → List Bool → (ℕ → ℕ) → ℕ} |
| (hf : ∀ i, Represented (f i)) : Represented (fun s a => ∑ i, f i s a) := by |
| choose e he using hf |
| exact ⟨Expr.finiteSum e, by intros; simp [he]⟩ |
| theorem rename (hf : Represented f) (r : ℕ → ℕ) : |
| Represented (fun s a => f s (fun k => a (r k))) := by |
| obtain ⟨e,he⟩ := hf |
| exact ⟨e.rename r, by intros; simp [he]⟩ |
| theorem subst (hf : Represented f) {v : ℕ → List Bool → (ℕ → ℕ) → ℕ} |
| (hv : ∀ k, Represented (v k)) : Represented (fun s a => f s (fun k => v k s a)) := by |
| obtain ⟨e,he⟩ := hf; choose d hd using hv |
| exact ⟨e.subst d, by intros; simp [he,hd]⟩ |
| theorem congr (hf : Represented f) (h : ∀ s a, f s a=g s a) : Represented g := by |
| obtain ⟨e,he⟩ := hf; exact ⟨e, fun s a => (he s a).trans (h s a)⟩ |
| end Represented |
| end OptimalMaxCut.CounterMachine.Expr |
| namespace OptimalMaxCut.LongCode |
| open scoped BigOperators |
| open Finset MaxCutGames.Foundations.Hastad |
| open OptimalMaxCut.Unweighted |
| attribute [local instance] Classical.propDecidable |
|
|
| theorem roundedWeights_integer {I : Type} [Fintype I] {N : ℕ} |
| (p : Law I) (endpoints : I → Fin N × Fin N) (v0 : Fin N) |
| (P : ℕ) (hP : 0 < P) (u v : Fin N) : |
| roundedWeights p endpoints v0 P hP u v = |
| if u=v then 0 else |
| ((∑ i : I, ((if endpoints i = (u,v) then ⌊(P:ℚ)*p.weight i⌋₊ else 0) + |
| (if endpoints i = (v,u) then ⌊(P:ℚ)*p.weight i⌋₊ else 0)) : ℕ) : ℚ) / P := by |
| by_cases huv : u=v |
| · simp [roundedWeights, aggregate, huv] |
| · simp only [roundedWeights, aggregate, huv, ↓reduceIte, Law.push, Fintype.sum_option, |
| Law.grid, Law.gridWeight] |
| have hn : (v0,v0) ≠ (u,v) := by rintro ⟨⟩; exact huv rfl |
| have hn' : (v0,v0) ≠ (v,u) := by rintro ⟨⟩; exact huv rfl |
| simp only [hn, hn', ↓reduceIte, zero_add, Nat.cast_sum, Nat.cast_add] |
| rw [Finset.sum_add_distrib, add_div, Finset.sum_div, Finset.sum_div] |
| congr 1 <;> (apply Finset.sum_congr rfl; intro i hi; split_ifs <;> simp) |
|
|
| namespace InstanceAdapter |
| variable {q : ℕ} |
|
|
| def degree (g : MaxCutGames.Foundations.Target.Instance q) (y : Fin g.vertices) : ℕ := |
| ∑ e : Fin g.constraints.length, if g.constraints[e].target = y then 1 else 0 |
|
|
| theorem degree_eq (g : MaxCutGames.Foundations.Target.Instance q) (y : Fin g.vertices) : |
| degree g y = Law.fiberSize (fun e : Fin g.constraints.length => g.constraints[e].target) y := by |
| let : Nonempty (Fin g.constraints.length) := Fin.pos_iff_nonempty.mp g.constraintCount_positive |
| simp only [degree, Law.fiberSize_eq_sum, Fin.getElem_fin] |
| apply Finset.sum_congr rfl |
| intro e he |
| split_ifs <;> simp_all |
|
|
| theorem sampleLaw_weight (g : MaxCutGames.Foundations.Target.Instance q) (t : ℚ) |
| (ht : t ∈ Set.Icc (-1:ℚ) 1) (y : Fin g.vertices) (e f : Fin g.constraints.length) |
| (x z : Cube (Fin q)) : |
| ((ofInstance g).sampleLaw t ht).weight (y,e,f,x,z) = |
| if g.constraints[e].target=y ∧ g.constraints[f].target=y then |
| (degree g y : ℚ) * (jointLaw t ht q).weight (x,z) / |
| ((g.constraints.length:ℚ)*(degree g y:ℚ)^2) |
| else 0 := by |
| let : Nonempty (Fin g.constraints.length) := Fin.pos_iff_nonempty.mp g.constraintCount_positive |
| simp only [Game.sampleLaw, Law.bind, ofInstance, Law.fiberMarginal, Law.fiberConditional, |
| Fintype.card_fin, ← degree_eq] |
| simp only [Fin.getElem_fin] at * |
| by_cases hd : degree g y = 0 |
| · simp [hd] |
| · have hdQ : (degree g y:ℚ) ≠ 0 := by exact_mod_cast hd |
| by_cases he : g.constraints[e.val].target=y <;> by_cases hf : g.constraints[f.val].target=y <;> |
| simp [hd,he,hf] ; field_simp |
|
|
| end InstanceAdapter |
| end OptimalMaxCut.LongCode |
| namespace OptimalMaxCut.LongCode.InstanceAdapter |
| open scoped BigOperators |
| open Finset MaxCutGames.Foundations.Target MaxCutGames.Foundations.Hastad |
| open CounterMachine.Expr |
| attribute [local instance] Classical.propDecidable |
|
|
| /-- Exact unary game codec used by the supplied binary reduction. -/ |
| def rowWords {n q : ℕ} (c : Constraint n q) : List ℕ := |
| [c.source.val,c.target.val] ++ c.permutation.images.toList.map Fin.val |
| def words {q : ℕ} (g : Instance q) : List ℕ := |
| [g.vertices,q,g.constraints.length] ++ g.constraints.flatMap rowWords |
| def bits {q : ℕ} (g : Instance q) : List Bool := unaryWords (words g) |
|
|
| @[simp] theorem rowWords_length {n q : ℕ} (c : Constraint n q) : |
| (rowWords c).length = q+2 := by simp [rowWords] |
|
|
| theorem flatMap_getD {A B : Type} (l : List A) (f : A → List B) (d : B) (r : ℕ) |
| (hf : ∀ a ∈ l, (f a).length=r) (e : Fin l.length) (j : ℕ) (hj : j<r) : |
| ((l.flatMap f)[e.val*r+j]?).getD d = ((f l[e])[j]?).getD d := by |
| induction l with |
| | nil => exact e.elim0 |
| | cons a l ih => |
| rcases e with ⟨e,he⟩ |
| simp only [Fin.getElem_fin] at * |
| cases e with |
| | zero => simp only [List.flatMap_cons, zero_mul, zero_add, List.getElem_cons_zero] |
| rw [List.getElem?_append_left (by simpa [hf a (by simp)] using hj)] |
| | succ e => |
| have ha := hf a (by simp) |
| simp only [List.flatMap_cons, List.getElem_cons_succ] |
| rw [List.getElem?_append_right (by rw [ha]; nlinarith)] |
| have hx : (e+1)*r+j-(f a).length=e*r+j := by rw [ha, Nat.add_mul]; omega |
| rw [hx] |
| exact ih (fun b hb => hf b (by simp [hb])) ⟨e,by simpa using he⟩ |
|
|
| theorem word_header {q : ℕ} (g : Instance q) : |
| wordValue (bits g) 0 = g.vertices ∧ wordValue (bits g) 1 = q ∧ |
| wordValue (bits g) 2 = g.constraints.length := by |
| simp [bits,wordValue_encoded,words] |
|
|
| theorem word_row {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) |
| (j : ℕ) (hj : j<q+2) : |
| wordValue (bits g) (3+e.val*(q+2)+j) = ((rowWords g.constraints[e])[j]?).getD 0 := by |
| rw [bits, wordValue_encoded] |
| simp only [words, List.cons_append, List.nil_append] |
| have hx : 3+e.val*(q+2)+j = (e.val*(q+2)+j)+1+1+1 := by omega |
| rw [hx] |
| simp only [List.getElem?_cons_succ] |
| exact flatMap_getD g.constraints rowWords 0 (q+2) (by intros; simp) e j hj |
|
|
| theorem row_source {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) : |
| wordValue (bits g) (3+e.val*(q+2)) = g.constraints[e].source.val := by |
| simpa [rowWords] using word_row g e 0 (by omega) |
| theorem row_target {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) : |
| wordValue (bits g) (3+e.val*(q+2)+1) = g.constraints[e].target.val := by |
| simpa [rowWords] using word_row g e 1 (by omega) |
| theorem row_image {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) (i : Fin q) : |
| wordValue (bits g) (3+e.val*(q+2)+(2+i.val)) = g.constraints[e].permutation.images[i].val := by |
| have h := word_row g e (2+i.val) (by omega) |
| simpa [rowWords, Nat.add_comm 2] using h |
|
|
| end OptimalMaxCut.LongCode.InstanceAdapter |
| namespace OptimalMaxCut.CounterMachine.Expr.Represented |
| open scoped BigOperators |
| open Finset |
| attribute [local instance] Classical.propDecidable |
| variable {f g h j : List Bool → (ℕ → ℕ) → ℕ} |
| theorem iteEq (hf : Represented f) (hg : Represented g) (hh : Represented h) (hj : Represented j) : |
| Represented (fun s a => if f s a=g s a then h s a else j s a) := by |
| exact (cond (eq hf hg) hh hj).congr (by intros; split_ifs <;> simp_all) |
| theorem iteAndEq {v w : List Bool → (ℕ → ℕ) → ℕ} |
| (hf : Represented f) (hg : Represented g) (hh : Represented h) (hj : Represented j) |
| (hv : Represented v) (hw : Represented w) : |
| Represented (fun s a => if f s a=g s a ∧ h s a=j s a then v s a else w s a) := by |
| exact (cond ((eq hf hg).mul (eq hh hj)) hv hw).congr (by intros; split_ifs <;> simp_all) |
| theorem indicatorAnd {P Q : List Bool → (ℕ → ℕ) → Prop} |
| (hp : Represented (fun s a => if P s a then 1 else 0)) |
| (hq : Represented (fun s a => if Q s a then 1 else 0)) : |
| Represented (fun s a => if P s a ∧ Q s a then 1 else 0) := |
| (hp.mul hq).congr (fun _ _ => indicator_and _ _) |
| theorem iteProp {P : List Bool → (ℕ → ℕ) → Prop} |
| (hp : Represented (fun s a => if P s a then 1 else 0)) |
| (hh : Represented h) (hj : Represented j) : |
| Represented (fun s a => if P s a then h s a else j s a) := by |
| exact (cond hp hh hj).congr (by intros; split_ifs <;> simp_all) |
| theorem bounded {F : List Bool → (ℕ → ℕ) → ℕ → ℕ} |
| (hb : Represented f) |
| (hF : Represented (fun s a => F s (fun k => a (k+1)) (a 0))) : |
| Represented (fun s a => ∑ i ∈ range (f s a), F s a i) := by |
| exact (sum hb hF).congr (by intros; rfl) |
| end OptimalMaxCut.CounterMachine.Expr.Represented |
|
|
| namespace OptimalMaxCut.RawGrid |
| open scoped BigOperators |
| open Finset MaxCutGames.Foundations.Hastad |
| open CounterMachine.Expr LongCode |
| attribute [local instance] Classical.propDecidable |
|
|
| def vertices (s : List Bool) : ℕ := wordValue s 0 |
| def edges (s : List Bool) : ℕ := wordValue s 2 |
| def row (q : ℕ) (s : List Bool) (e j : ℕ) := wordValue s (3+e*(q+2)+j) |
| def degree (q : ℕ) (s : List Bool) (y : ℕ) := |
| ∑ e ∈ range (edges s), if row q s e 1=y then 1 else 0 |
| def lookup {q : ℕ} (x : Cube (Fin q)) (j : ℕ) : ℕ := |
| ∑ i : Fin q, if i.val=j then (finTwoEquiv.symm (x i)).val else 0 |
| def permCode {q : ℕ} (s : List Bool) (e : ℕ) (x : Cube (Fin q)) : ℕ := |
| ∑ i : Fin q, lookup x (row q s e (2+i.val)) * 2^i.val |
| def query {q : ℕ} (s : List Bool) (e : ℕ) (x : Cube (Fin q)) : ℕ := |
| permCode s e x+2^q*row q s e 0 |
| def gridSize (q K : ℕ) (s : List Bool) : ℕ := |
| (K+1)*(vertices s * (edges s * (edges s * (2^q*2^q)))+1) |
| def atom {q : ℕ} (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) |
| (s : List Bool) (y e f : ℕ) (x z : Cube (Fin q)) : ℕ := |
| if row q s e 1=y ∧ row q s f 1=y then |
| gridSize q K s*degree q s y*((jointLaw t ht q).weight (x,z)).num.toNat / |
| (((jointLaw t ht q).weight (x,z)).den*edges s*(degree q s y)^2) |
| else 0 |
|
|
| noncomputable def weights (q : ℕ) (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) |
| (s : List Bool) (u v : ℕ) : ℕ := |
| if u=v then 0 else |
| ∑ y ∈ range (vertices s), ∑ e ∈ range (edges s), ∑ f ∈ range (edges s), |
| ∑ x : Cube (Fin q), ∑ z : Cube (Fin q), |
| ((if query s e x=u ∧ query s f (antipode z)=v then atom t ht K s y e f x z else 0)+ |
| (if query s e x=v ∧ query s f (antipode z)=u then atom t ht K s y e f x z else 0)) |
|
|
| namespace Rep |
| open CounterMachine.Expr.Represented |
| variable {f g h : List Bool → (ℕ → ℕ) → ℕ} |
| theorem vertices : Represented (fun s _ => RawGrid.vertices s) := word (Represented.const 0) |
| theorem edges : Represented (fun s _ => RawGrid.edges s) := word (Represented.const 2) |
| theorem row (q : ℕ) (hf : Represented f) (hg : Represented g) : |
| Represented (fun s a => RawGrid.row q s (f s a) (g s a)) := |
| word (((Represented.const 3).add (hf.mul (Represented.const (q+2)))).add hg) |
| theorem degree (q : ℕ) (hy : Represented f) : Represented (fun s a => RawGrid.degree q s (f s a)) := by |
| apply bounded edges |
| exact eq (row q (Represented.arg 0) (Represented.const 1)) (hy.rename Nat.succ) |
| theorem lookup {q : ℕ} (x : Cube (Fin q)) (hj : Represented f) : |
| Represented (fun s a => RawGrid.lookup x (f s a)) := by |
| exact Represented.finiteSum (fun i => iteEq (Represented.const i.val) hj (Represented.const (finTwoEquiv.symm (x i)).val) (Represented.const 0)) |
| theorem permCode {q : ℕ} (x : Cube (Fin q)) (he : Represented f) : |
| Represented (fun s a => RawGrid.permCode s (f s a) x) := by |
| exact Represented.finiteSum (fun i => (lookup x (row q he (Represented.const (2+i.val)))).mul (Represented.const (2^i.val))) |
| theorem query {q : ℕ} (x : Cube (Fin q)) (he : Represented f) : |
| Represented (fun s a => RawGrid.query s (f s a) x) := |
| (permCode x he).add ((Represented.const (2^q)).mul (row q he (Represented.const 0))) |
| theorem gridSize (q K : ℕ) : Represented (fun s _ => RawGrid.gridSize q K s) := |
| (Represented.const (K+1)).mul ((vertices.mul (edges.mul (edges.mul (Represented.const (2^q*2^q))))).add (Represented.const 1)) |
| theorem atom {q : ℕ} (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) |
| (x z : Cube (Fin q)) (hy : Represented f) (he : Represented g) (hf : Represented h) : |
| Represented (fun s a => RawGrid.atom t ht K s (f s a) (g s a) (h s a) x z) := by |
| refine iteAndEq (row q he (Represented.const 1)) hy (row q hf (Represented.const 1)) hy ?_ (Represented.const 0) |
| exact ((gridSize q K).mul (degree q hy) |>.mul (Represented.const ((jointLaw t ht q).weight (x,z)).num.toNat)).div |
| (((Represented.const ((jointLaw t ht q).weight (x,z)).den).mul edges).mul ((degree q hy).pow 2)) |
|
|
| theorem weights (q : ℕ) (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) |
| (hu : Represented f) (hv : Represented g) : |
| Represented (fun s a => RawGrid.weights q t ht K s (f s a) (g s a)) := by |
| refine iteEq hu hv (Represented.const 0) ?_ |
| apply bounded vertices |
| apply bounded edges |
| apply bounded edges |
| apply Represented.finiteSum |
| intro x |
| apply Represented.finiteSum |
| intro z |
| let hu' := hu.rename (fun j => j+3) |
| let hv' := hv.rename (fun j => j+3) |
| have hA := atom t ht K x z (Represented.arg 2) (Represented.arg 1) (Represented.arg 0) |
| exact (iteAndEq (query x (Represented.arg 1)) hu' (query (antipode z) (Represented.arg 0)) hv' hA (Represented.const 0)).add |
| (iteAndEq (query x (Represented.arg 1)) hv' (query (antipode z) (Represented.arg 0)) hu' hA (Represented.const 0)) |
| end Rep |
| end OptimalMaxCut.RawGrid |
|
|
| end |
|
|
| end OAI |
|
|
