math / data /lean /OAI /Probability /MatroidSecretary /Labels /LabeledTransport.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
7.29 kB
import OAI.Probability.MatroidProphet.Main
import Mathlib.Combinatorics.Matroid.Map
namespace OAI
namespace MatroidProphet.LabeledTransport
open MeasureTheory Finset
open scoped BigOperators
variable {α : Type*} [Fintype α] {n bits : ℕ}
/-- The same offline maximum on an arbitrary finite label type. -/
noncomputable def optimum (M : Matroid α) (w : α → ℝ) : ℝ := by
classical
exact Finset.univ.sup' Finset.univ_nonempty
(fun I : Finset α => if M.Indep (I : Set α) then ∑ a ∈ I, w a else 0)
theorem sum_le_optimum (M : Matroid α) (w : α → ℝ) (I : Finset α)
(hI : M.Indep (I : Set α)) : (∑ a ∈ I, w a) ≤ optimum M w := by
classical
have h := Finset.le_sup' (s := (Finset.univ : Finset (Finset α)))
(f := fun J => if M.Indep (J : Set α) then ∑ a ∈ J, w a else 0)
(Finset.mem_univ I)
simpa only [optimum, ite_eq_left hI] using h
theorem optimum_nonneg (M : Matroid α) (w : α → ℝ) : 0 ≤ optimum M w := by
simpa using sum_le_optimum M w ∅ (by simp)
omit [Fintype α] in
/-- Relabeling preserves the full ground set; it does not discard loops. -/
theorem mapEquiv_ground (M : Matroid α) (hE : M.E = Set.univ)
(e : α ≃ Fin n) : (M.mapEquiv e).E = Set.univ := by
simp [hE]
/-- The all-independent-sets benchmark is exactly unchanged by label encoding. -/
theorem optimum_eq_indexed (M : Matroid α) (e : α ≃ Fin n) (w : α → ℝ) :
optimum M w = MatroidProphet.optimum (M.mapEquiv e) (w ∘ e.symm) := by
classical
apply le_antisymm
· apply Finset.sup'_le
intro I _
split_ifs with hI
· have hi : (M.mapEquiv e).Indep ((I.map e.toEmbedding : Finset (Fin n)) : Set (Fin n)) := by
simpa using hI.map e e.injective.injOn
have h := MatroidProphet.sum_le_optimum (M.mapEquiv e) (w ∘ e.symm)
(I.map e.toEmbedding) hi
simpa using h
· exact MatroidProphet.optimum_nonneg _ _
· apply Finset.sup'_le
intro I _
split_ifs with hI
· have hi : M.Indep ((I.map e.symm.toEmbedding : Finset α) : Set α) := by
simpa using (Matroid.mapEquiv_indep_iff.mp hI)
have h := sum_le_optimum M w (I.map e.symm.toEmbedding) hi
simpa using h
· exact optimum_nonneg _ _
abbrev History (α : Type*) {n : ℕ} (k : Fin n) := Fin (k.val + 1) → α × ℝ
/-- A physical arrival order visits every label once, indexed by arrival time. -/
abbrev ArrivalOrder (α : Type*) (n : ℕ) := Fin n ≃ α
instance arrivalOrderMeasurableSpace : MeasurableSpace (ArrivalOrder α n) := ⊤
instance arrivalOrderMeasurableSingletonClass :
MeasurableSingletonClass (ArrivalOrder α n) := ⟨fun _ => trivial⟩
variable [MeasurableSpace α] [MeasurableSingletonClass α]
/-- A rule on physical labels receives only the same sample and history data. -/
structure OnlineRule (α : Type*) [MeasurableSpace α] (n bits : ℕ) where
decide : (k : Fin n) → Seed bits → (α → ℝ) → History α k → Bool
measurable_decide : ∀ k, Measurable
(fun x : Seed bits × ((α → ℝ) × History α k) => decide k x.1 x.2.1 x.2.2)
def encodeHistory (e : α ≃ Fin n) {k : Fin n} (h : History α k) :
MatroidProphet.History n k := fun j => (e (h j).1, (h j).2)
/-- Decode the indexed rule without adding any future-information input. -/
noncomputable def decodeRule (e : α ≃ Fin n) (A : MatroidProphet.OnlineRule n bits) :
OnlineRule α n bits where
decide k r s h := A.decide k r (s ∘ e.symm) (encodeHistory e h)
measurable_decide k := by
have hinput : Measurable (fun x : Seed bits × ((α → ℝ) × History α k) =>
(x.1, (x.2.1 ∘ e.symm, encodeHistory e x.2.2))) := by
apply Measurable.prodMk measurable_fst
apply Measurable.prodMk
· apply Measurable.of_eval
intro i
exact (measurable_pi_apply (e.symm i)).comp (measurable_fst.comp measurable_snd)
· apply Measurable.of_eval
intro j
apply Measurable.prodMk
· exact (measurable_of_finite e).comp
(measurable_fst.comp ((measurable_pi_apply j).comp
(measurable_snd.comp measurable_snd)))
· exact measurable_snd.comp ((measurable_pi_apply j).comp
(measurable_snd.comp measurable_snd))
exact (A.measurable_decide k).comp hinput
def history (w : α → ℝ) (π : ArrivalOrder α n) (k : Fin n) : History α k :=
fun j => let a := π (prefixIndex k j); (a, w a)
def decisionAt (A : OnlineRule α n bits) (r : Seed bits) (s w : α → ℝ)
(π : ArrivalOrder α n) (k : Fin n) : Bool := A.decide k r s (history w π k)
noncomputable def acceptedThrough (A : OnlineRule α n bits) (r : Seed bits)
(s w : α → ℝ) (π : ArrivalOrder α n) (t : ℕ) : Finset α := by
classical
exact univ.filter fun a => (π.symm a).val < t ∧ decisionAt A r s w π (π.symm a) = true
noncomputable def reward (A : OnlineRule α n bits) (r : Seed bits)
(s w : α → ℝ) (π : ArrivalOrder α n) : ℝ :=
∑ a ∈ acceptedThrough A r s w π n, w a
omit [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α] in
theorem encode_history (e : α ≃ Fin n) (w : α → ℝ) (π : ArrivalOrder α n)
(k : Fin n) :
encodeHistory e (history w π k) =
MatroidProphet.history (w ∘ e.symm) (π.trans e) k := by
ext j <;> simp [encodeHistory, history, MatroidProphet.history]
theorem decode_decision (e : α ≃ Fin n) (A : MatroidProphet.OnlineRule n bits)
(r : Seed bits) (s w : α → ℝ) (π : ArrivalOrder α n) (k : Fin n) :
decisionAt (decodeRule e A) r s w π k =
MatroidProphet.decisionAt A r (s ∘ e.symm) (w ∘ e.symm) (π.trans e) k := by
simp only [decisionAt, decodeRule, MatroidProphet.decisionAt, encode_history]
theorem decode_acceptedThrough (e : α ≃ Fin n) (A : MatroidProphet.OnlineRule n bits)
(r : Seed bits) (s w : α → ℝ) (π : ArrivalOrder α n) (t : ℕ) :
acceptedThrough (decodeRule e A) r s w π t =
(MatroidProphet.acceptedThrough A r (s ∘ e.symm) (w ∘ e.symm)
(π.trans e) t).map e.symm.toEmbedding := by
classical
ext label
rw [Finset.mem_map_equiv]
simp only [acceptedThrough, MatroidProphet.acceptedThrough, Finset.mem_filter,
Finset.mem_univ, true_and]
simp [decode_decision]
theorem decode_reward (e : α ≃ Fin n) (A : MatroidProphet.OnlineRule n bits)
(r : Seed bits) (s w : α → ℝ) (π : ArrivalOrder α n) :
reward (decodeRule e A) r s w π =
MatroidProphet.reward A r (s ∘ e.symm) (w ∘ e.symm) (π.trans e) := by
simp [reward, decode_acceptedThrough, MatroidProphet.reward, MatroidProphet.accepted]
/-- Prefix feasibility transports back to the original labels, including loops. -/
theorem decode_feasible (M : Matroid α) (e : α ≃ Fin n)
(A : MatroidProphet.OnlineRule n bits) (hA : Feasible (M.mapEquiv e) A)
(r : Seed bits) (s w : α → ℝ) (π : ArrivalOrder α n) (t : ℕ)
(hs : ∀ a, 0 ≤ s a) (hw : ∀ a, 0 ≤ w a) :
M.Indep (acceptedThrough (decodeRule e A) r s w π t : Set α) := by
have h := hA r (s ∘ e.symm) (w ∘ e.symm) (π.trans e) t
(fun i => hs (e.symm i)) (fun i => hw (e.symm i))
rw [Matroid.mapEquiv_indep_iff] at h
simpa [decode_acceptedThrough] using h
end MatroidProphet.LabeledTransport
end OAI