| import OAI.Probability.MatroidProphet.Main |
| import OAI.Probability.MatroidSecretary.Accounting.WeightedRewardModel |
|
|
| namespace OAI |
|
|
| /-! The literal rounded-payoff maximum-branch claim `eq:maximum` in setup.tex. |
| The observed input stays `w`; only the score attached to an accepted label is |
| rounded. This distinguishes the source assertion from a raw-payoff bound. -/ |
|
|
| namespace MatroidProphet |
|
|
| open MeasureTheory Finset Set |
|
|
| lemma hiddenWorstScore_nonneg {n bits : ℕ} (A : HiddenRule n bits) |
| (w score : Weights n) (hscore : ∀ e, 0 ≤ score e) (r : Seed bits) : |
| 0 ≤ hiddenWorstScore A w score r := by |
| classical |
| apply Finset.le_inf' |
| intro π _ |
| exact Finset.sum_nonneg fun e _ => hscore e |
|
|
| namespace Maximum |
|
|
| variable {n bits : ℕ} {K : Type*} [Countable K] [MeasurableSpace K] |
| [MeasurableSingletonClass K] [LinearOrder K] |
|
|
| / |
| raw reward. Therefore every nonnegative scoring of labels can use this event. -/ |
| lemma maximumHidden_accepted_single_qualifier (M : Matroid (Fin n)) |
| (key : ℝ → K) (hkey : Measurable key) (active : K → Prop) |
| (mask : Seed bits → Finset (Fin n)) (w : Weights n) (r : Seed bits) (g : Fin n) |
| (hg : g ∉ mask r) |
| (ha : ∀ e, threshold M active mask r (fun f => key (w f)) (e, key (w e)) ↔ e = g) |
| (π : ArrivalOrder n) : |
| hiddenAcceptedThrough (maximumHidden M key hkey active mask) r w π n = {g} := by |
| classical |
| let A := maximumHidden M key hkey active mask |
| have hsingle : accepted A.core r (observed A r w) w π = {g} := by |
| apply firstRule_single_qualifier key hkey (threshold M active mask) |
| intro e |
| rw [threshold_congr_samples M active mask r |
| (fun f => key (observed A r w f)) (fun f => key (w f))] |
| · exact ha e |
| · intro f hf |
| simp [observed, A, maximumHidden, hf] |
| change accepted A.core r (observed A r w) w π \ mask r = {g} |
| rw [hsingle] |
| exact Finset.sdiff_eq_self_of_disjoint (by simpa using hg) |
|
|
| / |
| vector, while decisions still use exactly the original observations. -/ |
| theorem maximum_expectation_top_score (M : Matroid (Fin n)) |
| (key : ℝ → K) (hkey : Measurable key) (active : K → Prop) |
| (w score : Weights n) (hscore : ∀ e, 0 ≤ score e) (g : Fin n) |
| (hg : M.Indep ({g} : Set (Fin n))) (hag : active (key (w g))) |
| (htop : ∀ f, M.Indep ({f} : Set (Fin n)) → active (key (w f)) → f ≠ g → |
| higher (g, key (w g)) (f, key (w f))) : |
| score g / 4 ≤ bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ |
| (fun H => hiddenWorstScore |
| (maximumHidden M key hkey active (seedSet (bits := n))) w score (setSeed H)) := by |
| classical |
| let A := maximumHidden M key hkey active (seedSet (bits := n)) |
| let F : Finset (Fin n) → ℝ := fun H => hiddenWorstScore A w score (setSeed H) |
| change score g / 4 ≤ bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ F |
| have hF : ∀ H ⊆ Finset.univ, 0 ≤ F H := |
| fun H _ => hiddenWorstScore_nonneg A w score hscore (setSeed H) |
| have hsuccess (H : Finset (Fin n)) (hgH : g ∉ H) |
| (hqual : ∀ e, threshold M active seedSet (setSeed H) |
| (fun f => key (w f)) (e, key (w e)) ↔ e = g) : score g ≤ F H := by |
| apply Finset.le_inf' |
| intro π _ |
| change score g ≤ ∑ e ∈ hiddenAcceptedThrough A (setSeed H) w π n, score e |
| rw [maximumHidden_accepted_single_qualifier M key hkey active seedSet w |
| (setSeed H) g (by simpa using hgH) hqual π, Finset.sum_singleton] |
| let P : Finset (Fin n) := Finset.univ.filter fun f => |
| M.Indep ({f} : Set (Fin n)) ∧ active (key (w f)) ∧ f ≠ g |
| by_cases hP : P.Nonempty |
| · obtain ⟨h, hhP, hsecond⟩ := exists_top (fun f => key (w f)) P hP |
| have hh := (Finset.mem_filter.mp hhP).2 |
| apply maximum_expectation_two Finset.univ g h (Finset.mem_univ _) (Finset.mem_univ _) |
| (Ne.symm hh.2.2) F (score g) hF |
| intro H _ hgH hhH |
| apply hsuccess H hgH |
| exact threshold_top_two M active seedSet (setSeed H) (fun f => key (w f)) |
| g h hg hag hh.1 hh.2.1 htop |
| (fun f hf haf hfg hfh => hsecond f (Finset.mem_filter.mpr ⟨Finset.mem_univ f, hf, haf, hfg⟩) hfh) |
| (by simpa using hgH) (by simpa using hhH) |
| · apply maximum_expectation_one Finset.univ g (Finset.mem_univ _) F (score g) |
| (hscore g) hF |
| intro H _ hgH |
| apply hsuccess H hgH |
| apply threshold_only_positive M active seedSet (setSeed H) (fun f => key (w f)) |
| g hg hag |
| · intro f hf haf |
| by_contra hfg |
| exact hP ⟨f, Finset.mem_filter.mpr ⟨Finset.mem_univ f, hf, haf, hfg⟩⟩ |
| · simpa using hgH |
|
|
| end Maximum |
|
|
| namespace SourceContracts |
|
|
| / |
| the maximum branch is at least one quarter of the largest rounded nonloop. |
| The observation mask is fair on every label and the minimum stays inside |
| the expectation. Empty, rank-zero, and all-zero instances are included. -/ |
| theorem maximum_rounded {n : ℕ} (M : Matroid (Fin n)) (w : Weights n) |
| (_hw : ∀ e, 0 ≤ w e) : |
| maximumRounded M w / 4 ≤ |
| ∫ r, hiddenWorstScore (roundedMaximumHidden M (seedSet (bits := n))) |
| w (fun e => roundedWeight weightBase (w e)) r |
| ∂bernoulliSeedLaw (fun _ => (1 / 2 : ℝ)) |
| (fun _ => by norm_num) (fun _ => by norm_num) := by |
| classical |
| rw [integral_bernoulliSeedLaw] |
| let score : Weights n := fun e => roundedWeight weightBase (w e) |
| let A := roundedMaximumHidden M (seedSet (bits := n)) |
| let F := bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ |
| (fun H => hiddenWorstScore A w score (setSeed H)) |
| change maximumRounded M w / 4 ≤ F |
| have hs : ∀ e, 0 ≤ score e := |
| fun e => roundedWeight_nonneg (by norm_num [weightBase]) (w e) |
| have hF : 0 ≤ F := by |
| apply bitsExpectation_nonneg _ (fun _ => by norm_num) (fun _ => by norm_num) |
| intro H _ |
| exact hiddenWorstScore_nonneg A w score hs (setSeed H) |
| have hlabel (e : Fin n) (he : M.Indep ({e} : Set (Fin n))) : score e ≤ 4 * F := by |
| let a : Fin n → WithBot ℤ := fun f => Priority.asLevel (roundedLevel weightBase (w f)) |
| by_cases hea : a e = ⊥ |
| · have hz : score e = 0 := by |
| change levelWeight weightBase (a e) = 0 |
| rw [hea] |
| rfl |
| rw [hz] |
| exact mul_nonneg (by norm_num) hF |
| · let P : Finset (Fin n) := Finset.univ.filter fun f => |
| M.Indep ({f} : Set (Fin n)) ∧ a f ≠ ⊥ |
| have heP : e ∈ P := Finset.mem_filter.mpr ⟨Finset.mem_univ e, he, hea⟩ |
| obtain ⟨g, hgP, htop⟩ := Maximum.exists_top a P ⟨e, heP⟩ |
| have hg := (Finset.mem_filter.mp hgP).2 |
| have hwin : score g / 4 ≤ F := |
| Maximum.maximum_expectation_top_score M |
| (fun x => Priority.asLevel (roundedLevel weightBase x)) |
| ((measurable_of_countable Priority.asLevel).comp (measurable_roundedLevel weightBase)) |
| (fun x => x ≠ ⊥) w score hs g hg.1 hg.2 |
| (fun f hf haf hfg => htop f (Finset.mem_filter.mpr |
| ⟨Finset.mem_univ f, hf, haf⟩) hfg) |
| have hkey : a e ≤ a g := by |
| by_cases heg : e = g |
| · exact heg ▸ le_rfl |
| · rcases htop e heP heg with hlt | ⟨heq, _⟩ |
| · exact hlt.le |
| · exact heq.symm.le |
| have hscore : score e ≤ score g := |
| levelWeight_mono (by norm_num [weightBase]) hkey |
| linarith |
| have hfour : maximumRounded M w ≤ 4 * F := by |
| apply Finset.sup'_le |
| intro o _ |
| cases o with |
| | none => exact mul_nonneg (by norm_num) hF |
| | some e => |
| change (if M.Indep ({e} : Set (Fin n)) then score e else 0) ≤ _ |
| split_ifs with he |
| · exact hlabel e he |
| · exact mul_nonneg (by norm_num) hF |
| linarith |
|
|
| end SourceContracts |
| end MatroidProphet |
|
|
| end OAI |
|
|
