| import Mathlib |
| import OAI.Computability.MinUncut.Search.SampleEnumeration |
| import OAI.Computability.MinUncut.Graphs.GraphOutput |
| import OAI.Computability.MinUncut.PCP.Hastad |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
| namespace MinUncut.SourceBridge |
| open MinUncut.Inner MinUncut.Outer |
| open MinUncutGames.Reduction |
| attribute [local instance] Classical.propDecidable |
|
|
| def boolField (b : Bool) : F₂ := if b then 1 else 0 |
|
|
| def fieldBool (x : F₂) : Bool := decide (x=1) |
|
|
| lemma boolField_fieldBool (x : F₂) : boolField (fieldBool x)=x := by |
| fin_cases x <;> rfl |
|
|
| lemma fieldBool_boolField (b : Bool) : fieldBool (boolField b)=b := by |
| cases b <;> rfl |
|
|
| def equation {N : Type} (e : CloneGap.Equation N) : Equation N := |
| ⟨![e.first,e.second,e.third],boolField e.rhs⟩ |
|
|
| lemma satisfied_equation {N : Type} (e : CloneGap.Equation N) (b : N → Bool) : |
| Satisfied (fun x => boolField (b x)) (equation e) ↔ CloneGap.satisfied e b=true := by |
| change boolField (b e.first)+boolField (b e.second)+boolField (b e.third)=boolField e.rhs ↔ |
| ((b e.first ^^ b e.second ^^ b e.third)==e.rhs)=true |
| cases e.rhs <;> cases b e.first <;> cases b e.second <;> cases b e.third <;> decide |
| |
| def equations (input : SourceEncoding.Input) (i : Fin input.equations.length) : |
| Equation (Fin input.«variables») := equation input.equations[i] |
|
|
| instance entriesNonempty (input : SourceEncoding.Input) : Nonempty (Fin input.equations.length) := |
| Fin.pos_iff_nonempty.mp (List.length_pos_iff.mpr input.nonempty) |
|
|
| lemma sum_list_count {A : Type*} (xs : List A) (f : A → Bool) : |
| (∑ i : Fin xs.length, if f xs[i] then (1:ℝ) else 0)=(xs.countP f:ℝ) := by |
| induction xs with |
| | nil => simp |
| | cons x xs ih => |
| simp only [List.length_cons] at * |
| rw [Fin.sum_univ_succ] |
| change (if f x then (1:ℝ) else 0)+(∑ i : Fin xs.length, if f xs[i] then (1:ℝ) else 0)=_ |
| rw [ih,List.countP_cons] |
| cases f x <;> simp [add_comm] |
| |
| lemma sum_satisfied (input : SourceEncoding.Input) (bits : Fin input.«variables» → Bool) : |
| (∑ i : Fin input.equations.length, |
| if Satisfied (fun x => boolField (bits x)) (equations input i) then (1:ℝ) else 0)= |
| (input.equations.countP (fun e => CloneGap.satisfied e bits):ℝ) := by |
| simp_rw [equations,satisfied_equation] |
| exact sum_list_count input.equations (fun e => CloneGap.satisfied e bits) |
|
|
| lemma fraction_eq (input : SourceEncoding.Input) (bits : Fin input.«variables» → Bool) : |
| equationFraction (equations input) (fun x => boolField (bits x))= |
| (MinUncutGames.Outer.HastadSource.success input bits:ℝ) := by |
| unfold equationFraction MinUncutGames.Outer.HastadSource.success |
| rw [sum_satisfied] |
| simp |
|
|
| lemma fraction_eq_assignment (input : SourceEncoding.Input) (s : Fin input.«variables» → F₂) : |
| equationFraction (equations input) s= |
| (MinUncutGames.Outer.HastadSource.success input (fun x => fieldBool (s x)):ℝ) := by |
| simpa only [boolField_fieldBool] using (fraction_eq input (fun x => fieldBool (s x))) |
|
|
| lemma source_sound {ξ : ℚ} (hξ : ξ≤1/2) (R : MinUncutGames.Outer.HastadSource.Reduction ξ) |
| (F : MinUncutGames.Foundations.Target.Formula) (hF : ¬F.Satisfiable) |
| (s : Fin (R.reduce F).«variables» → F₂) : |
| equationFraction (equations (R.reduce F)) s≤3/4 := by |
| rw [fraction_eq_assignment] |
| have hh : (MinUncutGames.Outer.HastadSource.success (R.reduce F) (fun x => fieldBool (s x)):ℝ)≤ |
| ((1+ξ)/2:ℚ) := Rat.cast_le.mpr (R.soundness F hF _) |
| have hξ' : (ξ:ℝ)≤1/2 := by |
| simpa only [Rat.cast_div,Rat.cast_one,Rat.cast_ofNat] using (Rat.cast_le.mpr hξ : (ξ:ℝ) ≤ ((1/2:ℚ):ℝ)) |
| push_cast at hh |
| linarith |
|
|
| lemma source_complete {ξ : ℚ} (R : MinUncutGames.Outer.HastadSource.Reduction ξ) |
| (F : MinUncutGames.Foundations.Target.Formula) (hF : F.Satisfiable) |
| (t : ℕ) (b : ℝ) (hξ : (t:ℝ)*(ξ:ℝ)≤b) : |
| ∃ s : Fin (R.reduce F).«variables» → F₂, |
| (t:ℝ)*(1-equationFraction (equations (R.reduce F)) s)≤b := by |
| obtain ⟨bits,hb⟩ := R.completeness F hF |
| refine ⟨fun x => boolField (bits x),?_⟩ |
| rw [fraction_eq] |
| have hb' : 1-(ξ:ℝ)≤(MinUncutGames.Outer.HastadSource.success (R.reduce F) bits:ℝ) := by exact_mod_cast hb |
| exact (mul_le_mul_of_nonneg_left (by linarith : |
| 1-(MinUncutGames.Outer.HastadSource.success (R.reduce F) bits:ℝ)≤(ξ:ℝ)) |
| (Nat.cast_nonneg t)).trans hξ |
|
|
| end MinUncut.SourceBridge |
|
|
| end |
| namespace MinUncut.Costed.SourceWords |
| open MinUncutGames.Reduction MinUncut.SourceBridge |
|
|
| lemma flatMap_word {N : ℕ} (xs : List (CloneGap.Equation (Fin N))) (i : ℕ) (hi : i<xs.length) (p : Fin 4) : |
| ((xs.flatMap SourceEncoding.equationWords).drop (4*i+p.val)).headI= |
| ((SourceEncoding.equationWords xs[i]).drop p.val).headI := by |
| induction xs generalizing i with |
| | nil => simp at hi |
| | cons e xs ih => |
| cases i with |
| | zero => |
| fin_cases p <;> simp [SourceEncoding.equationWords] |
| | succ i => |
| have hh : i<xs.length := by simpa using hi |
| have he : 4*(i+1)+p.val=(((4*i+p.val)+1)+1)+1+1 := by omega |
| rw [he] |
| simpa only [List.flatMap_cons,SourceEncoding.equationWords,List.cons_append, |
| List.nil_append,List.drop_succ_cons,List.getElem_cons_succ] using ih i hh |
|
|
| lemma input_word (input : SourceEncoding.Input) (i : Fin input.equations.length) (p : Fin 4) : |
| ((SourceEncoding.inputWords input).drop (2+4*i.val+p.val)).headI= |
| ((SourceEncoding.equationWords input.equations[i]).drop p.val).headI := by |
| have he : 2+4*i.val+p.val=(4*i.val+p.val)+1+1 := by omega |
| rw [he] |
| simpa only [SourceEncoding.inputWords,List.cons_append,List.nil_append,List.drop_succ_cons,Fin.getElem_fin] using |
| flatMap_word input.equations i.val i.isLt p |
|
|
| lemma input_name (input : SourceEncoding.Input) (i : Fin input.equations.length) (p : Fin 3) : |
| ((SourceEncoding.inputWords input).drop (2+4*i.val+p.val)).headI= |
| ((equations input i).names p).val := by |
| rw [input_word input i ⟨p.val,by omega⟩] |
| fin_cases p <;> rfl |
| |
| lemma input_rhs (input : SourceEncoding.Input) (i : Fin input.equations.length) : |
| ((SourceEncoding.inputWords input).drop (2+4*i.val+3)).headI=(equations input i).rhs.val := by |
| rw [input_word input i ⟨3,by decide⟩] |
| simp only [SourceEncoding.equationWords,List.drop_succ_cons,List.drop_zero,List.headI_cons, |
| equations,equation,boolField,Fin.getElem_fin] |
| cases input.equations[i.val].rhs <;> norm_num [ZMod.val_one_eq_one_mod] |
| |
| end MinUncut.Costed.SourceWords |
| |
| noncomputable section |
| open scoped BigOperators |
| namespace MinUncut.Outer.LocalTemplate |
| open MinUncut.Inner MinUncut.FiniteGaussian MinUncut.FiniteProof |
| attribute [local instance] Classical.propDecidable |
| |
| variable {I Name : Type*} |
|
|
| def width (h : Bool) : ℕ := if h then 1 else 3 |
| abbrev Alphabet (h : I → Bool) := (j : I) → Fin (width (h j)) → F₂ |
|
|
| lemma slot_width (U : I → Equation Name) (h : I → Bool) (pos : I → Fin 3) (j : I) : |
| secondSlotCount (secondQuestion U h pos j)=width (h j) := by |
| cases hh : h j <;> simp [secondQuestion,slotQuestion,hh,secondSlotCount,width] |
| |
| def alphabetEquiv (U : I → Equation Name) (h : I → Bool) (pos : I → Fin 3) : |
| SecondAlphabet (secondQuestion U h pos) ≃ₗ[F₂] Alphabet h where |
| toFun a j k := a j (Fin.cast (slot_width U h pos j).symm k) |
| invFun a j k := a j (Fin.cast (slot_width U h pos j) k) |
| left_inv a := by funext j k; simp |
| right_inv a := by funext j k; simp |
| map_add' _ _ := rfl |
| map_smul' _ _ := rfl |
|
|
| section Transport |
| variable {V A W B : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] |
| [AddCommGroup W] [Module F₂ W] [AddTorsor W B] {m n : ℕ} |
|
|
| def formsPull (e : A ≃ᵃ[F₂] B) : Forms B ≃ Forms A := |
| e.symm.arrowCongrEquiv (AffineEquiv.refl F₂ F₂) |
|
|
| @[simp] lemma formsPull_apply (e : A ≃ᵃ[F₂] B) (f : Forms B) (a : A) : |
| formsPull e f a=f (e a) := rfl |
|
|
| def facesPull (e : A ≃ᵃ[F₂] B) : FaceArray B m n ≃ FaceArray A m n := |
| Equiv.piCongrRight (fun _=>formsPull e) |
|
|
| lemma facesPull_eq (e : A ≃ᵃ[F₂] B) (C : FaceArray B m n) : |
| facesPull e C=pullbackFaces e.toAffineMap C := by |
| funext r |
| ext a |
| rfl |
|
|
| @[simp] lemma facesPull_label (e : A ≃ᵃ[F₂] B) (C : FaceArray B m n) (a : A) : |
| labelCode (facesPull e C) a=labelCode C (e a) := by |
| rw [facesPull_eq] |
| rfl |
|
|
| variable [Fintype A] [Fintype B] |
|
|
| def samplePull (e : A ≃ᵃ[F₂] B) (g : GridData) : |
| LocalSample B m n g ≃ LocalSample A m n g := |
| (facesPull e).prodCongr ((facesPull e).prodCongr (Equiv.refl _)) |
|
|
| lemma noiseWeight_pull (e : A ≃ᵃ[F₂] B) (a : ℚ) (C D : FaceArray B m n) (j : Test) : |
| noiseWeight a (facesPull e C) (facesPull e D) j=noiseWeight a C D j := by |
| cases j <;> try rfl |
| simp only [noiseWeight,RowNoise.rationalDensity] |
| apply Finset.prod_congr rfl |
| intro r _ |
| have hc : Fintype.card (Forms A)=Fintype.card (Forms B) := (Fintype.card_congr (formsPull e)).symm |
| have he : facesPull e D r=facesPull e C r ↔ D r=C r := (formsPull e).injective.eq_iff |
| simp only [RowNoise.rationalRowDensity,hc,he] |
|
|
| lemma localWeight_pull (e : A ≃ᵃ[F₂] B) (g : GridData) (a b : ℚ) (j : Test) |
| (p : LocalSample B m n g) : localWeight g a b j (samplePull e g p)=localWeight g a b j p := by |
| have hc : Fintype.card (FaceArray A m n)=Fintype.card (FaceArray B m n) := |
| (Fintype.card_congr (facesPull (m:=m) (n:=n) e)).symm |
| simp only [localWeight,samplePull,Equiv.prodCongr_apply,Prod.map,Equiv.refl_apply,hc,noiseWeight_pull] |
| end Transport |
|
|
| variable [Fintype I] {m n : ℕ} |
|
|
| def localSampleEquiv (U : I → Equation Name) (h : I → Bool) (pos : I → Fin 3) (g : GridData) : |
| LocalSample (Alphabet h) m n g ≃ LocalSample (SecondAlphabet (secondQuestion U h pos)) m n g := |
| samplePull (alphabetEquiv U h pos).toAffineEquiv g |
|
|
| lemma localSample_weight (U : I → Equation Name) (h : I → Bool) (pos : I → Fin 3) |
| (g : GridData) (a b : ℚ) (j : Test) (p : LocalSample (Alphabet h) m n g) : |
| localWeight g a b j (localSampleEquiv U h pos g p)=localWeight g a b j p := |
| localWeight_pull _ _ _ _ _ _ |
|
|
| end MinUncut.Outer.LocalTemplate |
|
|
| end |
| namespace MinUncut.Outer |
| open MinUncut.Inner MinUncut.FiniteGaussian MinUncut.FiniteProof OuterSmoothness |
| namespace SampleEnumeration |
|
|
| local instance bridgeCodeDecidableEq (m n : ℕ) : DecidableEq (Code m n) := codeEq m n |
|
|
| def testQuery {N t m n : ℕ} (U : Fin t → Equation (Fin N)) (h : Fin t → Bool) (pos : Fin t → Fin 3) |
| (B C : FaceArray (SecondAlphabet (secondQuestion U h pos)) m n) (z : Code m n) |
| (s : ScoreIndex m n → Bool) : Test → QueryDemand (A := FamilyAlphabet (Name := Fin N) (I := Fin t)) |
| | .first => comparison (.inr (secondQuestion U h pos)) (.inr (secondQuestion U h pos)) |
| (fun a => s (false,labelCode B a)) (fun a => s (true,labelCode B a)) |
| | .second => comparison (.inr (secondQuestion U h pos)) (.inr (secondQuestion U h pos)) |
| (fun a => s (true,labelCode B a)) (fun a => s (true,labelCode C a)) |
| | .third => comparison (.inr (secondQuestion U h pos)) (.inr (secondQuestion U h pos)) |
| (fun a => Function.update (fun z => s (true,z)) z true (labelCode B a)) |
| (fun a => Function.update (fun z => s (true,z)) z false (labelCode B a)) |
| | .fourth => comparison (.inl U) (.inr (secondQuestion U h pos)) |
| (fun a => s (true,labelCode (pullbackFaces (projection U h pos) C) a)) |
| (fun a => s (true,labelCode C a)) |
|
|
| lemma testQuery_eq {N t m n : ℕ} (U : Fin t → Equation (Fin N)) (h : Fin t → Bool) (pos : Fin t → Fin 3) |
| (B C : FaceArray (SecondAlphabet (secondQuestion U h pos)) m n) (z : Code m n) |
| (s : ScoreIndex m n → Bool) (j : Test) : testQuery U h pos B C z s j=Outer.testQuery U h pos B C z s j := by |
| cases j <;> try rfl |
| simp only [testQuery,Outer.testQuery,Function.update_apply] |
| apply congrArg₂ (comparison _ _) |
| · funext a |
| split_ifs <;> rfl |
| · funext a |
| split_ifs <;> rfl |
| |
| def hidden {s t k : ℕ} (o : OuterSample (Fin t) (Fin s) k) : Fin t → Bool := |
| fun j => decide (j∈o.1.val) |
|
|
| lemma hidden_eq {s t k : ℕ} (o : OuterSample (Fin t) (Fin s) k) : hidden o=sampleHidden o := by |
| funext j |
| simp [hidden,sampleHidden,hiddenSet] |
|
|
| def rawQuery {N s t k m n : ℕ} (eqs : Fin s → Equation (Fin N)) (g : GridData) (σ η : ℚ) |
| (o : OuterSample (Fin t) (Fin s) k) (j : Test) |
| (p : LocalSample (SecondAlphabet (secondQuestion (sampleFirst eqs o) (hidden o) o.2.2)) m n g) : |
| QueryDemand (A := FamilyAlphabet (Name := Fin N) (I := Fin t)) := |
| testQuery (sampleFirst eqs o) (hidden o) o.2.2 p.1 p.2.1 p.2.2.1 |
| (rationalScoreTable σ η (fun i => midpoint g.T g.L (p.2.2.2 i))) j |
|
|
| def query {N s t k m n : ℕ} (eqs : Fin s → Equation (Fin N)) (g : GridData) (σ η : ℚ) |
| (j : Test) (e : Elementary (I := Fin t) eqs k m n g) : |
| QueryDemand (A := FamilyAlphabet (Name := Fin N) (I := Fin t)) := |
| ((hidden_eq e.1) ▸ rawQuery eqs g σ η e.1 j) e.2 |
|
|
| lemma query_eq {N s t k m n : ℕ} (eqs : Fin s → Equation (Fin N)) (g : GridData) (σ η : ℚ) |
| (j : Test) (e : Elementary (I := Fin t) eqs k m n g) : |
| query eqs g σ η j e=elementaryQuery eqs g σ η j e := by |
| have helper (h h' : Fin t → Bool) (hh : h=h') : |
| (hh ▸ (fun p : LocalSample (SecondAlphabet (secondQuestion (sampleFirst eqs e.1) h e.1.2.2)) m n g => |
| testQuery (sampleFirst eqs e.1) h e.1.2.2 p.1 p.2.1 p.2.2.1 |
| (rationalScoreTable σ η (fun i => midpoint g.T g.L (p.2.2.2 i))) j))= |
| (fun p : LocalSample (SecondAlphabet (secondQuestion (sampleFirst eqs e.1) h' e.1.2.2)) m n g => |
| Outer.testQuery (sampleFirst eqs e.1) h' e.1.2.2 p.1 p.2.1 p.2.2.1 |
| (rationalScoreTable σ η (fun i => midpoint g.T g.L (p.2.2.2 i))) j) := by |
| cases hh |
| funext p |
| exact testQuery_eq _ _ _ _ _ _ _ _ |
| exact congrFun (helper _ _ (hidden_eq e.1)) e.2 |
|
|
| def demand {N s t k m n : ℕ} (eqs : Fin s → Equation (Fin N)) (g : GridData) (σ η : ℚ) |
| (e : AllElementary (I := Fin t) eqs k m n g) : PathRealization.Demand (FamilyVariable (Fin N) (Fin t)) := |
| (query eqs g σ η e.1 e.2).signed familyBase |
|
|
| lemma demand_eq {N s t k m n : ℕ} (eqs : Fin s → Equation (Fin N)) (g : GridData) (σ η : ℚ) |
| (e : AllElementary (I := Fin t) eqs k m n g) : |
| demand eqs g σ η e=allDemand eqs g σ η e := by |
| simp only [demand,allDemand,query_eq] |
|
|
| end SampleEnumeration |
| end MinUncut.Outer |
|
|
| noncomputable section |
| namespace MinUncut.Outer.LocalTemplate |
| open MinUncut.Inner MinUncut.FiniteProof |
| attribute [local instance] Classical.propDecidable |
| variable {Name I : Type*} |
|
|
| def projectSlot : (h : Bool) → Fin 3 → Triple → (Fin (width h) → F₂) |
| | false,_,x => x |
| | true,p,x => fun _=>x p |
|
|
| def project (h : I → Bool) (pos : I → Fin 3) (x : I → Triple) : Alphabet h := |
| fun j=>projectSlot (h j) (pos j) (x j) |
|
|
| def decode (h : I → Bool) (x : I → Triple) : Alphabet h := |
| project h (fun _=>0) x |
|
|
| def originTable (U : I → Equation Name) : I → Triple := fun j _=>(U j).rhs |
|
|
| lemma slotCount_width (E : Equation Name) (b : Bool) (p : Fin 3) : |
| secondSlotCount (slotQuestion E b p)=width b := by cases b <;> rfl |
| |
| lemma slotProjection_cast (E : Equation Name) (b : Bool) (p : Fin 3) (a : alphabet E) |
| (k : Fin (width b)) : |
| slotProjection E b p a (Fin.cast (slotCount_width E b p).symm k)=projectSlot b p a.val k := by |
| cases b <;> rfl |
| |
| lemma alphabetEquiv_projection (U : I → Equation Name) (h : I → Bool) (pos : I → Fin 3) |
| (a : FirstAlphabet U) : |
| alphabetEquiv U h pos (projection U h pos a)=project h pos (fun j=>(a j).val) := by |
| funext j k |
| exact slotProjection_cast (U j) (h j) (pos j) (a j) k |
|
|
| lemma alphabetEquiv_zero (U : I → Equation Name) (h : I → Bool) (pos : I → Fin 3) : |
| alphabetEquiv U h pos 0=0 := map_zero _ |
|
|
| variable {N t : ℕ} |
|
|
| lemma decodeSlot (b : Bool) (x : Triple) (k : Fin (width b)) |
| (hk : k.val<3) : x ⟨k.val,hk⟩=projectSlot b 0 x k := by |
| cases b |
| · rfl |
| · have he : k.val=0 := by have hi:=k.isLt; change k.val<1 at hi; omega |
| change x ⟨k.val,hk⟩=x 0 |
| congr 1 |
| exact Fin.ext he |
| |
| lemma alphabetEquiv_decode (U : Fin t → Equation (Fin N)) (h : Fin t → Bool) (pos : Fin t → Fin 3) |
| (x : Fin t → Triple) : |
| alphabetEquiv U h pos (decodeSecond (secondQuestion U h pos) x)=decode h x := by |
| funext j k |
| exact decodeSlot (h j) (x j) k _ |
|
|
| lemma extend_second_rep (U : Fin t → Equation (Fin N)) (h : Fin t → Bool) (pos : Fin t → Fin 3) |
| (P : Alphabet h → Bool) : |
| extendTable (.inr (secondQuestion U h pos)) |
| (rep (familyBase (.inr (secondQuestion U h pos))) (fun a=>P (alphabetEquiv U h pos a))).val = |
| (fun x=>P 0 == P (decode h x)) := by |
| funext x |
| simp only [extendTable,decodeAlphabet,rep,familyBase] |
| change (P (alphabetEquiv U h pos 0) == |
| P (alphabetEquiv U h pos (decodeSecond (secondQuestion U h pos) x)))=_ |
| rw [alphabetEquiv_zero,alphabetEquiv_decode] |
|
|
| lemma extend_first_rep (U : Fin t → Equation (Fin N)) (h : Fin t → Bool) (pos : Fin t → Fin 3) |
| (P : Alphabet h → Bool) : |
| extendTable (.inl U) |
| (rep (familyBase (.inl U)) (fun a=>P (alphabetEquiv U h pos (projection U h pos a)))).val = |
| (fun x=>if ∀j,Valid (U j) (x j) then |
| P (project h pos (originTable U)) == P (project h pos x) else false) := by |
| funext x |
| simp only [extendTable,decodeAlphabet] |
| by_cases hx : ∀j,Valid (U j) (x j) |
| · simp only [decodeFirst,dite_eq_left hx,ite_eq_left hx, |
| rep,familyBase,alphabetEquiv_projection] |
| exact congrArg (fun a => P (project h pos (originTable U)) == P a) |
| (alphabetEquiv_projection U h pos (fun j => ⟨x j,hx j⟩)) |
| · simp only [decodeFirst,dite_eq_right hx,ite_eq_right hx] |
| rfl |
|
|
| lemma first_base (U : Fin t → Equation (Fin N)) (h : Fin t → Bool) (pos : Fin t → Fin 3) |
| (P : Alphabet h → Bool) : |
| P (alphabetEquiv U h pos (projection U h pos (familyBase (.inl U))))= |
| P (project h pos (originTable U)) := by |
| exact congrArg P (alphabetEquiv_projection U h pos (familyBase (.inl U))) |
|
|
| lemma second_base (U : Fin t → Equation (Fin N)) (h : Fin t → Bool) (pos : Fin t → Fin 3) |
| (P : Alphabet h → Bool) : |
| P (alphabetEquiv U h pos (familyBase (.inr (secondQuestion U h pos))))=P 0 := by |
| exact congrArg P (alphabetEquiv_zero U h pos) |
|
|
| open scoped BigOperators |
| open MinUncut.Inner MinUncut.FiniteGaussian MinUncut.FiniteProof OuterSmoothness |
| attribute [local instance] Classical.propDecidable |
| variable {Name I S : Type} [Fintype I] [Fintype S] {k m n : ℕ} {g : GridData} |
|
|
| abbrev Index (I : Type) [Fintype I] (k m n : ℕ) (g : GridData) := |
| Test × Σ H : FixedSets I k, (I → Fin 3) × LocalSample (Alphabet (hiddenSet H.val)) m n g |
|
|
| instance indexFintype : Fintype (Index I k m n g) := by unfold Index; infer_instance |
| |
| def occurrence (eqs : S → Equation Name) : ((I → S) × Index I k m n g) ≃ AllElementary (I := I) eqs k m n g where |
| toFun p := (p.2.1,⟨(p.2.2.1,p.1,p.2.2.2.1), |
| localSampleEquiv (fun i=>eqs (p.1 i)) (hiddenSet p.2.2.1.val) p.2.2.2.1 g p.2.2.2.2⟩) |
| invFun p := (p.2.1.2.1,p.1,⟨p.2.1.1,p.2.1.2.2, |
| (localSampleEquiv (sampleFirst eqs p.2.1) (sampleHidden p.2.1) p.2.1.2.2 g).symm p.2.2⟩) |
| left_inv p := by |
| rcases p with ⟨u,j,H,pos,p⟩ |
| simp only [localSampleEquiv] |
| rfl |
| right_inv p := by |
| rcases p with ⟨j,⟨⟨H,u,pos⟩,p⟩⟩ |
| simp only [localSampleEquiv] |
| rfl |
|
|
| def weight (a : ℚ) (b : Test → ℚ) (e : Index I k m n g) : ℚ := |
| localWeight g a (b e.1) e.1 e.2.2.2 |
|
|
| def repetitions (a : ℚ) (b : Test → ℚ) (e : Index I k m n g) : ℕ := |
| multiplicity (innerDenominator (Fintype.card I) m n g a b) (weight a b e) |
|
|
| lemma occurrence_weight (eqs : S → Equation Name) (a : ℚ) (b : Test → ℚ) |
| (u : I → S) (e : Index I k m n g) : |
| allWeight eqs g a b (occurrence eqs (u,e))= |
| (Fintype.card (OuterSample I S k):ℚ)⁻¹*weight a b e := by |
| change _*localWeight g a (b e.1) e.1 |
| (localSampleEquiv (fun i=>eqs (u i)) (hiddenSet e.2.1.val) e.2.2.1 g e.2.2.2)=_ |
| rw [localSample_weight] |
| rfl |
|
|
| lemma weight_nonneg (hT : 0<g.T) (hL : 0<g.L) {a : ℚ} (ha : 0≤a) (ha1 : a≤1) |
| (b : Test → ℚ) (hb : ∀j,0<b j) (e : Index I k m n g) : 0≤weight a b e := |
| localWeight_nonneg g hT hL ha ha1 (hb e.1) e.1 e.2.2.2 |
|
|
| omit [Fintype S] in |
| lemma weight_den (eqs : S → Equation Name) (u : I → S) (a : ℚ) (b : Test → ℚ) |
| (e : Index I k m n g) : (weight a b e).den ∣ innerDenominator (Fintype.card I) m n g a b := by |
| have hh := localWeight_den (secondQuestion (fun i=>eqs (u i)) (hiddenSet e.2.1.val) e.2.2.1) |
| g a b e.1 (localSampleEquiv (fun i=>eqs (u i)) (hiddenSet e.2.1.val) e.2.2.1 g e.2.2.2) |
| rw [localSample_weight] at hh |
| exact hh |
|
|
| lemma occurrence_multiplicity [Nonempty S] (eqs : S → Equation Name) (hk : k≤Fintype.card I) |
| (hT : 0<g.T) (hL : 0<g.L) {a : ℚ} (ha : 0≤a) (ha1 : a≤1) |
| (b : Test → ℚ) (hb : ∀j,0<b j) (u : I → S) (e : Index I k m n g) : |
| multiplicity (samplerDenominator I S k m n g a b) |
| (allWeight eqs g a b (occurrence eqs (u,e)))=repetitions a b e := by |
| let : Nonempty (FixedSets I k) := fixedSets_nonempty hk |
| have hc : (0:ℚ)<Fintype.card (OuterSample I S k) := by exact_mod_cast Fintype.card_pos |
| have hw := weight_nonneg hT hL ha ha1 b hb e |
| have he := occurrence_weight eqs a b u e |
| have hd := elementaryWeight_den eqs hk g a b e.1 (occurrence eqs (u,e)).2 |
| change (allWeight eqs g a b (occurrence eqs (u,e))).den ∣ _ at hd |
| apply Nat.cast_injective (R := ℚ) |
| rw [multiplicity_cast (by rw [he]; positivity) hd, repetitions, |
| multiplicity_cast hw (weight_den eqs u a b e),he] |
| simp only [samplerDenominator,Nat.cast_mul] |
| field_simp |
| |
| open MinUncut.Inner MinUncut.FiniteProof MinUncut.FiniteGaussian |
| attribute [local instance] Classical.propDecidable |
| variable {I Name : Type*} [Fintype I] {m n : ℕ} |
|
|
| structure Query (h : I → Bool) where |
| first : Bool |
| left : Alphabet h → Bool |
| right : Alphabet h → Bool |
|
|
| def query (h : I → Bool) (B C : FaceArray (Alphabet h) m n) (z : Code m n) |
| (s : ScoreIndex m n → Bool) : Test → Query h |
| | .first => ⟨false,(fun a=>s (false,labelCode B a)),(fun a=>s (true,labelCode B a))⟩ |
| | .second => ⟨false,(fun a=>s (true,labelCode B a)),(fun a=>s (true,labelCode C a))⟩ |
| | .third => ⟨false,(fun a=>Function.update (fun z=>s (true,z)) z true (labelCode B a)), |
| (fun a=>Function.update (fun z=>s (true,z)) z false (labelCode B a))⟩ |
| | .fourth => ⟨true,(fun a=>s (true,labelCode C a)),(fun a=>s (true,labelCode C a))⟩ |
|
|
| def Query.realize {h : I → Bool} (T : Query h) (U : I → Equation Name) (pos : I → Fin 3) : |
| QueryDemand (A := FamilyAlphabet (Name := Name) (I := I)) := |
| if T.first then |
| comparison (.inl U) (.inr (secondQuestion U h pos)) |
| (fun a=>T.left (alphabetEquiv U h pos (projection U h pos a))) |
| (fun a=>T.right (alphabetEquiv U h pos a)) |
| else |
| comparison (.inr (secondQuestion U h pos)) (.inr (secondQuestion U h pos)) |
| (fun a=>T.left (alphabetEquiv U h pos a)) |
| (fun a=>T.right (alphabetEquiv U h pos a)) |
|
|
| omit [Fintype I] in |
| lemma query_realize (U : I → Equation Name) (h : I → Bool) (pos : I → Fin 3) |
| (B C : FaceArray (Alphabet h) m n) (z : Code m n) (s : ScoreIndex m n → Bool) (j : Test) : |
| (query h B C z s j).realize U pos = |
| testQuery U h pos (facesPull (alphabetEquiv U h pos).toAffineEquiv B) |
| (facesPull (alphabetEquiv U h pos).toAffineEquiv C) z s j := by |
| cases j <;> simp only [query,Query.realize,Bool.false_eq_true,ite_false,ite_true,testQuery] |
| all_goals apply congrArg₂ (comparison _ _) |
| all_goals funext a |
| all_goals rfl |
| |
| structure Signature (I : Type*) where |
| rhs : I → F₂ |
| same : I → Fin 3 → Fin 3 → Bool |
|
|
| def signature (U : I → Equation Name) : Signature I := |
| ⟨fun i=>(U i).rhs,fun i p q=>decide ((U i).names p=(U i).names q)⟩ |
|
|
| def Signature.Valid (s : Signature I) (x : I → Triple) : Prop := |
| ∀i, parity (x i)=s.rhs i ∧ ∀p q,s.same i p q=true → x i p=x i q |
|
|
| def Signature.origin (s : Signature I) : I → Triple := fun i _=>s.rhs i |
|
|
| omit [Fintype I] in |
| lemma signature_valid (U : I → Equation Name) (x : I → Triple) : |
| (signature U).Valid x ↔ ∀i,Valid (U i) (x i) := by |
| simp only [Signature.Valid,signature,Valid,decide_eq_true_eq] |
| omit [Fintype I] in |
| lemma signature_origin (U : I → Equation Name) : (signature U).origin=originTable U := rfl |
|
|
| variable {N t : ℕ} |
|
|
| def Query.leftBase {h : Fin t → Bool} (T : Query h) (pos : Fin t → Fin 3) (s : Signature (Fin t)) : Bool := |
| if T.first then T.left (project h pos s.origin) else T.left 0 |
|
|
| def Query.leftTable {h : Fin t → Bool} (T : Query h) (pos : Fin t → Fin 3) |
| (s : Signature (Fin t)) : (Fin t → Triple) → Bool := |
| if T.first then fun x=>if s.Valid x then T.leftBase pos s == T.left (project h pos x) else false |
| else fun x=>T.left 0 == T.left (decode h x) |
|
|
| def Query.rightTable {h : Fin t → Bool} (T : Query h) : (Fin t → Triple) → Bool := |
| fun x=>T.right 0 == T.right (decode h x) |
|
|
| def Query.localSign {h : Fin t → Bool} (T : Query h) (pos : Fin t → Fin 3) (s : Signature (Fin t)) : Bool := |
| T.leftBase pos s == T.right 0 |
|
|
| lemma Query.left_extended {h : Fin t → Bool} (T : Query h) (U : Fin t → Equation (Fin N)) |
| (pos : Fin t → Fin 3) : |
| extendTable (T.realize U pos).left.1 (rep (familyBase (T.realize U pos).left.1) |
| (T.realize U pos).left.2).val = T.leftTable pos (signature U) := by |
| rcases T with ⟨first,left,right⟩ |
| cases first |
| · exact extend_second_rep U h pos left |
| · change extendTable (.inl U) (rep (familyBase (.inl U)) |
| (fun a=>left (alphabetEquiv U h pos (projection U h pos a)))).val = |
| (fun x=>if (signature U).Valid x then |
| left (project h pos (signature U).origin) == left (project h pos x) else false) |
| simp_rw [signature_valid] |
| exact extend_first_rep U h pos left |
|
|
| lemma Query.right_extended {h : Fin t → Bool} (T : Query h) (U : Fin t → Equation (Fin N)) |
| (pos : Fin t → Fin 3) : |
| extendTable (T.realize U pos).right.1 (rep (familyBase (T.realize U pos).right.1) |
| (T.realize U pos).right.2).val = T.rightTable := by |
| rcases T with ⟨first,left,right⟩ |
| cases first <;> exact extend_second_rep U h pos right |
| |
| lemma Query.signed_equal {h : Fin t → Bool} (T : Query h) (U : Fin t → Equation (Fin N)) |
| (pos : Fin t → Fin 3) : |
| ((T.realize U pos).signed familyBase).equal=T.localSign pos (signature U) := by |
| rcases T with ⟨first,left,right⟩ |
| cases first |
| · change (left (alphabetEquiv U h pos (familyBase (.inr (secondQuestion U h pos)))) == |
| right (alphabetEquiv U h pos (familyBase (.inr (secondQuestion U h pos))))) = (left 0 == right 0) |
| rw [second_base U h pos left,second_base U h pos right] |
| · change (left (alphabetEquiv U h pos (projection U h pos (familyBase (.inl U)))) == |
| right (alphabetEquiv U h pos (familyBase (.inr (secondQuestion U h pos))))) = |
| (left (project h pos (signature U).origin) == right 0) |
| rw [first_base U h pos left,second_base U h pos right,signature_origin] |
|
|
| end MinUncut.Outer.LocalTemplate |
|
|
| end |
|
|
| end OAI |
|
|
