| import OAI.Combinatorics.DiscreteConvexity.Basic |
| import Mathlib.Data.Fintype.Pi |
| import Mathlib.Data.Fintype.Prod |
| import Mathlib.Data.Fintype.Powerset |
| import Mathlib.Data.Finset.Union |
|
|
| namespace OAI |
|
|
| /-! |
| # Finite objects in the elementary covering argument |
|
|
| Sampling is indexed by ordered pairs of edges, including diagonal pairs. |
| Different pairs remain different indices even if their unions coincide. |
| Residual generators are indexed by injective ordered tuples. |
| -/ |
|
|
| namespace TalagrandDiscreteConvexity.Covering |
|
|
| variable {V : Type*} [DecidableEq V] |
|
|
| / |
| def EdgeTuple (H : Family V) (t : ℕ) := |
| {f : Fin t → ↥H // Function.Injective f} |
|
|
| noncomputable instance edgeTupleFintype (H : Family V) (t : ℕ) : |
| Fintype (EdgeTuple H t) := by |
| classical |
| exact Subtype.fintype _ |
|
|
| / |
| abbrev PairIndex (H : Family V) := ↥H × ↥H |
|
|
| / |
| abbrev Sample (H : Family V) := Finset (PairIndex H) |
|
|
| def tupleUnion {H : Family V} {t : ℕ} (f : EdgeTuple H t) : Finset V := |
| Finset.univ.biUnion (fun i => (f.val i).val) |
|
|
| noncomputable def tuplePairs {H : Family V} {t : ℕ} |
| (f : EdgeTuple H t) : Finset (PairIndex H) := by |
| classical |
| exact Finset.univ.image (fun ij : Fin t × Fin t => (f.val ij.1, f.val ij.2)) |
|
|
| @[simp] theorem mem_tupleUnion {H : Family V} {t : ℕ} |
| {f : EdgeTuple H t} {v : V} : |
| v ∈ tupleUnion f ↔ ∃ i, v ∈ (f.val i).val := by |
| simp [tupleUnion] |
|
|
| @[simp] theorem mem_tuplePairs {H : Family V} {t : ℕ} |
| {f : EdgeTuple H t} {p : PairIndex H} : |
| p ∈ tuplePairs f ↔ ∃ i j, (f.val i, f.val j) = p := by |
| classical |
| simp [tuplePairs, Prod.exists] |
|
|
| / |
| noncomputable def weightedDegree (H : Family V) (rho : ℝ) (r : ℕ) |
| (I : Finset V) : ℝ := by |
| classical |
| exact ((H.filter (fun e => I ⊆ e)).card : ℝ) * rho ^ (r - I.card) |
|
|
| / |
| noncomputable def regularFamily (H C0 : Family V) : Family V := by |
| classical |
| exact H.filter (fun e => ∀ I ∈ C0, ¬ I ⊆ e) |
|
|
| @[simp] theorem mem_regularFamily {H C0 : Family V} {e : Finset V} : |
| e ∈ regularFamily H C0 ↔ e ∈ H ∧ ∀ I ∈ C0, ¬ I ⊆ e := by |
| classical |
| simp [regularFamily] |
|
|
| theorem regularFamily_subset (H C0 : Family V) : regularFamily H C0 ⊆ H := by |
| intro e he |
| exact (mem_regularFamily.mp he).1 |
|
|
| section FiniteGround |
|
|
| variable [Fintype V] |
|
|
| / |
| noncomputable def initialFamily (H : Family V) (rho : ℝ) (r : ℕ) |
| (T : ℝ) : Family V := by |
| classical |
| exact Finset.univ.filter (fun I => I.card ≤ r ∧ T < weightedDegree H rho r I) |
|
|
| / |
| noncomputable def regularEdges (H : Family V) (rho : ℝ) (r : ℕ) |
| (T : ℝ) : Family V := regularFamily H (initialFamily H rho r T) |
|
|
| / |
| noncomputable def denseFamily (H : Family V) (m : ℕ) : Family V := by |
| classical |
| exact Finset.univ.filter (fun S => m ≤ (H.filter (fun e => e ⊆ S)).card) |
|
|
| @[simp] theorem mem_initialFamily {H : Family V} {rho T : ℝ} |
| {r : ℕ} {I : Finset V} : |
| I ∈ initialFamily H rho r T ↔ I.card ≤ r ∧ T < weightedDegree H rho r I := by |
| classical |
| simp [initialFamily] |
|
|
| @[simp] theorem mem_regularEdges {H : Family V} {rho T : ℝ} |
| {r : ℕ} {e : Finset V} : |
| e ∈ regularEdges H rho r T ↔ |
| e ∈ H ∧ ∀ I ∈ initialFamily H rho r T, ¬ I ⊆ e := by |
| exact mem_regularFamily |
|
|
| @[simp] theorem mem_denseFamily {H : Family V} {m : ℕ} {S : Finset V} : |
| S ∈ denseFamily H m ↔ m ≤ (H.filter (fun e => e ⊆ S)).card := by |
| classical |
| simp [denseFamily] |
|
|
| theorem regularEdges_subset (H : Family V) (rho : ℝ) (r : ℕ) (T : ℝ) : |
| regularEdges H rho r T ⊆ H := regularFamily_subset _ _ |
|
|
| end FiniteGround |
|
|
| end TalagrandDiscreteConvexity.Covering |
|
|
| end OAI |
|
|
