File size: 7,508 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 | import OAI.Probability.MatroidSecretary.Secretary.Model
import OAI.Probability.MatroidSecretary.Secretary.Observation
import OAI.Probability.MatroidSecretary.Secretary.Replay
namespace OAI
/-!
# The actual history-only secretary rule reconstructed from a complete initial seed
The decoder consumes only the initial seed and the label set of the already
observed prefix. The observation vector is extracted from actual past arrivals.
A total mask-consistency guard rejects on unsupported decoder outcomes, ensuring
feasibility for every initial seed rather than merely almost surely.
-/
namespace MatroidProphet.SecretaryReplay
open MeasureTheory
/-- A concrete secretary rule from a hidden rule and a precommitted decoder.
The seed type is finite, but its law is arbitrary and need not be uniform. -/
noncomputable def reconstructedRule {n bits : ℕ} {Q : Type*}
[Fintype Q] [MeasurableSpace Q] [MeasurableSingletonClass Q]
(A : HiddenRule n bits) (K : Q → Fin (n + 1))
(decode : Q → Finset (Fin n) → Seed bits) : SecretaryRule n Q where
prefixLength := K
measurable_prefixLength := measurable_of_finite K
decide k q h :=
let P := prefixLabels (K q).val h
let r := decode q P
if A.mask r = P then A.core.decide k r (prefixWeights (K q).val h) h else false
measurable_decide k := by
classical
apply measurable_from_prod_countable_right
intro q
have hp := measurable_prefixLabels k (K q).val
have hr : Measurable (fun h : History n k => decode q (prefixLabels (K q).val h)) :=
(measurable_of_finite (decode q)).comp hp
have hs : MeasurableSet {z : Seed bits × Finset (Fin n) | A.mask z.1 = z.2} :=
(Set.toFinite _).measurableSet
have hm : MeasurableSet {h : History n k |
A.mask (decode q (prefixLabels (K q).val h)) = prefixLabels (K q).val h} :=
(hr.prodMk hp) hs
exact Measurable.ite hm
((A.core.measurable_decide k).comp
(hr.prodMk ((measurable_prefixWeights k (K q).val).prodMk measurable_id)))
measurable_const
/-- Once the prefix is complete, the decoder sees its full label set; no suffix
label changes the reconstructed seed. -/
theorem decoder_history {n bits : ℕ} {Q : Type*}
(K : Q → Fin (n + 1)) (decode : Q → Finset (Fin n) → Seed bits)
(q : Q) (w : Weights n) (π : ArrivalOrder n) (k : Fin n)
(hk : (K q).val ≤ k.val) :
decode q (prefixLabels (K q).val (history w π k)) =
decode q (orderPrefix π (K q).val) := by
rw [prefixLabels_history w π k (K q).val (hk.trans (Nat.le_succ _))]
/-- On mask-consistent outcomes the actual no-sample secretary execution exactly
replays the hidden rule at every prefix. -/
theorem reconstructed_acceptedThrough {n bits : ℕ} {Q : Type*}
[Fintype Q] [MeasurableSpace Q] [MeasurableSingletonClass Q]
(A : HiddenRule n bits) (K : Q → Fin (n + 1))
(decode : Q → Finset (Fin n) → Seed bits)
(q : Q) (w : Weights n) (π : ArrivalOrder n) (t : ℕ)
(hmask : A.mask (decode q (orderPrefix π (K q).val)) = orderPrefix π (K q).val) :
secretaryAcceptedThrough (reconstructedRule A K decode) q w π t =
hiddenAcceptedThrough A (decode q (orderPrefix π (K q).val)) w π t := by
classical
ext e
by_cases hk : (π.symm e).val < (K q).val
· have he : e ∈ A.mask (decode q (orderPrefix π (K q).val)) := by
rw [hmask, mem_orderPrefix]
exact hk
simp [secretaryAcceptedThrough, secretaryDecisionAt, reconstructedRule, hk,
hiddenAcceptedThrough, he]
· have hle : (K q).val ≤ (π.symm e).val := Nat.le_of_not_gt hk
have hp := prefixLabels_history w π (π.symm e) (K q).val (hle.trans (Nat.le_succ _))
have ho := prefixWeights_eq_observed A (decode q (orderPrefix π (K q).val))
w π (π.symm e) (K q).val (hle.trans (Nat.le_succ _)) hmask
have he : e ∉ A.mask (decode q (orderPrefix π (K q).val)) := by
rw [hmask, mem_orderPrefix]
exact hk
simp only [secretaryAcceptedThrough, hiddenAcceptedThrough, acceptedThrough,
Finset.mem_sdiff, Finset.mem_filter, Finset.mem_univ, true_and, he,
not_false_eq_true, and_true]
simp [secretaryDecisionAt, reconstructedRule, hk, hp, hmask, ho, decisionAt]
/-- On an unsupported decoder outcome the total construction accepts nothing. -/
theorem reconstructed_acceptedThrough_of_mismatch {n bits : ℕ} {Q : Type*}
[Fintype Q] [MeasurableSpace Q] [MeasurableSingletonClass Q]
(A : HiddenRule n bits) (K : Q → Fin (n + 1))
(decode : Q → Finset (Fin n) → Seed bits)
(q : Q) (w : Weights n) (π : ArrivalOrder n) (t : ℕ)
(hmask : A.mask (decode q (orderPrefix π (K q).val)) ≠ orderPrefix π (K q).val) :
secretaryAcceptedThrough (reconstructedRule A K decode) q w π t = ∅ := by
classical
apply Finset.eq_empty_iff_forall_notMem.mpr
intro e
by_cases hk : (π.symm e).val < (K q).val
· simp [secretaryAcceptedThrough, secretaryDecisionAt, reconstructedRule, hk]
· have hle : (K q).val ≤ (π.symm e).val := Nat.le_of_not_gt hk
have hp := prefixLabels_history w π (π.symm e) (K q).val (hle.trans (Nat.le_succ _))
simp [secretaryAcceptedThrough, secretaryDecisionAt, reconstructedRule, hp, hmask]
/-- Feasibility is pointwise for every complete initial seed, including null
outcomes of the conditional reconstruction kernels. -/
theorem reconstructed_feasible {n bits : ℕ} {Q : Type*}
[Fintype Q] [MeasurableSpace Q] [MeasurableSingletonClass Q]
(M : Matroid (Fin n)) (A : HiddenRule n bits)
(K : Q → Fin (n + 1)) (decode : Q → Finset (Fin n) → Seed bits)
(hA : ∀ (w : Weights n), (∀ e, 0 ≤ w e) →
∀ (r : Seed bits) (π : ArrivalOrder n) (t : ℕ),
M.Indep (hiddenAcceptedThrough A r w π t : Set (Fin n))) :
SecretaryFeasible M (reconstructedRule A K decode) := by
intro q w hw π t
by_cases hm : A.mask (decode q (orderPrefix π (K q).val)) = orderPrefix π (K q).val
· rw [reconstructed_acceptedThrough A K decode q w π t hm]
exact hA w hw _ π t
· rw [reconstructed_acceptedThrough_of_mismatch A K decode q w π t hm]
simp
/-- Exact replay includes reward, with the actual fixed vector on every accept. -/
theorem reconstructed_reward {n bits : ℕ} {Q : Type*}
[Fintype Q] [MeasurableSpace Q] [MeasurableSingletonClass Q]
(A : HiddenRule n bits) (K : Q → Fin (n + 1))
(decode : Q → Finset (Fin n) → Seed bits)
(q : Q) (w : Weights n) (π : ArrivalOrder n)
(hmask : A.mask (decode q (orderPrefix π (K q).val)) = orderPrefix π (K q).val) :
secretaryReward (reconstructedRule A K decode) q w π =
hiddenReward A (decode q (orderPrefix π (K q).val)) w π := by
unfold secretaryReward hiddenReward
rw [reconstructed_acceptedThrough A K decode q w π n hmask]
/-- The pointwise comparison permits arbitrary full-seed-aware suffix orders. -/
theorem worstReward_le_reconstructed {n bits : ℕ} {Q : Type*}
[Fintype Q] [MeasurableSpace Q] [MeasurableSingletonClass Q]
(A : HiddenRule n bits) (K : Q → Fin (n + 1))
(decode : Q → Finset (Fin n) → Seed bits)
(q : Q) (w : Weights n) (π : ArrivalOrder n)
(hmask : A.mask (decode q (orderPrefix π (K q).val)) = orderPrefix π (K q).val) :
hiddenWorstReward A w (decode q (orderPrefix π (K q).val)) ≤
secretaryReward (reconstructedRule A K decode) q w π := by
rw [reconstructed_reward A K decode q w π hmask]
exact hiddenWorstReward_le A w _ π
end MatroidProphet.SecretaryReplay
end OAI
|