| import OAI.Probability.MatroidProphet.Pivots.Interleavings |
| import Mathlib.Data.Fintype.Fin |
|
|
| namespace OAI |
|
|
| namespace MatroidProphet |
| namespace Pivots |
|
|
| open Finset |
|
|
| variable {r q : ℕ} |
|
|
| def oldBefore (time : Occurrence r q → ℕ) (t : ℕ) : ℕ := |
| (Finset.univ.filter (fun i : Fin r => time (Sum.inl i) < t)).card |
|
|
| def movableBefore (time : Occurrence r q → ℕ) (t : ℕ) : ℕ := |
| (Finset.univ.filter (fun i : Fin q => time (Sum.inr i) < t)).card |
|
|
| lemma oldBefore_mono (time : Occurrence r q → ℕ) : Monotone (oldBefore time) := by |
| intro u v huv |
| apply Finset.card_le_card |
| intro i hi |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, |
| lt_of_lt_of_le (Finset.mem_filter.mp hi).2 huv⟩ |
|
|
| lemma movableBefore_mono (time : Occurrence r q → ℕ) : Monotone (movableBefore time) := by |
| intro u v huv |
| apply Finset.card_le_card |
| intro i hi |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, |
| lt_of_lt_of_le (Finset.mem_filter.mp hi).2 huv⟩ |
|
|
| lemma oldBefore_lt_after (time : Occurrence r q → ℕ) (i : Fin r) {t : ℕ} |
| (hit : time (Sum.inl i) < t) : |
| oldBefore time (time (Sum.inl i)) < oldBefore time t := by |
| apply Finset.card_lt_card |
| apply Finset.ssubset_iff_subset_ne.mpr |
| constructor |
| · intro j hj |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, lt_trans (Finset.mem_filter.mp hj).2 hit⟩ |
| · intro heq |
| have hi : i ∈ Finset.univ.filter (fun j : Fin r => time (Sum.inl j) < t) := by simp [hit] |
| rw [← heq] at hi |
| simp at hi |
|
|
| lemma movableBefore_lt_after (time : Occurrence r q → ℕ) (i : Fin q) {t : ℕ} |
| (hit : time (Sum.inr i) < t) : |
| movableBefore time (time (Sum.inr i)) < movableBefore time t := by |
| apply Finset.card_lt_card |
| apply Finset.ssubset_iff_subset_ne.mpr |
| constructor |
| · intro j hj |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, lt_trans (Finset.mem_filter.mp hj).2 hit⟩ |
| · intro heq |
| have hi : i ∈ Finset.univ.filter (fun j : Fin q => time (Sum.inr j) < t) := by simp [hit] |
| rw [← heq] at hi |
| simp at hi |
|
|
| lemma movableBefore_self_lt (time : Occurrence r q → ℕ) (i : Fin q) : |
| movableBefore time (time (Sum.inr i)) < q := by |
| have hcard : (Finset.univ.filter (fun j : Fin q => time (Sum.inr j) < time (Sum.inr i))).card < |
| (Finset.univ : Finset (Fin q)).card := by |
| apply Finset.card_lt_card |
| apply Finset.ssubset_iff_subset_ne.mpr |
| refine ⟨Finset.filter_subset _ _, ?_⟩ |
| intro heq |
| have hi : i ∈ (Finset.univ : Finset (Fin q)) := Finset.mem_univ _ |
| rw [← heq] at hi |
| simp at hi |
| simpa [movableBefore] using hcard |
|
|
| lemma old_time_lt_iff (time : Occurrence r q → ℕ) (horder : OldOrdered time) |
| (i j : Fin r) : time (Sum.inl i) < time (Sum.inl j) ↔ i < j := by |
| refine ⟨fun hij => ?_, fun hij => horder i j hij⟩ |
| by_contra h |
| rcases lt_or_eq_of_le (le_of_not_gt h) with hji | rfl |
| · exact Nat.lt_asymm (horder j i hji) hij |
| · exact Nat.lt_irrefl _ hij |
|
|
| lemma oldBefore_self (time : Occurrence r q → ℕ) (horder : OldOrdered time) (i : Fin r) : |
| oldBefore time (time (Sum.inl i)) = i.val := by |
| unfold oldBefore |
| have heq : Finset.univ.filter (fun j : Fin r => time (Sum.inl j) < time (Sum.inl i)) = |
| Finset.Iio i := by |
| ext j |
| simp [old_time_lt_iff time horder] |
| rw [heq, Fin.card_Iio] |
|
|
| def scoreExponent (s : ℕ) (time : Occurrence r q → ℕ) : Occurrence r q → ℕ |
| | Sum.inl i => (s + 1) * (i.val + 1) |
| | Sum.inr i => (s + 1) * oldBefore time (time (Sum.inr i)) + |
| movableBefore time (time (Sum.inr i)) + 1 |
|
|
| @[simp] lemma scoreExponent_old (s : ℕ) (time : Occurrence r q → ℕ) (i : Fin r) : |
| scoreExponent s time (Sum.inl i) = (s + 1) * (i.val + 1) := rfl |
|
|
| lemma scoreExponent_preserves_order (s : ℕ) (hqs : q ≤ s) |
| (time : Occurrence r q → ℕ) (horder : OldOrdered time) |
| {o p : Occurrence r q} (hop : time o < time p) : |
| scoreExponent s time o < scoreExponent s time p := by |
| cases o with |
| | inl i => |
| cases p with |
| | inl j => |
| have hij := (old_time_lt_iff time horder i j).mp hop |
| exact Nat.mul_lt_mul_of_pos_left (Nat.add_lt_add_right hij 1) (by omega) |
| | inr j => |
| have hcnt := oldBefore_lt_after time i hop |
| rw [oldBefore_self time horder i] at hcnt |
| have hmul := Nat.mul_le_mul_left (s + 1) (Nat.succ_le_of_lt hcnt) |
| simp only [Nat.succ_eq_add_one] at hmul |
| simp only [scoreExponent] |
| omega |
| | inr i => |
| have hbound := lt_of_lt_of_le (movableBefore_self_lt time i) hqs |
| have hmono := oldBefore_mono time (Nat.le_of_lt hop) |
| cases p with |
| | inl j => |
| rw [oldBefore_self time horder j] at hmono |
| have hmul := Nat.mul_le_mul_left (s + 1) hmono |
| simp only [scoreExponent, Nat.mul_add, Nat.mul_one] |
| omega |
| | inr j => |
| have hstrict := movableBefore_lt_after time i hop |
| rcases Nat.eq_or_lt_of_le hmono with heq | hlt |
| · simp only [scoreExponent] |
| rw [heq] |
| omega |
| · have hmul := Nat.mul_le_mul_left (s + 1) (Nat.succ_le_of_lt hlt) |
| simp only [Nat.succ_eq_add_one, Nat.mul_add, Nat.mul_one] at hmul |
| simp only [scoreExponent] |
| omega |
|
|
| lemma scoreExponent_injective (s : ℕ) (hqs : q ≤ s) |
| (time : Occurrence r q → ℕ) (horder : OldOrdered time) (htime : Function.Injective time) : |
| Function.Injective (scoreExponent s time) := by |
| intro o p heq |
| apply htime |
| apply le_antisymm |
| · by_contra h |
| have hlt := scoreExponent_preserves_order s hqs time horder (Nat.lt_of_not_ge h) |
| omega |
| · by_contra h |
| have hlt := scoreExponent_preserves_order s hqs time horder (Nat.lt_of_not_ge h) |
| omega |
|
|
| end Pivots |
| end MatroidProphet |
|
|
| end OAI |
|
|
