| import Mathlib |
| import OAI.Computability.DirectedFeedback.RankGraph.RoundBoolean |
| |
| namespace OAI |
|
|
| section |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical |
| noncomputable section |
| open scoped Classical |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| open DirectedFeedback.SourceProbability |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : ℕ} [NeZero M] [NeZero T] |
| omit [Fintype U] [Fintype X] [NeZero M] [NeZero T] [Nonempty X] in |
| theorem vertices_takePrefix {t : ℕ} (ht : t ≤ T) (a : PrefixData U X M T) : |
| vertices (takePrefix ht a) = takePrefix ht (vertices a) := rfl |
|
|
| variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| variable (deleted : OutputVertex (M := M) G ψLaw → Bool) |
| variable (ord : OutputVertex (M := M) G ψLaw → ℕ) |
| variable (hord : ∀ {a b}, deleted a = false → deleted b = false → |
| OutputArc G ψLaw hYX fiber a b → ord a < ord b) |
| variable (hrank : ∀ r, deleted (.inl r) = false) |
|
|
| def prefixBit (d : Full U X M T N) (t : ℕ) : Set (Fin t → X) → Bool := |
| if h : t ≤ T then referenceBit (rankOrder G ψLaw ord) d.1.val rankLength_ge |
| (.inl ⟨⟨t,by omega⟩,takePrefix h (vertices d.2)⟩) else fun _ => false |
|
|
| include hord hrank in |
| theorem prefixBit_properties (d : Full U X M T N) {t : ℕ} (ht : t ≤ T) : |
| prefixBit G ψLaw ord d t ∅ = false ∧ prefixBit G ψLaw ord d t Set.univ = true := by |
| simp only [prefixBit, dite_eq_left ht] |
| exact ⟨reference_empty rankLength_ge d.1.property |
| (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) _, |
| reference_univ rankLength_ge d.1.property |
| (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) _⟩ |
|
|
| def prefixTransition (d : Full U X M T N) (t : ℕ) : Fin (cellCount t) := |
| if h : t ≤ T then transition (prefixBit G ψLaw ord d t) (prefixCell t (sets d.2)) |
| (prefixBit_properties G ψLaw hYX fiber deleted ord hord hrank d h).1 |
| (prefixBit_properties G ψLaw hYX fiber deleted ord hord hrank d h).2 |
| else 0 |
|
|
| theorem prefixBit_lift (d : Full U X M T N) (t : ℕ) (ht : t < T) |
| (A : Set (Fin t → X)) : |
| prefixBit G ψLaw ord d (t+1) (Fin.init ⁻¹' A) = prefixBit G ψLaw ord d t A := by |
| simp only [prefixBit, dite_eq_left (show t+1 ≤ T by omega), dite_eq_left (show t ≤ T by omega), referenceBit] |
| exact (compare_prefix_big (ord := rankOrder G ψLaw ord) (ψ := d.1.val) |
| t ht (takePrefix (by omega) (vertices d.2)) A _ _ _).symm |
| |
| theorem full_membership (fallback : X) (d : Full U X M T N) |
| (hgood : Good (rankOrder G ψLaw ord) d.1.val rankLength_ge (fullWildcard (V := V) (Y := Y) d).tuple) |
| (a : Fin T → X) |
| (ha : cell d.2 a = prefixTransition G ψLaw hYX fiber deleted ord hord hrank d T) |
| (j : Fin T) : |
| (d.2 j).2.2 (a j) = bigFunction G ψLaw hYX fiber deleted ord hord hrank fallback |
| (d.1, ⟨j,takePrefix (Nat.le_of_lt j.isLt) d.2⟩) (d.2 j).1 (d.2 j).2.2 := by |
| let g := prefixBit G ψLaw ord d |
| let r := prefixTransition G ψLaw hYX fiber deleted ord hord hrank d |
| have hg (t : ℕ) (ht : t ≤ T) : Monotone (g t) := by |
| simp only [g, prefixBit, dite_eq_left ht] |
| exact good_monotone rankLength_ge d.1.property |
| (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) _ |
| (good_take_prefix _ _ rankLength_ge T le_rfl (vertices d.2) hgood t ht) |
| have hr (t : ℕ) (ht : t ≤ T) : Transition (g t) (prefixCell t (sets d.2)) (r t) := by |
| simp only [r, prefixTransition, dite_eq_left ht] |
| exact transition_spec _ _ _ _ |
| have hh := full_transition_membership g (sets d.2) r T hg |
| (prefixBit_lift G ψLaw ord d) hr a ha j |
| have hgood' : Good (rankOrder G ψLaw ord) d.1.val rankLength_ge |
| (.inl ⟨⟨j.val+1,by have := j.isLt; omega⟩, |
| Fin.snoc (vertices (takePrefix (Nat.le_of_lt j.isLt) d.2)) (d.2 j).1⟩) := by |
| convert good_take_prefix (rankOrder G ψLaw ord) d.1.val rankLength_ge T le_rfl |
| (vertices d.2) hgood (j.val+1) (by have := j.isLt; omega) using 1 |
| congr 2 |
| funext i |
| refine Fin.lastCases ?_ (fun k => ?_) i |
| · simp [vertices, takePrefix] |
| · simp [vertices, takePrefix] |
| have hvertices : takePrefix (by have := j.isLt; omega : j.val+1 ≤ T) (vertices d.2) = |
| Fin.snoc (vertices (takePrefix (Nat.le_of_lt j.isLt) d.2)) (d.2 j).1 := by |
| funext i |
| refine Fin.lastCases ?_ (fun k => ?_) i |
| · simp [vertices, takePrefix] |
| · simp [vertices, takePrefix] |
| simp only [vertices_takePrefix] at hvertices |
| have hgood'' := hgood' |
| simp only [vertices_takePrefix] at hgood'' |
| have hb (b : Bool) : decide (b = true) = b := by cases b <;> rfl |
| simp only [g, r, conditionedValue, stepFunction, prefixBit, |
| dite_eq_left (Nat.le_of_lt j.isLt), dite_eq_left (show j.val+1 ≤ T by have := j.isLt; omega), |
| prefixTransition, sets, dite_eq_left j.isLt, Set.mem_ofPred_eq, |
| hb, bigFunction, conditionedBig, normalizedCondition, ↓reduceIte, |
| bigStepBit, cell_takePrefix, vertices_takePrefix, hgood''] at hh ⊢ |
| rw [hvertices] at hh |
| exact hh |
| |
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : ℕ} [NeZero M] [NeZero T] |
| variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| variable (deleted : OutputVertex (M := M) G ψLaw → Bool) |
| variable (ord : OutputVertex (M := M) G ψLaw → ℕ) |
| variable (hord : ∀ {a b}, deleted a = false → deleted b = false → |
| OutputArc G ψLaw hYX fiber a b → ord a < ord b) |
| variable (hrank : ∀ r, deleted (.inl r) = false) |
| |
| def favorable (d : Full U X M T N) : Bool := decide ( |
| 0 < (fullLaw G ψLaw).weight d ∧ fullDeleted G ψLaw deleted d = false ∧ |
| Good (rankOrder G ψLaw ord) d.1.val rankLength_ge (fullWildcard (V := V) (Y := Y) d).tuple) |
| |
| def prefixValue (fallback : X) (ψ : Emb (rankLength X T) N) (t : ℕ) |
| (a : PrefixData U X M t) (u : U) (b : X → Bool) : ℝ := |
| if ht : t < T then |
| if bigFunction G ψLaw hYX fiber deleted ord hord hrank fallback (ψ,⟨⟨t,ht⟩,a⟩) u b |
| then 1 else 0 |
| else 0 |
| |
| theorem favorable_count (fallback : X) (d : Full U X M T N) |
| (hd : favorable G ψLaw deleted ord d = true) (i : Fin M) : |
| bias i * T / (2*M) ≤ count i (prefixValue G ψLaw hYX fiber deleted ord hord hrank fallback) |
| d.1 d.2 := by |
| obtain ⟨hpos,hkeep,hgood⟩ := of_decide_eq_true hd |
| have hk : deleted (.inr (.inl (.inl ⟨d,hpos⟩))) = false := by |
| simpa only [fullDeleted, extend, dite_eq_left hpos] using hkeep |
| obtain ⟨x,hx,hstar⟩ := full_unstarred G ψLaw hYX fiber deleted ord hord hrank ⟨d,hpos⟩ hk hgood |
| have hm (j : Fin T) := full_membership G ψLaw hYX fiber deleted ord hord hrank fallback d hgood x |
| (by simpa only [prefixTransition, prefixBit, dite_eq_left le_rfl, takePrefix_self, fullWildcard, cell] using hx) j |
| have he : count i (prefixValue G ψLaw hYX fiber deleted ord hord hrank fallback) d.1 d.2 = |
| (fullCount d.2 i x : ℝ) := by |
| simp only [count, fullCount, Finset.card_filter, Nat.cast_sum, Nat.cast_ite, |
| Nat.cast_one, Nat.cast_zero, prefixValue] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simp only [dite_eq_left j.isLt] |
| rw [← hm j] |
| by_cases hi : (d.2 j).2.1 = i <;> cases (d.2 j).2.2 (x j) <;> simp [hi] |
| rw [he] |
| exact not_lt.mp (fun h => hstar ⟨i,h⟩) |
| |
| theorem favorable_probability (D H ρ : ℝ) (hH : 0 < H) |
| (hcost : H * (fullLaw G ψLaw).probability (fullDeleted G ψLaw deleted) ≤ D) |
| (hbad : (fullLaw (M := M) G ψLaw).probability (fun d => decide (¬ |
| Good (rankOrder G ψLaw ord) d.1.val rankLength_ge |
| (fullWildcard (V := V) (Y := Y) d).tuple)) ≤ ρ) |
| (hnum : ρ + D/H ≤ 1/2) : |
| 1/2 ≤ (fullLaw G ψLaw).probability (favorable G ψLaw deleted ord) := by |
| have he := expectation_mono_support (fullLaw (M := M) G ψLaw) |
| (f := fun _ => (1:ℝ)) |
| (g := fun d => (if favorable G ψLaw deleted ord d then 1 else 0) + |
| (if fullDeleted G ψLaw deleted d then 1 else 0) + |
| (if decide (¬Good (rankOrder G ψLaw ord) d.1.val rankLength_ge |
| (fullWildcard (V := V) (Y := Y) d).tuple) then 1 else 0)) (by |
| intro d hp |
| by_cases hg : Good (rankOrder G ψLaw ord) d.1.val rankLength_ge |
| (fullWildcard (V := V) (Y := Y) d).tuple |
| <;> cases hk : fullDeleted G ψLaw deleted d <;> simp [favorable,hp,hg,hk]) |
| simp only [expectation_add, ← probability_eq_expect, expectation_const] at he |
| have hc : (fullLaw G ψLaw).probability (fullDeleted G ψLaw deleted) ≤ D/H := |
| (le_div_iff₀ hH).mpr (by simpa [mul_comm] using hcost) |
| linarith |
| |
| theorem full_acceptance (fallback : X) |
| (hprob : 1/2 ≤ (fullLaw G ψLaw).probability (favorable G ψLaw deleted ord)) (i : Fin M) : |
| bias i / 4 ≤ (common (M := M) G ψLaw).expectation (fun d => |
| (bigMarginal G).expectation (fun u => (subsetLaw i).probability |
| (bigFunction G ψLaw hYX fiber deleted ord hord hrank fallback d u))) := by |
| have hh := acceptance_lower_bound ψLaw (bigMarginal G) subsetLaw i T |
| (prefixValue G ψLaw hYX fiber deleted ord hord hrank fallback) (bias i) (bias_pos i).le |
| (favorable G ψLaw deleted ord) |
| (by intro ψ t a u b; unfold prefixValue; split_ifs <;> norm_num) |
| hprob (fun d hd => by |
| simpa only [Fintype.card_fin] using |
| (favorable_count G ψLaw hYX fiber deleted ord hord hrank fallback d hd i)) |
| apply hh.trans_eq |
| apply expectation_congr |
| intro d |
| change (bigMarginal G).expectation (fun u => |
| (subsetLaw i).expectation (prefixValue G ψLaw hYX fiber deleted ord hord hrank fallback |
| d.1 d.2.1.val d.2.2 u)) = _ |
| apply expectation_congr |
| intro u |
| rw [probability_eq_expect] |
| apply expectation_congr |
| intro b |
| simp only [prefixValue, dite_eq_left d.2.1.isLt] |
| |
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped BigOperators |
| namespace DirectedFeedback.Ranks |
| |
| def Homogeneous {C : Type*} (r : ℕ) (color : Finset ℕ → C) (s : Finset ℕ) : Prop := |
| ∃ c, ∀ t ⊆ s, t.card = r → color t = c |
| |
| theorem end_homogeneous {C : Type*} [Fintype C] [Nonempty C] (r : ℕ) |
| (R : ℕ → ℕ) (hR : ∀ k, ∀ (s : Finset ℕ), R k ≤ s.card → |
| ∀ color : Finset ℕ → C, ∃ h ⊆ s, h.card = k ∧ Homogeneous r color h) : |
| ∀ k, ∃ N, ∀ (s : Finset ℕ), N ≤ s.card → ∀ color : Finset ℕ → C, |
| ∃ h ⊆ s, h.card = k ∧ ∃ tag : ℕ → C, |
| ∀ t ⊆ h, t.card = r + 1 → ∀ a ∈ t, |
| (∀ b ∈ t, a ≤ b) → color t = tag a := by |
| classical |
| intro k |
| induction k with |
| | zero => |
| refine ⟨0, ?_⟩ |
| intro s _ color |
| refine ⟨∅, Finset.empty_subset _, rfl, (fun _ => color ∅), ?_⟩ |
| intro t ht hcard a ha _ |
| have : t = ∅ := Finset.subset_empty.mp ht |
| simp [this] at ha |
| | succ k ih => |
| obtain ⟨N, hN⟩ := ih |
| refine ⟨R N + 1, ?_⟩ |
| intro s hs color |
| have hsne : s.Nonempty := Finset.card_pos.mp (by omega) |
| let v := s.min' hsne |
| have hv : v ∈ s := Finset.min'_mem _ _ |
| have hrest : R N ≤ (s.erase v).card := by |
| rw [Finset.card_erase_of_mem hv] |
| omega |
| obtain ⟨B, hBs, hBcard, c, hc⟩ := hR N (s.erase v) hrest (fun t => color (insert v t)) |
| obtain ⟨H, hHB, hHcard, tag, htag⟩ := hN B hBcard.ge color |
| have hvH : v ∉ H := fun h => (Finset.mem_erase.mp (hBs (hHB h))).1 rfl |
| have hvmin : ∀ a ∈ B, v < a := by |
| intro a ha |
| have hsa := Finset.mem_erase.mp (hBs ha) |
| exact lt_of_le_of_ne (Finset.min'_le _ _ hsa.2) hsa.1.symm |
| refine ⟨insert v H, Finset.insert_subset hv (hHB.trans (hBs.trans (Finset.erase_subset _ _))), |
| by simp [hvH, hHcard], (fun a => if a = v then c else tag a), ?_⟩ |
| intro t ht hcard a ha hamin |
| by_cases hvt : v ∈ t |
| · have hat : a = v := by |
| apply Nat.le_antisymm (hamin v hvt) |
| rcases Finset.mem_insert.mp (ht ha) with hav | haH |
| · exact hav ▸ le_rfl |
| · exact (hvmin a (hHB haH)).le |
| subst a |
| have het : t.erase v ⊆ B := by |
| intro a ha |
| rcases Finset.mem_insert.mp (ht (Finset.mem_erase.mp ha).2) with hav | haH |
| · exact False.elim ((Finset.mem_erase.mp ha).1 hav) |
| · exact hHB haH |
| have hecard : (t.erase v).card = r := by |
| rw [Finset.card_erase_of_mem hvt, hcard] |
| omega |
| have h := hc (t.erase v) het hecard |
| simpa [Finset.insert_erase hvt] using h |
| · have htH : t ⊆ H := by |
| intro b hb |
| rcases Finset.mem_insert.mp (ht hb) with hbv | hbH |
| · exact False.elim (hvt (hbv ▸ hb)) |
| · exact hbH |
| have hav : a ≠ v := fun he => hvt (he ▸ ha) |
| simp only [ite_eq_right hav] |
| exact htag t htH hcard a ha hamin |
| |
| theorem finite_ramsey {C : Type*} [Fintype C] [Nonempty C] : |
| ∀ r k : ℕ, ∃ N ≥ k, ∀ (s : Finset ℕ), N ≤ s.card → |
| ∀ color : Finset ℕ → C, ∃ h ⊆ s, h.card = k ∧ Homogeneous r color h := by |
| classical |
| intro r |
| induction r with |
| | zero => |
| intro k |
| refine ⟨k, le_rfl, ?_⟩ |
| intro s hs color |
| obtain ⟨h, hhs, hh⟩ := Finset.exists_subset_card_eq hs |
| refine ⟨h, hhs, hh, color ∅, ?_⟩ |
| intro t _ ht |
| rw [Finset.card_eq_zero.mp ht] |
| | succ r ih => |
| choose R hRk hR using ih |
| intro k |
| obtain ⟨N, hN⟩ := end_homogeneous r R hR (Fintype.card C * k) |
| refine ⟨max N k, le_max_right _ _, ?_⟩ |
| intro s hs color |
| obtain ⟨H, hHs, hHcard, tag, htag⟩ := hN s ((le_max_left _ _).trans hs) color |
| obtain ⟨c, _, hc⟩ := Finset.exists_le_card_fiber_of_mul_le_card_of_maps_to |
| (s := H) (t := (Finset.univ : Finset C)) (f := tag) |
| (fun _ _ => Finset.mem_univ _) Finset.univ_nonempty |
| (by simpa using hHcard.ge : Fintype.card C * k ≤ H.card) |
| obtain ⟨h, hsub, hcard⟩ := Finset.exists_subset_card_eq hc |
| refine ⟨h, hsub.trans (Finset.filter_subset _ _ |>.trans hHs), hcard, c, ?_⟩ |
| intro t ht htcard |
| have htne : t.Nonempty := Finset.card_pos.mp (by omega) |
| let a := t.min' htne |
| have ha : a ∈ t := Finset.min'_mem _ _ |
| have ha' := Finset.mem_filter.mp (hsub (ht ha)) |
| rw [htag t (ht.trans (hsub.trans (Finset.filter_subset _ _))) htcard a ha |
| (fun b hb => Finset.min'_le _ _ hb), ha'.2] |
| |
| end DirectedFeedback.Ranks |
| |
| noncomputable section |
| open scoped BigOperators |
| namespace DirectedFeedback.Ranks |
| |
| variable {I J : Type*} [Fintype I] [Fintype J] |
| |
| def payoff (a : I → J → ℝ) (x : I → ℝ) (y : J → ℝ) : ℝ := |
| ∑ i, ∑ j, x i * y j * a i j |
| |
| theorem payoff_left (a : I → J → ℝ) (x x' : I → ℝ) (y : J → ℝ) (r s : ℝ) : |
| payoff a (r • x + s • x') y = r * payoff a x y + s * payoff a x' y := by |
| simp only [payoff, Pi.add_apply, Pi.smul_apply, smul_eq_mul, add_mul, |
| Finset.sum_add_distrib, Finset.mul_sum, mul_assoc] |
| |
| theorem payoff_right (a : I → J → ℝ) (x : I → ℝ) (y y' : J → ℝ) (r s : ℝ) : |
| payoff a x (r • y + s • y') = r * payoff a x y + s * payoff a x y' := by |
| simp only [payoff, Pi.add_apply, Pi.smul_apply, smul_eq_mul, mul_add, add_mul, |
| Finset.sum_add_distrib, Finset.mul_sum] |
| congr 1 <;> apply Finset.sum_congr rfl <;> intro i _ <;> |
| apply Finset.sum_congr rfl <;> intro j _ <;> ring |
| |
| def probabilitySimplex (Index : Type*) [Fintype Index] : Set (Index → ℝ) := |
| {weights | (∀ index, 0 ≤ weights index) ∧ ∑ index, weights index = 1} |
| |
| theorem single_mem_probabilitySimplex {Index : Type*} [Fintype Index] [DecidableEq Index] |
| (index : Index) : Pi.single index 1 ∈ probabilitySimplex Index := |
| ⟨le_update_iff.2 ⟨zero_le_one, fun _ _ => le_rfl⟩, by simp⟩ |
| |
| theorem convex_probabilitySimplex (Index : Type*) [Fintype Index] : |
| Convex ℝ (probabilitySimplex Index) := by |
| intro left hleft right hright weightLeft weightRight hweightLeft hweightRight hsum |
| refine ⟨fun index => ?_, ?_⟩ |
| · exact add_nonneg (mul_nonneg hweightLeft (hleft.1 index)) |
| (mul_nonneg hweightRight (hright.1 index)) |
| · simp_rw [Pi.add_apply, Pi.smul_apply] |
| rwa [Finset.sum_add_distrib, ← Finset.smul_sum, ← Finset.smul_sum, |
| hleft.2, hright.2, smul_eq_mul, smul_eq_mul, mul_one, mul_one] |
| |
| theorem isCompact_probabilitySimplex (Index : Type*) [Fintype Index] : |
| IsCompact (probabilitySimplex Index) := by |
| have hform : probabilitySimplex Index = |
| (⋂ index : Index, {weights : Index → ℝ | 0 ≤ weights index}) ∩ |
| {weights | ∑ index, weights index = 1} := by |
| ext weights |
| simp only [probabilitySimplex, Set.mem_inter_iff, Set.mem_iInter, Set.mem_ofPred_eq] |
| apply IsCompact.of_isClosed_subset (s := Set.Icc (0 : Index → ℝ) 1) isCompact_Icc |
| · rw [hform] |
| exact (isClosed_iInter fun index => |
| isClosed_le continuous_const (continuous_apply index)).inter |
| (isClosed_eq (by fun_prop) continuous_const) |
| · intro weights hweights |
| refine ⟨hweights.1, fun index => ?_⟩ |
| change weights index ≤ 1 |
| rw [← hweights.2] |
| exact Finset.single_le_sum (fun other _ => hweights.1 other) (Finset.mem_univ index) |
| |
| theorem finite_minimax [Nonempty I] [Nonempty J] (a : I → J → ℝ) (δ : ℝ) |
| (hresponse : ∀ y ∈ probabilitySimplex J, ∃ i, (∑ j, y j * a i j) ≤ δ) : |
| ∃ x ∈ probabilitySimplex I, ∀ j, (∑ i, x i * a i j) ≤ δ := by |
| classical |
| have hI : (probabilitySimplex I).Nonempty := ⟨Pi.single (Classical.arbitrary I) 1, |
| single_mem_probabilitySimplex _⟩ |
| have hJ : (probabilitySimplex J).Nonempty := ⟨Pi.single (Classical.arbitrary J) 1, |
| single_mem_probabilitySimplex _⟩ |
| have hleft (y : J → ℝ) : Continuous (fun x : I → ℝ => payoff a x y) := by |
| unfold payoff |
| fun_prop |
| have hright (x : I → ℝ) : Continuous (fun y : J → ℝ => payoff a x y) := by |
| unfold payoff |
| fun_prop |
| have hcLeft (y : J → ℝ) : ConvexOn ℝ (probabilitySimplex I) (fun x => payoff a x y) := by |
| refine ⟨convex_probabilitySimplex _, ?_⟩ |
| intro x _ x' _ r s _ _ _ |
| exact (payoff_left a x x' y r s).le |
| have hcRight (x : I → ℝ) : ConcaveOn ℝ (probabilitySimplex J) (fun y => payoff a x y) := by |
| refine ⟨convex_probabilitySimplex _, ?_⟩ |
| intro y _ y' _ r s _ _ _ |
| exact (payoff_right a x y y' r s).ge |
| obtain ⟨x, hx, y, hy, hxy⟩ := Sion.exists_isSaddlePointOn hI (convex_probabilitySimplex _) |
| (isCompact_probabilitySimplex _) (fun y _ => (hleft y).continuousOn.lowerSemicontinuousOn) |
| (fun y _ => (hcLeft y).quasiconvexOn) (convex_probabilitySimplex _) hJ |
| (isCompact_probabilitySimplex _) (fun x _ => (hright x).continuousOn.upperSemicontinuousOn) |
| (fun x _ => (hcRight x).quasiconcaveOn) |
| obtain ⟨i, hi⟩ := hresponse y hy |
| refine ⟨x, hx, ?_⟩ |
| intro j |
| have hsaddle := hxy (Pi.single i 1) (single_mem_probabilitySimplex _) |
| (Pi.single j 1) (single_mem_probabilitySimplex _) |
| have hpureLeft : payoff a (Pi.single i 1) y = ∑ j, y j * a i j := by |
| simp [payoff, Pi.single_apply, ite_mul] |
| have hpureRight : payoff a x (Pi.single j 1) = ∑ i, x i * a i j := by |
| simp [payoff, Pi.single_apply, mul_ite, ite_mul] |
| rw [hpureLeft, hpureRight] at hsaddle |
| exact hsaddle.trans hi |
| |
| theorem rational_simplex_approximation [Nonempty I] (x : I → ℝ) |
| (hx : x ∈ probabilitySimplex I) (ε : ℝ) (hε : 0 < ε) : |
| ∃ q : I → ℚ, (∀ i, 0 ≤ q i) ∧ (∑ i, q i = 1) ∧ |
| (∑ i, |(q i : ℝ) - x i|) < ε := by |
| classical |
| let n : ℝ := Fintype.card I |
| have hn : 0 < n := by |
| change 0 < (Fintype.card I : ℝ) |
| exact_mod_cast (Fintype.card_pos : 0 < Fintype.card I) |
| let d := ε / (2 * n) |
| have hd : 0 < d := by dsimp [d]; positivity |
| have hex (i : I) : ∃ q : ℚ, 0 ≤ q ∧ (q : ℝ) ≤ x i ∧ x i - q < d := by |
| by_cases hxi : x i = 0 |
| · exact ⟨0, le_rfl, by simp [hxi], by simpa [hxi] using hd⟩ |
| have hp : 0 < x i := lt_of_le_of_ne (hx.1 i) (Ne.symm hxi) |
| obtain ⟨q, hq1, hq2⟩ := exists_rat_btwn (show max 0 (x i - d) < x i by |
| exact max_lt hp (by linarith)) |
| refine ⟨q, ?_, hq2.le, ?_⟩ |
| · exact_mod_cast (le_max_left _ _).trans hq1.le |
| · have hh := (le_max_right _ _).trans_lt hq1 |
| linarith |
| choose q hqnonneg hqle hqerr using hex |
| let deficit : ℚ := 1 - ∑ i, q i |
| have hdef : 0 ≤ deficit := by |
| have hsum : (∑ i, (q i : ℝ)) ≤ 1 := by |
| rw [← hx.2] |
| exact Finset.sum_le_sum (fun i _ => hqle i) |
| dsimp [deficit] |
| exact_mod_cast (sub_nonneg.mpr hsum) |
| have herr : (deficit : ℝ) < ε / 2 := by |
| have hh := Finset.sum_lt_sum_of_nonempty Finset.univ_nonempty (fun i _ => hqerr i) |
| have hdid : (∑ _i : I, d) = ε / 2 := by |
| simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul] |
| change n * (ε / (2 * n)) = ε / 2 |
| field_simp |
| rw [Finset.sum_sub_distrib, hx.2, hdid] at hh |
| simpa [deficit] using hh |
| let i₀ : I := Classical.arbitrary I |
| let q' : I → ℚ := fun i => q i + if i = i₀ then deficit else 0 |
| refine ⟨q', (fun i => add_nonneg (hqnonneg i) (by split_ifs <;> positivity)), ?_, ?_⟩ |
| · simp [q', Finset.sum_add_distrib, deficit] |
| · calc |
| (∑ i, |(q' i : ℝ) - x i|) ≤ |
| ∑ i, ((x i - (q i : ℝ)) + if i = i₀ then (deficit : ℝ) else 0) := by |
| apply Finset.sum_le_sum |
| intro i _ |
| dsimp [q'] |
| push_cast |
| split_ifs with hi |
| · have ht := abs_add_le ((q i : ℝ) - x i) (deficit : ℝ) |
| rw [abs_of_nonpos (sub_nonpos.mpr (hqle i)), |
| abs_of_nonneg (show (0 : ℝ) ≤ (deficit : ℝ) by exact_mod_cast hdef)] at ht |
| calc |
| |(q i : ℝ) + (deficit : ℝ) - x i| = |
| |((q i : ℝ) - x i) + (deficit : ℝ)| := by congr 1; ring |
| _ ≤ -((q i : ℝ) - x i) + (deficit : ℝ) := ht |
| _ = _ := by ring |
| · rw [Rat.cast_zero, add_zero, add_zero, abs_of_nonpos (sub_nonpos.mpr (hqle i))] |
| linarith |
| _ = 2 * deficit := by |
| rw [Finset.sum_add_distrib, Finset.sum_sub_distrib, hx.2] |
| simp [deficit] |
| ring |
| _ < ε := by linarith |
| |
| end DirectedFeedback.Ranks |
| |
| noncomputable section |
| open scoped BigOperators |
| namespace DirectedFeedback.Ranks |
| |
| abbrev Triple (n : ℕ) := {s : Finset (Fin n) // s.card = 3} |
| abbrev Increasing (L N : ℕ) := {f : Fin L → Fin N // StrictMono f} |
| |
| theorem triple_nonempty {L : ℕ} (hL : 3 ≤ L) : Nonempty (Triple L) := by |
| classical |
| refine ⟨⟨Finset.univ.image (Fin.castLE hL), ?_⟩⟩ |
| rw [Finset.card_image_of_injective _ (Fin.castLE_injective hL)] |
| simp |
| |
| def toFinite (N : ℕ) (s : Finset ℕ) : Finset (Fin N) := |
| s.preimage Fin.val Fin.val_injective.injOn |
| |
| @[simp] theorem toFinite_image {N : ℕ} (s : Finset (Fin N)) : |
| toFinite N (s.image Fin.val) = s := by |
| classical |
| ext x |
| simp [toFinite, Fin.val_inj] |
| |
| abbrev RankTest (L N : ℕ) := (Triple L × Triple L) × Finset (Finset (Fin N)) |
| |
| def rankPayoff {L N : ℕ} (ψ : Increasing L N) (t : RankTest L N) : ℝ := |
| (if t.1.1.val.image ψ.val ∈ t.2 then 1 else 0) - |
| (if t.1.2.val.image ψ.val ∈ t.2 then 1 else 0) |
| |
| theorem rankPayoff_abs {L N : ℕ} (ψ : Increasing L N) (t : RankTest L N) : |
| |rankPayoff ψ t| ≤ 1 := by |
| unfold rankPayoff |
| split_ifs <;> norm_num |
| |
| theorem bucket_close (b : ℕ) (hb : 0 < b) (x y : ℝ) (_hx : 0 ≤ x) (hy : 0 ≤ y) |
| (h : ⌊(b : ℝ) * x⌋₊ = ⌊(b : ℝ) * y⌋₊) : x - y ≤ 1 / b := by |
| have hb' : (0 : ℝ) < b := by exact_mod_cast hb |
| have h1 := Nat.lt_floor_add_one ((b : ℝ) * x) |
| have h2 := Nat.floor_le (mul_nonneg hb'.le hy) |
| rw [h] at h1 |
| apply (le_div_iff₀ hb').mpr |
| nlinarith |
|
|
| theorem rank_spreading (L : ℕ) (hL : 3 ≤ L) (η : ℝ) (hη : 0 < η) : |
| ∃ N ≥ L, ∃ μ : Increasing L N → ℚ, |
| (∀ ψ, 0 ≤ μ ψ) ∧ (∑ ψ, μ ψ = 1) ∧ |
| ∀ I I' : Triple L, ∀ A : Finset (Finset (Fin N)), |
| |(∑ ψ, (μ ψ : ℝ) * if I.val.image ψ.val ∈ A then 1 else 0) - |
| (∑ ψ, (μ ψ : ℝ) * if I'.val.image ψ.val ∈ A then 1 else 0)| ≤ η := by |
| classical |
| let : Nonempty (Triple L) := triple_nonempty hL |
| let P := Triple L × Triple L |
| let c : ℝ := Fintype.card P |
| have hc : 0 < c := by |
| dsimp [c] |
| exact_mod_cast (Fintype.card_pos : 0 < Fintype.card P) |
| obtain ⟨b₀, hb₀⟩ := exists_nat_one_div_lt (show 0 < η / (4 * c) by positivity) |
| let b := b₀ + 1 |
| have hb : 0 < b := Nat.succ_pos _ |
| have hb' : (0 : ℝ) < b := by exact_mod_cast hb |
| have hcb : c * (1 / (b : ℝ)) < η / 4 := by |
| have hh := mul_lt_mul_of_pos_left hb₀ hc |
| have heq : c * (η / (4 * c)) = η / 4 := by field_simp |
| simpa [b, heq] using hh |
| obtain ⟨N, hNL, hN⟩ := finite_ramsey (C := P → Fin (b + 1)) 3 L |
| let : Nonempty (Increasing L N) := ⟨⟨Fin.castLE hNL, fun _ _ h => h⟩⟩ |
| have hresponse : ∀ τ ∈ probabilitySimplex (RankTest L N), ∃ ψ : Increasing L N, |
| (∑ t, τ t * rankPayoff ψ t) ≤ η / 4 := by |
| intro τ hτ |
| let q (p : P) (Z : Finset (Fin N)) : ℝ := |
| ∑ A : Finset (Finset (Fin N)), τ (p, A) * if Z ∈ A then 1 else 0 |
| have hq0 (p : P) (Z : Finset (Fin N)) : 0 ≤ q p Z := by |
| apply Finset.sum_nonneg |
| intro A _ |
| split_ifs <;> simp [hτ.1 (p, A)] |
| have hq1 (p : P) (Z : Finset (Fin N)) : q p Z ≤ 1 := by |
| calc |
| q p Z ≤ ∑ A : Finset (Finset (Fin N)), τ (p, A) := by |
| apply Finset.sum_le_sum |
| intro A _ |
| split_ifs <;> simp [hτ.1 (p, A)] |
| _ ≤ ∑ p' : P, ∑ A : Finset (Finset (Fin N)), τ (p', A) := by |
| exact Finset.single_le_sum (fun p' _ => Finset.sum_nonneg (fun A _ => hτ.1 (p', A))) |
| (Finset.mem_univ p) |
| _ = 1 := by |
| have hh := hτ.2 |
| rw [Fintype.sum_prod_type] at hh |
| exact hh |
| let color (s : Finset ℕ) (p : P) : Fin (b + 1) := |
| ⟨⌊(b : ℝ) * q p (toFinite N s)⌋₊, by |
| have hh := Nat.floor_mono (mul_le_mul_of_nonneg_left (hq1 p (toFinite N s)) hb'.le) |
| simp only [mul_one, Nat.floor_natCast] at hh |
| omega⟩ |
| obtain ⟨H, hHN, hHcard, tag, htag⟩ := hN (Finset.range N) (by simp) color |
| let ψ₀ : Fin L → Fin N := fun i => |
| ⟨H.orderEmbOfFin hHcard i, Finset.mem_range.mp (hHN (H.orderEmbOfFin_mem hHcard i))⟩ |
| have hψ : StrictMono ψ₀ := fun i j hij => (H.orderEmbOfFin hHcard).strictMono hij |
| let ψ : Increasing L N := ⟨ψ₀, hψ⟩ |
| have hmono (I : Triple L) : color ((I.val.image ψ.val).image Fin.val) = tag := by |
| apply htag |
| · intro a ha |
| obtain ⟨v, hv, rfl⟩ := Finset.mem_image.mp ha |
| obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hv |
| exact H.orderEmbOfFin_mem hHcard i |
| · rw [Finset.card_image_of_injective _ Fin.val_injective, |
| Finset.card_image_of_injective _ hψ.injective] |
| exact I.property |
| have hclose (p : P) : q p (p.1.val.image ψ.val) - q p (p.2.val.image ψ.val) ≤ 1 / b := by |
| apply bucket_close b hb _ _ (hq0 _ _) (hq0 _ _) |
| have heq := congrArg (fun f => (f p).val) ((hmono p.1).trans (hmono p.2).symm) |
| simpa only [color, toFinite_image] using heq |
| refine ⟨ψ, ?_⟩ |
| calc |
| (∑ t, τ t * rankPayoff ψ t) = |
| ∑ p : P, (q p (p.1.val.image ψ.val) - q p (p.2.val.image ψ.val)) := by |
| rw [Fintype.sum_prod_type] |
| simp only [rankPayoff, mul_sub, Finset.sum_sub_distrib, q] |
| rfl |
| _ ≤ ∑ _p : P, (1 / (b : ℝ)) := Finset.sum_le_sum (fun p _ => hclose p) |
| _ = c * (1 / (b : ℝ)) := by simp [c] |
| _ ≤ η / 4 := hcb.le |
| obtain ⟨x, hx, hxbound⟩ := finite_minimax rankPayoff (η / 4) hresponse |
| obtain ⟨μ, hμ0, hμ1, hμerr⟩ := rational_simplex_approximation x hx (η / 2) (by positivity) |
| have hμbound (t : RankTest L N) : (∑ ψ, (μ ψ : ℝ) * rankPayoff ψ t) < η := by |
| have hle : (∑ ψ, (μ ψ : ℝ) * rankPayoff ψ t) ≤ |
| (∑ ψ, x ψ * rankPayoff ψ t) + ∑ ψ, |(μ ψ : ℝ) - x ψ| := by |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_le_sum |
| intro ψ _ |
| have hh : ((μ ψ : ℝ) - x ψ) * rankPayoff ψ t ≤ |(μ ψ : ℝ) - x ψ| := by |
| calc |
| _ ≤ |((μ ψ : ℝ) - x ψ) * rankPayoff ψ t| := le_abs_self _ |
| _ = |(μ ψ : ℝ) - x ψ| * |rankPayoff ψ t| := abs_mul _ _ |
| _ ≤ |(μ ψ : ℝ) - x ψ| * 1 := |
| mul_le_mul_of_nonneg_left (rankPayoff_abs ψ t) (abs_nonneg _) |
| _ = _ := mul_one _ |
| linarith |
| have hh := hxbound t |
| linarith |
| refine ⟨N, hNL, μ, hμ0, hμ1, ?_⟩ |
| intro I I' A |
| have h1 := hμbound ((I, I'), A) |
| have h2 := hμbound ((I', I), A) |
| simp only [rankPayoff, mul_sub, Finset.sum_sub_distrib] at h1 h2 |
| exact abs_le.mpr ⟨by linarith, h1.le⟩ |
| |
| end DirectedFeedback.Ranks |
| open scoped Classical |
| namespace DirectedFeedback.Ranks |
| open DirectedFeedback.SourceProbability |
| open DirectedFeedback.SourceProbability.FiniteDistribution |
| |
| def Spreads {L N : ℕ} (μ : FiniteDistribution (Increasing L N)) (η : ℝ) : Prop := |
| ∀ I I' : Triple L, ∀ A : Finset (Finset (Fin N)), |
| |μ.probability (fun ψ => decide (I.val.image ψ.val ∈ A)) - |
| μ.probability (fun ψ => decide (I'.val.image ψ.val ∈ A))| ≤ η |
| |
| theorem exists_spreading_law (L : ℕ) (hL : 3 ≤ L) (η : ℝ) (hη : 0 < η) : |
| ∃ N ≥ L, ∃ μ : FiniteDistribution (Increasing L N), Spreads μ η ∧ |
| ∀ ψ, ∃ q : ℚ, μ.weight ψ = q := by |
| obtain ⟨N, hNL, q, hq0, hq1, hq⟩ := rank_spreading L hL η hη |
| let μ : FiniteDistribution (Increasing L N) := |
| ⟨fun ψ => q ψ, fun ψ => by exact_mod_cast hq0 ψ, by exact_mod_cast hq1⟩ |
| refine ⟨N, hNL, μ, ?_, fun ψ => ⟨q ψ, rfl⟩⟩ |
| intro I I' A |
| convert hq I I' A using 1 |
| simp only [probability, μ, decide_eq_true_eq, mul_ite, mul_one, mul_zero] |
| |
| theorem triple_data_processing {L N : ℕ} {η : ℝ} |
| (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η) |
| (f g : Fin 3 → Fin L) (hf : StrictMono f) (hg : StrictMono g) |
| (K : (Fin 3 → Fin N) → Bool) : |
| |μ.probability (fun ψ => K (ψ.val ∘ f)) - |
| μ.probability (fun ψ => K (ψ.val ∘ g))| ≤ η := by |
| classical |
| let I (f : Fin 3 → Fin L) (hf : StrictMono f) : Triple L := |
| ⟨Finset.univ.image f, by rw [Finset.card_image_of_injective _ hf.injective]; simp⟩ |
| let event (s : Finset (Fin N)) : Bool := |
| if h : s.card = 3 then K (s.orderEmbOfFin h) else false |
| let A : Finset (Finset (Fin N)) := Finset.univ.filter (fun s => event s = true) |
| have hevent (f : Fin 3 → Fin L) (hf : StrictMono f) (ψ : Increasing L N) : |
| decide ((I f hf).val.image ψ.val ∈ A) = K (ψ.val ∘ f) := by |
| have hmono := ψ.property.comp hf |
| have hc : ((I f hf).val.image ψ.val).card = 3 := by |
| rw [Finset.card_image_of_injective _ ψ.property.injective] |
| exact (I f hf).property |
| have heq := Finset.orderEmbOfFin_unique hc (f := ψ.val ∘ f) |
| (fun j => by simp [I]) hmono |
| simp only [A, Finset.mem_filter, Finset.mem_univ, true_and] |
| have hh : event ((I f hf).val.image ψ.val) = K (ψ.val ∘ f) := by |
| dsimp [event] |
| rw [dite_eq_left hc, ← heq] |
| simp [hh] |
| simpa only [hevent] using hs (I f hf) (I g hg) A |
| |
| def tripleVector {L : ℕ} (a c h : Fin L) : Fin 3 → Fin L := ![a, c, h] |
| |
| theorem tripleVector_strict {L : ℕ} {a c h : Fin L} (hac : a < c) (hch : c < h) : |
| StrictMono (tripleVector a c h) := by |
| intro i j hij |
| fin_cases i <;> fin_cases j <;> simp_all [tripleVector] |
| exact hac.trans hch |
| |
| end DirectedFeedback.Ranks |
| |
| namespace DirectedFeedback.RankGraph |
| open DirectedFeedback.SourceProbability |
| open DirectedFeedback.SourceProbability.FiniteDistribution |
| open DirectedFeedback.Ranks |
| variable {U V X Y : Type} {T N L : ℕ} |
| |
| theorem comparison_expectations {η : ℝ} |
| (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η) |
| (ord : Rank U V X Y T N → ℕ) (d : Tuple U V T) |
| (E : Set (Domain U V X Y T d)) (a c h a' c' h' : Fin L) |
| (hac : a < c) (hch : c < h) (hac' : a' < c') (hch' : c' < h') : |
| |μ.probability (fun ψ => compareBit ord ψ.val d E a c h) - |
| μ.probability (fun ψ => compareBit ord ψ.val d E a' c' h')| ≤ η := by |
| classical |
| exact triple_data_processing μ hs _ _ (tripleVector_strict hac hch) |
| (tripleVector_strict hac' hch') |
| (fun r => decide (ord (vertex d (fun lambda => if lambda ∈ E then r 0 else r 2)) < |
| ord (marker (r 1)))) |
|
|
| theorem ordered_disagreement {I : Type*} [Fintype I] |
| (μ : FiniteDistribution I) (p q : I → Bool) |
| (hpq : (∀ i, p i ≤ q i) ∨ (∀ i, q i ≤ p i)) {η : ℝ} |
| (hc : |μ.probability p - μ.probability q| ≤ η) : |
| μ.probability (fun i => decide (p i ≠ q i)) ≤ η := by |
| rcases hpq with h | h |
| · rw [indicator_difference μ p q (fun i => (Bool.le_iff_imp.mp (h i)))] |
| exact (le_abs_self _).trans (by rwa [abs_sub_comm]) |
| · have he := indicator_difference μ q p (fun i => (Bool.le_iff_imp.mp (h i))) |
| have hh : (fun i => decide (p i ≠ q i)) = (fun i => decide (q i ≠ p i)) := by |
| funext i; simp [ne_comm] |
| rw [hh, he] |
| exact (le_abs_self _).trans hc |
| |
| theorem compare_marker_mono (ord : Rank U V X Y T N → ℕ) |
| (hord : ∀ {a b}, Arc a b → ord a < ord b) |
| (ψ : Increasing L N) (d : Tuple U V T) (E : Set (Domain U V X Y T d)) |
| (a h : Fin L) {c c' : Fin L} (hc : c ≤ c') : |
| compareBit ord ψ.val d E a c h ≤ compareBit ord ψ.val d E a c' h := by |
| rcases hc.eq_or_lt with rfl | hc |
| · exact le_rfl |
| rw [Bool.le_iff_imp] |
| simp only [compareBit, decide_eq_true_eq] |
| exact fun hh => hh.trans (hord (marker_arc (ψ.property hc))) |
|
|
| theorem comparison_disagreement (hL : 30 ≤ L) {η : ℝ} |
| (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η) |
| (ord : Rank U V X Y T N → ℕ) |
| (hord : ∀ {a b}, Arc a b → ord a < ord b) |
| (d : Tuple U V T) (E : Set (Domain U V X Y T d)) |
| (a c h : Fin L) (hu : usable a c h) : |
| μ.probability (fun ψ => decide (compareBit ord ψ.val d E a c h ≠ |
| referenceBit ord ψ.val hL d E)) ≤ 3 * η := by |
| have hua := hu.1 |
| have hac := hu.2.1 |
| have huc := hu.2.2.1 |
| have hucL := hu.2.2.2.1 |
| have huh := hu.2.2.2.2 |
| let z : Fin L := ⟨0, by omega⟩ |
| let lo : Fin L := ⟨1, by omega⟩ |
| let ref : Fin L := ⟨14, by omega⟩ |
| let hi : Fin L := ⟨L - 2, by omega⟩ |
| let cp : Fin L := ⟨c.val + 1, by omega⟩ |
| let A0 (ψ : Increasing L N) := compareBit ord ψ.val d E lo ref hi |
| let A1 (ψ : Increasing L N) := compareBit ord ψ.val d E lo c hi |
| let A2 (ψ : Increasing L N) := compareBit ord ψ.val d E z c cp |
| let A3 (ψ : Increasing L N) := compareBit ord ψ.val d E a c h |
| have h01 : μ.probability (fun ψ => decide (A0 ψ ≠ A1 ψ)) ≤ η := by |
| apply ordered_disagreement |
| · rcases le_total ref c with hc | hc |
| · exact Or.inl (fun ψ => compare_marker_mono ord hord ψ d E lo hi hc) |
| · exact Or.inr (fun ψ => compare_marker_mono ord hord ψ d E lo hi hc) |
| · exact comparison_expectations μ hs ord d E lo ref hi lo c hi |
| (by simp [Fin.lt_def, lo, ref]) (by simp [Fin.lt_def, ref, hi]; omega) |
| (by simp [Fin.lt_def, lo]; omega) (by simp [Fin.lt_def, hi]; omega) |
| have h12 : μ.probability (fun ψ => decide (A1 ψ ≠ A2 ψ)) ≤ η := by |
| apply ordered_disagreement |
| · apply Or.inl |
| intro ψ |
| apply compareBit_mono_of_arc hord |
| exact twoLevel_arc ψ.property d (Set.Subset.refl _) (by simp [Fin.lt_def, z, lo]) |
| (by simp [Fin.lt_def, z, hi]; omega) (by simp [Fin.lt_def, cp, hi]; omega) |
| · exact comparison_expectations μ hs ord d E lo c hi z c cp |
| (by simp [Fin.lt_def, lo]; omega) (by simp [Fin.lt_def, hi]; omega) |
| (by simp [Fin.lt_def, z]; omega) (by simp [Fin.lt_def, cp]) |
| have h23 : μ.probability (fun ψ => decide (A2 ψ ≠ A3 ψ)) ≤ η := by |
| apply ordered_disagreement |
| · apply Or.inr |
| intro ψ |
| apply compareBit_mono_of_arc hord |
| exact twoLevel_arc ψ.property d (Set.Subset.refl _) (by simp [Fin.lt_def, z]; omega) |
| (by simp [Fin.lt_def, z]; omega) (by simp [Fin.lt_def, cp]; omega) |
| · exact comparison_expectations μ hs ord d E z c cp a c h |
| (by simp [Fin.lt_def, z]; omega) (by simp [Fin.lt_def, cp]) hac (by omega) |
| have hh := probability_disagree_triangle μ A0 A1 A3 |
| have hh' := probability_disagree_triangle μ A1 A2 A3 |
| have he : μ.probability (fun ψ => decide (A0 ψ ≠ A3 ψ)) ≤ 3 * η := by linarith |
| calc |
| _ = μ.probability (fun ψ => decide (A0 ψ ≠ A3 ψ)) := by |
| apply congrArg (μ.probability) |
| funext ψ |
| change decide (A3 ψ ≠ A0 ψ) = decide (A0 ψ ≠ A3 ψ) |
| apply Bool.eq_iff_iff.mpr |
| simp only [decide_eq_true_eq] |
| exact ne_comm |
| _ ≤ _ := he |
| |
| theorem goodness_probability [Fintype X] [Fintype Y] |
| (hL : 30 ≤ L) {η : ℝ} (hη : 0 ≤ η) |
| (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η) |
| (ord : Rank U V X Y T N → ℕ) |
| (hord : ∀ {a b}, Arc a b → ord a < ord b) (d : Tuple U V T) : |
| μ.probability (fun ψ => decide (¬Good ord ψ.val hL d)) ≤ |
| 3 * η * (L : ℝ)^3 * 2^(Fintype.card (Domain U V X Y T d)) := by |
| classical |
| let J := Set (Domain U V X Y T d) × Fin L × Fin L × Fin L |
| let bad (j : J) (ψ : Increasing L N) : Bool := |
| decide (usable j.2.1 j.2.2.1 j.2.2.2 ∧ |
| compareBit ord ψ.val d j.1 j.2.1 j.2.2.1 j.2.2.2 ≠ referenceBit ord ψ.val hL d j.1) |
| have hb (j : J) : μ.probability (bad j) ≤ 3 * η := by |
| by_cases hu : usable j.2.1 j.2.2.1 j.2.2.2 |
| · simpa only [bad, hu, true_and] using comparison_disagreement hL μ hs ord hord d j.1 |
| j.2.1 j.2.2.1 j.2.2.2 hu |
| · simp only [bad, hu, false_and, decide_false, probability_false] |
| positivity |
| calc |
| _ ≤ μ.probability (fun ψ => decide (∃ j : J, bad j ψ = true)) := by |
| apply probability_mono |
| intro ψ hp |
| have hn : ¬Good ord ψ.val hL d := of_decide_eq_true hp |
| unfold Good at hn |
| push Not at hn |
| obtain ⟨E, a, c, h, hu, he⟩ := hn |
| apply decide_eq_true |
| refine ⟨(E, a, c, h), ?_⟩ |
| simpa only [bad, decide_eq_true_eq] using And.intro hu he |
| _ ≤ ∑ j : J, μ.probability (bad j) := probability_exists_le_sum μ bad |
| _ ≤ ∑ _j : J, 3 * η := Finset.sum_le_sum (fun j _ => hb j) |
| _ = _ := by simp [J, Fintype.card_set, Nat.cast_mul, Nat.cast_pow]; ring |
| |
| end DirectedFeedback.RankGraph |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.RankGraph |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open Ranks |
| variable {U V X Y : Type} [Fintype X] [Fintype Y] [Nonempty X] |
| variable {T N L : ℕ} |
| |
| theorem domain_card_bound (hYX : Fintype.card Y ≤ Fintype.card X) (d : Tuple U V T) : |
| Fintype.card (Domain U V X Y T d) ≤ (Fintype.card X)^T := by |
| have hm : 1 ≤ Fintype.card X := Fintype.card_pos |
| rcases d with ⟨t,s⟩ | ⟨t,s,v⟩ |
| · change Fintype.card (Fin t.val → X) ≤ _ |
| rw [Fintype.card_fun, Fintype.card_fin] |
| exact Nat.pow_le_pow_right hm (by have := t.isLt |
| · change Fintype.card ((Fin t.val → X) × Y) ≤ _ |
| rw [Fintype.card_prod, Fintype.card_fun, Fintype.card_fin] |
| calc |
| _ ≤ (Fintype.card X)^t.val * Fintype.card X := Nat.mul_le_mul_left _ hYX |
| _ = (Fintype.card X)^(t.val+1) := (pow_succ _ _).symm |
| _ ≤ _ := Nat.pow_le_pow_right hm t.isLt |
|
|
| theorem goodness_bound (hYX : Fintype.card Y ≤ Fintype.card X) |
| (hL : 30 ≤ L) {η ρ : ℝ} (hη : 0 ≤ η) |
| (haccuracy : 3*η*(L:ℝ)^3*2^((Fintype.card X)^T) ≤ ρ) |
| (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η) |
| (ord : Rank U V X Y T N → ℕ) |
| (hord : ∀ {a b}, Arc a b → ord a < ord b) (d : Tuple U V T) : |
| μ.probability (fun ψ => decide (¬Good ord ψ.val hL d)) ≤ ρ := by |
| apply (goodness_probability hL hη μ hs ord hord d).trans |
| apply le_trans _ haccuracy |
| apply mul_le_mul_of_nonneg_left _ (by positivity) |
| exact pow_le_pow_right₀ (by norm_num : (1:ℝ) ≤ 2) (domain_card_bound hYX d) |
|
|
| theorem sampled_goodness {Ω : Type*} [Fintype Ω] |
| (hYX : Fintype.card Y ≤ Fintype.card X) (hL : 30 ≤ L) {η ρ : ℝ} (hη : 0 ≤ η) |
| (haccuracy : 3*η*(L:ℝ)^3*2^((Fintype.card X)^T) ≤ ρ) |
| (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η) |
| (ν : FiniteDistribution Ω) (tuple : Ω → Tuple U V T) |
| (ord : Rank U V X Y T N → ℕ) |
| (hord : ∀ {a b}, Arc a b → ord a < ord b) : |
| (μ.product ν).probability (fun a => decide (¬Good ord a.1.val hL (tuple a.2))) ≤ ρ := by |
| rw [probability_eq_expect, expectation_product, expectation_comm] |
| simp_rw [← probability_eq_expect] |
| calc |
| _ ≤ ν.expectation (fun _ => ρ) := expectation_mono _ (fun a => |
| goodness_bound hYX hL hη haccuracy μ hs ord hord (tuple a)) |
| _ = _ := expectation_const _ _ |
|
|
| end DirectedFeedback.RankGraph |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games Ranks |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : ℕ} [NeZero M] [NeZero T] |
| variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| variable (deleted : OutputVertex (M := M) G ψLaw → Bool) |
| variable (ord : OutputVertex (M := M) G ψLaw → ℕ) |
| variable (hord : ∀ {a b}, deleted a = false → deleted b = false → |
| OutputArc G ψLaw hYX fiber a b → ord a < ord b) |
| variable (hrank : ∀ r, deleted (.inl r) = false) |
| variable {η ρ : ℝ} (hη : 0 ≤ η) |
| variable (haccuracy : 3*η*(rankLength X T : ℝ)^3*2^((Fintype.card X)^T) ≤ ρ) |
| variable (hs : Spreads ψLaw η) |
|
|
| include hord hrank hη haccuracy hs in |
| theorem full_badness : |
| (fullLaw (M := M) G ψLaw).probability (fun d => decide (¬ |
| Good (rankOrder G ψLaw ord) d.1.val rankLength_ge |
| (fullWildcard (V := V) (Y := Y) d).tuple)) ≤ ρ := by |
| exact sampled_goodness hYX rankLength_ge hη haccuracy ψLaw hs |
| ((atomLaw (bigMarginal G) subsetLaw).iid T) |
| (fun a => Sum.inl ⟨⟨T,by omega⟩,vertices a⟩) |
| (rankOrder G ψLaw ord) (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) |
|
|
| end DirectedFeedback.Construction |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
