File size: 5,204 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
import OAI.Probability.MatroidProphet.Main
import OAI.Probability.MatroidSecretary.Secretary.Model
import Mathlib.MeasureTheory.Integral.Bochner.Basic

namespace OAI

open MeasureTheory Finset

namespace MatroidProphet

variable {n : ℕ} {Q : Type*} [MeasurableSpace Q]

lemma secretaryDecisionAt_congr (A : SecretaryRule n Q) (q : Q)
    (w w' : Weights n) (π π' : ArrivalOrder n) (k : Fin n)
    (hh : history w π k = history w' π' k) :
    secretaryDecisionAt A q w π k = secretaryDecisionAt A q w' π' k := by
  simp only [secretaryDecisionAt, hh]

lemma secretaryAcceptedThrough_mono (A : SecretaryRule n Q) (q : Q)
    (w : Weights n) (π : ArrivalOrder n) {t t' : ℕ} (ht : t ≤ t') :
    secretaryAcceptedThrough A q w π t ⊆ secretaryAcceptedThrough A q w π t' := by
  intro e he
  simp only [secretaryAcceptedThrough, mem_filter, mem_univ, true_and] at he ⊢
  exact ⟨lt_of_lt_of_le he.1 ht, he.2⟩

lemma secretaryAcceptedThrough_arrived (A : SecretaryRule n Q) (q : Q)
    (w : Weights n) (π : ArrivalOrder n) (t : ℕ) (e : Fin n)
    (he : e ∈ secretaryAcceptedThrough A q w π t) : (π.symm e).val < t :=
  (Finset.mem_filter.mp he).2.1

lemma secretaryAcceptedThrough_not_prefix (A : SecretaryRule n Q) (q : Q)
    (w : Weights n) (π : ArrivalOrder n) (t : ℕ) (e : Fin n)
    (he : e ∈ secretaryAcceptedThrough A q w π t) :
    (A.prefixLength q).val ≤ (π.symm e).val := by
  have hd := (Finset.mem_filter.mp he).2.2
  by_contra hn
  have hlt : (π.symm e).val < (A.prefixLength q).val := Nat.lt_of_not_ge hn
  simp [secretaryDecisionAt, hlt] at hd

lemma secretaryAcceptedThrough_prefix_empty (A : SecretaryRule n Q) (q : Q)
    (w : Weights n) (π : ArrivalOrder n) (t : ℕ)
    (ht : t ≤ (A.prefixLength q).val) :
    secretaryAcceptedThrough A q w π t = ∅ := by
  apply Finset.eq_empty_iff_forall_notMem.mpr
  intro e he
  exact (not_lt_of_ge (secretaryAcceptedThrough_not_prefix A q w π t e he))
    (lt_of_lt_of_le (secretaryAcceptedThrough_arrived A q w π t e he) ht)

lemma secretaryReward_nonneg (A : SecretaryRule n Q) (q : Q)
    (w : Weights n) (π : ArrivalOrder n) (hw : ∀ e, 0 ≤ w e) :
    0 ≤ secretaryReward A q w π := by
  exact Finset.sum_nonneg fun e _ => hw e

lemma secretaryReward_le_optimum (M : Matroid (Fin n)) (A : SecretaryRule n Q)
    (hA : SecretaryFeasible M A) (q : Q) (w : Weights n)
    (hw : ∀ e, 0 ≤ w e) (π : ArrivalOrder n) :
    secretaryReward A q w π ≤ optimum M w :=
  sum_le_optimum M w _ (hA q w hw π n)

lemma measurable_secretaryDecisionAt (A : SecretaryRule n Q)
    (π : ArrivalOrder n) (k : Fin n) :
    Measurable (fun x : Q × Weights n => secretaryDecisionAt A x.1 x.2 π k) := by
  classical
  have hp : MeasurableSet {x : Q × Weights n | k.val < (A.prefixLength x.1).val} :=
    (A.measurable_prefixLength.comp measurable_fst)
      (by trivial : MeasurableSet {K : Fin (n + 1) | k.val < K.val})
  exact Measurable.ite hp measurable_const
    ((A.measurable_decide k).comp
      (measurable_fst.prodMk ((measurable_history π k).comp measurable_snd)))

lemma secretaryReward_eq_sum (A : SecretaryRule n Q) (q : Q)
    (w : Weights n) (π : ArrivalOrder n) :
    secretaryReward A q w π =
      ∑ e : Fin n, if secretaryDecisionAt A q w π (π.symm e) = true then w e else 0 := by
  classical
  unfold secretaryReward secretaryAcceptedThrough
  rw [Finset.sum_filter]
  apply Finset.sum_congr rfl
  intro e _
  simp only [(π.symm e).isLt, true_and]

lemma measurable_secretaryReward_fixed_order (A : SecretaryRule n Q)
    (π : ArrivalOrder n) :
    Measurable (fun x : Q × Weights n => secretaryReward A x.1 x.2 π) := by
  classical
  simp_rw [secretaryReward_eq_sum]
  apply Finset.measurable_sum
  intro e _
  have hd := measurable_secretaryDecisionAt A π (π.symm e)
  have ht : MeasurableSet {x : Q × Weights n |
      secretaryDecisionAt A x.1 x.2 π (π.symm e) = true} :=
    hd (measurableSet_singleton true)
  exact Measurable.ite ht ((measurable_pi_apply e).comp measurable_snd) measurable_const

/-- No independence from the entire seed is imposed on the measurable arrival order. -/
lemma measurable_secretaryReward (A : SecretaryRule n Q) :
    Measurable (fun x : ArrivalOrder n × (Q × Weights n) =>
      secretaryReward A x.2.1 x.2.2 x.1) :=
  measurable_from_prod_countable_right (measurable_secretaryReward_fixed_order A)

lemma integrable_secretaryReward (M : Matroid (Fin n)) (A : SecretaryRule n Q)
    (hA : SecretaryFeasible M A) (w : Weights n) (hw : ∀ e, 0 ≤ w e)
    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ]
    (q : Ω → Q) (π : Ω → ArrivalOrder n) (hq : Measurable q) (hπ : Measurable π) :
    Integrable (fun ω => secretaryReward A (q ω) w (π ω)) μ := by
  have hm : Measurable (fun ω => secretaryReward A (q ω) w (π ω)) :=
    (measurable_secretaryReward A).comp
    (hπ.prodMk (hq.prodMk measurable_const))
  apply (integrable_const (optimum M w)).mono' hm.aestronglyMeasurable
  apply ae_of_all
  intro ω
  rw [Real.norm_eq_abs, abs_of_nonneg (secretaryReward_nonneg A (q ω) w (π ω) hw)]
  exact secretaryReward_le_optimum M A hA (q ω) w hw (π ω)

end MatroidProphet

end OAI