| import Mathlib.Basic.Real.Basic |
| import Mathlib.Combinatorics.SetFamily.Shatter |
| import Mathlib.LinearAlgebra.Dual.Lemmas |
| import Mathlib.Algebra.Order.BigOperators.Group.Finset |
| import Mathlib.Tactic.Linarith |
|
|
| namespace OAI |
|
|
| namespace MatroidProphet |
| namespace Pivots |
|
|
| open scoped BigOperators |
|
|
| variable {ι X : Type*} [Fintype ι] [DecidableEq ι] |
| variable [AddCommGroup X] [Module ℝ X] |
|
|
| def RealizesSigns (v : ι → X →ₗ[ℝ] ℝ) (c : ι → ℝ) |
| (t : Finset ι) (x : X) : Prop := |
| ∀ i, if i ∈ t then 0 < v i x + c i else v i x + c i < 0 |
|
|
| noncomputable def affinePatterns (v : ι → X →ₗ[ℝ] ℝ) (c : ι → ℝ) : |
| Finset (Finset ι) := by |
| classical |
| exact Finset.univ.filter (fun t => ∃ x, RealizesSigns v c t x) |
|
|
| lemma mem_affinePatterns {v : ι → X →ₗ[ℝ] ℝ} {c : ι → ℝ} {t : Finset ι} : |
| t ∈ affinePatterns v c ↔ ∃ x, RealizesSigns v c t x := by |
| classical |
| simp [affinePatterns] |
|
|
| private lemma exists_positive_combination |
| (v : ι → X →ₗ[ℝ] ℝ) (c : ι → ℝ) |
| (hreal : ∀ t : Finset ι, ∃ x, RealizesSigns v c t x) |
| (a : ι → ℝ) (ha : ∃ i, a i ≠ 0) : |
| ∃ x, 0 < ∑ i, a i * (v i x + c i) := by |
| classical |
| obtain ⟨x, hx⟩ := hreal (Finset.univ.filter (fun i => 0 < a i)) |
| have hpos (i : ι) (hai : 0 < a i) : 0 < v i x + c i := by |
| simpa [RealizesSigns, hai] using hx i |
| have hneg (i : ι) (hai : ¬ 0 < a i) : v i x + c i < 0 := by |
| simpa [RealizesSigns, hai] using hx i |
| refine ⟨x, Finset.sum_pos' (fun i _ => ?_) ?_⟩ |
| · by_cases hai : 0 < a i |
| · exact mul_nonneg (le_of_lt hai) (le_of_lt (hpos i hai)) |
| · exact mul_nonneg_of_nonpos_of_nonpos (le_of_not_gt hai) (le_of_lt (hneg i hai)) |
| · obtain ⟨i, hi⟩ := ha |
| refine ⟨i, Finset.mem_univ i, ?_⟩ |
| by_cases hai : 0 < a i |
| · exact mul_pos hai (hpos i hai) |
| · exact mul_pos_of_neg_of_neg (lt_of_le_of_ne (le_of_not_gt hai) hi) (hneg i hai) |
|
|
| omit [DecidableEq ι] in |
| private lemma sum_affine_eq_of_linear_combination_zero |
| {v : ι → X →ₗ[ℝ] ℝ} (c : ι → ℝ) {a : ι → ℝ} |
| (ha : ∑ i, a i • v i = 0) (x : X) : |
| (∑ i, a i * (v i x + c i)) = ∑ i, a i * c i := by |
| have hz := congrArg (fun f : X →ₗ[ℝ] ℝ => f x) ha |
| simp only [LinearMap.sum_apply, LinearMap.smul_apply, smul_eq_mul, |
| LinearMap.zero_apply] at hz |
| simp_rw [mul_add, Finset.sum_add_distrib] |
| rw [hz, zero_add] |
|
|
| lemma linearIndependent_of_all_signs |
| (v : ι → X →ₗ[ℝ] ℝ) (c : ι → ℝ) |
| (hreal : ∀ t : Finset ι, ∃ x, RealizesSigns v c t x) : |
| LinearIndependent ℝ v := by |
| classical |
| rw [Fintype.linearIndependent_iff] |
| intro a ha i |
| by_contra hi |
| obtain ⟨x, hx⟩ := exists_positive_combination v c hreal a ⟨i, hi⟩ |
| obtain ⟨y, hy⟩ := exists_positive_combination v c hreal (fun j => -a j) |
| ⟨i, neg_ne_zero.mpr hi⟩ |
| simp only [neg_mul, Finset.sum_neg_distrib] at hy |
| rw [sum_affine_eq_of_linear_combination_zero c ha x] at hx |
| rw [sum_affine_eq_of_linear_combination_zero c ha y] at hy |
| linarith |
|
|
| lemma all_signs_of_shatters {v : ι → X →ₗ[ℝ] ℝ} {c : ι → ℝ} |
| {s : Finset ι} (hs : (affinePatterns v c).Shatters s) : |
| ∀ t : Finset s, ∃ x, |
| RealizesSigns (fun i : s => v i) (fun i : s => c i) t x := by |
| classical |
| intro t |
| obtain ⟨u, hu, hsu⟩ := hs (t := t.image Subtype.val) (by |
| intro i hi |
| obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hi |
| exact j.property) |
| obtain ⟨x, hx⟩ := mem_affinePatterns.mp hu |
| refine ⟨x, fun i => ?_⟩ |
| have hi : (i : ι) ∈ u ↔ i ∈ t := by |
| have heq := congrArg (fun z : Finset ι => (i : ι) ∈ z) hsu |
| simpa [Finset.mem_image, i.property] using heq |
| simpa only [hi] using hx i |
|
|
| lemma shatters_card_le_finrank [FiniteDimensional ℝ X] |
| {v : ι → X →ₗ[ℝ] ℝ} {c : ι → ℝ} {s : Finset ι} |
| (hs : (affinePatterns v c).Shatters s) : s.card ≤ Module.finrank ℝ X := by |
| have hli := linearIndependent_of_all_signs |
| (fun i : s => v i) (fun i : s => c i) (all_signs_of_shatters hs) |
| have hc := hli.fintype_card_le_finrank |
| simpa using hc |
|
|
| lemma card_affinePatterns_le [FiniteDimensional ℝ X] |
| (v : ι → X →ₗ[ℝ] ℝ) (c : ι → ℝ) : |
| (affinePatterns v c).card ≤ |
| ∑ k ∈ Finset.Iic (Module.finrank ℝ X), (Fintype.card ι).choose k := by |
| classical |
| have hdim : (affinePatterns v c).vcDim ≤ Module.finrank ℝ X := by |
| unfold Finset.vcDim |
| exact Finset.sup_le (fun s hs => shatters_card_le_finrank (Finset.mem_shatterer.mp hs)) |
| exact (Finset.card_le_card_shatterer _).trans |
| (Finset.card_shatterer_le_sum_vcDim.trans |
| (Finset.sum_le_sum_of_subset_of_nonneg (Finset.Iic_subset_Iic.mpr hdim) |
| (fun _ _ _ => Nat.zero_le _))) |
|
|
| end Pivots |
| end MatroidProphet |
|
|
| end OAI |
|
|
