Datasets:

roseking
/

openAI-math-dataset

import OAI.Probability.MatroidSecretary.Labels.RelabelingModel
import OAI.Probability.MatroidProphet.Main
import Mathlib.Combinatorics.Matroid.Loop

namespace OAI

/-! Exact transport from arbitrary finite labels to the `Fin n` information model. -/

namespace MatroidProphet.Relabeling

open Finset MeasureTheory

variable {α β : Type*}

lemma sum_le_finiteOptimum [Fintype α] (M : Matroid α) (w : α → ℝ)
    (I : Finset α) (hI : M.Indep (I : Set α)) :
    (∑ a ∈ I, w a) ≤ finiteOptimum 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 [finiteOptimum, ite_eq_left hI] using h

lemma finiteOptimum_nonneg [Fintype α] (M : Matroid α) (w : α → ℝ) :
    0 ≤ finiteOptimum M w := by
  simpa using sum_le_finiteOptimum M w ∅ (by simp)

lemma finiteOptimum_le [Fintype α] (M : Matroid α) (w : α → ℝ) {z : ℝ}
    (hz : 0 ≤ z) (h : ∀ I : Finset α, M.Indep (I : Set α) → (∑ a ∈ I, w a) ≤ z) :
    finiteOptimum M w ≤ z := by
  classical
  apply Finset.sup'_le
  intro I _
  split_ifs with hI
  · exact h I hI
  · exact hz

/-- Changing finite labels preserves the exact offline optimum, for arbitrary real weights. -/
theorem finiteOptimum_mapEquiv [Fintype α] [Fintype β]
    (M : Matroid α) (e : α ≃ β) (w : α → ℝ) :
    finiteOptimum (M.mapEquiv e) (encodeWeights e w) = finiteOptimum M w := by
  classical
  apply le_antisymm
  · apply finiteOptimum_le _ _ (finiteOptimum_nonneg M w)
    intro J hJ
    have hI : M.Indep ((J.map e.symm.toEmbedding : Finset α) : Set α) := by
      simpa using (Matroid.mapEquiv_indep_iff.mp hJ)
    simpa [encodeWeights] using sum_le_finiteOptimum M w (J.map e.symm.toEmbedding) hI
  · apply finiteOptimum_le _ _ (finiteOptimum_nonneg _ _)
    intro I hI
    have hJ : (M.mapEquiv e).Indep ((I.map e.toEmbedding : Finset β) : Set β) := by
      simpa using hI
    simpa [encodeWeights] using
      sum_le_finiteOptimum (M.mapEquiv e) (encodeWeights e w) (I.map e.toEmbedding) hJ

@[simp] theorem finiteOptimum_fin {n : ℕ} (M : Matroid (Fin n)) (w : Weights n) :
    finiteOptimum M w = optimum M w := rfl

@[simp] theorem encodeWeights_nonnegative_iff (e : α ≃ β) (w : α → ℝ) :
    (∀ b, 0 ≤ encodeWeights e w b) ↔ (∀ a, 0 ≤ w a) := by
  constructor
  · intro h a
    simpa [encodeWeights] using h (e a)
  · intro h b
    exact h (e.symm b)

@[simp] theorem mapEquiv_ground_univ (M : Matroid α) (e : α ≃ β)
    (hE : M.E = Set.univ) : (M.mapEquiv e).E = Set.univ := by
  simp [hE]

@[simp] theorem mapEquiv_loop_iff (M : Matroid α) (e : α ≃ β) (a : α) :
    (M.mapEquiv e).IsLoop (e a) ↔ M.IsLoop a := by
  exact Matroid.mapEmbedding_isLoop_iff

/-- Every finite labeled matroid has a full-ground `Fin n` representative with
exactly the original offline benchmark and all loop labels retained. -/
theorem exists_fin_representation [Fintype α] (M : Matroid α) (hE : M.E = Set.univ) :
    ∃ (e : α ≃ Fin (Fintype.card α)),
      (M.mapEquiv e).E = Set.univ ∧
      (∀ w : α → ℝ, optimum (M.mapEquiv e) (encodeWeights e w) = finiteOptimum M w) ∧
      (∀ a, (M.mapEquiv e).IsLoop (e a) ↔ M.IsLoop a) := by
  refine ⟨Fintype.equivFin α, mapEquiv_ground_univ M _ hE, ?_, ?_⟩
  · intro w
    exact finiteOptimum_mapEquiv M _ w
  · intro a
    exact mapEquiv_loop_iff M _ a

/-- Coordinate reindexing is Borel, with no regularity assumption on weights. -/
theorem measurable_encodeWeights (e : α ≃ β) : Measurable (encodeWeights e) := by
  apply Measurable.of_eval
  intro b
  exact measurable_pi_apply (e.symm b)

theorem measurable_encodeHistory [Fintype α] [MeasurableSpace α]
    [MeasurableSingletonClass α] {n : ℕ} (e : α ≃ Fin n) (k : Fin n) :
    Measurable (encodeHistory e k) := by
  apply Measurable.of_eval
  intro j
  exact ((measurable_of_finite e).comp (measurable_fst.comp (measurable_pi_apply j))).prodMk
    (measurable_snd.comp (measurable_pi_apply j))

/-- The transported rule is measurable in precisely its permissible inputs. -/
theorem measurable_transportedDecision [Fintype α] [MeasurableSpace α]
    [MeasurableSingletonClass α] {n bits : ℕ} (e : α ≃ Fin n)
    (A : OnlineRule n bits) (k : Fin n) :
    Measurable (fun x : Seed bits × ((α → ℝ) × LabeledHistory α k) =>
      transportedDecision e A k x.1 x.2.1 x.2.2) := by
  exact (A.measurable_decide k).comp
    (measurable_fst.prodMk (((measurable_encodeWeights e).comp
      (measurable_fst.comp measurable_snd)).prodMk
        ((measurable_encodeHistory e k).comp (measurable_snd.comp measurable_snd))))

@[simp] theorem encodeHistory_labeledHistory {n : ℕ} (e : α ≃ Fin n)
    (w : α → ℝ) (π : LabeledOrder α n) (k : Fin n) :
    encodeHistory e k (labeledHistory w π k) =
      history (encodeWeights e w) (π.trans e) k := by
  funext j
  simp [encodeHistory, labeledHistory, history, encodeWeights]

theorem transportedDecision_eq_decisionAt {n bits : ℕ} (e : α ≃ Fin n)
    (A : OnlineRule n bits) (r : Seed bits) (s v : α → ℝ)
    (π : LabeledOrder α n) (k : Fin n) :
    transportedDecision e A k r s (labeledHistory v π k) =
      decisionAt A r (encodeWeights e s) (encodeWeights e v) (π.trans e) k := by
  simp only [transportedDecision, encodeHistory_labeledHistory, decisionAt]

/-- Exact accepted-set equality holds at every prefix, not just at termination. -/
theorem transportedAcceptedThrough_eq_map [Fintype α] {n bits : ℕ}
    (e : α ≃ Fin n) (A : OnlineRule n bits) (r : Seed bits)
    (s v : α → ℝ) (π : LabeledOrder α n) (t : ℕ) :
    transportedAcceptedThrough e A r s v π t =
      (acceptedThrough A r (encodeWeights e s) (encodeWeights e v)
        (π.trans e) t).map e.symm.toEmbedding := by
  classical
  ext a
  rw [Finset.mem_map_equiv]
  simp only [transportedAcceptedThrough, acceptedThrough, Finset.mem_filter,
    Finset.mem_univ, true_and]
  simp only [transportedDecision_eq_decisionAt, Equiv.symm_symm,
    Equiv.symm_trans_apply, Equiv.symm_apply_apply]

/-- The cardinal relabeling preserves the actual sum of accepted weights exactly. -/
theorem transportedReward_eq_reward [Fintype α] {n bits : ℕ}
    (e : α ≃ Fin n) (A : OnlineRule n bits) (r : Seed bits)
    (s v : α → ℝ) (π : LabeledOrder α n) :
    transportedReward e A r s v π =
      reward A r (encodeWeights e s) (encodeWeights e v) (π.trans e) := by
  simp [transportedReward, transportedAcceptedThrough_eq_map, reward, accepted, encodeWeights]

/-- Every-prefix feasibility transfers without dropping loops or exceptional inputs. -/
theorem transported_feasible [Fintype α] {n bits : ℕ}
    (M : Matroid α) (e : α ≃ Fin n) (A : OnlineRule n bits)
    (hA : Feasible (M.mapEquiv e) A) (r : Seed bits)
    (s v : α → ℝ) (π : LabeledOrder α n) (t : ℕ)
    (hs : ∀ a, 0 ≤ s a) (hv : ∀ a, 0 ≤ v a) :
    M.Indep (transportedAcceptedThrough e A r s v π t : Set α) := by
  have hi := hA r (encodeWeights e s) (encodeWeights e v) (π.trans e) t
    ((encodeWeights_nonnegative_iff e s).2 hs) ((encodeWeights_nonnegative_iff e v).2 hv)
  simpa only [transportedAcceptedThrough_eq_map, Finset.coe_map, Equiv.coe_toEmbedding]
    using Matroid.mapEquiv_indep_iff.mp hi

/-- The relabeled implementation retains every previous acceptance irrevocably. -/
theorem transportedAcceptedThrough_mono [Fintype α] {n bits : ℕ}
    (e : α ≃ Fin n) (A : OnlineRule n bits) (r : Seed bits)
    (s v : α → ℝ) (π : LabeledOrder α n) {t t' : ℕ} (htt' : t ≤ t') :
    transportedAcceptedThrough e A r s v π t ⊆
      transportedAcceptedThrough e A r s v π t' := by
  rw [transportedAcceptedThrough_eq_map, transportedAcceptedThrough_eq_map]
  exact Finset.map_subset_map.mpr (acceptedThrough_mono A r _ _ _ htt')

end MatroidProphet.Relabeling

end OAI

	import OAI.Probability.MatroidSecretary.Labels.RelabelingModel
	import OAI.Probability.MatroidProphet.Main
	import Mathlib.Combinatorics.Matroid.Loop

	namespace OAI

	/-! Exact transport from arbitrary finite labels to the `Fin n` information model. -/

	namespace MatroidProphet.Relabeling

	open Finset MeasureTheory

	variable {α β : Type*}

	lemma sum_le_finiteOptimum [Fintype α] (M : Matroid α) (w : α → ℝ)
	(I : Finset α) (hI : M.Indep (I : Set α)) :
	(∑ a ∈ I, w a) ≤ finiteOptimum 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 [finiteOptimum, ite_eq_left hI] using h

	lemma finiteOptimum_nonneg [Fintype α] (M : Matroid α) (w : α → ℝ) :
	0 ≤ finiteOptimum M w := by
	simpa using sum_le_finiteOptimum M w ∅ (by simp)

	lemma finiteOptimum_le [Fintype α] (M : Matroid α) (w : α → ℝ) {z : ℝ}
	(hz : 0 ≤ z) (h : ∀ I : Finset α, M.Indep (I : Set α) → (∑ a ∈ I, w a) ≤ z) :
	finiteOptimum M w ≤ z := by
	classical
	apply Finset.sup'_le
	intro I _
	split_ifs with hI
	· exact h I hI
	· exact hz

	/-- Changing finite labels preserves the exact offline optimum, for arbitrary real weights. -/
	theorem finiteOptimum_mapEquiv [Fintype α] [Fintype β]
	(M : Matroid α) (e : α ≃ β) (w : α → ℝ) :
	finiteOptimum (M.mapEquiv e) (encodeWeights e w) = finiteOptimum M w := by
	classical
	apply le_antisymm
	· apply finiteOptimum_le _ _ (finiteOptimum_nonneg M w)
	intro J hJ
	have hI : M.Indep ((J.map e.symm.toEmbedding : Finset α) : Set α) := by
	simpa using (Matroid.mapEquiv_indep_iff.mp hJ)
	simpa [encodeWeights] using sum_le_finiteOptimum M w (J.map e.symm.toEmbedding) hI
	· apply finiteOptimum_le _ _ (finiteOptimum_nonneg _ _)
	intro I hI
	have hJ : (M.mapEquiv e).Indep ((I.map e.toEmbedding : Finset β) : Set β) := by
	simpa using hI
	simpa [encodeWeights] using
	sum_le_finiteOptimum (M.mapEquiv e) (encodeWeights e w) (I.map e.toEmbedding) hJ

	@[simp] theorem finiteOptimum_fin {n : ℕ} (M : Matroid (Fin n)) (w : Weights n) :
	finiteOptimum M w = optimum M w := rfl

	@[simp] theorem encodeWeights_nonnegative_iff (e : α ≃ β) (w : α → ℝ) :
	(∀ b, 0 ≤ encodeWeights e w b) ↔ (∀ a, 0 ≤ w a) := by
	constructor
	· intro h a
	simpa [encodeWeights] using h (e a)
	· intro h b
	exact h (e.symm b)

	@[simp] theorem mapEquiv_ground_univ (M : Matroid α) (e : α ≃ β)
	(hE : M.E = Set.univ) : (M.mapEquiv e).E = Set.univ := by
	simp [hE]

	@[simp] theorem mapEquiv_loop_iff (M : Matroid α) (e : α ≃ β) (a : α) :
	(M.mapEquiv e).IsLoop (e a) ↔ M.IsLoop a := by
	exact Matroid.mapEmbedding_isLoop_iff

	/-- Every finite labeled matroid has a full-ground `Fin n` representative with
	exactly the original offline benchmark and all loop labels retained. -/
	theorem exists_fin_representation [Fintype α] (M : Matroid α) (hE : M.E = Set.univ) :
	∃ (e : α ≃ Fin (Fintype.card α)),
	(M.mapEquiv e).E = Set.univ ∧
	(∀ w : α → ℝ, optimum (M.mapEquiv e) (encodeWeights e w) = finiteOptimum M w) ∧
	(∀ a, (M.mapEquiv e).IsLoop (e a) ↔ M.IsLoop a) := by
	refine ⟨Fintype.equivFin α, mapEquiv_ground_univ M _ hE, ?_, ?_⟩
	· intro w
	exact finiteOptimum_mapEquiv M _ w
	· intro a
	exact mapEquiv_loop_iff M _ a

	/-- Coordinate reindexing is Borel, with no regularity assumption on weights. -/
	theorem measurable_encodeWeights (e : α ≃ β) : Measurable (encodeWeights e) := by
	apply Measurable.of_eval
	intro b
	exact measurable_pi_apply (e.symm b)

	theorem measurable_encodeHistory [Fintype α] [MeasurableSpace α]
	[MeasurableSingletonClass α] {n : ℕ} (e : α ≃ Fin n) (k : Fin n) :
	Measurable (encodeHistory e k) := by
	apply Measurable.of_eval
	intro j
	exact ((measurable_of_finite e).comp (measurable_fst.comp (measurable_pi_apply j))).prodMk
	(measurable_snd.comp (measurable_pi_apply j))

	/-- The transported rule is measurable in precisely its permissible inputs. -/
	theorem measurable_transportedDecision [Fintype α] [MeasurableSpace α]
	[MeasurableSingletonClass α] {n bits : ℕ} (e : α ≃ Fin n)
	(A : OnlineRule n bits) (k : Fin n) :
	Measurable (fun x : Seed bits × ((α → ℝ) × LabeledHistory α k) =>
	transportedDecision e A k x.1 x.2.1 x.2.2) := by
	exact (A.measurable_decide k).comp
	(measurable_fst.prodMk (((measurable_encodeWeights e).comp
	(measurable_fst.comp measurable_snd)).prodMk
	((measurable_encodeHistory e k).comp (measurable_snd.comp measurable_snd))))

	@[simp] theorem encodeHistory_labeledHistory {n : ℕ} (e : α ≃ Fin n)
	(w : α → ℝ) (π : LabeledOrder α n) (k : Fin n) :
	encodeHistory e k (labeledHistory w π k) =
	history (encodeWeights e w) (π.trans e) k := by
	funext j
	simp [encodeHistory, labeledHistory, history, encodeWeights]

	theorem transportedDecision_eq_decisionAt {n bits : ℕ} (e : α ≃ Fin n)
	(A : OnlineRule n bits) (r : Seed bits) (s v : α → ℝ)
	(π : LabeledOrder α n) (k : Fin n) :
	transportedDecision e A k r s (labeledHistory v π k) =
	decisionAt A r (encodeWeights e s) (encodeWeights e v) (π.trans e) k := by
	simp only [transportedDecision, encodeHistory_labeledHistory, decisionAt]

	/-- Exact accepted-set equality holds at every prefix, not just at termination. -/
	theorem transportedAcceptedThrough_eq_map [Fintype α] {n bits : ℕ}
	(e : α ≃ Fin n) (A : OnlineRule n bits) (r : Seed bits)
	(s v : α → ℝ) (π : LabeledOrder α n) (t : ℕ) :
	transportedAcceptedThrough e A r s v π t =
	(acceptedThrough A r (encodeWeights e s) (encodeWeights e v)
	(π.trans e) t).map e.symm.toEmbedding := by
	classical
	ext a
	rw [Finset.mem_map_equiv]
	simp only [transportedAcceptedThrough, acceptedThrough, Finset.mem_filter,
	Finset.mem_univ, true_and]
	simp only [transportedDecision_eq_decisionAt, Equiv.symm_symm,
	Equiv.symm_trans_apply, Equiv.symm_apply_apply]

	/-- The cardinal relabeling preserves the actual sum of accepted weights exactly. -/
	theorem transportedReward_eq_reward [Fintype α] {n bits : ℕ}
	(e : α ≃ Fin n) (A : OnlineRule n bits) (r : Seed bits)
	(s v : α → ℝ) (π : LabeledOrder α n) :
	transportedReward e A r s v π =
	reward A r (encodeWeights e s) (encodeWeights e v) (π.trans e) := by
	simp [transportedReward, transportedAcceptedThrough_eq_map, reward, accepted, encodeWeights]

	/-- Every-prefix feasibility transfers without dropping loops or exceptional inputs. -/
	theorem transported_feasible [Fintype α] {n bits : ℕ}
	(M : Matroid α) (e : α ≃ Fin n) (A : OnlineRule n bits)
	(hA : Feasible (M.mapEquiv e) A) (r : Seed bits)
	(s v : α → ℝ) (π : LabeledOrder α n) (t : ℕ)
	(hs : ∀ a, 0 ≤ s a) (hv : ∀ a, 0 ≤ v a) :
	M.Indep (transportedAcceptedThrough e A r s v π t : Set α) := by
	have hi := hA r (encodeWeights e s) (encodeWeights e v) (π.trans e) t
	((encodeWeights_nonnegative_iff e s).2 hs) ((encodeWeights_nonnegative_iff e v).2 hv)
	simpa only [transportedAcceptedThrough_eq_map, Finset.coe_map, Equiv.coe_toEmbedding]
	using Matroid.mapEquiv_indep_iff.mp hi

	/-- The relabeled implementation retains every previous acceptance irrevocably. -/
	theorem transportedAcceptedThrough_mono [Fintype α] {n bits : ℕ}
	(e : α ≃ Fin n) (A : OnlineRule n bits) (r : Seed bits)
	(s v : α → ℝ) (π : LabeledOrder α n) {t t' : ℕ} (htt' : t ≤ t') :
	transportedAcceptedThrough e A r s v π t ⊆
	transportedAcceptedThrough e A r s v π t' := by
	rw [transportedAcceptedThrough_eq_map, transportedAcceptedThrough_eq_map]
	exact Finset.map_subset_map.mpr (acceptedThrough_mono A r _ _ _ htt')

	end MatroidProphet.Relabeling

	end OAI