| import Mathlib |
| import OAI.Computability.MinUncut.Games.Sampling |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
| namespace MinUncut.Outer |
| open MinUncut.Inner |
| attribute [local instance] Classical.propDecidable |
| variable {Name I : Type*} [Fintype I] |
|
|
| abbrev HintCoefficients (I : Type*) (q : ℕ) := |
| Fin q → (F₂ × ((I → F₂) × (I → Module.Dual F₂ Triple))) |
|
|
| def secondHints {q : ℕ} (V : I → SecondQuestion Name) (c : HintCoefficients I q) : |
| Fin q → Forms (SecondAlphabet V) := fun k => hintGenerator V (c k) |
|
|
| def firstHints {q : ℕ} (U : I → Equation Name) (hidden : I → Bool) (pos : I → Fin 3) |
| (c : HintCoefficients I q) : Fin q → Forms (FirstAlphabet U) := |
| fun k => formPullback (projection U hidden pos) (secondHints (secondQuestion U hidden pos) c k) |
|
|
| structure HintedStrategy (Name I : Type*) [Fintype I] (q : ℕ) where |
| first : (U : I → Equation Name) → (Fin q → Forms (FirstAlphabet U)) → FirstAlphabet U |
| second : (V : I → SecondQuestion Name) → (Fin q → Forms (SecondAlphabet V)) → SecondAlphabet V |
|
|
| def hintedWins {q : ℕ} (strategy : HintedStrategy Name I q) |
| (U : I → Equation Name) (hidden : I → Bool) (pos : I → Fin 3) |
| (c : HintCoefficients I q) : Prop := |
| projection U hidden pos (strategy.first U (firstHints U hidden pos c)) = |
| strategy.second (secondQuestion U hidden pos) (secondHints (secondQuestion U hidden pos) c) |
|
|
| def patch {X : Type*} (A : I → Prop) (background : I → X) (active : {i // A i} → X) : I → X := |
| fun i => if h : A i then active ⟨i,h⟩ else background i |
|
|
| omit [Fintype I] in |
| @[simp] lemma patch_active {X : Type*} (A : I → Prop) (background : I → X) |
| (active : {i // A i} → X) (i : {i // A i}) : patch A background active i = active i := by |
| simp [patch,i.property] |
|
|
| omit [Fintype I] in |
| @[simp] lemma patch_inactive {X : Type*} (A : I → Prop) (background : I → X) |
| (active : {i // A i} → X) (i : I) (hi : ¬A i) : patch A background active i = background i := by |
| simp [patch,hi] |
|
|
| omit [Fintype I] in |
| lemma patch_comp {X Y : Type*} (A : I → Prop) (background : I → X) |
| (active : {i // A i} → X) (f : X → Y) : |
| (fun i => f (patch A background active i)) = patch A (fun i => f (background i)) (fun i => f (active i)) := by |
| funext i |
| by_cases h : A i <;> simp [patch,h] |
|
|
| def slotZero (v : SecondQuestion Name) : Fin (secondSlotCount v) := |
| ⟨0,by cases v <;> exact Nat.zero_lt_succ _⟩ |
|
|
| def readBit (V : I → SecondQuestion Name) (a : SecondAlphabet V) (i : I) : F₂ := |
| a i (slotZero (V i)) |
|
|
| omit [Fintype I] in |
| lemma projection_hidden_bit (U : I → Equation Name) (hidden : I → Bool) (pos : I → Fin 3) |
| (a : FirstAlphabet U) (i : I) (hi : hidden i=true) : |
| readBit (secondQuestion U hidden pos) (projection U hidden pos a) i=(a i).val (pos i) := by |
| change (slotProjection (U i) (hidden i) (pos i) (a i)) |
| (slotZero (slotQuestion (U i) (hidden i) (pos i)))=_ |
| rw [hi] |
| rfl |
|
|
| lemma firstHints_position_independent {q : ℕ} (U : I → Equation Name) (hidden : I → Bool) |
| (pos pos' : I → Fin 3) (c : HintCoefficients I q) |
| (h : ∀ k j, hidden j=true → pos j≠pos' j → (c k).2.1 j=0) : |
| firstHints U hidden pos c=firstHints U hidden pos' c := by |
| funext k |
| exact pulledHint_independent_active U hidden pos pos' _ _ _ (h k) |
|
|
| lemma ordinary_accepts_of_valid_coordinate (E : Equation Name) (a : alphabet E) |
| (p : Fin 3) (b : F₂) (he : a.val p=b) : |
| ordinaryAccepts E (E.names p) a.val b=true := by |
| apply decide_eq_true |
| refine ⟨a.property,?_⟩ |
| intro p' hp' |
| exact (a.property.2 p' p hp').trans he |
|
|
| omit [Fintype I] in |
|
|
| lemma secondQuestion_patch (A : I → Prop) (hidden : I → Bool) |
| (hA : ∀ i, A i → hidden i=true) (bgU : I → Equation Name) (bgp : I → Fin 3) |
| (U : {i // A i} → Equation Name) (p : {i // A i} → Fin 3) : |
| secondQuestion (patch A bgU U) hidden (patch A bgp p) = |
| patch A (secondQuestion bgU hidden bgp) (fun i => Sum.inl ((U i).names (p i))) := by |
| funext i |
| by_cases hi : A i |
| · simp [patch,secondQuestion,slotQuestion,hA i hi,hi] |
| · simp [patch,secondQuestion,hi] |
|
|
| end MinUncut.Outer |
|
|
| namespace MinUncut.Outer |
| open MinUncut.Inner |
| attribute [local instance] Classical.propDecidable |
| variable {Name I : Type*} [Fintype I] |
|
|
| theorem active_simulation {q : ℕ} (strategy : HintedStrategy Name I q) |
| (A : I → Prop) (hidden : I → Bool) (hA : ∀ i, A i → hidden i=true) |
| (c : HintCoefficients I q) (hzero : ∀ k i, A i → (c k).2.1 i=0) |
| (bgU : I → Equation Name) (bgp : I → Fin 3) : |
| ∃ (a : ({i // A i} → Equation Name) → {i // A i} → Triple) |
| (b : ({i // A i} → Name) → {i // A i} → F₂), |
| ∀ (U : {i // A i} → Equation Name) (p : {i // A i} → Fin 3), |
| hintedWins strategy (patch A bgU U) hidden (patch A bgp p) c → |
| ∀ j, ordinaryAccepts (U j) ((U j).names (p j)) (a U j) |
| (b (fun i => (U i).names (p i)) j)=true := by |
| classical |
| let p₀ : I → Fin 3 := patch A bgp (fun _ => 0) |
| let first (U : {i // A i} → Equation Name) : FirstAlphabet (patch A bgU U) := |
| strategy.first (patch A bgU U) (firstHints (patch A bgU U) hidden p₀ c) |
| let V (y : {i // A i} → Name) : I → SecondQuestion Name := |
| patch A (secondQuestion bgU hidden bgp) (fun i => Sum.inl (y i)) |
| let second (y : {i // A i} → Name) : SecondAlphabet (V y) := |
| strategy.second (V y) (secondHints (V y) c) |
| let a := fun U (j : {i // A i}) => (first U j).val |
| let b := fun y (j : {i // A i}) => readBit (V y) (second y) j |
| refine ⟨a,b,?_⟩ |
| intro U p hwin j |
| have hints : firstHints (patch A bgU U) hidden (patch A bgp p) c = |
| firstHints (patch A bgU U) hidden p₀ c := by |
| apply firstHints_position_independent |
| intro k i _ hdiff |
| apply hzero k i |
| by_contra hi |
| exact hdiff (by simp [p₀,patch,hi]) |
| have hv : secondQuestion (patch A bgU U) hidden (patch A bgp p) = |
| V (fun i => (U i).names (p i)) := secondQuestion_patch A hidden hA bgU bgp U p |
| unfold hintedWins at hwin |
| rw [hints] at hwin |
| have hb := congrArg (fun z => |
| readBit (secondQuestion (patch A bgU U) hidden (patch A bgp p)) z j) hwin |
| rw [projection_hidden_bit _ _ _ _ _ (hA j j.property)] at hb |
| have hcoord : a U j (p j)=b (fun i => (U i).names (p i)) j := by |
| simp only [patch_active] at hb |
| rw [hv] at hb |
| exact hb |
| have hvalid : Valid (U j) (a U j) := by |
| have hv' : Valid (patch A bgU U j) (a U j) := (first U j).property |
| simpa only [patch_active] using hv' |
| apply decide_eq_true |
| refine ⟨hvalid,?_⟩ |
| intro p' hp' |
| exact (hvalid.2 p' (p j) hp').trans hcoord |
|
|
| end MinUncut.Outer |
|
|
| end |
|
|
| end OAI |
|
|
