File size: 7,822 Bytes
dd14c26 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | 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]
/-- A singleton qualifier gives the actual singleton accepted set, not just its
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)
/-- The all-order top-label guarantee remains valid for any nonnegative score
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 literal source `eq:maximum`: expected minimum *rounded* reward of
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
|