Mathesis

Profile

Adhishraya Sharmaadhishrayasperson2026-09-27T17:43:43Z

Declsecond_probe

(n : Nat) → @Eq Nat (@HAdd.hAdd Nat Nat Nat (@instHAdd Nat instAddNat) n 0) n

Thesis

Declsecond_probeDeclaration kindtheorem

(n : Nat) → @Eq Nat (@HAdd.hAdd Nat Nat Nat (@instHAdd Nat instAddNat) n 0) n

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

Pajor's inequality, with no finiteness assumptions: the traces of 𝒜 on A are at most as many as the subsets of A shattered by 𝒜. For a finite trace family this is a descent on the number of traces that never consumes the ground set; an infinite trace family forces infinitely many shattered singletons, and both sides are ⊤.

Dvir, Filmus and Moran, A Sauer-Shelah-Perles Lemma for Lattices, credit the Boolean lattice case to Pajor (Sous-espaces ℓ₁ⁿ des espaces de Banach, Travaux en Cours 16, Hermann, Paris, 1985) and to Aharoni and Holzman, unpublished. Their Theorem 1.2 is the lattice form, for finite lattices with nonvanishing Möbius function: a family shatters at least as many elements as it has members. Reading that for a family of traces on a ground set is the standard translation into the language of set families, and the statement here carries no finiteness hypothesis, which theirs does.

Declencard_image_inter_le_encard_shatters

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, ((fun x => A ∩ x) '' 𝒜).encard ≤ {B | B ⊆ A ∧ Shatters 𝒜 B}.encard

TopicTraces and shattering

Relations

Generalised byMTH.C-2026-6005
At Y = Bool this specialises to Pajor's inequality.
Asserted by Dhruv Gupta

ThesisStepDefinitionCited result

Declencard_image_inter_le_encard_shattersDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, ((fun x => A ∩ x) '' 𝒜).encard ≤ {B | B ⊆ A ∧ Shatters 𝒜 B}.encard

Shatters

Uses

infinite_setOf_shatters
pajor_encard_aux

Declpajor_encard_auxDeclaration kindtheorem
```
∀ {α : Type u_1} {A : Set α} (N : ℕ) (𝒜 : Set (Set α)),
  ((fun x => A ∩ x) '' 𝒜).Finite →
    ((fun x => A ∩ x) '' 𝒜).ncard ≤ N → ((fun x => A ∩ x) '' 𝒜).encard ≤ {B | B ⊆ A ∧ Shatters 𝒜 B}.encard
```
Shatters Shatters.mono shatters_bot
Uses
Used by
- encard_image_inter_le_encard_shatters

Decltrace_sep_unionDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α} {x : α},
  (fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∉ C} ∪ (fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∈ C} = (fun x => A ∩ x) '' 𝒜

Used by

pajor_encard_aux

Decltrace_sep_disjointDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α} {x : α},
  x ∈ A → Disjoint ((fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∉ C}) ((fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∈ C})

Used by

pajor_encard_aux

DeclnotMem_of_shatters_sep_rightDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, Shatters {C | C ∈ 𝒜 ∧ x ∈ C} B → x ∉ B
```
Shatters Shatters.preimage_compl
Uses
- notMem_of_forall_notMem
Used by
- pajor_encard_aux

DeclnotMem_of_shatters_sep_leftDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, Shatters {C | C ∈ 𝒜 ∧ x ∉ C} B → x ∉ B

Shatters

Uses

notMem_of_forall_notMem

Used by

pajor_encard_aux

DeclnotMem_of_forall_notMemDeclaration kindtheorem
A family whose members all avoid x shatters only sets avoiding x.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, (∀ C ∈ 𝒜, x ∉ C) → Shatters 𝒜 B → x ∉ B
```
Shatters Shatters.exists_ge
Used by
- notMem_of_shatters_sep_left
- notMem_of_shatters_sep_right
Declinsert_injOn_notMemDeclaration kindtheorem
Inserting a fixed element is injective on the sets avoiding it: the element can be removed again, recovering the argument.
```
∀ {α : Type u_1} (x : α), Set.InjOn (insert x) {B | x ∉ B}
```
Used by
- pajor_encard_aux

Declexists_splitterDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α},
  ((fun x => A ∩ x) '' 𝒜).Nontrivial → ∃ x ∈ A, (∃ C ∈ 𝒜, x ∈ C) ∧ ∃ C ∈ 𝒜, x ∉ C

Uses

exists_splitter_of_not_subset

Used by

pajor_encard_aux

Declexists_splitter_of_not_subsetDeclaration kindtheorem

A point of A witnessing that one trace fails to contain another is a point at which 𝒜 splits.

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A C C' : Set α},
  C ∈ 𝒜 → C' ∈ 𝒜 → ¬A ∩ C ⊆ A ∩ C' → ∃ x ∈ A, (∃ D ∈ 𝒜, x ∈ D) ∧ ∃ D ∈ 𝒜, x ∉ D

Used by

exists_splitter

Decldisjoint_image_insertDeclaration kindtheorem
A family whose members all avoid x is disjoint from any family of sets containing x.
```
∀ {α : Type u_1} {x : α} {𝒮 𝒯 : Set (Set α)}, (∀ B ∈ 𝒮, x ∉ B) → Disjoint 𝒮 (insert x '' 𝒯)
```
Used by
- pajor_encard_aux
DeclShatters.insertDeclaration kindtheorem
If B is shattered both by the members of 𝒜 avoiding x and by the members of 𝒜 containing x, then 𝒜 shatters insert x B. This is the exchange step in the proof of Pajor's inequality.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α},
  Shatters {C | C ∈ 𝒜 ∧ x ∉ C} B → Shatters {C | C ∈ 𝒜 ∧ x ∈ C} B → Shatters 𝒜 (insert x B)
```
Shatters
Uses
- Shatters.exists_inter_eq
- Shatters.of_forall_subset
Used by
- pajor_encard_aux
Declinfinite_setOf_shattersDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, ((fun x => A ∩ x) '' 𝒜).Infinite → {B | B ⊆ A ∧ Shatters 𝒜 B}.Infinite
```
Shatters splitPoints
Uses
- finite_image_inter_of_finite_splitPoints
- singleton_image_splitPoints_subset
Used by
- encard_image_inter_le_encard_shatters
Declsingleton_image_splitPoints_subsetDeclaration kindtheorem
The singleton of a point at which 𝒜 splits is shattered by 𝒜.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (fun x => {x}) '' splitPoints✝ 𝒜 A ⊆ {B | B ⊆ A ∧ Shatters 𝒜 B}
```
Shatters splitPoints
Uses
- shatters_singleton
Used by
- infinite_setOf_shatters
Declshatters_singletonDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {x : α}, Shatters 𝒜 {x} ↔ (∃ C ∈ 𝒜, x ∈ C) ∧ ∃ C ∈ 𝒜, x ∉ C
```
Shatters
Uses
- Shatters.exists_inter_eq
- Shatters.of_forall_subset
Used by
- singleton_image_splitPoints_subset
DeclShatters.of_forall_subsetDeclaration kindtheorem
Shatters read at Set α, as an introduction rule; the ∩-shaped companion of Shatters.of_forall_le.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (∀ ⦃B : Set α⦄, B ⊆ A → ∃ C ∈ 𝒜, A ∩ C = B) → Shatters 𝒜 A
```
Shatters
Used by
- Shatters.insert
- shatters_singleton
DeclShatters.exists_inter_eqDeclaration kindtheorem
Shatters read at Set α, where ⊓ is ∩ and ≤ is ⊆: every subset of A is the intersection of A with a member of 𝒜. Definitionally the same statement, stated in the shape every use site wants, so that consumers obtain an ∩-typed equation directly.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A B : Set α}, Shatters 𝒜 A → B ⊆ A → ∃ C ∈ 𝒜, A ∩ C = B
```
Shatters
Used by
- Shatters.insert
- shatters_singleton
Declfinite_image_inter_of_finite_splitPointsDeclaration kindtheorem
A family splitting A at finitely many elements has finitely many traces on A.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (splitPoints✝ 𝒜 A).Finite → ((fun x => A ∩ x) '' 𝒜).Finite
```
splitPoints
Uses
- injOn_inter_splitPoints
Used by
- infinite_setOf_shatters
DeclinjOn_inter_splitPointsDeclaration kindtheorem
A trace of 𝒜 on A is determined by its restriction to the elements at which 𝒜 splits: elsewhere, membership in the trace is decided by A alone.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, Set.InjOn (fun x => x ∩ splitPoints✝ 𝒜 A) ((fun x => A ∩ x) '' 𝒜)
```
splitPoints
Used by
- finite_image_inter_of_finite_splitPoints
DefinitionShattersdefYaël Dillies
A set family 𝒜 shatters a set A if all subsets of A can be obtained as the intersection of A with some element of the set family. We also say that A is traced by 𝒜.
```
{α : Type u_1} → [SemilatticeInf α] → Set α → α → Prop
```

Cited resultShatters.exists_getheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 : Set α} {A : α}, Shatters 𝒜 A → ∃ B ∈ 𝒜, A ≤ B

Cited resultShatters.monotheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 ℬ : Set α} {A : α}, 𝒜 ⊆ ℬ → Shatters 𝒜 A → Shatters ℬ A

Cited resultShatters.preimage_compltheoremYaël Dillies

∀ {α : Type u_1} [inst : BooleanAlgebra α] {𝒜 : Set α} {A : α}, Shatters 𝒜 A → Shatters ((fun x => xᶜ) ⁻¹' 𝒜) A

Cited resultshatters_bottheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 : Set α} [inst_1 : OrderBot α], Shatters 𝒜 ⊥ ↔ 𝒜.Nonempty

DefinitionsplitPointsdef
The elements of A at which 𝒜 splits: some member of 𝒜 contains them and some does not. These are exactly the elements whose singleton 𝒜 shatters.
```
{α : Type u_1} → Set (Set α) → Set α → Set α
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

DeclHasVCDimLE.vcGrowth_le_exp

∀ {α : Type u_1} {n d : ℕ} {𝒜 : Set (Set α)}, HasVCDimLE d 𝒜 → d ≤ n → ↑(vcGrowth n 𝒜) ≤ (Real.exp 1 / ↑d * ↑n) ^ d

TopicTraces and shattering

ThesisStepHypothesisDefinitionCited result

DeclHasVCDimLE.vcGrowth_le_expDeclaration kindtheorem

∀ {α : Type u_1} {n d : ℕ} {𝒜 : Set (Set α)}, HasVCDimLE d 𝒜 → d ≤ n → ↑(vcGrowth n 𝒜) ≤ (Real.exp 1 / ↑d * ↑n) ^ d

HasVCDimLE vcGrowth

Uses

HasVCDimLE.vcGrowth_le_sum_range
sum_choose_le_exp_pow

Declsum_choose_le_exp_powDeclaration kindtheorem
```
∀ (d m : ℕ), 0 < d → d ≤ m → ∑ i ∈ Finset.range (d + 1), ↑(m.choose i) ≤ (Real.exp 1 / ↑d * ↑m) ^ d
```
Uses
Used by
- HasVCDimLE.vcGrowth_le_exp
Declsum_choose_mul_pow_le_add_one_powDeclaration kindtheorem
Truncating a binomial expansion at degree d can only decrease it, for t ≥ 0.
```
∀ {m d : ℕ} {t : ℝ}, 0 ≤ t → d ≤ m → ∑ i ∈ Finset.range (d + 1), ↑(m.choose i) * t ^ i ≤ (1 + t) ^ m
```
Used by
- sum_choose_le_exp_pow

Declsum_choose_le_mul_sum_choose_mul_powDeclaration kindtheorem

Undoing the weighting t ^ i costs a single factor (m / d) ^ d, since t = d / m and each i in range is at most d.

∀ {m d : ℕ},
  0 < ↑d →
    0 < ↑m →
      ↑d ≤ ↑m →
        ∑ i ∈ Finset.range (d + 1), ↑(m.choose i) ≤
          (↑m / ↑d) ^ d * ∑ i ∈ Finset.range (d + 1), ↑(m.choose i) * (↑d / ↑m) ^ i

Used by

sum_choose_le_exp_pow

Declone_add_div_pow_le_exp_powDeclaration kindtheorem
At t = d / m, the binomial base is bounded by exp 1 raised to the degree.
```
∀ {m d : ℕ}, 0 < ↑m → (1 + ↑d / ↑m) ^ m ≤ Real.exp 1 ^ d
```
Used by
- sum_choose_le_exp_pow
DeclHasVCDimLE.vcGrowth_le_sum_rangeDeclaration kindtheorem
The Sauer-Shelah inequality, with the sum indexed by Finset.range (d + 1).
```
∀ {α : Type u_1} {n d : ℕ} {𝒜 : Set (Set α)}, HasVCDimLE d 𝒜 → vcGrowth n 𝒜 ≤ ∑ k ∈ Finset.range (d + 1), n.choose k
```
HasVCDimLE vcGrowth
Uses
- HasVCDimLE.vcGrowth_le
Used by
- HasVCDimLE.vcGrowth_le_exp
DeclHasVCDimLE.vcGrowth_leDeclaration kindtheorem
```
∀ {α : Type u_1} {n d : ℕ} {𝒜 : Set (Set α)}, HasVCDimLE d 𝒜 → vcGrowth n 𝒜 ≤ ∑ k ∈ Finset.Iic d, n.choose k
```
HasVCDimLE vcGrowth vcGrowth_le_iff
Uses
- HasVCDimLE.ncard_image_inter_le
Used by
- HasVCDimLE.vcGrowth_le_sum_range
DeclHasVCDimLE.ncard_image_inter_leDeclaration kindtheorem
The Sauer-Shelah inequality: a family of VC dimension at most d traces at most ∑ k ≤ d, n.choose k sets on any finite set of size at most n. The proof here derives it from Pajor's inequality.
Simon, A Guide to NIP Theories, states the same bound as his Lemma 6.4, for the growth function of a class of VC dimension at most k, and records in the notes to that chapter that the lemma is implicit in Vapnik and Chervonenkis (1971) and was rediscovered independently by Shelah (1972) and by Sauer (1972). Dvir, Filmus and Moran state it in the introduction to A Sauer-Shelah-Perles Lemma for Lattices and cite the same three sources. Perles is carried in the name they give the lemma; a publication of his is cited by neither source.
```
∀ {α : Type u_1} {n d : ℕ} {𝒜 : Set (Set α)} {A : Set α},
  HasVCDimLE d 𝒜 → A.Finite → A.ncard ≤ n → ((fun x => A ∩ x) '' 𝒜).ncard ≤ ∑ k ∈ Finset.Iic d, n.choose k
```
HasVCDimLE Shatters
Uses
Used by
- HasVCDimLE.vcGrowth_le
Declncard_setOf_ncard_leDeclaration kindtheorem
```
∀ {α : Type u_1} {A : Set α},
  A.Finite → ∀ (d : ℕ), {B | B ⊆ A ∧ B.ncard ≤ d}.ncard = ∑ k ∈ Finset.Iic d, A.ncard.choose k
```
Uses
Used by
- HasVCDimLE.ncard_image_inter_le

DeclsetOf_subset_and_ncard_le_zeroDeclaration kindtheorem

∀ {α : Type u_1} {A : Set α}, A.Finite → {B | B ⊆ A ∧ B.ncard ≤ 0} = {∅}

Used by

ncard_setOf_ncard_le

DeclsetOf_subset_and_ncard_le_succDeclaration kindtheorem
The subsets of A of size at most d + 1 split into those of size at most d and those of size exactly d + 1.
```
∀ {α : Type u_1} (d : ℕ) (A : Set α),
  {B | B ⊆ A ∧ B.ncard ≤ d + 1} = {B | B ⊆ A ∧ B.ncard ≤ d} ∪ {B | B ⊆ A ∧ B.ncard = d + 1}
```
Used by
- ncard_setOf_ncard_le

Decldisjoint_setOf_ncard_le_setOf_ncard_eqDeclaration kindtheorem

∀ {α : Type u_1} (d : ℕ) (A : Set α), Disjoint {B | B ⊆ A ∧ B.ncard ≤ d} {B | B ⊆ A ∧ B.ncard = d + 1}

Used by

ncard_setOf_ncard_le

Declncard_image_inter_le_ncard_setOf_shattersDeclaration kindtheorem
The ncard transfer of encard_image_inter_le_encard_shatters, for A finite. Internal: the general statement is the encard one, which needs no hypothesis.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α},
  A.Finite → ((fun x => A ∩ x) '' 𝒜).ncard ≤ {B | B ⊆ A ∧ Shatters 𝒜 B}.ncard
```
Shatters
Uses
- encard_image_inter_le_encard_shatters
- finite_setOf_subset_and
Used by
- HasVCDimLE.ncard_image_inter_le
Declencard_image_inter_le_encard_shattersDeclaration kindtheorem
Pajor's inequality, with no finiteness assumptions: the traces of 𝒜 on A are at most as many as the subsets of A shattered by 𝒜. For a finite trace family this is a descent on the number of traces that never consumes the ground set; an infinite trace family forces infinitely many shattered singletons, and both sides are ⊤.
Dvir, Filmus and Moran, A Sauer-Shelah-Perles Lemma for Lattices, credit the Boolean lattice case to Pajor (Sous-espaces ℓ₁ⁿ des espaces de Banach, Travaux en Cours 16, Hermann, Paris, 1985) and to Aharoni and Holzman, unpublished. Their Theorem 1.2 is the lattice form, for finite lattices with nonvanishing Möbius function: a family shatters at least as many elements as it has members. Reading that for a family of traces on a ground set is the standard translation into the language of set families, and the statement here carries no finiteness hypothesis, which theirs does.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, ((fun x => A ∩ x) '' 𝒜).encard ≤ {B | B ⊆ A ∧ Shatters 𝒜 B}.encard
```
Shatters
Uses
- infinite_setOf_shatters
- pajor_encard_aux
Used by
- ncard_image_inter_le_ncard_setOf_shatters
Declpajor_encard_auxDeclaration kindtheorem
```
∀ {α : Type u_1} {A : Set α} (N : ℕ) (𝒜 : Set (Set α)),
  ((fun x => A ∩ x) '' 𝒜).Finite →
    ((fun x => A ∩ x) '' 𝒜).ncard ≤ N → ((fun x => A ∩ x) '' 𝒜).encard ≤ {B | B ⊆ A ∧ Shatters 𝒜 B}.encard
```
Shatters Shatters.mono shatters_bot
Uses
Used by
- encard_image_inter_le_encard_shatters

Decltrace_sep_unionDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α} {x : α},
  (fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∉ C} ∪ (fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∈ C} = (fun x => A ∩ x) '' 𝒜

Used by

pajor_encard_aux

Decltrace_sep_disjointDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α} {x : α},
  x ∈ A → Disjoint ((fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∉ C}) ((fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∈ C})

Used by

pajor_encard_aux

DeclnotMem_of_shatters_sep_rightDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, Shatters {C | C ∈ 𝒜 ∧ x ∈ C} B → x ∉ B
```
Shatters Shatters.preimage_compl
Uses
- notMem_of_forall_notMem
Used by
- pajor_encard_aux

DeclnotMem_of_shatters_sep_leftDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, Shatters {C | C ∈ 𝒜 ∧ x ∉ C} B → x ∉ B

Shatters

Uses

notMem_of_forall_notMem

Used by

pajor_encard_aux

DeclnotMem_of_forall_notMemDeclaration kindtheorem
A family whose members all avoid x shatters only sets avoiding x.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, (∀ C ∈ 𝒜, x ∉ C) → Shatters 𝒜 B → x ∉ B
```
Shatters Shatters.exists_ge
Used by
- notMem_of_shatters_sep_left
- notMem_of_shatters_sep_right
Declinsert_injOn_notMemDeclaration kindtheorem
Inserting a fixed element is injective on the sets avoiding it: the element can be removed again, recovering the argument.
```
∀ {α : Type u_1} (x : α), Set.InjOn (insert x) {B | x ∉ B}
```
Used by
- pajor_encard_aux

Declexists_splitterDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α},
  ((fun x => A ∩ x) '' 𝒜).Nontrivial → ∃ x ∈ A, (∃ C ∈ 𝒜, x ∈ C) ∧ ∃ C ∈ 𝒜, x ∉ C

Uses

exists_splitter_of_not_subset

Used by

pajor_encard_aux

Declexists_splitter_of_not_subsetDeclaration kindtheorem

A point of A witnessing that one trace fails to contain another is a point at which 𝒜 splits.

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A C C' : Set α},
  C ∈ 𝒜 → C' ∈ 𝒜 → ¬A ∩ C ⊆ A ∩ C' → ∃ x ∈ A, (∃ D ∈ 𝒜, x ∈ D) ∧ ∃ D ∈ 𝒜, x ∉ D

Used by

exists_splitter

Decldisjoint_image_insertDeclaration kindtheorem
A family whose members all avoid x is disjoint from any family of sets containing x.
```
∀ {α : Type u_1} {x : α} {𝒮 𝒯 : Set (Set α)}, (∀ B ∈ 𝒮, x ∉ B) → Disjoint 𝒮 (insert x '' 𝒯)
```
Used by
- pajor_encard_aux
DeclShatters.insertDeclaration kindtheorem
If B is shattered both by the members of 𝒜 avoiding x and by the members of 𝒜 containing x, then 𝒜 shatters insert x B. This is the exchange step in the proof of Pajor's inequality.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α},
  Shatters {C | C ∈ 𝒜 ∧ x ∉ C} B → Shatters {C | C ∈ 𝒜 ∧ x ∈ C} B → Shatters 𝒜 (insert x B)
```
Shatters
Uses
- Shatters.exists_inter_eq
- Shatters.of_forall_subset
Used by
- pajor_encard_aux
Declinfinite_setOf_shattersDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, ((fun x => A ∩ x) '' 𝒜).Infinite → {B | B ⊆ A ∧ Shatters 𝒜 B}.Infinite
```
Shatters splitPoints
Uses
- finite_image_inter_of_finite_splitPoints
- singleton_image_splitPoints_subset
Used by
- encard_image_inter_le_encard_shatters
Declsingleton_image_splitPoints_subsetDeclaration kindtheorem
The singleton of a point at which 𝒜 splits is shattered by 𝒜.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (fun x => {x}) '' splitPoints✝ 𝒜 A ⊆ {B | B ⊆ A ∧ Shatters 𝒜 B}
```
Shatters splitPoints
Uses
- shatters_singleton
Used by
- infinite_setOf_shatters
Declshatters_singletonDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {x : α}, Shatters 𝒜 {x} ↔ (∃ C ∈ 𝒜, x ∈ C) ∧ ∃ C ∈ 𝒜, x ∉ C
```
Shatters
Uses
- Shatters.exists_inter_eq
- Shatters.of_forall_subset
Used by
- singleton_image_splitPoints_subset
DeclShatters.of_forall_subsetDeclaration kindtheorem
Shatters read at Set α, as an introduction rule; the ∩-shaped companion of Shatters.of_forall_le.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (∀ ⦃B : Set α⦄, B ⊆ A → ∃ C ∈ 𝒜, A ∩ C = B) → Shatters 𝒜 A
```
Shatters
Used by
- Shatters.insert
- shatters_singleton
DeclShatters.exists_inter_eqDeclaration kindtheorem
Shatters read at Set α, where ⊓ is ∩ and ≤ is ⊆: every subset of A is the intersection of A with a member of 𝒜. Definitionally the same statement, stated in the shape every use site wants, so that consumers obtain an ∩-typed equation directly.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A B : Set α}, Shatters 𝒜 A → B ⊆ A → ∃ C ∈ 𝒜, A ∩ C = B
```
Shatters
Used by
- Shatters.insert
- shatters_singleton
Declfinite_image_inter_of_finite_splitPointsDeclaration kindtheorem
A family splitting A at finitely many elements has finitely many traces on A.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (splitPoints✝ 𝒜 A).Finite → ((fun x => A ∩ x) '' 𝒜).Finite
```
splitPoints
Uses
- injOn_inter_splitPoints
Used by
- infinite_setOf_shatters
DeclinjOn_inter_splitPointsDeclaration kindtheorem
A trace of 𝒜 on A is determined by its restriction to the elements at which 𝒜 splits: elsewhere, membership in the trace is decided by A alone.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, Set.InjOn (fun x => x ∩ splitPoints✝ 𝒜 A) ((fun x => A ∩ x) '' 𝒜)
```
splitPoints
Used by
- finite_image_inter_of_finite_splitPoints
Declfinite_setOf_subset_andDeclaration kindtheorem
Any collection of subsets of a finite set is finite.
```
∀ {α : Type u_1} {A : Set α}, A.Finite → ∀ (p : Set α → Prop), {B | B ⊆ A ∧ p B}.Finite
```
Used by
DeclHasVCDimLE.ncard_le_of_shattersDeclaration kindtheorem
A family of VC dimension at most d shatters only sets of size at most d.
```
∀ {α : Type u_1} {d : ℕ} {𝒜 : Set (Set α)} {B : Set α}, HasVCDimLE d 𝒜 → Shatters 𝒜 B → B.ncard ≤ d
```
HasVCDimLE Shatters
Uses
- HasVCDimLE.finite_of_shatters
Used by
- HasVCDimLE.ncard_image_inter_le
DeclHasVCDimLE.finite_of_shattersDeclaration kindtheorem
A family of VC dimension at most d shatters only finite sets.
```
∀ {α : Type u_1} {d : ℕ} {𝒜 : Set (Set α)} {B : Set α}, HasVCDimLE d 𝒜 → Shatters 𝒜 B → B.Finite
```
HasVCDimLE Shatters Shatters.subset
Used by
- HasVCDimLE.ncard_le_of_shatters
Hypothesish𝒜
```
HasVCDimLE d 𝒜
```
Hypothesishdn
```
d ≤ n
```
DefinitionHasVCDimLEdefYaël Dillies
A set family 𝒜 has VC dimension at most d if all the sets it shatters have size at most d.
```
{α : Type u_1} → ℕ → Set (Set α) → Prop
```
DefinitionShattersdefYaël Dillies
A set family 𝒜 shatters a set A if all subsets of A can be obtained as the intersection of A with some element of the set family. We also say that A is traced by 𝒜.
```
{α : Type u_1} → [SemilatticeInf α] → Set α → α → Prop
```

Cited resultShatters.exists_getheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 : Set α} {A : α}, Shatters 𝒜 A → ∃ B ∈ 𝒜, A ≤ B

Cited resultShatters.monotheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 ℬ : Set α} {A : α}, 𝒜 ⊆ ℬ → Shatters 𝒜 A → Shatters ℬ A

Cited resultShatters.preimage_compltheoremYaël Dillies

∀ {α : Type u_1} [inst : BooleanAlgebra α] {𝒜 : Set α} {A : α}, Shatters 𝒜 A → Shatters ((fun x => xᶜ) ⁻¹' 𝒜) A

Cited resultShatters.subsettheoremYaël Dillies

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A B : Set α}, A ⊆ B → Shatters 𝒜 B → Shatters 𝒜 A

Cited resultshatters_bottheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 : Set α} [inst_1 : OrderBot α], Shatters 𝒜 ⊥ ↔ 𝒜.Nonempty

DefinitionsplitPointsdef
The elements of A at which 𝒜 splits: some member of 𝒜 contains them and some does not. These are exactly the elements whose singleton 𝒜 shatters.
```
{α : Type u_1} → Set (Set α) → Set α → Set α
```
DefinitionvcGrowthdefYaël Dillies
The growth of a set family is the maximum number of sets it cuts out from any set of size at most n.
```
{α : Type u_1} → ℕ → Set (Set α) → ℕ
```

Cited resultvcGrowth_le_ifftheoremYaël Dillies

∀ {α : Type u_1} {n : ℕ} {𝒜 : Set (Set α)} {d : ℕ},
  vcGrowth n 𝒜 ≤ d ↔ ∀ ⦃A : Set α⦄, A.Finite → A.ncard ≤ n → ((fun x => A ∩ x) '' 𝒜).ncard ≤ d

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

The cardinal Pajor inequality for determined traces: the traces of 𝒜 on A that are determined by finitely many points inject into the shattered subsets, with no hypotheses. Unlike the ℕ∞-valued encard_determined_le_encard_shatters, this bounds genuine cardinalities; the full trace family cannot replace the determined traces (not_mk_image_inter_le_mk_shatters).

Declmk_determined_le_mk_shatters

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α},
  Cardinal.mk ↑{t | t ∈ (fun x => A ∩ x) '' 𝒜 ∧ ∃ F, F.Finite ∧ ∀ t' ∈ (fun x => A ∩ x) '' 𝒜, t' ∩ F = t ∩ F → t' = t} ≤
    Cardinal.mk ↑{B | B ⊆ A ∧ Shatters 𝒜 B}

TopicTraces and shattering

Relations

Limited byMTH.C-2026-6004
The full trace family cannot replace the determined traces: the half-line cuts over the rationals trace continuum-many sets while shattering only countably many.
Asserted by Dhruv Gupta

ThesisStepDefinitionCited result

Declmk_determined_le_mk_shattersDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α},
  Cardinal.mk ↑{t | t ∈ (fun x => A ∩ x) '' 𝒜 ∧ ∃ F, F.Finite ∧ ∀ t' ∈ (fun x => A ∩ x) '' 𝒜, t' ∩ F = t ∩ F → t' = t} ≤
    Cardinal.mk ↑{B | B ⊆ A ∧ Shatters 𝒜 B}

Shatters diag

Uses

encard_determined_le_encard_shatters
finite_image_inter_of_finite_diag
mk_determined_le_of_infinite_diag
mk_diag_le_mk_shatters

Declmk_diag_le_mk_shattersDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, Cardinal.mk ↑(diag✝ 𝒜 A) ≤ Cardinal.mk ↑{B | B ⊆ A ∧ Shatters 𝒜 B}

Shatters diag

Uses

shatters_singleton

Used by

mk_determined_le_mk_shatters

Declmk_determined_le_of_infinite_diagDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α},
  (diag✝ 𝒜 A).Infinite →
    Cardinal.mk
        ↑{t | t ∈ (fun x => A ∩ x) '' 𝒜 ∧ ∃ F, F.Finite ∧ ∀ t' ∈ (fun x => A ∩ x) '' 𝒜, t' ∩ F = t ∩ F → t' = t} ≤
      Cardinal.mk ↑(diag✝ 𝒜 A)

diag

Uses

witness_diag

Used by

mk_determined_le_mk_shatters

Declwitness_diagDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A t F : Set α},
  (∀ t' ∈ (fun x => A ∩ x) '' 𝒜, t' ∩ F = t ∩ F → t' = t) →
    t ∈ (fun x => A ∩ x) '' 𝒜 → ∀ t' ∈ (fun x => A ∩ x) '' 𝒜, t' ∩ (F ∩ diag✝ 𝒜 A) = t ∩ (F ∩ diag✝ 𝒜 A) → t' = t

diag

Uses

mem_iff_mem_of_notMem_diag

Used by

mk_determined_le_of_infinite_diag

Declfinite_image_inter_of_finite_diagDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (diag✝ 𝒜 A).Finite → ((fun x => A ∩ x) '' 𝒜).Finite
```
diag
Uses
- mem_iff_mem_of_notMem_diag
Used by
- mk_determined_le_mk_shatters

Declmem_iff_mem_of_notMem_diagDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A t t' : Set α},
  t ∈ (fun x => A ∩ x) '' 𝒜 → t' ∈ (fun x => A ∩ x) '' 𝒜 → ∀ {y : α}, y ∉ diag✝ 𝒜 A → (y ∈ t ↔ y ∈ t')

diag

Used by

finite_image_inter_of_finite_diag
witness_diag

Declencard_determined_le_encard_shattersDeclaration kindtheorem
The traces of 𝒜 on A that are determined by finitely many points are at most as many as the shattered subsets: the restriction of encard_image_inter_le_encard_shatters to the determined traces. Its cardinal-valued sharpening, which is genuinely stronger than the ℕ∞ statement, is mk_determined_le_mk_shatters.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α},
  {t | t ∈ (fun x => A ∩ x) '' 𝒜 ∧ ∃ F, F.Finite ∧ ∀ t' ∈ (fun x => A ∩ x) '' 𝒜, t' ∩ F = t ∩ F → t' = t}.encard ≤
    {B | B ⊆ A ∧ Shatters 𝒜 B}.encard
```
Shatters
Uses
- encard_image_inter_le_encard_shatters
Used by
- mk_determined_le_mk_shatters
Declencard_image_inter_le_encard_shattersDeclaration kindtheorem
Pajor's inequality, with no finiteness assumptions: the traces of 𝒜 on A are at most as many as the subsets of A shattered by 𝒜. For a finite trace family this is a descent on the number of traces that never consumes the ground set; an infinite trace family forces infinitely many shattered singletons, and both sides are ⊤.
Dvir, Filmus and Moran, A Sauer-Shelah-Perles Lemma for Lattices, credit the Boolean lattice case to Pajor (Sous-espaces ℓ₁ⁿ des espaces de Banach, Travaux en Cours 16, Hermann, Paris, 1985) and to Aharoni and Holzman, unpublished. Their Theorem 1.2 is the lattice form, for finite lattices with nonvanishing Möbius function: a family shatters at least as many elements as it has members. Reading that for a family of traces on a ground set is the standard translation into the language of set families, and the statement here carries no finiteness hypothesis, which theirs does.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, ((fun x => A ∩ x) '' 𝒜).encard ≤ {B | B ⊆ A ∧ Shatters 𝒜 B}.encard
```
Shatters
Uses
- infinite_setOf_shatters
- pajor_encard_aux
Used by
- encard_determined_le_encard_shatters
Declpajor_encard_auxDeclaration kindtheorem
```
∀ {α : Type u_1} {A : Set α} (N : ℕ) (𝒜 : Set (Set α)),
  ((fun x => A ∩ x) '' 𝒜).Finite →
    ((fun x => A ∩ x) '' 𝒜).ncard ≤ N → ((fun x => A ∩ x) '' 𝒜).encard ≤ {B | B ⊆ A ∧ Shatters 𝒜 B}.encard
```
Shatters Shatters.mono shatters_bot
Uses
Used by
- encard_image_inter_le_encard_shatters

Decltrace_sep_unionDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α} {x : α},
  (fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∉ C} ∪ (fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∈ C} = (fun x => A ∩ x) '' 𝒜

Used by

pajor_encard_aux

Decltrace_sep_disjointDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α} {x : α},
  x ∈ A → Disjoint ((fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∉ C}) ((fun x => A ∩ x) '' {C | C ∈ 𝒜 ∧ x ∈ C})

Used by

pajor_encard_aux

DeclnotMem_of_shatters_sep_rightDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, Shatters {C | C ∈ 𝒜 ∧ x ∈ C} B → x ∉ B
```
Shatters Shatters.preimage_compl
Uses
- notMem_of_forall_notMem
Used by
- pajor_encard_aux

DeclnotMem_of_shatters_sep_leftDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, Shatters {C | C ∈ 𝒜 ∧ x ∉ C} B → x ∉ B

Shatters

Uses

notMem_of_forall_notMem

Used by

pajor_encard_aux

DeclnotMem_of_forall_notMemDeclaration kindtheorem
A family whose members all avoid x shatters only sets avoiding x.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α}, (∀ C ∈ 𝒜, x ∉ C) → Shatters 𝒜 B → x ∉ B
```
Shatters Shatters.exists_ge
Used by
- notMem_of_shatters_sep_left
- notMem_of_shatters_sep_right
Declinsert_injOn_notMemDeclaration kindtheorem
Inserting a fixed element is injective on the sets avoiding it: the element can be removed again, recovering the argument.
```
∀ {α : Type u_1} (x : α), Set.InjOn (insert x) {B | x ∉ B}
```
Used by
- pajor_encard_aux

Declexists_splitterDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α},
  ((fun x => A ∩ x) '' 𝒜).Nontrivial → ∃ x ∈ A, (∃ C ∈ 𝒜, x ∈ C) ∧ ∃ C ∈ 𝒜, x ∉ C

Uses

exists_splitter_of_not_subset

Used by

pajor_encard_aux

Declexists_splitter_of_not_subsetDeclaration kindtheorem

A point of A witnessing that one trace fails to contain another is a point at which 𝒜 splits.

∀ {α : Type u_1} {𝒜 : Set (Set α)} {A C C' : Set α},
  C ∈ 𝒜 → C' ∈ 𝒜 → ¬A ∩ C ⊆ A ∩ C' → ∃ x ∈ A, (∃ D ∈ 𝒜, x ∈ D) ∧ ∃ D ∈ 𝒜, x ∉ D

Used by

exists_splitter

Decldisjoint_image_insertDeclaration kindtheorem
A family whose members all avoid x is disjoint from any family of sets containing x.
```
∀ {α : Type u_1} {x : α} {𝒮 𝒯 : Set (Set α)}, (∀ B ∈ 𝒮, x ∉ B) → Disjoint 𝒮 (insert x '' 𝒯)
```
Used by
- pajor_encard_aux
DeclShatters.insertDeclaration kindtheorem
If B is shattered both by the members of 𝒜 avoiding x and by the members of 𝒜 containing x, then 𝒜 shatters insert x B. This is the exchange step in the proof of Pajor's inequality.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {B : Set α} {x : α},
  Shatters {C | C ∈ 𝒜 ∧ x ∉ C} B → Shatters {C | C ∈ 𝒜 ∧ x ∈ C} B → Shatters 𝒜 (insert x B)
```
Shatters
Uses
- Shatters.exists_inter_eq
- Shatters.of_forall_subset
Used by
- pajor_encard_aux
Declinfinite_setOf_shattersDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, ((fun x => A ∩ x) '' 𝒜).Infinite → {B | B ⊆ A ∧ Shatters 𝒜 B}.Infinite
```
Shatters splitPoints
Uses
- finite_image_inter_of_finite_splitPoints
- singleton_image_splitPoints_subset
Used by
- encard_image_inter_le_encard_shatters
Declsingleton_image_splitPoints_subsetDeclaration kindtheorem
The singleton of a point at which 𝒜 splits is shattered by 𝒜.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (fun x => {x}) '' splitPoints✝ 𝒜 A ⊆ {B | B ⊆ A ∧ Shatters 𝒜 B}
```
Shatters splitPoints
Uses
- shatters_singleton
Used by
- infinite_setOf_shatters
Declshatters_singletonDeclaration kindtheorem
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {x : α}, Shatters 𝒜 {x} ↔ (∃ C ∈ 𝒜, x ∈ C) ∧ ∃ C ∈ 𝒜, x ∉ C
```
Shatters
Uses
- Shatters.exists_inter_eq
- Shatters.of_forall_subset
Used by
- mk_diag_le_mk_shatters
- singleton_image_splitPoints_subset
DeclShatters.of_forall_subsetDeclaration kindtheorem
Shatters read at Set α, as an introduction rule; the ∩-shaped companion of Shatters.of_forall_le.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (∀ ⦃B : Set α⦄, B ⊆ A → ∃ C ∈ 𝒜, A ∩ C = B) → Shatters 𝒜 A
```
Shatters
Used by
- Shatters.insert
- shatters_singleton
DeclShatters.exists_inter_eqDeclaration kindtheorem
Shatters read at Set α, where ⊓ is ∩ and ≤ is ⊆: every subset of A is the intersection of A with a member of 𝒜. Definitionally the same statement, stated in the shape every use site wants, so that consumers obtain an ∩-typed equation directly.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A B : Set α}, Shatters 𝒜 A → B ⊆ A → ∃ C ∈ 𝒜, A ∩ C = B
```
Shatters
Used by
- Shatters.insert
- shatters_singleton
Declfinite_image_inter_of_finite_splitPointsDeclaration kindtheorem
A family splitting A at finitely many elements has finitely many traces on A.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, (splitPoints✝ 𝒜 A).Finite → ((fun x => A ∩ x) '' 𝒜).Finite
```
splitPoints
Uses
- injOn_inter_splitPoints
Used by
- infinite_setOf_shatters
DeclinjOn_inter_splitPointsDeclaration kindtheorem
A trace of 𝒜 on A is determined by its restriction to the elements at which 𝒜 splits: elsewhere, membership in the trace is decided by A alone.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A : Set α}, Set.InjOn (fun x => x ∩ splitPoints✝ 𝒜 A) ((fun x => A ∩ x) '' 𝒜)
```
splitPoints
Used by
- finite_image_inter_of_finite_splitPoints
DefinitionShattersdefYaël Dillies
A set family 𝒜 shatters a set A if all subsets of A can be obtained as the intersection of A with some element of the set family. We also say that A is traced by 𝒜.
```
{α : Type u_1} → [SemilatticeInf α] → Set α → α → Prop
```

Cited resultShatters.exists_getheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 : Set α} {A : α}, Shatters 𝒜 A → ∃ B ∈ 𝒜, A ≤ B

Cited resultShatters.monotheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 ℬ : Set α} {A : α}, 𝒜 ⊆ ℬ → Shatters 𝒜 A → Shatters ℬ A

Cited resultShatters.preimage_compltheoremYaël Dillies

∀ {α : Type u_1} [inst : BooleanAlgebra α] {𝒜 : Set α} {A : α}, Shatters 𝒜 A → Shatters ((fun x => xᶜ) ⁻¹' 𝒜) A

Definitiondiagdef
The points of A on which 𝒜 is not constant.
```
{α : Type u_1} → Set (Set α) → Set α → Set α
```

Cited resultshatters_bottheoremYaël Dillies

∀ {α : Type u_1} [inst : SemilatticeInf α] {𝒜 : Set α} [inst_1 : OrderBot α], Shatters 𝒜 ⊥ ↔ 𝒜.Nonempty

DefinitionsplitPointsdef
The elements of A at which 𝒜 splits: some member of 𝒜 contains them and some does not. These are exactly the elements whose singleton 𝒜 shatters.
```
{α : Type u_1} → Set (Set α) → Set α → Set α
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

The full trace family cannot replace the determined traces in mk_determined_le_mk_shatters: the half-line cuts over ℚ trace continuum-many sets while shattering only countably many.

Declnot_mk_image_inter_le_mk_shatters

¬Cardinal.mk ↑((fun x => Set.univ ∩ x) '' Set.range fun r => {q | ↑q < r}) ≤
    Cardinal.mk ↑{B | B ⊆ Set.univ ∧ Shatters (Set.range fun r => {q | ↑q < r}) B}

TopicTraces and shattering

Relations

LimitsMTH.C-2026-6003
The full trace family cannot replace the determined traces: the half-line cuts over the rationals trace continuum-many sets while shattering only countably many.
Asserted by Dhruv Gupta

ThesisStepDefinition

Declnot_mk_image_inter_le_mk_shattersDeclaration kindtheorem

¬Cardinal.mk ↑((fun x => Set.univ ∩ x) '' Set.range fun r => {q | ↑q < r}) ≤
    Cardinal.mk ↑{B | B ⊆ Set.univ ∧ Shatters (Set.range fun r => {q | ↑q < r}) B}

Shatters cut

Uses

countable_setOf_shatters_range_cut
cut_injective

Declcut_injectiveDeclaration kindtheorem
```
Function.Injective cut✝
```
cut
Used by
- not_mk_image_inter_le_mk_shatters
Declcountable_setOf_shatters_range_cutDeclaration kindtheorem
```
{B | B ⊆ Set.univ ∧ Shatters (Set.range cut✝) B}.Countable
```
Shatters cut
Uses
- subsingleton_of_shatters_range_cut
Used by
- not_mk_image_inter_le_mk_shatters
Declsubsingleton_of_shatters_range_cutDeclaration kindtheorem
```
∀ {B : Set ℚ}, Shatters (Set.range cut✝) B → B.Subsingleton
```
Shatters cut
Used by
- countable_setOf_shatters_range_cut
DefinitionShattersdefYaël Dillies
A set family 𝒜 shatters a set A if all subsets of A can be obtained as the intersection of A with some element of the set family. We also say that A is traced by 𝒜.
```
{α : Type u_1} → [SemilatticeInf α] → Set α → α → Prop
```
Definitioncutdef
```
ℝ → Set ℚ
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

Pajor's inequality for multiclass concept classes, with no hypotheses on the domain, the label type or the family: the traces of 𝒞 on S are at most as many as the pair-cubes of 𝒞 supported inside S.

The count runs on a split of the family at a point where two traces differ, taking one branch per realised value with no residual bucket. A cube of a branch never constrains the split point, so a cube pair-shattered by μ branches is counted μ times on the left and supplies 1 + μ.choose 2 cubes on the right, which closes the accounting because μ ≤ 1 + μ.choose 2 for μ ≥ 1, with equality exactly at μ ∈ {1, 2}. An infinite trace family forces infinitely many one-point cubes and both sides are ⊤.

At Y = Bool this specialises to encard_image_inter_le_encard_shatters, which is encard_image_inter_le_encard_shatters_of_multiclass below. The pair-cube is Natarajan's shattering witness for spaces of functions, from p. 81 of On learning sets and functions; see the module docstring.

Declencard_image_restrict_le_encard_pairCubes

∀ {X : Type u_1} {Y : Type u_2} (𝒞 : Set (X → Y)) (S : Set X), (S.restrict '' 𝒞).encard ≤ (pairCubes 𝒞 S).encard

TopicMulticlass dimensions

Relations

GeneralisesMTH.C-2026-6001
At Y = Bool this specialises to Pajor's inequality.
Asserted by Dhruv Gupta
Shares definitions withMTH.C-2026-6006
Built on the same pair patterns and pair-shattering; neither implies the other.
Asserted by Dhruv Gupta

ThesisStepDefinition

Declencard_image_restrict_le_encard_pairCubesDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2} (𝒞 : Set (X → Y)) (S : Set X), (S.restrict '' 𝒞).encard ≤ (pairCubes 𝒞 S).encard
```
pairCubes
Uses
- exists_injOn_pairCubes
- infinite_pairCubes_of_infinite_image_restrict
Declinfinite_pairCubes_of_infinite_image_restrictDeclaration kindtheorem
Infinitely many traces force infinitely many cubes. Either the family disagrees at infinitely many points of S, each of which carries a one-point cube, or it realises infinitely many labels at one point, which carries infinitely many one-point cubes. The proof runs the contrapositive: finitely many cubes bound both the disagreement set and, above each of its points, the set of realised labels, and a trace is determined by its values on the disagreement set, so the traces embed in a finite product. This is what makes the multiclass inequality hypothesis-free, as infinite_setOf_shatters does in the binary case.
```
∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)} {S : Set X}, (S.restrict '' 𝒞).Infinite → (pairCubes 𝒞 S).Infinite
```
pairCubes pairSupport singCube
Uses
Used by
- encard_image_restrict_le_encard_pairCubes
DeclsingCube_right_injectiveDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2} (z : X) (u : Y), Function.Injective (singCube✝ z u)
```
pairOf singCube
Uses
- pairOf_right_injective
- singCube_apply_self
Used by
- infinite_pairCubes_of_infinite_image_restrict
DeclsingCube_apply_selfDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2} (z : X) (u v : Y), singCube✝ z u v z = pairOf✝ u v
```
pairOf singCube
Uses
- graft_self
Used by
- singCube_right_injective

DeclsingCube_mem_pairCubesDeclaration kindtheorem

∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)} {S : Set X} {u v : Y} {z : X},
  z ∈ S → (∃ c ∈ 𝒞, c z = u) → (∃ c ∈ 𝒞, c z = v) → singCube✝ z u v ∈ pairCubes 𝒞 S

pairCubes singCube

Uses

const_empty_mem_pairCubes
mem_pairCubes_graft_pairOf

Used by

infinite_pairCubes_of_infinite_image_restrict

DeclpairSupport_singCubeDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2} {u v : Y} (z : X), u ≠ v → pairSupport (singCube✝ z u v) = {z}
```
graft pairOf pairSupport singCube
Uses
Used by
- infinite_pairCubes_of_infinite_image_restrict
Declexists_injOn_pairCubesDeclaration kindtheorem
The whole accounting, as one injection from traces to cubes.
At a point where two traces differ, every realised value gets its own branch, and a trace is routed by the value it takes there. The branch injections supplied by the induction hypothesis land in cubes that avoid that point, and a cube pair-shattered by μ branches carries μ traces into μ of the 1 + μ.choose 2 cubes available above it: the cube itself for the branch selected as the anchor, and one graft for each of the other μ - 1. Injectivity is read off the graft, since pairOf u · is injective and the pattern below the new point is recovered by evaluating away from it.
```
∀ {X : Type u_1} {Y : Type u_2} (S : Set X) (N : ℕ) (𝒞 : Set (X → Y)),
  (S.restrict '' 𝒞).Finite →
    (S.restrict '' 𝒞).ncard ≤ N → ∃ φ, Set.MapsTo φ (S.restrict '' 𝒞) (pairCubes 𝒞 S) ∧ Set.InjOn φ (S.restrict '' 𝒞)
```
IsPairPattern PairShatters graft pairCubes pairOf pairSupport
Uses
Used by
- encard_image_restrict_le_encard_pairCubes
DeclpairOf_right_injectiveDeclaration kindtheorem
```
∀ {Y : Type u_2} (u : Y), Function.Injective (pairOf✝ u)
```
pairOf
Uses
- pairOf_self
Used by
- exists_injOn_pairCubes
- singCube_right_injective
Declncard_image_restrict_sep_ltDeclaration kindtheorem
Splitting off one realised value at a point of S where the family is not constant strictly lowers the number of traces, because a second value survives outside the branch.
```
∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)} {S : Set X} {x : X} {u : Y},
 x ∈ S →
 ∀ {c : X → Y},
 c ∈ 𝒞 → c x ≠ u → (S.restrict '' 𝒞).Finite → (S.restrict '' {d | d ∈ 𝒞 ∧ d x = u}).ncard < (S.restrict '' 𝒞).ncard
```
Uses
- disjoint_image_restrict_sep
Used by
- exists_injOn_pairCubes

Decldisjoint_image_restrict_sepDeclaration kindtheorem

Two branches at one point of S cut disjoint families of traces.

∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)} {S : Set X} {x : X} {u v : Y},
  x ∈ S → u ≠ v → Disjoint (S.restrict '' {d | d ∈ 𝒞 ∧ d x = u}) (S.restrict '' {d | d ∈ 𝒞 ∧ d x = v})

Used by

ncard_image_restrict_sep_lt

Declmem_pairCubes_graft_pairOfDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)} {S : Set X} {P : X → Set Y} {x : X} {u v : Y},
  x ∈ S →
    P ∈ pairCubes {c | c ∈ 𝒞 ∧ c x = u} S →
      P ∈ pairCubes {c | c ∈ 𝒞 ∧ c x = v} S → graft P x (pairOf✝ u v) ∈ pairCubes 𝒞 S
```
IsPairPattern PairShatters graft pairCubes pairOf pairSupport
Uses
Used by
- exists_injOn_pairCubes
- singCube_mem_pairCubes

DeclpairSupport_graft_subsetDeclaration kindtheorem

∀ {X : Type u_1} {Y : Type u_2} {S : Set X} {P : X → Set Y} {x : X},
  x ∈ S → pairSupport P ⊆ S → ∀ (s : Set Y), pairSupport (graft P x s) ⊆ S

graft pairSupport

Uses

graft_of_ne

Used by

mem_pairCubes_graft_pairOf

DeclpairShatters_graftDeclaration kindtheorem
The graft. A pattern pair-shattered by the branch at a and by the branch at b extends by one unconstrained point carrying the pair {a, b} there to a pattern pair-shattered by the whole family. The selection at the new point names the branch that realises it. This is the multiclass exchange step, and it mirrors Shatters.insert.
The two labels are not required to differ. Distinctness is what makes the result a pair pattern, and it enters at mem_pairCubes_graft_pairOf, not here.
```
∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)} {P : X → Set Y} {x : X} {a b : Y},
  P x = ∅ →
    PairShatters {c | c ∈ 𝒞 ∧ c x = a} P → PairShatters {c | c ∈ 𝒞 ∧ c x = b} P → PairShatters 𝒞 (graft P x {a, b})
```
PairShatters graft pairSupport
Uses
Used by
- mem_pairCubes_graft_pairOf

DeclpairSupport_graftDeclaration kindtheorem

∀ {X : Type u_1} {Y : Type u_2} (P : X → Set Y) (x : X) {s : Set Y},
  s.Nonempty → pairSupport (graft P x s) = insert x (pairSupport P)

graft pairSupport

Uses

graft_of_ne
graft_self

Used by

pairShatters_graft
pairSupport_singCube

DeclpairOf_isPairPatternDeclaration kindtheorem
```
∀ {Y : Type u_2} (u v : Y), pairOf✝ u v = ∅ ∨ (pairOf✝ u v).encard = 2
```
pairOf
Uses
- pairOf_of_ne
- pairOf_self
Used by
- mem_pairCubes_graft_pairOf
DeclpairOf_selfDeclaration kindtheorem
```
∀ {Y : Type u_2} {u v : Y}, u = v → pairOf✝ u v = ∅
```
pairOf
Used by
DeclpairOf_of_neDeclaration kindtheorem
```
∀ {Y : Type u_2} {u v : Y}, u ≠ v → pairOf✝ u v = {u, v}
```
pairOf
Used by

DeclisPairPattern_graftDeclaration kindtheorem

∀ {X : Type u_1} {Y : Type u_2} {P : X → Set Y},
  IsPairPattern P → ∀ (x : X) {s : Set Y}, s = ∅ ∨ s.encard = 2 → IsPairPattern (graft P x s)

IsPairPattern graft

Uses

graft_of_ne
graft_self

Used by

mem_pairCubes_graft_pairOf

Declgraft_empty_selfDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2} {P : X → Set Y} {x : X}, P x = ∅ → graft P x ∅ = P
```
graft
Uses
- graft_of_ne
- graft_self
Used by
- mem_pairCubes_graft_pairOf

DeclPairShatters.monoDeclaration kindtheorem

∀ {X : Type u_1} {Y : Type u_2} {𝒞 𝒟 : Set (X → Y)} {P : X → Set Y}, 𝒞 ⊆ 𝒟 → PairShatters 𝒞 P → PairShatters 𝒟 P

PairShatters pairSupport

Used by

mem_pairCubes_graft_pairOf

Declgraft_eq_graftDeclaration kindtheorem

∀ {X : Type u_1} {Y : Type u_2} {P P' : X → Set Y} {x : X},
  P x = ∅ → P' x = ∅ → ∀ {s s' : Set Y}, graft P x s = graft P' x s' → P = P' ∧ s = s'

graft

Uses

graft_of_ne
graft_self

Used by

exists_injOn_pairCubes

Declgraft_selfDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2} (P : X → Set Y) (x : X) (s : Set Y), graft P x s x = s
```
graft
Used by
Declgraft_of_neDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2} {x z : X} (P : X → Set Y) (s : Set Y), z ≠ x → graft P x s z = P z
```
graft
Used by
Declexists_sel_atDeclaration kindtheorem
The single-point case: an admissible label at x extends to a selection taking it there.
```
∀ {X : Type u_1} {Y : Type u_2} {P : X → Set Y} {x : X} {u : Y},
  u ∈ P x → ∃ τ, τ x = u ∧ ∀ ⦃z : X⦄, z ∈ pairSupport P → τ z ∈ P z
```
pairSupport
Uses
- exists_sel
Used by
- exists_injOn_pairCubes
- mem_pairCubes_graft_pairOf
Declexists_selDeclaration kindtheorem
A choice of admissible labels prescribed on part of the domain extends to a selection for the whole pattern. The prescribed values arrive as a total function, so off the support there is always a label to copy and no hypothesis on Y is needed.
```
∀ {X : Type u_1} {Y : Type u_2} {P : X → Set Y} {B : Set X} {σ : X → Y},
  (∀ ⦃z : X⦄, z ∈ B → z ∈ pairSupport P → σ z ∈ P z) → ∃ τ, (∀ ⦃z : X⦄, z ∈ pairSupport P → τ z ∈ P z) ∧ Set.EqOn τ σ B
```
pairSupport
Used by
- exists_sel_at

Declexists_injOn_of_subsingletonDeclaration kindtheorem

∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)} {S : Set X},
  (S.restrict '' 𝒞).Subsingleton → ∃ φ, Set.MapsTo φ (S.restrict '' 𝒞) (pairCubes 𝒞 S) ∧ Set.InjOn φ (S.restrict '' 𝒞)

pairCubes

Uses

const_empty_mem_pairCubes

Used by

exists_injOn_pairCubes

Declconst_empty_mem_pairCubesDeclaration kindtheorem
The unconstrained pattern is a cube of every nonempty family. It is the multiclass reading of shatters_bot.
```
∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)} (S : Set X), 𝒞.Nonempty → (fun x => ∅) ∈ pairCubes 𝒞 S
```
IsPairPattern PairShatters pairCubes pairSupport
Uses
- pairSupport_const_empty
Used by
- exists_injOn_of_subsingleton
- singCube_mem_pairCubes
DeclpairSupport_const_emptyDeclaration kindtheorem
```
∀ {X : Type u_1} {Y : Type u_2}, (pairSupport fun x => ∅) = ∅
```
pairSupport
Used by
- const_empty_mem_pairCubes
- pairSupport_singCube
DefinitionIsPairPatterndef
A pattern is a pair pattern when it offers either no constraint or exactly two labels at each point. The two labels are recorded as a set, so their order carries no information.
```
{X : Type u_1} → {Y : Type u_2} → (X → Set Y) → Prop
```
DefinitionPairShattersdef
A family pair-shatters a pattern when every choice of one admissible label per constrained point is realised by some member.
```
{X : Type u_1} → {Y : Type u_2} → Set (X → Y) → (X → Set Y) → Prop
```
Definitiongraftdef
Overwrite a pattern at one point. Stated without a decidable equality on X, since the two branches are separated by a hypothesis rather than by a test.
```
{X : Type u_1} → {Y : Type u_2} → (X → Set Y) → X → Set Y → X → Set Y
```
DefinitionpairCubesdef
The pair-cubes of 𝒞 over S: pair patterns supported inside S and pair-shattered by 𝒞.
```
{X : Type u_1} → {Y : Type u_2} → Set (X → Y) → Set X → Set (X → Set Y)
```
DefinitionpairOfdef
The unordered pair {u, v}, degenerating to the empty set when u = v. Carrying the degenerate case inside the pair lets one formula cover both branches of the injection.
```
{Y : Type u_2} → Y → Y → Set Y
```
DefinitionpairSupportdef
The points at which a pattern constrains a concept.
```
{X : Type u_1} → {Y : Type u_2} → (X → Set Y) → Set X
```
DefinitionsingCubedef
The cube supported at the single point z, offering the labels u and v there.
```
{X : Type u_1} → {Y : Type u_2} → X → Y → Y → X → Set Y
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

HasDSDimLE.hasNatarajanDimLE has no converse. The six-cycle on a two-point domain has Natarajan dimension 1, a Natarajan witness on both points being a four-cycle, while its whole trace family is a two-dimensional pseudo-cube, so its DS dimension is at least 2.

This is the hexagon Brukhim, Carmon, Dinur, Moran and Yehudayoff record after their Definition 6, and the four-cycle test the proof turns on is their Example 7. Their Theorem 2 pushes the separation to a class of Natarajan dimension 1 and infinite DS dimension; that construction rests on hyperbolic pseudo-manifolds and is cited in the module docstring rather than formalised here.

Declexists_hasNatarajanDimLE_not_hasDSDimLE

∃ 𝒞, HasNatarajanDimLE 1 𝒞 ∧ ¬HasDSDimLE 1 𝒞

TopicMulticlass dimensions

Relations

Shares definitions withMTH.C-2026-6005
Built on the same pair patterns and pair-shattering; neither implies the other.
Asserted by Dhruv Gupta

ThesisStepDefinition

Declexists_hasNatarajanDimLE_not_hasDSDimLEDeclaration kindtheorem
```
∃ 𝒞, HasNatarajanDimLE 1 𝒞 ∧ ¬HasDSDimLE 1 𝒞
```
HasDSDimLE HasNatarajanDimLE sixCycle
Uses
- sixCycle_dsShatters
- sixCycle_hasNatarajanDimLE_one
DeclsixCycle_hasNatarajanDimLE_oneDeclaration kindtheorem
```
HasNatarajanDimLE 1 sixCycle✝
```
HasNatarajanDimLE IsPairPattern PairShatters pairSupport sixCycle
Uses
- sixCycle_no_square
- sixCycle_realises
Used by
- exists_hasNatarajanDimLE_not_hasDSDimLE

DeclsixCycle_realisesDeclaration kindtheorem

∀ {P : Fin 2 → Set (Fin 6)},
  PairShatters sixCycle✝ P →
    pairSupport P = Set.univ → ∀ {y₀ y₁ : Fin 6}, y₀ ∈ P 0 → y₁ ∈ P 1 → sixCycleEdge✝ y₀ y₁ = true

PairShatters pairSupport sixCycle sixCycleEdge

Used by

sixCycle_hasNatarajanDimLE_one

DeclsixCycle_no_squareDeclaration kindtheorem

∀ (a b c d : Fin 6),
  sixCycleEdge✝ a c = true →
    sixCycleEdge✝ a d = true → sixCycleEdge✝ b c = true → sixCycleEdge✝ b d = true → a = b ∨ c = d

sixCycleEdge

Used by

sixCycle_hasNatarajanDimLE_one

DeclsixCycle_dsShattersDeclaration kindtheorem
```
DSShatters sixCycle✝ Set.univ
```
DSShatters sixCycle sixCycleEdge
Uses
Used by
- exists_hasNatarajanDimLE_not_hasDSDimLE
DeclsixCycle_nonemptyDeclaration kindtheorem
```
sixCycle✝.Nonempty
```
sixCycle sixCycleEdge
Used by
- sixCycle_dsShatters

DeclsixCycle_nbrDeclaration kindtheorem

∀ (c : Fin 2 → Fin 6),
  sixCycleEdge✝ (c 0) (c 1) = true →
    ∀ (i : Fin 2), ∃ c', sixCycleEdge✝ (c' 0) (c' 1) = true ∧ c' i ≠ c i ∧ ∀ (j : Fin 2), j ≠ i → c' j = c j

sixCycleEdge

Used by

sixCycle_dsShatters

DecldsShatters_univDeclaration kindtheorem

A family whose members each have, in every direction, a neighbour in the family is DS-shattered on the whole domain.

∀ {X : Type u_1} {Y : Type u_2} {𝒞 : Set (X → Y)},
  𝒞.Nonempty →
    (Set.univ.restrict '' 𝒞).Finite →
      (∀ c ∈ 𝒞, ∀ (i : X), ∃ c' ∈ 𝒞, c' i ≠ c i ∧ ∀ (j : X), j ≠ i → c' j = c j) → DSShatters 𝒞 Set.univ

DSShatters IsPseudoCube

Used by

sixCycle_dsShatters

DefinitionDSShattersdef
A family DS-shatters a set when its traces there contain a pseudo-cube.
```
{X : Type u_1} → {Y : Type u_2} → Set (X → Y) → Set X → Prop
```
DefinitionHasDSDimLEdef
A family has DS dimension at most d when every set it DS-shatters has size at most d.
```
{X : Type u_1} → {Y : Type u_2} → ℕ → Set (X → Y) → Prop
```
DefinitionHasNatarajanDimLEdef
A family has Natarajan dimension at most d when every pair pattern it pair-shatters has support of size at most d.
```
{X : Type u_1} → {Y : Type u_2} → ℕ → Set (X → Y) → Prop
```
DefinitionIsPairPatterndef
A pattern is a pair pattern when it offers either no constraint or exactly two labels at each point. The two labels are recorded as a set, so their order carries no information.
```
{X : Type u_1} → {Y : Type u_2} → (X → Set Y) → Prop
```
DefinitionIsPseudoCubedef
A family of labellings of S is a pseudo-cube when it is nonempty and finite and every member has, in every direction, a neighbour in the family differing there and agreeing everywhere else. Over two labels the pseudo-cubes are exactly the Boolean cubes; over more labels there are others.
```
{X : Type u_1} → {Y : Type u_2} → {S : Set X} → Set (↑S → Y) → Prop
```
DefinitionPairShattersdef
A family pair-shatters a pattern when every choice of one admissible label per constrained point is realised by some member.
```
{X : Type u_1} → {Y : Type u_2} → Set (X → Y) → (X → Set Y) → Prop
```
DefinitionpairSupportdef
The points at which a pattern constrains a concept.
```
{X : Type u_1} → {Y : Type u_2} → (X → Set Y) → Set X
```
DefinitionsixCycledef
The six-cycle read as a family of labellings of a two-point domain. Its traces form a two-dimensional pseudo-cube containing no two-dimensional Boolean cube, a six-cycle having no four-cycle.
```
Set (Fin 2 → Fin 6)
```
DefinitionsixCycleEdgedef
The edges of a six-cycle on six labels.
```
Fin 6 → Fin 6 → Bool
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

Shelah's ded bound on the traces of a family of finite VC dimension. On an infinite ground set a family of finite VC dimension traces at most ded #A sets, and by mk_image_inter_range_cut_eq_ded the bound is attained. The infiniteness of A is not decorative: see exists_finite_ground_hasVCDimLE_not_mk_image_inter_le_ded.

DeclHasVCDimLE.mk_image_inter_le_ded

∀ {α : Type u} {𝒜 : Set (Set α)} {A : Set α} {d : ℕ},
  HasVCDimLE d 𝒜 → A.Infinite → Cardinal.mk ↑((fun x => A ∩ x) '' 𝒜) ≤ ded (Cardinal.mk ↑A)

TopicCardinal bounds

Relations

Limited byMTH.C-2026-6008
No cardinal function smaller than ded bounds the traces, which places ded at the exact strength of the bound.
Asserted by Dhruv Gupta

ThesisStepHypothesisDefinition

DeclHasVCDimLE.mk_image_inter_le_dedDeclaration kindtheorem

∀ {α : Type u} {𝒜 : Set (Set α)} {A : Set α} {d : ℕ},
  HasVCDimLE d 𝒜 → A.Infinite → Cardinal.mk ↑((fun x => A ∩ x) '' 𝒜) ≤ ded (Cardinal.mk ↑A)

HasVCDimLE Shatters ded

Uses

exists_shatters_of_ded_lt_mk_image_inter

Declexists_shatters_of_ded_lt_mk_image_interDeclaration kindtheorem
Shelah's theorem. A family that traces more than ded #A sets on an infinite ground set A shatters finite subsets of A of every size. The proof takes a subset B ⊆ A of least cardinality on which the family still traces more than ded #A sets, enumerates B by an initial ordinal so that every proper initial segment is smaller than B and therefore carries at most ded #A traces, prunes the tree of traces along that enumeration to the nodes at least (ded #A)⁺ members pass through, and walks down the pruned tree collecting one point per step.
The conclusion cannot be strengthened to an infinite shattered set: the finite subsets of ℕ shatter every finite set and no infinite one.
The statement is due to Shelah. Both expositions used here, Adler, Introduction to theories without the independence property, Theorem 23, and Simon, A Guide to NIP Theories, Proposition 2.69, state it for the space of complete φ-types over a parameter set rather than for a set family, and the reading under which a complete φ-type over A is a trace on A and the independence property is the shattering of arbitrarily large finite sets is the standard translation of that statement, not a form either source asserts.
```
∀ {α : Type u} {𝒜 : Set (Set α)} {A : Set α},
 A.Infinite →
 ded (Cardinal.mk ↑A) < Cardinal.mk ↑((fun x => A ∩ x) '' 𝒜) →
 ∀ (n : ℕ), ∃ S ⊆ A, S.Finite ∧ S.ncard = n ∧ Shatters 𝒜 S
```
Shatters ded
Uses
Used by
- HasVCDimLE.mk_image_inter_le_ded
Declmk_Iio_lt_ordDeclaration kindtheorem
```
∀ {ν : Cardinal.{u}} (w : ν.ord.ToType), Cardinal.mk ↑(Set.Iio w) < ν
```
Used by
- exists_shatters_of_ded_lt_mk_image_inter
Declexists_shatter_tuple_of_enumDeclaration kindtheorem
Shelah's argument in the tree language: an enumeration of a ground set of size μ all of whose initial segments carry at most θ traces, with ded μ ≤ θ and more than θ traces on the whole set, yields for each n a set of n indices on which 𝒜 cuts out every pattern. The ceiling θ⁺ is regular, so the pruning of mk_sdiff_core_lt applies and the core keeps the whole width.
```
∀ {α : Type u} {𝒜 : Set (Set α)} {W : Type u} {e : W → α} [inst : LinearOrder W] [WellFoundedLT W] {μ θ : Cardinal.{u}},
 Cardinal.aleph0 ≤ μ →
 Cardinal.mk W = μ →
 Cardinal.aleph0 ≤ θ →
 ded μ ≤ θ →
 (∀ (w : W), Cardinal.mk ↑((fun x => e '' Set.Iic w ∩ x) '' 𝒜) ≤ θ) →
 θ < Cardinal.mk ↑((fun x => Set.range e ∩ x) '' 𝒜) →
 ∀ (n : ℕ), ∃ S, S.Finite ∧ S.ncard = n ∧ ∀ (σ : Set W), ∃ C ∈ 𝒜, ∀ x ∈ S, e x ∈ C ↔ x ∈ σ
```
big bigAt core ded enc truncate valIn valOut
Uses
Used by
- exists_shatters_of_ded_lt_mk_image_inter
Declself_le_dedDeclaration kindtheorem
```
∀ (κ : Cardinal.{u}), κ ≤ ded κ
```
ded dedSet
Uses
- bddAbove_dedSet
- self_mem_dedSet
Used by
- exists_shatter_tuple_of_enum
- exists_shatters_of_ded_lt_mk_image_inter
Declmk_truncate_image_enc_imageDeclaration kindtheorem
The level-w nodes of the tree of codes are the traces on the initial segment e '' Iic w.
```
∀ {α : Type u} {𝒜 : Set (Set α)} {W : Type u} {e : W → α} [inst : LinearOrder W] (w : W),
  Cardinal.mk ↑(truncate w '' enc✝ e '' 𝒜) = Cardinal.mk ↑((fun x => e '' Set.Iic w ∩ x) '' 𝒜)
```
enc truncate
Uses
Used by
- exists_shatter_tuple_of_enum

Decltruncate_enc_eq_iffDeclaration kindtheorem

∀ {α W : Type u} {e : W → α} {C C' : Set α} [inst : LinearOrder W] {w : W},
  truncate w (enc✝ e C) = truncate w (enc✝ e C') ↔ ∀ v ≤ w, e v ∈ C ↔ e v ∈ C'

enc truncate

Uses

enc_apply_eq_iff
truncate_apply

Used by

mk_truncate_image_enc_image

Declmk_sdiff_core_ltDeclaration kindtheorem
Pruning to the core costs fewer than lam members: a member outside the core has a narrow truncation, the narrow nodes at one level are fewer than lam and carry fewer than lam members each, and there are fewer than lam levels. Regularity of lam closes both sums.
```
∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β]
 {F : Set (Lex (W → β))} {lam : Cardinal.{u}},
 lam.IsRegular →
 Cardinal.mk W < lam → (∀ (w : W), Cardinal.mk ↑(truncate w '' F) < lam) → Cardinal.mk ↑(F \ core✝ lam F) < lam
```
big bigAt core truncate
Used by
- exists_shatter_tuple_of_enum
Declmk_image_inter_range_le_mk_enc_imageDeclaration kindtheorem
The traces on the range of e are at most as many as the codes along e, two members with the same code agreeing at every index.
```
∀ {α : Type u} {𝒜 : Set (Set α)} {W : Type u} {e : W → α},
  Cardinal.mk ↑((fun x => Set.range e ∩ x) '' 𝒜) ≤ Cardinal.mk ↑(enc✝ e '' 𝒜)
```
enc
Uses
Used by
- exists_shatter_tuple_of_enum
Declmk_image_le_mk_imageDeclaration kindtheorem
If g separates at most as much as f does on s, then f '' s is no larger than g '' s.
```
∀ {β γ δ : Type u} {s : Set β} {f : β → γ} {g : β → δ},
  (∀ x ∈ s, ∀ y ∈ s, g x = g y → f x = f y) → Cardinal.mk ↑(f '' s) ≤ Cardinal.mk ↑(g '' s)
```
Used by
- mk_image_inter_range_le_mk_enc_image
- mk_truncate_image_enc_image
Declinter_eq_inter_iffDeclaration kindtheorem
```
∀ {α : Type u} {C C' D : Set α}, D ∩ C = D ∩ C' ↔ ∀ a ∈ D, a ∈ C ↔ a ∈ C'
```
Used by
- mk_image_inter_range_le_mk_enc_image
- mk_truncate_image_enc_image

Declenc_eq_iffDeclaration kindtheorem

∀ {α W : Type u} {e : W → α} {C C' : Set α}, enc✝ e C = enc✝ e C' ↔ ∀ (w : W), e w ∈ C ↔ e w ∈ C'

enc

Uses

enc_apply_eq_iff

Used by

mk_image_inter_range_le_mk_enc_image

Declenc_apply_eq_iffDeclaration kindtheorem

∀ {α W : Type u} {e : W → α} {C C' : Set α} {w : W}, ofLex (enc✝ e C) w = ofLex (enc✝ e C') w ↔ (e w ∈ C ↔ e w ∈ C')

enc valIn valOut

Uses

enc_apply
valIn_ne_valOut

Used by

enc_eq_iff
truncate_enc_eq_iff

Declexists_shatter_tupleDeclaration kindtheorem
The induction that produces the shattered points. In a two-valued tree whose core is wide, every wide node carries, for each n, a set of n indices above its own level on which the members of F below it realise every pattern. The step spends the wide node: lt_mk_big_fiber gives more than μ wide nodes below it, exists_level concentrates them on one level, the pigeonhole on finite index sets returns two of them with a common tuple, and the index where the two disagree is the new point. Its position, strictly above the old level and at or below the new one, is what keeps the points distinct. This is the combinatorial form of the claim proved by induction in Adler, Theorem 23, and in Simon, Proposition 2.69.
```
∀ {W : Type u} [inst : LinearOrder W] [WellFoundedLT W] {F : Set (Lex (W → WithBot (ULift.{u, 0} Bool)))}
 {μ lam : Cardinal.{u}},
 Cardinal.aleph0 ≤ μ →
 Cardinal.mk W = μ →
 lam.IsRegular →
 Cardinal.mk ↑(F \ core✝ lam F) < lam →
 ded μ < lam →
 (∀ g ∈ F, ∀ (x : W), ofLex g x = valIn✝ ∨ ofLex g x = valOut✝) →
 ∀ (n : ℕ) (w : W),
 ∀ p ∈ bigAt✝ lam F w,
 ∃ S,
 S.Finite ∧
 S.ncard = n ∧
 (∀ x ∈ S, w < x) ∧
 ∀ (σ : Set W), ∃ g ∈ F, truncate w g = p ∧ ∀ x ∈ S, ofLex g x = valIn✝ ↔ x ∈ σ
```
bigAt core ded truncate valIn valOut
Uses
Used by
- exists_shatter_tuple_of_enum

Declval_of_mem_image_truncateDeclaration kindtheorem

A node inherits two-valuedness from the members it truncates.

∀ {W : Type u} [inst : LinearOrder W] {F : Set (Lex (W → WithBot (ULift.{u, 0} Bool)))}
  {q : Lex (W → WithBot (ULift.{u, 0} Bool))} {x v : W},
  (∀ g ∈ F, ∀ (y : W), ofLex g y = valIn✝ ∨ ofLex g y = valOut✝) →
    q ∈ truncate v '' F → x ≤ v → ofLex q x = valIn✝ ∨ ofLex q x = valOut✝

truncate valIn valOut

Uses

ofLex_truncate_of_le

Used by

exists_shatter_tuple

DeclofLex_truncate_of_leDeclaration kindtheorem

Below the level of truncation the sequence is unchanged.

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β] {v : W}
  {g : Lex (W → β)} {x : W}, x ≤ v → ofLex (truncate v g) x = ofLex g x

truncate

Uses

truncate_apply

Used by

exists_shatter_tuple
val_of_mem_image_truncate

Declmk_setOf_finite_ncard_leDeclaration kindtheorem
The finite subsets of an infinite W of a prescribed size are at most #W many. This is the pigeonhole that forces two nodes at one level to carry the same tuple.
```
∀ {W : Type u}, Cardinal.aleph0 ≤ Cardinal.mk W → ∀ (n : ℕ), Cardinal.mk ↑{S | S.Finite ∧ S.ncard = n} ≤ Cardinal.mk W
```
Used by
- exists_shatter_tuple

Decllt_of_mk_ltDeclaration kindtheorem

The level found by exists_level lies strictly above the node's own level: at or below it the fibre is a single node, hence too small.

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β]
  {F : Set (Lex (W → β))} {lam μ : Cardinal.{u}} {v w : W} {p : Lex (W → β)},
  Cardinal.aleph0 ≤ μ → μ < Cardinal.mk ↑{q | q ∈ bigAt✝ lam F v ∧ truncate w q = p} → w < v

bigAt truncate

Uses

truncate_truncate

Used by

exists_shatter_tuple

Decllt_mk_big_fiberDeclaration kindtheorem
The step at which ded enters the argument. Below a wide node p, the core members extending p are at least lam many, and they form a set of branches whose nodes are the wide nodes extending p together with the truncations of p itself. The tree bound therefore caps them by ded of that node set, so if the wide nodes extending p were at most μ the count would be at most ded (μ + #W), which is below lam.
```
∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β]
 {F : Set (Lex (W → β))} {lam μ : Cardinal.{u}} {w : W} {p : Lex (W → β)} [WellFoundedLT W],
 lam.IsRegular →
 Cardinal.mk ↑(F \ core✝ lam F) < lam →
 p ∈ bigAt✝ lam F w → ded (μ + Cardinal.mk W) < lam → μ < Cardinal.mk ↑{q | q ∈ big✝ lam F ∧ truncate w q = p}
```
big bigAt core ded truncate
Uses
Used by
- exists_shatter_tuple

Decltruncate_truncateDeclaration kindtheorem

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β] (w v : W)
  (b : Lex (W → β)), truncate w (truncate v b) = truncate (min w v) b

truncate

Used by

exists_shatter_tuple
lt_mk_big_fiber
lt_of_mk_lt

Declmk_le_ded_of_truncate_memDeclaration kindtheorem
The tree bound: a set 𝒮 of sequences all of whose truncations lie in 𝒟 has at most ded #𝒟 elements. Equivalently, a tree with at most κ nodes has at most ded κ branches. The order is taken on 𝒮 ∪ 𝒟 with 𝒟 as the dense subset: given f < g there, either g lies in 𝒟 and brackets the pair by itself, or g lies in 𝒮 and the truncation of g at the first index where f and g differ lies between them.
```
∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β] [WellFoundedLT W]
 {𝒮 𝒟 : Set (Lex (W → β))} {κ : Cardinal.{u}},
 (∀ f ∈ 𝒮, ∀ (w : W), truncate w f ∈ 𝒟) → Cardinal.mk ↑𝒟 ≤ κ → Cardinal.mk ↑𝒮 ≤ ded κ
```
ded truncate
Uses
Used by
- lt_mk_big_fiber

Decltruncate_leDeclaration kindtheorem

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β] [WellFoundedLT W]
  (w : W) (b : Lex (W → β)), truncate w b ≤ b

truncate

Uses

lex_lt_iff
truncate_apply

Used by

mk_le_ded_of_truncate_mem

Declmk_le_dedDeclaration kindtheorem
The defining property of ded, in the form used downstream: a linear order with a dense subset of size at most κ has at most ded κ points.
```
∀ {κ : Cardinal.{u}} {J : Type u} [inst : LinearOrder J] {E : Set J},
  Cardinal.mk ↑E ≤ κ → IsDenseIn E → Cardinal.mk J ≤ ded κ
```
IsDenseIn ded dedSet
Uses
- bddAbove_dedSet
Used by
- mk_le_ded_of_truncate_mem

Decllt_truncateDeclaration kindtheorem

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β] {a b : Lex (W → β)}
  {w : W}, (∀ j < w, ofLex a j = ofLex b j) → ofLex a w < ofLex b w → a < truncate w b

truncate

Uses

lex_lt_iff
truncate_apply

Used by

mk_le_ded_of_truncate_mem

Decltruncate_applyDeclaration kindtheorem

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β] (w : W)
  (b : Lex (W → β)) (v : W), ofLex (truncate w b) v = if v ≤ w then ofLex b v else ⊥

truncate

Used by

exists_shatter_tuple
lt_truncate
ofLex_truncate_of_le
truncate_enc_eq_iff
truncate_le

Decllex_lt_iffDeclaration kindtheorem

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] {a b : Lex (W → β)},
  a < b ↔ ∃ i, (∀ j < i, ofLex a j = ofLex b j) ∧ ofLex a i < ofLex b i

Used by

lt_truncate
mk_le_ded_of_truncate_mem
truncate_le

Declle_mk_core_fiberDeclaration kindtheorem

A wide node stays wide inside the core, the pruning having removed fewer than lam members.

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β]
  {F : Set (Lex (W → β))} {lam : Cardinal.{u}} {w : W} {p : Lex (W → β)},
  lam.IsRegular →
    Cardinal.mk ↑(F \ core✝ lam F) < lam →
      p ∈ bigAt✝ lam F w → lam ≤ Cardinal.mk ↑{g | g ∈ core✝ lam F ∧ truncate w g = p}

bigAt core truncate

Used by

lt_mk_big_fiber

Declexists_levelDeclaration kindtheorem

The wide nodes below a fixed node spread over the levels, so if they are more than μ in total and the levels are at most μ, one level already carries more than μ of them.

∀ {W : Type u} [inst : LinearOrder W] {β : Type u} [inst_1 : LinearOrder β] [inst_2 : OrderBot β]
  {F : Set (Lex (W → β))} {lam μ : Cardinal.{u}} {w : W} {p : Lex (W → β)},
  Cardinal.aleph0 ≤ μ →
    Cardinal.mk W ≤ μ →
      μ < Cardinal.mk ↑{q | q ∈ big✝ lam F ∧ truncate w q = p} →
        ∃ v, μ < Cardinal.mk ↑{q | q ∈ bigAt✝ lam F v ∧ truncate w q = p}

big bigAt truncate

Used by

exists_shatter_tuple

Declenc_apply_eq_valIn_orDeclaration kindtheorem

∀ {α W : Type u} {e : W → α} (C : Set α) (w : W), ofLex (enc✝ e C) w = valIn✝ ∨ ofLex (enc✝ e C) w = valOut✝

enc valIn valOut

Uses

enc_apply

Used by

exists_shatter_tuple_of_enum

Declenc_apply_eq_valIn_iffDeclaration kindtheorem
```
∀ {α W : Type u} {e : W → α} (C : Set α) (w : W), ofLex (enc✝ e C) w = valIn✝ ↔ e w ∈ C
```
enc valIn valOut
Uses
- enc_apply
- valIn_ne_valOut
Used by
- exists_shatter_tuple_of_enum
DeclvalIn_ne_valOutDeclaration kindtheorem
```
valIn✝ ≠ valOut✝
```
valIn valOut
Used by

Declenc_applyDeclaration kindtheorem

∀ {α W : Type u} {e : W → α} {C : Set α} (w : W), ofLex (enc✝ e C) w = if e w ∈ C then valIn✝ else valOut✝

enc valIn valOut

Used by

enc_apply_eq_iff
enc_apply_eq_valIn_iff
enc_apply_eq_valIn_or

Declexists_minimal_subsetDeclaration kindtheorem
The reduction that makes the tree small. Among the subsets of A whose trace family outruns θ there is one of least cardinality, Cardinal being well-ordered. Along an enumeration of that subset every proper initial segment carries at most θ traces, which is what the tree bound needs and what a well-order of A itself does not supply.
```
∀ {α : Type u} {𝒜 : Set (Set α)} {A : Set α} {θ : Cardinal.{u}},
 θ < Cardinal.mk ↑((fun x => A ∩ x) '' 𝒜) →
 ∃ B ⊆ A,
 θ < Cardinal.mk ↑((fun x => B ∩ x) '' 𝒜) ∧
 ∀ B' ⊆ A, Cardinal.mk ↑B' < Cardinal.mk ↑B → Cardinal.mk ↑((fun x => B' ∩ x) '' 𝒜) ≤ θ
```
Used by
- exists_shatters_of_ded_lt_mk_image_inter
Declded_le_dedDeclaration kindtheorem
```
∀ {κ₁ κ₂ : Cardinal.{u}}, κ₁ ≤ κ₂ → ded κ₁ ≤ ded κ₂
```
IsDenseIn ded dedSet
Uses
- bddAbove_dedSet
- self_mem_dedSet
Used by
- exists_shatters_of_ded_lt_mk_image_inter
Declself_mem_dedSetDeclaration kindtheorem
```
∀ (κ : Cardinal.{u}), κ ∈ dedSet✝ κ
```
IsDenseIn dedSet
Uses
- isDenseIn_univ
Used by
- ded_le_ded
- self_le_ded
DeclisDenseIn_univDeclaration kindtheorem
```
∀ {I : Type u_1} [inst : Preorder I], IsDenseIn Set.univ
```
IsDenseIn
Used by
- self_mem_dedSet
DeclbddAbove_dedSetDeclaration kindtheorem
```
∀ (κ : Cardinal.{u}), BddAbove (dedSet✝ κ)
```
dedSet
Uses
- dedSet_le
Used by
DecldedSet_leDeclaration kindtheorem
```
∀ {κ c : Cardinal.{u}}, c ∈ dedSet✝ κ → c ≤ 2 ^ (κ + κ)
```
IsDenseIn dedSet
Uses
- IsDenseIn.mk_le_two_pow_mul
Used by
- bddAbove_dedSet
DeclIsDenseIn.mk_le_two_pow_mulDeclaration kindtheorem
A linear order with a dense subset D has at most 2 ^ #D * 2 ^ #D points, since a point is determined by the pair of cuts it induces on D.
```
∀ {J : Type u} [inst : LinearOrder J] {E : Set J}, IsDenseIn E → Cardinal.mk J ≤ 2 ^ Cardinal.mk ↑E * 2 ^ Cardinal.mk ↑E
```
IsDenseIn cutCode
Uses
- cutCode_injective
Used by
- dedSet_le
DeclcutCode_injectiveDeclaration kindtheorem
```
∀ {I : Type u_1} {D : Set I} [inst : LinearOrder I], IsDenseIn D → Function.Injective (cutCode✝ D)
```
IsDenseIn cutCode
Uses
- cutCode_ne
Used by
- IsDenseIn.mk_le_two_pow_mul

DeclcutCode_neDeclaration kindtheorem

∀ {I : Type u_1} {D : Set I} [inst : LinearOrder I], IsDenseIn D → ∀ {x y : I}, x < y → cutCode✝ D x ≠ cutCode✝ D y

IsDenseIn cutCode

Used by

cutCode_injective

Hypothesish𝒜
```
HasVCDimLE d 𝒜
```
HypothesishA
```
A.Infinite
```
DefinitionHasVCDimLEdefYaël Dillies
A set family 𝒜 has VC dimension at most d if all the sets it shatters have size at most d.
```
{α : Type u_1} → ℕ → Set (Set α) → Prop
```
DefinitionIsDenseIndef
D is dense in a preorder I when every pair a < b brackets a point of D, that is, when there is d ∈ D with a ≤ d ≤ b. On a linear order without jumps this agrees with strict betweenness; on an order with jumps it is strictly weaker, and it is the form under which ded bounds the size of the order.
```
{I : Type u_1} → [Preorder I] → Set I → Prop
```
DefinitionShattersdefYaël Dillies
A set family 𝒜 shatters a set A if all subsets of A can be obtained as the intersection of A with some element of the set family. We also say that A is traced by 𝒜.
```
{α : Type u_1} → [SemilatticeInf α] → Set α → α → Prop
```

Definitionbigdef

The wide nodes of the tree of truncations of F, at all levels.

{W : Type u} →
  [LinearOrder W] →
    {β : Type u} → [inst : LinearOrder β] → [OrderBot β] → Cardinal.{u} → Set (Lex (W → β)) → Set (Lex (W → β))

DefinitionbigAtdef

The level-w truncations of F that at least lam members of F extend.

{W : Type u} →
  [LinearOrder W] →
    {β : Type u} → [inst : LinearOrder β] → [OrderBot β] → Cardinal.{u} → Set (Lex (W → β)) → W → Set (Lex (W → β))

Definitioncoredef

The members of F all of whose truncations are wide.

{W : Type u} →
  [LinearOrder W] →
    {β : Type u} → [inst : LinearOrder β] → [OrderBot β] → Cardinal.{u} → Set (Lex (W → β)) → Set (Lex (W → β))

DefinitioncutCodedef

The pair of cuts a point of I induces on D.

{I : Type u_1} → [Preorder I] → (D : Set I) → I → Set ↑D × Set ↑D

Definitiondeddef
ded κ is the supremum of the cardinalities of the linear orders that admit a dense subset of size at most κ. The supremum is taken over a set of cardinals bounded above by 2 ^ (κ + κ), so it is not a junk value. Carriers are restricted to Type u, which does not move the supremum, every witness having size at most 2 ^ (κ + κ).
```
Cardinal.{u} → Cardinal.{u}
```
DefinitiondedSetdef
The set of cardinalities of linear orders with a dense subset of size at most κ.
```
Cardinal.{u} → Set Cardinal.{u}
```

Definitionencdef

The code of C along an indexing e of the ground set.

{α W : Type u} → (W → α) → Set α → Lex (W → WithBot (ULift.{u, 0} Bool))

Definitiontruncatedef

The sequence agreeing with b up to w and equal to ⊥ above it.

{W : Type u} → [LinearOrder W] → {β : Type u} → [inst : LinearOrder β] → [OrderBot β] → W → Lex (W → β) → Lex (W → β)

DefinitionvalIndef
The two defined values of the alphabet coding a partial trace; ⊥ marks the positions where the trace is undefined.
```
WithBot (ULift.{u, 0} Bool)
```
DefinitionvalOutdef
```
WithBot (ULift.{u, 0} Bool)
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

No cardinal function strictly smaller than ded bounds the traces of a family of finite VC dimension. For every infinite κ and every lam < ded κ there is a family of VC dimension 1 on a ground set of size exactly κ tracing more than lam sets. Together with HasVCDimLE.mk_image_inter_le_ded, which caps those traces at ded #A, this places ded at the exact strength of the bound.

The conclusion cannot be strengthened to a family tracing exactly ded κ sets. Chernikov and Shelah, On the number of Dedekind cuts and two-cardinal models of dependent theories, note after their definition of ded κ that "in general the supremum need not be attained", so at such a κ no family attains it and quantifying below the supremum is the available form. At κ = ℵ₀ the supremum is attained, by mk_image_inter_range_cut_eq_ded.

Declno_smaller_bound

∀ {κ : Cardinal.{u}},
  Cardinal.aleph0 ≤ κ →
    ∀ {lam : Cardinal.{u}},
      lam < ded κ → ∃ α 𝒜 A, Cardinal.mk ↑A = κ ∧ HasVCDimLE 1 𝒜 ∧ lam < Cardinal.mk ↑((fun x => A ∩ x) '' 𝒜)

TopicCardinal bounds

Relations

LimitsMTH.C-2026-6007
No cardinal function smaller than ded bounds the traces, which places ded at the exact strength of the bound.
Asserted by Dhruv Gupta

ThesisStepHypothesisDefinition

Declno_smaller_boundDeclaration kindtheorem

∀ {κ : Cardinal.{u}},
  Cardinal.aleph0 ≤ κ →
    ∀ {lam : Cardinal.{u}},
      lam < ded κ → ∃ α 𝒜 A, Cardinal.mk ↑A = κ ∧ HasVCDimLE 1 𝒜 ∧ lam < Cardinal.mk ↑((fun x => A ∩ x) '' 𝒜)

HasVCDimLE IsStrictlyDenseIn ded ded'dedSet'

Uses

ded'_eq_ded
exists_family_of_isStrictlyDenseIn
one_mem_dedSet'

Declone_mem_dedSet'Declaration kindtheorem
```
∀ (κ : Cardinal.{u}), 1 ∈ dedSet'✝ κ
```
IsStrictlyDenseIn dedSet'
Uses
- isStrictlyDenseIn_empty_punit
Used by
- no_smaller_bound
DeclisStrictlyDenseIn_empty_punitDeclaration kindtheorem
```
IsStrictlyDenseIn ∅
```
IsStrictlyDenseIn
Used by
- one_mem_dedSet'
Declexists_family_of_isStrictlyDenseInDeclaration kindtheorem
The witness attached to a strictly dense subset: a family of VC dimension 1 on a ground set of size exactly κ whose traces are at least as many as the points of J.
```
∀ {κ : Cardinal.{u}} {J : Type u} [inst : LinearOrder J] {E : Set J},
  Cardinal.aleph0 ≤ κ →
    Cardinal.mk ↑E ≤ κ →
      IsStrictlyDenseIn E →
        ∃ α 𝒜 A, Cardinal.mk ↑A = κ ∧ HasVCDimLE 1 𝒜 ∧ Cardinal.mk J ≤ Cardinal.mk ↑((fun x => A ∩ x) '' 𝒜)
```
HasVCDimLE IsStrictlyDenseIn padCuts padGround
Uses
Used by
- no_smaller_bound

Declmk_padGroundDeclaration kindtheorem

∀ {κ : Cardinal.{u}} {J P : Type u} {E : Set J},
  Cardinal.aleph0 ≤ κ → Cardinal.mk ↑E ≤ κ → Cardinal.mk P = κ → Cardinal.mk ↑(padGround✝ E) = κ

padGround

Used by

exists_family_of_isStrictlyDenseIn

DeclisChain_padCutsDeclaration kindtheorem

∀ (J P : Type u) [inst : LinearOrder J], IsChain (fun x1 x2 => x1 ⊆ x2) (padCuts✝ J P)

padCuts

Used by

exists_family_of_isStrictlyDenseIn

Declinter_padCuts_neDeclaration kindtheorem
A point of E strictly between j and j' separates the two traces: it lies in the trace at j' and, being above j, not in the trace at j.
```
∀ {J P : Type u} [inst : LinearOrder J] {E : Set J} {j j' e : J},
 e ∈ E → j < e → e < j' → padGround✝ E ∩ Sum.inl '' {a | a < j} ≠ padGround✝ E ∩ Sum.inl '' {a | a < j'}
```
padGround
Used by
- exists_family_of_isStrictlyDenseIn
DeclhasVCDimLE_one_of_isChainDeclaration kindtheorem
A family linearly ordered by inclusion has VC dimension at most 1. Shattering a two point set asks for a member meeting it in the first point alone and a member meeting it in the second point alone; whichever of the two members is contained in the other already contains its own point, so it meets the set in both. This is why the extremal families for ded are families of cuts: the number of cuts is exactly what a chain in a linear order can achieve.
```
∀ {α : Type u_2} {𝒜 : Set (Set α)}, IsChain (fun x1 x2 => x1 ⊆ x2) 𝒜 → HasVCDimLE 1 𝒜
```
HasVCDimLE Shatters
Used by
- exists_family_of_isStrictlyDenseIn
Declded'_eq_dedDeclaration kindtheorem
The convention question is empty at infinite cardinals: ded and ded' agree there. It is not empty in general, by ded'_one_lt_ded_one.
```
∀ {κ : Cardinal.{u}}, Cardinal.aleph0 ≤ κ → ded' κ = ded κ
```
ded ded'
Uses
- ded'_le_ded
- ded_le_ded'
Used by
- no_smaller_bound
Declded_le_ded'Declaration kindtheorem
The two readings of "dense subset" define the same cardinal function at every infinite cardinal. Every bracketing witness is turned into a strict witness of at least its size by mk_le_ded'_of_isDenseIn, at the cost of a countable factor in the dense subset, which an infinite κ absorbs.
```
∀ {κ : Cardinal.{u}}, Cardinal.aleph0 ≤ κ → ded κ ≤ ded' κ
```
IsDenseIn ded ded'
Uses
- ded_le
- mk_le_ded'_of_isDenseIn
Used by
- ded'_eq_ded
Declmk_le_ded'_of_isDenseInDeclaration kindtheorem
```
∀ {κ : Cardinal.{u}} {J : Type u} [inst : LinearOrder J] {E : Set J},
  Cardinal.aleph0 ≤ κ → Cardinal.mk ↑E ≤ κ → IsDenseIn E → Cardinal.mk J ≤ ded' κ
```
IsDenseIn ded'fatten fattenDense
Uses
Used by
- ded_le_ded'
Declmk_le_mk_fattenDeclaration kindtheorem
```
∀ {J : Type u} (E : Set J), Cardinal.mk J ≤ Cardinal.mk ↑(fatten✝ E)
```
fatten
Uses
- fatten_bot_injective
Used by
- mk_le_ded'_of_isDenseIn

Declfatten_bot_injectiveDeclaration kindtheorem

∀ {J : Type u} (E : Set J), Function.Injective fun x => ⟨toLex (x, 0), ⋯⟩

fatten

Used by

mk_le_mk_fatten

Declmk_le_ded'Declaration kindtheorem
The defining property of ded': a linear order with a strictly dense subset of size at most κ has at most ded' κ points.
```
∀ {κ : Cardinal.{u}} {J : Type u} [inst : LinearOrder J] {E : Set J},
  Cardinal.mk ↑E ≤ κ → IsStrictlyDenseIn E → Cardinal.mk J ≤ ded' κ
```
IsStrictlyDenseIn ded'dedSet'
Uses
- bddAbove_dedSet'
Used by
- mk_le_ded'_of_isDenseIn
DeclbddAbove_dedSet'Declaration kindtheorem
```
∀ (κ : Cardinal.{u}), BddAbove (dedSet'✝ κ)
```
dedSet'
Uses
- dedSet'_le
Used by
- mk_le_ded'
DecldedSet'_leDeclaration kindtheorem
```
∀ {κ c : Cardinal.{u}}, c ∈ dedSet'✝ κ → c ≤ 2 ^ (κ + κ)
```
IsDenseIn IsStrictlyDenseIn dedSet'
Uses
- IsStrictlyDenseIn.isDenseIn
- dedSet_le
Used by
- bddAbove_dedSet'
Declmk_fattenDense_leDeclaration kindtheorem
```
∀ {J : Type u} (E : Set J), Cardinal.mk ↑(fattenDense✝ E) ≤ Cardinal.mk ↑E * Cardinal.aleph0
```
fatten fattenDense
Uses
- fattenDense_code_injective
Used by
- mk_le_ded'_of_isDenseIn

DeclfattenDense_code_injectiveDeclaration kindtheorem

∀ {J : Type u} (E : Set J), Function.Injective fun p => (⟨(ofLex ↑↑p).1, ⋯⟩, (ofLex ↑↑p).2)

fatten fattenDense

Used by

mk_fattenDense_le

DeclisStrictlyDenseIn_fattenDenseDeclaration kindtheorem
```
∀ {J : Type u} [inst : LinearOrder J] {E : Set J}, IsDenseIn E → IsStrictlyDenseIn (fattenDense✝ E)
```
IsDenseIn IsStrictlyDenseIn fatten fattenDense
Uses
- exists_strictly_between_fatten
Used by
- mk_le_ded'_of_isDenseIn
Declexists_strictly_between_fattenDeclaration kindtheorem
The heart of the comparison: in the blow-up, every pair is separated strictly by a point lying over E. The three cases of the bracketing witness d are a < d < b, where the fibre over d supplies the point; d = a, where the point is taken higher in the fibre over a; and d = b, where it is taken lower in the fibre over b.
```
∀ {J : Type u} [inst : LinearOrder J] {E : Set J},
 IsDenseIn E →
 ∀ {u v : Lex (J × ℚ)}, u ∈ fatten✝ E → v ∈ fatten✝ E → u < v → ∃ z ∈ E, ∃ r, u < toLex (z, r) ∧ toLex (z, r) < v
```
IsDenseIn fatten
Uses
- mem_of_fatten_of_fst_eq
Used by
- isStrictlyDenseIn_fattenDense

Declmem_of_fatten_of_fst_eqDeclaration kindtheorem

∀ {J : Type u} {E : Set J} {u v : Lex (J × ℚ)},
  u ∈ fatten✝ E → v ∈ fatten✝ E → (ofLex u).1 = (ofLex v).1 → (ofLex u).2 < (ofLex v).2 → (ofLex u).1 ∈ E

fatten

Used by

exists_strictly_between_fatten

Declded_leDeclaration kindtheorem

The elimination rule for ded.

∀ {κ c : Cardinal.{u}},
  (∀ (J : Type u) (x : LinearOrder J) (E : Set J), Cardinal.mk ↑E ≤ κ → IsDenseIn E → Cardinal.mk J ≤ c) → ded κ ≤ c

IsDenseIn ded dedSet

Used by

ded_le_ded'

Declded'_le_dedDeclaration kindtheorem
Strict density is the stronger condition on the subset, so fewer orders are witnesses and the supremum is no larger. This holds at every cardinal.
```
∀ (κ : Cardinal.{u}), ded' κ ≤ ded κ
```
IsStrictlyDenseIn ded ded'
Uses
Used by
- ded'_eq_ded
Declmk_le_dedDeclaration kindtheorem
The defining property of ded, in the form used downstream: a linear order with a dense subset of size at most κ has at most ded κ points.
```
∀ {κ : Cardinal.{u}} {J : Type u} [inst : LinearOrder J] {E : Set J},
  Cardinal.mk ↑E ≤ κ → IsDenseIn E → Cardinal.mk J ≤ ded κ
```
IsDenseIn ded dedSet
Uses
- bddAbove_dedSet
Used by
- ded'_le_ded
DeclbddAbove_dedSetDeclaration kindtheorem
```
∀ (κ : Cardinal.{u}), BddAbove (dedSet✝ κ)
```
dedSet
Uses
- dedSet_le
Used by
- mk_le_ded
DecldedSet_leDeclaration kindtheorem
```
∀ {κ c : Cardinal.{u}}, c ∈ dedSet✝ κ → c ≤ 2 ^ (κ + κ)
```
IsDenseIn dedSet
Uses
- IsDenseIn.mk_le_two_pow_mul
Used by
- bddAbove_dedSet
- dedSet'_le
DeclIsDenseIn.mk_le_two_pow_mulDeclaration kindtheorem
A linear order with a dense subset D has at most 2 ^ #D * 2 ^ #D points, since a point is determined by the pair of cuts it induces on D.
```
∀ {J : Type u} [inst : LinearOrder J] {E : Set J}, IsDenseIn E → Cardinal.mk J ≤ 2 ^ Cardinal.mk ↑E * 2 ^ Cardinal.mk ↑E
```
IsDenseIn cutCode
Uses
- cutCode_injective
Used by
- dedSet_le
DeclcutCode_injectiveDeclaration kindtheorem
```
∀ {I : Type u_1} {D : Set I} [inst : LinearOrder I], IsDenseIn D → Function.Injective (cutCode✝ D)
```
IsDenseIn cutCode
Uses
- cutCode_ne
Used by
- IsDenseIn.mk_le_two_pow_mul

DeclcutCode_neDeclaration kindtheorem

∀ {I : Type u_1} {D : Set I} [inst : LinearOrder I], IsDenseIn D → ∀ {x y : I}, x < y → cutCode✝ D x ≠ cutCode✝ D y

IsDenseIn cutCode

Used by

cutCode_injective

Declded'_leDeclaration kindtheorem

The elimination rule for ded'.

∀ {κ c : Cardinal.{u}},
  (∀ (J : Type u) (x : LinearOrder J) (E : Set J), Cardinal.mk ↑E ≤ κ → IsStrictlyDenseIn E → Cardinal.mk J ≤ c) →
    ded' κ ≤ c

IsStrictlyDenseIn ded'dedSet'

Used by

ded'_le_ded

DeclIsStrictlyDenseIn.isDenseInDeclaration kindtheorem
```
∀ {I : Type u_1} {D : Set I} [inst : Preorder I], IsStrictlyDenseIn D → IsDenseIn D
```
IsDenseIn IsStrictlyDenseIn
Used by
- ded'_le_ded
- dedSet'_le
Hypothesishκ
```
Cardinal.aleph0 ≤ κ
```
Hypothesish
```
lam < ded κ
```
DefinitionHasVCDimLEdefYaël Dillies
A set family 𝒜 has VC dimension at most d if all the sets it shatters have size at most d.
```
{α : Type u_1} → ℕ → Set (Set α) → Prop
```
DefinitionIsDenseIndef
D is dense in a preorder I when every pair a < b brackets a point of D, that is, when there is d ∈ D with a ≤ d ≤ b. On a linear order without jumps this agrees with strict betweenness; on an order with jumps it is strictly weaker, and it is the form under which ded bounds the size of the order.
```
{I : Type u_1} → [Preorder I] → Set I → Prop
```
DefinitionIsStrictlyDenseIndef
D is strictly dense in a preorder I when every pair a < b has a point of D strictly between them. This is the second of the two readings of "dense subset" that the definition of ded in the literature leaves open; the first is IsDenseIn. Where the order has no jumps the two agree, and a linear order with a jump whose two endpoints lie in D satisfies IsDenseIn only. The literature on ded does not say which reading is meant; ded'_eq_ded shows the question does not affect the value of ded at an infinite cardinal.
```
{I : Type u_1} → [Preorder I] → Set I → Prop
```
DefinitionShattersdefYaël Dillies
A set family 𝒜 shatters a set A if all subsets of A can be obtained as the intersection of A with some element of the set family. We also say that A is traced by 𝒜.
```
{α : Type u_1} → [SemilatticeInf α] → Set α → α → Prop
```

DefinitioncutCodedef

The pair of cuts a point of I induces on D.

{I : Type u_1} → [Preorder I] → (D : Set I) → I → Set ↑D × Set ↑D

Definitiondeddef
ded κ is the supremum of the cardinalities of the linear orders that admit a dense subset of size at most κ. The supremum is taken over a set of cardinals bounded above by 2 ^ (κ + κ), so it is not a junk value. Carriers are restricted to Type u, which does not move the supremum, every witness having size at most 2 ^ (κ + κ).
```
Cardinal.{u} → Cardinal.{u}
```
Definitionded'def
ded' κ is the supremum of the cardinalities of the linear orders that admit a strictly dense subset of size at most κ. It is the same construction as ded, with strict betweenness in place of bracketing, and is bounded above by the same 2 ^ (κ + κ).
```
Cardinal.{u} → Cardinal.{u}
```
DefinitiondedSetdef
The set of cardinalities of linear orders with a dense subset of size at most κ.
```
Cardinal.{u} → Set Cardinal.{u}
```
DefinitiondedSet'def
The set of cardinalities of linear orders with a strictly dense subset of size at most κ.
```
Cardinal.{u} → Set Cardinal.{u}
```
Definitionfattendef
The blow-up of J along E: the lexicographic product J ×ₗ ℚ with the fibre over each point outside E collapsed to the single rational 0.
```
{J : Type u} → Set J → Set (Lex (J × ℚ))
```
DefinitionfattenDensedef
The part of the blow-up lying over E, that is, the union of the full ℚ fibres.
```
{J : Type u} → (E : Set J) → Set ↑(fatten✝ E)
```
DefinitionpadCutsdef
The witness family: the down sets of J, carried into the padded ground type.
```
(J P : Type u) → [LinearOrder J] → Set (Set (J ⊕ P))
```
DefinitionpadGrounddef
The ground set of the witness: a subset E of J together with a disjoint copy of P, whose points no member of the family below meets.
```
{J P : Type u} → Set J → Set (J ⊕ P)
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

Declfundamental_vc_compression_with_info

∀ (X : Type u) (C : ConceptClass X Bool), VCDim X C < ⊤ ↔ ∃ k cs, CompressionSchemeWithInfo.size cs = k

TopicCompression

ThesisStepDefinition

Declfundamental_vc_compression_with_infoDeclaration kindtheorem
```
∀ (X : Type u) (C : ConceptClass X Bool), VCDim X C < ⊤ ↔ ∃ k cs, CompressionSchemeWithInfo.size cs = k
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass VCDim
Uses
- compression_with_info_imp_vcdim_finite
- vcdim_finite_imp_compression_with_info
Declvcdim_finite_imp_compression_with_infoDeclaration kindtheorem
The forward direction of the Moran-Yehudayoff theorem: finite VC dimension implies existence of a compression scheme with finite side information.
The construction: 1. Build a proper finite-support learner L from VC + Sauer-Shelah 2. For sample S: extract c, Y = pointSupport S, HY = hypothesis envelope 3. Apply approximate minimax on the agreement game → distribution p on HY 4. Apply VC ε-approximation on agreement tests → T representative hypotheses 5. Kernel = union of witness subsets for T hypotheses 6. Side info = incidence: which hypothesis's witness contains each kernel point 7. Reconstruct by majority vote over T hypotheses
```
∀ (X : Type u) (C : ConceptClass X Bool), VCDim X C < ⊤ → ∃ k cs, CompressionSchemeWithInfo.size cs = k
```
CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.info_finite CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass FLT.Concept ProperFiniteSupportLearner ProperFiniteSupportLearner.sampleBound VCDim
Uses
- moran_yehudayoff_forward_construction
- vcdim_finite_imp_proper_finite_support_learner
Used by
- fundamental_vc_compression_with_info
Declvcdim_finite_imp_proper_finite_support_learnerDeclaration kindtheorem
Finite VC dimension implies existence of a proper finite-support learner. The construction uses ERM + finite_support_vc_approx on the disagreement family.
```
∀ (X : Type u) (C : ConceptClass X Bool), Set.Nonempty C → VCDim X C < ⊤ → ∃ _L, True
```
ConceptClass FLT.Concept FinitePMF Finset.boolVCDim ProperFiniteSupportLearner VCDim boolTestExpectation disagreementFamily empiricalPMF labeledSampleOfFinset supportError
Uses
Used by
- vcdim_finite_imp_compression_with_info
DeclsupportError_eq_boolTestExpectationDeclaration kindtheorem
supportError expressed in terms of boolTestExpectation of a disagreement test.
```
∀ {X : Type u} (Y : Finset X) (q : FinitePMF ↥Y) (h c : X → Bool),
  supportError Y q h c = boolTestExpectation q fun y => decide (h ↑y ≠ c ↑y)
```
FinitePMF FinitePMF.prob boolTestExpectation supportError
Used by
- vcdim_finite_imp_proper_finite_support_learner
DecldisagreementFamily_boolVCDim_leDeclaration kindtheorem
VC dimension of the disagreement family is bounded by VCDim(C). Restriction to Y and xor with c do not increase shattering dimension.
```
∀ {X : Type u} [inst : DecidableEq X] (C : ConceptClass X Bool) (c : X → Bool) (Y : Finset X) {d : ℕ},
  VCDim X C ≤ ↑d → (disagreementFamily✝ C c Y).boolVCDim ≤ d
```
ConceptClass FLT.Concept Finset.boolVCDim Shatters VCDim boolFamilyToFinsetFamily disagreementFamily
Used by
- vcdim_finite_imp_proper_finite_support_learner
Declmoran_yehudayoff_forward_constructionDeclaration kindtheorem
The Moran-Yehudayoff forward construction. Uses finalizeIncidenceScheme to package the majority-vote scheme with universe-correct Info type.
The agent must provide: compressCore, blockHyp, rowHyp, hsmall, hsub, hagree, hmajor. These are the MY wiring.
```
∀ (X : Type u) (C : ConceptClass X Bool),
 Set.Nonempty C →
 ∀ (L : ProperFiniteSupportLearner X C), VCDim X C < ⊤ → ∀ (_K : ℕ), ∃ k cs, CompressionSchemeWithInfo.size cs = k
```
CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass FLT.Concept FinitePMF FinitePMF.prob Finset.boolVCDim IncidenceInfo ProperFiniteSupportLearner ProperFiniteSupportLearner.learn ProperFiniteSupportLearner.sampleBound VCDim agreeTest agreeTests boolGamePayoff boolTestExpectation boundedSubsamples decodeWitnessLabel decodeWitnessXCoords empiricalPMF encodeWitnessInfo hypothesisEnvelope labeledSampleOfFinset pointSupport uniformPMF
Uses
Used by
- vcdim_finite_imp_compression_with_info

Declroundtrip_blockHyp_eq_repDeclaration kindtheorem

Generic roundtrip theorem for the hround sorry.

If:

encodeWitnessInfo is used in compressCore,
decodeWitnessXCoords and decodeWitnessLabel are used in blockHyp, and
the kernel contains the witness pairs with the correct labels,

then the decoded block hypothesis is exactly the representative hypothesis.

∀ {X : Type u} [inst : DecidableEq X] (learn : {m : ℕ} → (Fin m → X × Bool) → X → Bool) (kernel : Finset (X × Bool))
  (c : X → Bool) (K : ℕ) (W : Finset X) (h : X → Bool),
  kernel.card ≤ K →
    (∀ x ∈ W, (x, c x) ∈ kernel) →
      (∀ p ∈ kernel, p.2 = c p.1) →
        learn (labeledSampleOfFinset c W) = h →
          ∀ (x : X),
            have info := encodeWitnessInfo kernel c K W;
            have blockXCoords := decodeWitnessXCoords kernel info;
            have blockLabel := decodeWitnessLabel kernel;
            learn (labeledSampleOfFinset blockLabel blockXCoords) x = h x

decodeWitnessLabel decodeWitnessXCoords encodeWitnessInfo labeledSampleOfFinset

Uses

decodeWitnessLabel_eq_on_encoded
decodeWitnessXCoords_encode_eq
labeledSampleOfFinset_eq_of_eq_on_support

Used by

moran_yehudayoff_forward_construction

DecllabeledSampleOfFinset_eq_of_eq_on_supportDeclaration kindtheorem
If two label functions agree on all points of Z, then the labeled samples they induce on Z.equivFin are equal.
```
∀ {X : Type u} [DecidableEq X] {ℓ₁ ℓ₂ : X → Bool} {Z : Finset X},
  (∀ x ∈ Z, ℓ₁ x = ℓ₂ x) → labeledSampleOfFinset ℓ₁ Z = labeledSampleOfFinset ℓ₂ Z
```
labeledSampleOfFinset
Used by
- roundtrip_blockHyp_eq_rep
DecldecodeWitnessXCoords_encode_eqDeclaration kindtheorem
If every (x, c x) with x ∈ W lies in kernel, and kernel.card ≤ K, then decoding the encoded witness positions gives back exactly W.
```
∀ {X : Type u} [inst : DecidableEq X] (kernel : Finset (X × Bool)) (c : X → Bool) {K : ℕ} (W : Finset X),
  kernel.card ≤ K → (∀ x ∈ W, (x, c x) ∈ kernel) → decodeWitnessXCoords kernel (encodeWitnessInfo kernel c K W) = W
```
decodeWitnessXCoords encodeWitnessInfo
Used by
- roundtrip_blockHyp_eq_rep
DecldecodeWitnessLabel_eq_on_encodedDeclaration kindtheorem
On the encoded witness support, the decoded label function agrees with the true label function c, provided every pair in the kernel has the correct second coordinate.
```
∀ {X : Type u} [inst : DecidableEq X] (kernel : Finset (X × Bool)) (c : X → Bool) (W : Finset X),
  (∀ x ∈ W, (x, c x) ∈ kernel) → (∀ p ∈ kernel, p.2 = c p.1) → ∀ x ∈ W, decodeWitnessLabel kernel x = c x
```
decodeWitnessLabel
Used by
- roundtrip_blockHyp_eq_rep
Declmwu_approx_minimaxDeclaration kindtheorem
Genuine approximate minimax via MWU regret extraction. If every column mixture admits a pure row with expected payoff ≥ v, then there is a row mixture with payoff ≥ v - ε against every column.
```
∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [Nonempty R] [Nonempty C] [DecidableEq R]
 [DecidableEq C] (M : R → C → Bool) (v ε : ℝ),
 0 < ε →
 (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) →
 ∃ p, ∀ (c : C), v - ε ≤ boolGamePayoff M p c
```
FinitePMF FinitePMF.prob MWUConfig.potential MWUConfig.weights boolGamePayoff empiricalPMF mwuConfig mwuHitCount mwuRows uniformPMF
Uses
Used by
- moran_yehudayoff_forward_construction
Declweight_le_potentialDeclaration kindtheorem
A single weight is bounded by the potential.
```
∀ {C : Type u_1} [inst : Fintype C] (cfg : MWUConfig C) (c : C), cfg.weights c ≤ cfg.potential
```
MWUConfig MWUConfig.potential MWUConfig.weights
Uses
- MWUConfig.weights_pos
Used by
- mwu_approx_minimax

Declmwu_weight_eq_pow_hitCountDeclaration kindtheorem

Exact individual-weight tracking: the weight of column c after T rounds is (1-η) to the number of rounds in which c was hit.

∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [inst_2 : Nonempty C] (M : R → C → Bool) (η : ℝ)
  (hη1 : η < 1) (v : ℝ) (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) (T : ℕ)
  (c : C), (mwuConfig M η hη1 v hrow T).weights c = (1 - η) ^ mwuHitCount✝ M η hη1 v hrow T c

FinitePMF FinitePMF.prob MWUConfig MWUConfig.toPMF MWUConfig.weights mwuConfig mwuHitCount mwuRun mwuUpdateWeights

Uses

MWUConfig.mk.congr_simp
MWUConfig.weights_pos

Used by

mwu_approx_minimax

DeclMWUConfig.mk.congr_simpDeclaration kindtheorem

∀ {C : Type u_1} [inst : Fintype C] (weights weights_1 : C → ℝ) (e_weights : weights = weights_1)
  (weights_pos : ∀ (c : C), 0 < weights c),
  { weights := weights, weights_pos := weights_pos } = { weights := weights_1, weights_pos := ⋯ }

MWUConfig

Used by

mwu_weight_eq_pow_hitCount

Declmwu_potential_T_boundDeclaration kindtheorem
Potential bound after T steps: Φ_T ≤ |C| · (1 - ηv)^T.
This is the core MWU guarantee. Combined with individual weight lower bounds (w_T(c) = (1-η)^{losses(c)}), it yields the regret bound.
```
∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [inst_2 : Nonempty C] (M : R → C → Bool)
 (η : ℝ),
 0 ≤ η →
 ∀ (hη1 : η < 1) (v : ℝ) (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0)
 (T : ℕ), (mwuConfig M η hη1 v hrow T).potential ≤ ↑(Fintype.card C) * (1 - η * v) ^ T
```
FinitePMF FinitePMF.prob MWUConfig MWUConfig.potential MWUConfig.toPMF mwuConfig mwuRun mwuUpdateWeights
Uses
Used by
- mwu_approx_minimax

Declpotential_one_step_boundDeclaration kindtheorem

Potential bound after one step: Φ' ≤ Φ · (1 - η·v).

∀ {R : Type u_1} {C : Type u_2} [Fintype R] [inst : Fintype C] [inst_1 : Nonempty C] (M : R → C → Bool) (η : ℝ),
  0 ≤ η →
    ∀ (hη1 : η < 1) (v : ℝ) (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0)
      (cfg : MWUConfig C), (mwuUpdateWeights M η hη1 cfg ⋯.choose).potential ≤ cfg.potential * (1 - η * v)

FinitePMF FinitePMF.prob MWUConfig MWUConfig.potential MWUConfig.toPMF MWUConfig.weights mwuUpdateWeights

Uses

best_response_payoff_weights

Used by

mwu_potential_T_bound

Declbest_response_payoff_weightsDeclaration kindtheorem

Best response payoff ≥ v · Φ in terms of weights.

∀ {R : Type u_1} {C : Type u_2} [Fintype R] [inst : Fintype C] [inst_1 : Nonempty C] (M : R → C → Bool) (v : ℝ)
  (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) (cfg : MWUConfig C),
  v * cfg.potential ≤ ∑ c, cfg.weights c * if M ⋯.choose c = true then 1 else 0

FinitePMF FinitePMF.prob MWUConfig MWUConfig.potential MWUConfig.toPMF MWUConfig.weights

Uses

MWUConfig.potential_pos

Used by

potential_one_step_bound

DeclMWUConfig.potential_posDeclaration kindtheorem
```
∀ {C : Type u_1} [inst : Fintype C] [Nonempty C] (cfg : MWUConfig C), 0 < cfg.potential
```
MWUConfig MWUConfig.potential MWUConfig.weights
Uses
- MWUConfig.weights_pos
Used by
- best_response_payoff_weights
DeclMWUConfig.weights_posDeclaration kindtheorem
```
∀ {C : Type u_1} [inst : Fintype C] (self : MWUConfig C) (c : C), 0 < self.weights c
```
MWUConfig MWUConfig.weights
Used by

DeclmwuUpdateWeights.congr_simpDeclaration kindtheorem

∀ {C : Type u_1} [inst : Fintype C] {R : Type u_2} (M M_1 : R → C → Bool),
  M = M_1 →
    ∀ (η η_1 : ℝ) (e_η : η = η_1) (hη1 : η < 1) (cfg cfg_1 : MWUConfig C),
      cfg = cfg_1 → ∀ (r r_1 : R), r = r_1 → mwuUpdateWeights M η hη1 cfg r = mwuUpdateWeights M_1 η_1 ⋯ cfg_1 r_1

MWUConfig mwuUpdateWeights

Used by

mwu_potential_T_bound

DeclmwuInit_potentialDeclaration kindtheorem
```
∀ (C : Type u_1) [inst : Fintype C], (mwuInit C).potential = ↑(Fintype.card C)
```
MWUConfig.potential MWUConfig.weights mwuInit
Used by
- mwu_potential_T_bound
Declminimax_value_le_oneDeclaration kindtheorem
The minimax value of a Boolean game is at most 1.
```
∀ {R : Type u_1} {C : Type u_2} [Fintype R] [inst : Fintype C] [Nonempty C] (M : R → C → Bool) (v : ℝ),
  (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) → v ≤ 1
```
FinitePMF FinitePMF.prob uniformPMF
Uses
- FinitePMF.prob_nonneg
- FinitePMF.prob_sum_one
Used by
- mwu_approx_minimax
- mwu_potential_T_bound

DeclhitRate_from_potentialDeclaration kindtheorem

Arithmetic core: from the potential bound and sufficiently small η / large T, deduce a per-column hit-rate lower bound. Uses Real.log — exactly 4 Mathlib lemmas.

∀ {N H T : ℕ} {η v ε : ℝ},
  0 < ↑N →
    0 < η →
      η < 1 →
        v ≤ 1 →
          0 < T → (1 - η) ^ H ≤ ↑N * (1 - η * v) ^ T → η ≤ ε / 4 → Real.log ↑N / (η * ↑T) ≤ ε / 4 → v - ε ≤ ↑H / ↑T

Used by

mwu_approx_minimax

DeclboolGamePayoff_nonnegDeclaration kindtheorem
```
∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] (M : R → C → Bool) (p : FinitePMF R) (c : C),
  0 ≤ boolGamePayoff M p c
```
FinitePMF FinitePMF.prob boolGamePayoff
Uses
- FinitePMF.prob_nonneg
Used by
- mwu_approx_minimax

DeclboolGamePayoff_empirical_eq_hitCountDeclaration kindtheorem

Empirical payoff of the MWU row sequence equals the normalized hit count.

∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [inst_2 : Nonempty C] [inst_3 : DecidableEq R]
  (M : R → C → Bool) (η : ℝ) (hη1 : η < 1) (v : ℝ)
  (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) {T : ℕ} (hT : 0 < T) (c : C),
  boolGamePayoff M (empiricalPMF hT (mwuRows M η hη1 v hrow T)) c = ↑(mwuHitCount✝ M η hη1 v hrow T c) / ↑T

FinitePMF FinitePMF.prob boolGamePayoff empiricalPMF mwuHitCount mwuRows

Uses

boolGamePayoff_empirical_eq_avg
mwuHitCount_eq_sum_indicator

Used by

mwu_approx_minimax

DeclmwuHitCount_eq_sum_indicatorDeclaration kindtheorem

The recursive hit counter agrees with the sum of Boolean indicators over the emitted row sequence.

∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [inst_2 : Nonempty C] (M : R → C → Bool) (η : ℝ)
  (hη1 : η < 1) (v : ℝ) (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) (T : ℕ)
  (c : C), ↑(mwuHitCount✝ M η hη1 v hrow T c) = ∑ t, if M (mwuRows M η hη1 v hrow T t) c = true then 1 else 0

FinitePMF FinitePMF.prob MWUConfig MWUConfig.toPMF mwuConfig mwuHitCount mwuRows mwuRun

Used by

boolGamePayoff_empirical_eq_hitCount

DeclboolGamePayoff_empirical_eq_avgDeclaration kindtheorem

Specialized empirical-payoff identity for ApproxMinimax (avoids cyclic import with FiniteVCApprox).

∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : DecidableEq R] {T : ℕ} (hT : 0 < T) (rs : Fin T → R)
  (M : R → C → Bool) (c : C), boolGamePayoff M (empiricalPMF hT rs) c = (∑ t, if M (rs t) c = true then 1 else 0) / ↑T

FinitePMF.prob boolGamePayoff empiricalPMF

Used by

boolGamePayoff_empirical_eq_hitCount

DeclhypothesisEnvelope_subDeclaration kindtheorem
Every hypothesis in the envelope is in C.
```
∀ {X : Type u} {C : ConceptClass X Bool} (L : ProperFiniteSupportLearner X C) (c : X → Bool) (Y : Finset X),
  ∀ h ∈ hypothesisEnvelope L c Y, h ∈ C
```
ConceptClass FLT.Concept ProperFiniteSupportLearner ProperFiniteSupportLearner.learn ProperFiniteSupportLearner.sampleBound boundedSubsamples hypothesisEnvelope labeledSampleOfFinset
Uses
- ProperFiniteSupportLearner.output_mem
Used by
- moran_yehudayoff_forward_construction
DeclProperFiniteSupportLearner.output_memDeclaration kindtheorem
```
∀ {X : Type u} {C : ConceptClass X Bool} (self : ProperFiniteSupportLearner X C) {m : ℕ} (S : Fin m → X × Bool),
  self.learn S ∈ C
```
ConceptClass FLT.Concept ProperFiniteSupportLearner ProperFiniteSupportLearner.learn
Used by
- hypothesisEnvelope_sub
Declgood_on_support_gives_row_responseDeclaration kindtheorem
For each C-realizable sample, the proper learner provides a row-response for the minimax game on the hypothesis envelope.
```
∀ {X : Type u} {C : ConceptClass X Bool} (L : ProperFiniteSupportLearner X C),
  ∀ c ∈ C,
    ∀ (Y : Finset X) [Nonempty ↥Y] (HY : Finset (X → Bool)),
      HY = hypothesisEnvelope L c Y →
        ∀ (q : FinitePMF ↥Y), ∃ h, 2 / 3 ≤ ∑ y, q.prob y * if decide (↑h ↑y = c ↑y) = true then 1 else 0
```
ConceptClass FLT.Concept FinitePMF FinitePMF.prob ProperFiniteSupportLearner ProperFiniteSupportLearner.learn ProperFiniteSupportLearner.sampleBound boundedSubsamples hypothesisEnvelope labeledSampleOfFinset supportError
Uses
- ProperFiniteSupportLearner.good_on_support
- supportAgreement_eq_one_sub_supportError
Used by
- moran_yehudayoff_forward_construction
DeclsupportAgreement_eq_one_sub_supportErrorDeclaration kindtheorem
Weighted agreement = 1 - supportError.
```
∀ {X : Type u} (Y : Finset X) (q : FinitePMF ↥Y) (h c : X → Bool),
  (∑ y, q.prob y * if h ↑y = c ↑y then 1 else 0) = 1 - supportError Y q h c
```
FinitePMF FinitePMF.prob supportError
Uses
- FinitePMF.prob_sum_one
Used by
- good_on_support_gives_row_response
DeclProperFiniteSupportLearner.good_on_supportDeclaration kindtheorem
```
∀ {X : Type u} {C : ConceptClass X Bool} (self : ProperFiniteSupportLearner X C),
  ∀ c ∈ C,
    ∀ (Y : Finset X) (q : FinitePMF ↥Y),
      ∃ Z ⊆ Y, Z.card ≤ self.sampleBound ∧ supportError Y q (self.learn (labeledSampleOfFinset c Z)) c ≤ 1 / 3
```
ConceptClass FLT.Concept FinitePMF ProperFiniteSupportLearner ProperFiniteSupportLearner.learn ProperFiniteSupportLearner.sampleBound labeledSampleOfFinset supportError
Used by
- good_on_support_gives_row_response
Declfinite_support_vc_approxDeclaration kindtheorem
Finite-support distributions uniformly approximate any distribution on a VC class. For a class of VC dimension at most d and any ε > 0, there exists T = T(d, ε) such that every finitely supported distribution μ is within ε (uniformly over the class) of some empirical distribution on T points. A density-style reduction that lets the approximate minimax / MWU machinery, which lives in finite support, apply to general distributions.
```
∀ (d : ℕ) (ε : ℝ),
 0 < ε →
 ∃ T,
 ∃ (hT : 0 < T),
 ∀ {H : Type u_1} [inst : Fintype H] [inst_1 : DecidableEq H] (A : Finset (H → Bool)),
 A.boolVCDim ≤ d →
 ∀ (μ : FinitePMF H),
 ∃ hs, ∀ a ∈ A, |boolTestExpectation μ a - boolTestExpectation (empiricalPMF hT hs) a| ≤ ε
```
ConceptClass EmpiricalError FLT.Concept FinitePMF FinitePMF.prob FinitePMF.toPMF Finset.boolVCDim GrowthFunction Shatters TrueErrorReal VCDim boolFamilyToFinsetFamily boolTestExpectation empiricalPMF extendBool liftClass zeroOneLoss
Uses
Used by
- moran_yehudayoff_forward_construction
- vcdim_finite_imp_proper_finite_support_learner

DecltrueErrorReal_extend_falseDeclaration kindtheorem

∀ {H : Type u_1} [inst : Fintype H] [DecidableEq H] [inst_2 : MeasurableSpace H] [MeasurableSingletonClass H]
  (μ : FinitePMF H) (a : H → Bool),
  TrueErrorReal (H ⊕ ℕ) (extendBool✝ a) (fun x => false) (PMF.map Sum.inl (FinitePMF.toPMF✝ μ)).toMeasure =
    boolTestExpectation μ a

FinitePMF FinitePMF.prob FinitePMF.toPMF TrueError TrueErrorReal boolTestExpectation extendBool

Uses

FinitePMF.prob_nonneg
FinitePMF.prob_sum_one

Used by

finite_support_vc_approx

Declsymmetrization_uc_boundDeclaration kindtheorem
The symmetrization uniform convergence bound: two-sided version. P[∃h∈C: |TrueErr-EmpErr| ≥ ε] ≤ 4·GF(C,2m)·exp(-mε²/8).
Proof strategy (4 steps):
1. Decompose absolute value: |TrueErr - EmpErr| ≥ ε ↔ (TrueErr - EmpErr ≥ ε) ∨ (EmpErr - TrueErr ≥ ε)
have abs_decomp : ∀ (a b : ℝ), |a - b| ≥ ε ↔ a - b ≥ ε ∨ b - a ≥ ε := by intro a b; constructor · intro h; by_cases h' : a - b ≥ ε · exact Or.inl h' · exact Or.inr (by linarith [abs_sub_comm a b, le_abs_self (a - b)]) · intro h; cases h with | inl h => exact le_trans (le_of_eq (abs_of_nonneg (by linarith))) (by linarith) | inr h => exact le_trans (le_of_eq (abs_of_nonpos (by linarith) ▸ ...)) ...
2. Upper tail: P[∃h∈C: TrueErr-EmpErr ≥ ε] ≤ 2·GF(C,2m)·exp(-mε²/8)
- Direct application of symmetrization_step + double_sample_pattern_bound.
3. Lower tail: P[∃h∈C: EmpErr-TrueErr ≥ ε] ≤ 2·GF(C,2m)·exp(-mε²/8)
- Apply the symmetric argument: swap roles of S and S' in the double sample.
- Equivalently, apply symmetrization_step to the event EmpErr-TrueErr ≥ ε and bound the double-sample event {EmpErr_S - EmpErr_{S'} ≥ ε/2}.
- The bound is symmetric because D^m ⊗ D^m is symmetric under swapping factors. have swap_symmetry : DoubleSampleMeasure D m {p | ∃ h ∈ C, EmpErr(S) - EmpErr(S') ≥ ε/2} = DoubleSampleMeasure D m {p | ∃ h ∈ C, EmpErr(S') - EmpErr(S) ≥ ε/2} := Measure.prod_swap ...
4. Union bound: P[|gap| ≥ ε] ≤ P[gap ≥ ε] + P[gap ≤ -ε] ≤ 2·GF·exp(...) + 2·GF·exp(...) = 4·GF(C,2m)·exp(-mε²/8)
-- Uses: MeasureTheory.measure_union_le for the union of two events -- CAST: 2 * X + 2 * X = 4 * X in ENNReal (need ENNReal.add_mul or similar)
References: SSBD Theorem 6.7, Kakade-Tewari Lecture 19
```
∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
 [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 2 * Real.log 2 ≤ ↑m * ε ^ 2 →
 MeasureTheory.NullMeasurableSet
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 ∃ h ∈ C,
 |TrueErrorReal X h c D -
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool)| ≥
 ε} ≤
 ENNReal.ofReal (4 * ↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction TrueErrorReal zeroOneLoss
Uses
Used by
- finite_support_vc_approx

Declsymmetrization_step_lowerDeclaration kindtheorem

Symmetrization step for the lower tail: P[∃h: EmpErr-TrueErr ≥ ε] ≤ 2·P_{double}[∃h: EmpErr_S-EmpErr_{S'} ≥ ε/2].

Mirror of symmetrization_step for the opposite direction. Uses hoeffding_one_sided_upper instead of hoeffding_one_sided.

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε : ℝ),
            0 < ε →
              2 * Real.log 2 ≤ ↑m * ε ^ 2 →
                (MeasureTheory.Measure.pi fun x => D)
                    {xs |
                      ∃ h ∈ C,
                        EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) - TrueErrorReal X h c D ≥
                          ε} ≤
                  2 *
                    ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
                      {p |
                        ∃ h ∈ C,
                          EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) -
                              EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) ≥
                            ε / 2}

ConceptClass EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Uses

hoeffding_one_sided_upper

Used by

symmetrization_uc_bound

Declhoeffding_one_sided_upperDeclaration kindtheorem

Upper-tail Hoeffding: for iid Bernoulli(p) draws, the empirical average overshoots the mean by ≥ t with probability ≤ exp(-2mt²).

This is the mirror of hoeffding_one_sided (which bounds the lower tail). The proof uses the same sub-Gaussian machinery with Z_i = indicator(x_i) - p (instead of p - indicator(x_i)).

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (h c : Concept X Bool) (m : ℕ),
  0 < m →
    ∀ (t : ℝ),
      0 < t →
        t ≤ 1 →
          MeasurableSet {x | h x ≠ c x} →
            (MeasureTheory.Measure.pi fun x => D)
                {xs |
                  EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥ TrueErrorReal X h c D + t} ≤
              ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))

EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Used by

symmetrization_step_lower

Declsymmetrization_stepDeclaration kindtheorem
Symmetrization: the probability of a large gap TrueErr-EmpErr is at most twice the probability of a large gap EmpErr'-EmpErr on the double sample.
Proof strategy (6 steps):
1. Witness selection: For S in the bad event, ∃h* ∈ C with TrueErr(h) - EmpErr_S(h) ≥ ε.
-- In the bad event set, extract h* by classical choice have h_witness : ∀ xs ∈ bad_event, ∃ h* ∈ C, TrueErrorReal X h* c D - EmpiricalError X Bool h* (sample xs) (zeroOneLoss Bool) ≥ ε
2. Ghost sample mean: E_{S'}[EmpErr_{S'}(h)] = TrueErr(h) ≥ EmpErr_S(h*) + ε.
- Uses: MeasureTheory.integral_pi to compute E[EmpErr] over product measure.
- KEY LEMMA: For fixed h, E_{D^m}[EmpiricalError(h,S)] = TrueErrorReal(h,c,D). This is because EmpErr = (1/m)∑ indicator(x_i), and E[indicator(x_i)] = TrueErrorReal. have expected_emp_err : ∀ h* : Concept X Bool, ∫ xs, EmpiricalError X Bool h* (sample xs) (zeroOneLoss Bool) ∂(Measure.pi (fun _ : Fin m => D)) = TrueErrorReal X h* c D := by ...
3. Hoeffding on ghost sample: P_{S'}[EmpErr_{S'}(h) < TrueErr(h) - ε/2] ≤ exp(-mε²/2).
- Apply hoeffding_one_sided with t = ε/2.
- The hm_large hypothesis ensures exp(-mε²/2) < 1/2: 2·ln2 ≤ mε² ⟹ mε²/2 ≥ ln2 ⟹ exp(-mε²/2) ≤ 1/2. have hoeffding_ghost : ∀ h* ∈ C, Measure.pi (fun _ : Fin m => D) {xs' | EmpiricalError X Bool h* (sample xs') (zeroOneLoss Bool) < TrueErrorReal X h* c D - ε/2} ≤ ENNReal.ofReal (Real.exp (-m * (ε/2)^2 * 2)) := by intro h* _; exact hoeffding_one_sided D h* c m hm (ε/2) (by linarith) (by ...) (by ...)
4. Complementary probability: P_{S'}[EmpErr_{S'}(h) - EmpErr_S(h) ≥ ε/2] ≥ 1/2.
- From step 2: TrueErr(h) ≥ EmpErr_S(h) + ε
- From step 3: P[EmpErr_{S'} ≥ TrueErr - ε/2] ≥ 1/2
- Chain: EmpErr_{S'} ≥ TrueErr - ε/2 ≥ EmpErr_S + ε - ε/2 = EmpErr_S + ε/2
5. Conditional to unconditional: The witness h* from step 1 also witnesses the double-sample event ∃h∈C: EmpErr'-EmpErr ≥ ε/2. So: P_{S'}[double event | S bad] ≥ 1/2.
have conditional_bound : ∀ xs ∈ bad_event, Measure.pi (fun _ : Fin m => D) {xs' | ∃ h ∈ C, EmpiricalError ... xs' - EmpiricalError ... xs ≥ ε/2} ≥ ENNReal.ofReal (1/2) := by ...
6. Fubini integration: By Measure.prod_apply and Fubini: P_{S,S'}[double event] = ∫_S P_{S'}[double event | S] ≥ (1/2) · P_S[bad event] ⟹ P_S[bad event] ≤ 2 · P_{S,S'}[double event].
-- Uses: MeasureTheory.Measure.prod_apply or lintegral_prod -- MEASURABILITY: the double-sample event is measurable as a finite union -- of sets of the form {(xs,xs') | EmpErr'(h) - EmpErr(h) ≥ ε/2} for h ∈ C. -- Since C may be infinite, measurability requires care: the sup over h -- must be shown to be measurable. For finite restriction patterns (≤ 2^m -- on Fin m → Bool), this is a finite union.
MEASURABILITY CONCERNS:
- {xs | ∃ h ∈ C, ...} is NOT obviously measurable for infinite C. Strategy: decompose via restriction patterns. On any fixed xs, the set of labelings {(h(xs 0), ..., h(xs(m-1))) | h ∈ C} has at most GF(C,m) ≤ 2^m elements. So the ∃h event is a finite union of measurable sets.
- EmpiricalError is a finite sum of measurable functions, hence measurable.
- The product σ-algebra on (Fin m → X) × (Fin m → X) is generated by cylinder sets, and our events are in this σ-algebra.
References: SSBD Lemma 4.5, Kakade-Tewari Lecture 19 Lemma 1
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 2 * Real.log 2 ≤ ↑m * ε ^ 2 →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 ∃ h ∈ C,
 TrueErrorReal X h c D - EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥
 ε} ≤
 2 *
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
```
ConceptClass EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Uses
- hoeffding_one_sided
Used by
- symmetrization_uc_bound
Declhoeffding_one_sidedDeclaration kindtheorem
One-sided Hoeffding: for iid Bernoulli(p) draws, the empirical average undershoots the mean by ≥ t with probability ≤ exp(-2mt²).
Proof strategy (3 steps):
1. MGF bound (Hoeffding's lemma): For X ∈ [0,1] with E[X] = p, E[exp(s(X-p))] ≤ exp(s²/8).
- Adapt from cosh_le_exp_sq_half infrastructure in Rademacher.lean.
- Key: convexity of exp on [0,1] gives E[exp(sX)] ≤ p·exp(s) + (1-p)·exp(0), then the s²/8 bound follows from ln(1 + x) ≤ x and Taylor expansion. have mgf_bound : ∀ (s : ℝ), ∫ x, Real.exp (s * (indicator x - p)) ∂D ≤ Real.exp (s^2 / 8) := by ...
2. Product independence: E[exp(s·∑(X_i-p))] = ∏ E[exp(s(X_i-p))] ≤ exp(ms²/8).
- Uses MeasureTheory.Measure.pi independence structure.
- Needs: Measure.pi integral factorization for product of functions.
- MEASURABILITY: fun xs => Real.exp (s * ∑ i, f (xs i)) is measurable (composition of measurable functions). have product_bound : ∀ (s : ℝ), ∫ xs, Real.exp (s * ∑ i, (indicator (xs i) - p)) ∂Measure.pi (fun _ => D) ≤ Real.exp (m * s^2 / 8) := by ...
3. Exponential Markov + optimize: P[∑(X_i-p) ≤ -mt] = P[exp(-s·∑(X_i-p)) ≥ exp(smt)] ≤ exp(-smt + ms²/8). Optimize over s: set s = 4t to get ≤ exp(-2mt²).
- Uses Markov's inequality in ENNReal form.
- CAST ISSUE: Markov gives ENNReal bound, need to convert exp(-2mt²) between ENNReal.ofReal and the measure value. have markov_step : ∀ (s : ℝ) (hs : 0 < s), Measure.pi (fun _ => D) {xs | ∑ i, (indicator (xs i) - p) ≤ -(m : ℝ) * t} ≤ ENNReal.ofReal (Real.exp (-(s * m * t) + m * s^2 / 8)) := by ... have optimize : Real.exp (-(4*t * m * t) + m * (4*t)^2 / 8) = Real.exp (-2 * m * t^2) := by ring_nf
CAST ISSUES to watch:
- m : ℕ needs cast to ℝ in the exponent: (m : ℝ)
- EmpiricalError returns ℝ, TrueErrorReal returns ℝ, good — no ENNReal gap
- The measure value is ENNReal, the bound exp(-2mt²) is ℝ≥0∞ via ENNReal.ofReal
References: SSBD Lemma B.3, Hoeffding (1963)
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (h c : Concept X Bool) (m : ℕ),
 0 < m →
 ∀ (t : ℝ),
 0 < t →
 t ≤ 1 →
 MeasurableSet {x | h x ≠ c x} →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≤ TrueErrorReal X h c D - t} ≤
 ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))
```
EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Used by
- symmetrization_step
Decldouble_sample_pattern_boundDeclaration kindtheorem
On the double sample, the probability that any hypothesis has EmpErr' - EmpErr ≥ ε/2 is bounded by GF(C,2m) · exp(-mε²/8).
Proof strategy (Approach A — standard exchangeability, 5 steps):
1. EXCHANGEABILITY: Under D^m ⊗ D^m, the 2m draws z₁,...,z_{2m} are iid from D. The joint distribution is invariant under permutations of {1,...,2m}.
Key lemma: P_{D^m⊗D^m}[event(S,S')] = E_z[P_{split}[event | z]] where z = merged sample and the split is uniformly random among all C(2m,m) ways to partition z into two groups of m.
-- Measure.pi permutation invariance have pi_perm_invariant : ∀ (σ : Equiv.Perm (Fin (2*m))), (Measure.pi (fun _ : Fin (2*m) => D)).map (fun z i => z (σ i)) = Measure.pi (fun _ : Fin (2*m) => D) := by ... -- Consequence: the event probability equals the split-averaged probability have exchangeability : DoubleSampleMeasure D m {p | ∃ h ∈ C, gap(p) ≥ ε/2} = ∫ z, SplitMeasure m {vs | ∃ h ∈ C, gap(split z vs) ≥ ε/2} ∂(Measure.pi (fun _ : Fin (2*m) => D)) := by ...
2. CONDITIONING: For fixed merged sample z of 2m points:
- C restricts to at most GF(C,2m) distinct labeling patterns on z (deterministic).
- For each pattern p, define: diff(p, split) = EmpErr_{S'}(p) - EmpErr_S(p) = (1/m) ∑_{i∈S'} a_i - (1/m) ∑_{i∈S} a_i where a_i = 1[pattern(z_i) ≠ c(z_i)] ∈ {0,1}.
-- Number of distinct patterns have num_patterns : ∀ (z : MergedSample X m), Set.ncard {p : Fin (2*m) → Bool | ∃ h ∈ C, ∀ i, p i = (h (z i) ≠ c (z i))} ≤ GrowthFunction X C (2*m) := by ...
3. PER-PATTERN HOEFFDING ON SPLITS: For fixed z and fixed pattern p: Under uniformly random split (S,S') of z into two groups of m: diff(p, split) = (1/m) ∑_{i∈S'} a_i - (1/m) ∑_{i∈S} a_i
This is a function of the random partition. By Hoeffding's inequality for sampling without replacement (Serfling 1974): P_split[diff ≥ ε/2] ≤ exp(-mε²/8)
Alternative derivation: Hoeffding without replacement from Hoeffding with replacement (iid signs) via coupling. The without-replacement bound is actually TIGHTER (variance reduction), but the with-replacement bound suffices.
-- Per-pattern concentration have per_pattern_bound : ∀ (z : MergedSample X m) (a : Fin (2*m) → ℝ) (ha : ∀ i, a i ∈ Set.Icc 0 1), SplitMeasure m {vs | (1/m) * ∑ i ∈ second_group vs, a i - (1/m) * ∑ i ∈ first_group vs, a i ≥ ε/2} ≤ ENNReal.ofReal (Real.exp (-(m : ℝ) * (ε/2)^2 / 2)) := by ... -- Note: m*(ε/2)^2/2 = mε²/8
4. UNION BOUND: P_split[∃ pattern: diff ≥ ε/2 | z] ≤ (number of patterns) · max_pattern P_split[diff ≥ ε/2] ≤ GF(C,2m) · exp(-mε²/8)
have union_bound : ∀ (z : MergedSample X m), SplitMeasure m {vs | ∃ h ∈ C, gap(split z vs, h) ≥ ε/2} ≤ ENNReal.ofReal (GrowthFunction X C (2*m) * Real.exp (-(m : ℝ) * ε^2 / 8)) := by ...
5. INTEGRATE: P_{D^m⊗D^m}[event] = E_z[P_split[event|z]] (by step 1) ≤ E_z[GF(C,2m) · exp(-mε²/8)] (by step 4, pointwise) = GF(C,2m) · exp(-mε²/8) (bound is independent of z)
-- The bound is a constant, so integrating gives the same constant -- (using IsProbabilityMeasure for the 2m-fold product)
Infrastructure needed:
- Fin.sumFinEquiv : Fin m ⊕ Fin n ≃ Fin (m + n) (available in Mathlib)
- mergeSamples / splitMergedSample (defined above)
- SplitMeasure and ValidSplit (defined above)
- Measure.pi permutation invariance (to be proved or imported)
- Hoeffding for sampling without replacement
- GrowthFunction on 2m points + sauer_shelah_exp_bound from Rademacher.lean
MEASURABILITY CONCERNS:
- The merged sample z ↦ P_split[event|z] must be measurable as a function of z. Since the event is a finite union over patterns, and each pattern's indicator is a measurable function of z (finite evaluation), this follows.
- GrowthFunction X C (2*m) is a natural number (deterministic), no measurability issue.
References: SSBD Theorem 6.7, Hoeffding (1963), Serfling (1974)
```
∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
 [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 MeasureTheory.NullMeasurableSet
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2} ≤
 ENNReal.ofReal (↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction zeroOneLoss
Uses
- exchangeability_chain_bound
Used by
- symmetrization_uc_bound

Declexchangeability_chain_boundDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε : ℝ),
            0 < ε →
              ε ≤ 2 →
                Set.Nonempty C →
                  MeasureTheory.NullMeasurableSet
                      {p |
                        ∃ h ∈ C,
                          EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                              EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                            ε / 2}
                      ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
                    have μ := MeasureTheory.Measure.pi fun x => D;
                    (μ.prod μ)
                        {p |
                          ∃ h ∈ C,
                            EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                                EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                              ε / 2} ≤
                      ENNReal.ofReal (↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))

ConceptClass EmpiricalError FLT.Concept GrowthFunction SignVector boolToSign zeroOneLoss

Uses

finite_exchangeability_bound
rademacher_mgf_bound
restriction_pattern_count
zeroOneLoss.congr_simp

Used by

double_sample_pattern_bound

DeclzeroOneLoss.congr_simpDeclaration kindtheorem

∀ (Y : Type v) {inst : DecidableEq Y} [inst_1 : DecidableEq Y] (a a_1 : Y),
  a = a_1 → ∀ (a_2 a_3 : Y), a_2 = a_3 → zeroOneLoss Y a a_2 = zeroOneLoss Y a_1 a_3

zeroOneLoss

Used by

exchangeability_chain_bound

Declrestriction_pattern_countDeclaration kindtheorem
The number of distinct restriction patterns of C on any n points is at most GF(C,n). For z : Fin n → X, define patterns(z) = {p : Fin n → Bool | ∃ h ∈ C, ∀ i, p i = (h(z i) ≠ c(z i))}. Then patterns(z).ncard ≤ GrowthFunction X C n by definition of GrowthFunction.
```
∀ {X : Type u} [MeasurableSpace X] [Infinite X] (C : ConceptClass X Bool) (c : Concept X Bool) (n : ℕ) (z : Fin n → X),
  {p | ∃ h ∈ C, ∀ (i : Fin n), p i = decide (h (z i) ≠ c (z i))}.ncard ≤ GrowthFunction X C n
```
ConceptClass FLT.Concept GrowthFunction
Used by
- exchangeability_chain_bound

Declrademacher_mgf_boundDeclaration kindtheorem

Rademacher MGF bound.

∀ {m : ℕ},
  0 < m →
    ∀ (a : Fin m → ℝ) (c : ℝ),
      0 ≤ c →
        (∀ (i : Fin m), |a i| ≤ c) →
          ∀ (t : ℝ),
            0 ≤ t →
              1 / ↑(Fintype.card (SignVector m)) * ∑ σ, Real.exp (t * (1 / ↑m * ∑ i, a i * boolToSign (σ i))) ≤
                Real.exp (t ^ 2 * c ^ 2 / (2 * ↑m))

SignVector boolToSign

Uses

cosh_le_exp_sq_half

Used by

exchangeability_chain_bound

Declcosh_le_exp_sq_halfDeclaration kindtheorem
cosh(x) ≤ exp(x²/2). Standard sub-Gaussian bound.
```
∀ (x : ℝ), Real.cosh x ≤ Real.exp (x ^ 2 / 2)
```
Used by
- rademacher_mgf_bound

Declfinite_exchangeability_boundDeclaration kindtheorem

Generic finite exchangeability bound. Given a measure-preserving family of transformations on a probability space, a NullMeasurableSet S, and a pointwise bound on the sum of preimage indicators, conclude ν(S) ≤ B.

∀ {Ω : Type u_1} {G : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : Fintype G] [Nonempty G]
  {ν : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure ν] (T : G → Ω → Ω) (S : Set Ω),
  (∀ (g : G), MeasureTheory.MeasurePreserving (T g) ν ν) →
    MeasureTheory.NullMeasurableSet S ν →
      ∀ (B : ENNReal), (∀ (z : Ω), ∑ g, (T g ⁻¹' S).indicator 1 z ≤ B * ↑(Fintype.card G)) → ν S ≤ B

Used by

exchangeability_chain_bound

Declgrowth_exp_le_deltaDeclaration kindtheorem

∀ {X : Type u} [MeasurableSpace X] (C : ConceptClass X Bool) (v : ℕ),
  0 < v →
    ∀ (m : ℕ),
      0 < m →
        ∀ (ε δ : ℝ),
          0 < ε →
            0 < δ →
              δ < 1 →
                (∀ (n : ℕ), v ≤ n → GrowthFunction X C n ≤ ∑ i ∈ Finset.range (v + 1), n.choose i) →
                  (16 * Real.exp 1 * (↑v + 1) / ε ^ 2) ^ (v + 1) / δ ≤ ↑m →
                    4 * ↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)) ≤ δ ∧ 2 * Real.log 2 ≤ ↑m * ε ^ 2

ConceptClass GrowthFunction

Uses

growth_function_le_two_pow
pow_mul_exp_neg_le_factorial_div
sum_choose_le_exp_pow

Used by

finite_support_vc_approx

Declsum_choose_le_exp_powDeclaration kindtheorem
Pure combinatorial inequality: ∑_{i=0}^d C(m,i) ≤ (em/d)^d for d ≤ m, d ≥ 1.
```
∀ (d m : ℕ), 0 < d → d ≤ m → ∑ i ∈ Finset.range (d + 1), ↑(m.choose i) ≤ (Real.exp 1 * ↑m / ↑d) ^ d
```
Used by
- growth_exp_le_delta
Declpow_mul_exp_neg_le_factorial_divDeclaration kindtheorem
Key arithmetic lemma for PAC bound: for t > 0, t^d * exp(-t) ≤ (d+1)!/t. Follows from exp(t) ≥ t^(d+1)/(d+1)! (partial sum of Taylor series).
```
∀ {d : ℕ} {t : ℝ}, 0 < t → t ^ d * Real.exp (-t) ≤ ↑(d + 1).factorial / t
```
Used by
- growth_exp_le_delta
Declgrowth_function_le_two_powDeclaration kindtheorem
Trivial bound: GrowthFunction ≤ 2^n for all concept classes. Each restriction to an n-element set yields a function in S → Bool, and there are at most 2^n such functions.
```
∀ {X : Type u} (C : ConceptClass X Bool) (n : ℕ), GrowthFunction X C n ≤ 2 ^ n
```
ConceptClass FLT.Concept GrowthFunction
Used by
- growth_exp_le_delta
DeclboolTestExpectation_nonnegDeclaration kindtheorem
A convex combination of values in {0, 1} is nonnegative.
```
∀ {H : Type u_1} [inst : Fintype H] (μ : FinitePMF H) (f : H → Bool), 0 ≤ boolTestExpectation μ f
```
FinitePMF FinitePMF.prob boolTestExpectation
Uses
- FinitePMF.prob_nonneg
Used by
- finite_support_vc_approx
DeclboolTestExpectation_le_oneDeclaration kindtheorem
A convex combination of values in {0, 1} is at most 1.
```
∀ {H : Type u_1} [inst : Fintype H] (μ : FinitePMF H) (f : H → Bool), boolTestExpectation μ f ≤ 1
```
FinitePMF FinitePMF.prob boolTestExpectation
Uses
- FinitePMF.prob_nonneg
- FinitePMF.prob_sum_one
Used by
- finite_support_vc_approx
DeclFinitePMF.prob_nonnegDeclaration kindtheorem
```
∀ {H : Type u_1} [inst : Fintype H] (self : FinitePMF H) (h : H), 0 ≤ self.prob h
```
FinitePMF FinitePMF.prob
Used by
DeclFinitePMF.prob_sum_oneDeclaration kindtheorem
```
∀ {H : Type u_1} [inst : Fintype H] (self : FinitePMF H), ∑ h, self.prob h = 1
```
FinitePMF FinitePMF.prob
Used by

DeclfinalizeIncidenceSchemeDeclaration kindtheorem

Final existential wrapper: closes the theorem in the exact form expected.

∀ {X : Type u} {C : ConceptClass X Bool} (T K : ℕ)
  (compressCore : {m : ℕ} → (Fin m → X × Bool) → Finset (X × Bool) × IncidenceInfo T K)
  (blockHyp : Finset (X × Bool) → IncidenceInfo T K → Fin T → X → Bool)
  (rowHyp : {m : ℕ} → (S : Fin m → X × Bool) → (∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) → Fin T → X → Bool),
  0 < T →
    (∀ {m : ℕ} (S : Fin m → X × Bool), (compressCore S).1.card ≤ K) →
      (∀ {m : ℕ} (S : Fin m → X × Bool), ↑(compressCore S).1 ⊆ Set.range S) →
        (∀ {m : ℕ} (S : Fin m → X × Bool) (hreal : ∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) (i : Fin m) (t : Fin T),
            blockHyp (compressCore S).1 (compressCore S).2 t (S i).1 = rowHyp S hreal t (S i).1) →
          (∀ {m : ℕ} (S : Fin m → X × Bool) (hreal : ∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) (i : Fin m),
              (∑ t, if rowHyp S hreal t (S i).1 = (S i).2 then 1 else 0) / ↑T > 1 / 2) →
            ∃ k cs, CompressionSchemeWithInfo.size cs = k

CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass FLT.Concept IncidenceInfo mkIncidenceSchemeOfMajority

Used by

moran_yehudayoff_forward_construction

DeclencodeWitnessInfo.congr_simpDeclaration kindtheorem

∀ {X : Type u} {inst : DecidableEq X} [inst_1 : DecidableEq X] (kernel kernel_1 : Finset (X × Bool)),
  kernel = kernel_1 →
    ∀ (c c_1 : X → Bool),
      c = c_1 →
        ∀ (K : ℕ) (W W_1 : Finset X), W = W_1 → encodeWitnessInfo kernel c K W = encodeWitnessInfo kernel_1 c_1 K W_1

encodeWitnessInfo

Used by

moran_yehudayoff_forward_construction

DeclboolTestExpectation_empirical_eq_avgDeclaration kindtheorem
Bridges the FinitePMF view and the sample-average view: the expectation of a Bool-valued test under the empirical PMF of a sample equals the sample average (1/T) ∑_t f (s_t). This lets the MWU updates and the approximation transfer principle live in the same distributional framework.
```
∀ {H : Type u_1} [inst : Fintype H] [inst_1 : DecidableEq H] {T : ℕ} (hT : 0 < T) (hs : Fin T → H) (f : H → Bool),
 boolTestExpectation (empiricalPMF hT hs) f = (∑ t, if f (hs t) = true then 1 else 0) / ↑T
```
FinitePMF.prob boolTestExpectation empiricalPMF
Used by
DeclboolGamePayoff_eq_boolTestExpectationDeclaration kindtheorem
Identifies the game-theoretic payoff (a row distribution against a fixed column in the Bool game) with the corresponding test expectation. The translation that lets the MWU regret bound be applied directly to the compression problem.
```
∀ {R : Type u_1} [inst : Fintype R] [DecidableEq R] {C : Type u_2} (M : R → C → Bool) (p : FinitePMF R) (c : C),
  boolGamePayoff M p c = boolTestExpectation p fun r => M r c
```
FinitePMF FinitePMF.prob boolGamePayoff boolTestExpectation
Used by
- moran_yehudayoff_forward_construction
DeclagreeTests_boolVCDim_leDeclaration kindtheorem
VC dimension of the agreement-test family is bounded by 2^(d+1) - 1, where d bounds the VC dimension of the concept class C. Uses Assouad's coding argument directly: if a shattered set T in ↥HY has |T| ≥ 2^(d+1), embed bitstrings into T, extract d+1 distinct points from Y via shattering, and show these points are shattered by C (using the XOR trick where b(j) = decide(g(x_j) = c(x_j)) absorbs the agree/disagree flip).
```
∀ {X : Type u} [DecidableEq X] (C : ConceptClass X Bool) (c : X → Bool) (Y : Finset X) (HY : Finset (X → Bool)),
  (∀ h ∈ HY, h ∈ C) → ∀ {d : ℕ}, VCDim X C ≤ ↑d → (agreeTests c Y HY).boolVCDim ≤ 2 ^ (d + 1) - 1
```
ConceptClass FLT.Concept Finset.boolVCDim Shatters VCDim agreeTest agreeTests boolFamilyToFinsetFamily
Used by
- moran_yehudayoff_forward_construction
Declcompression_with_info_imp_vcdim_finiteDeclaration kindtheorem
Compression with side info implies finite VC dimension. Proof by pigeonhole: compress is injective on C-realizable labelings (by correctness), but compressed outputs form a bounded set.
```
∀ (X : Type u) (C : ConceptClass X Bool), (∃ k cs, cs.size = k) → VCDim X C < ⊤
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress CompressionSchemeWithInfo.info_finite CompressionSchemeWithInfo.kernelSize CompressionSchemeWithInfo.size ConceptClass FLT.Concept Shatters VCDim
Uses
Used by
- fundamental_vc_compression_with_info
Declshatters_subset_compressionDeclaration kindtheorem
```
∀ {X : Type u} {C : ConceptClass X Bool} {S T : Finset X}, T ⊆ S → Shatters X C S → Shatters X C T
```
ConceptClass FLT.Concept Shatters
Used by
- compression_with_info_imp_vcdim_finite
Declexp_beats_poly_compressionDeclaration kindtheorem
Exponential beats polynomial for the compression pigeonhole argument.
```
∀ (s : ℕ), (s + 1) ^ 2 * (4 * (s + 1) ^ 2) ^ s < 2 ^ (2 * (s + 1) * (s + 1))
```
Uses
- succ_le_two_pow_compression
Used by
- compression_with_info_imp_vcdim_finite
Declsucc_le_two_pow_compressionDeclaration kindtheorem
```
∀ (k : ℕ), k + 1 ≤ 2 ^ k
```
Used by
- exp_beats_poly_compression
Declcompress_with_info_injective_on_labelingsDeclaration kindtheorem
Pigeonhole core: if two C-realizable samples over the same points with different labelings produce the same (kernel, info) pair, correctness forces the labelings to agree.
```
∀ {X : Type u} {n : ℕ} {C : ConceptClass X Bool} (cs : CompressionSchemeWithInfo X Bool C) (pts : Fin n → X),
  Function.Injective pts →
    ∀ (f g : Fin n → Bool),
      (∃ c ∈ C, ∀ (i : Fin n), c (pts i) = f i) →
        (∃ c ∈ C, ∀ (i : Fin n), c (pts i) = g i) →
          ((cs.compress fun i => (pts i, f i)) = cs.compress fun i => (pts i, g i)) → f = g
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress CompressionSchemeWithInfo.reconstruct ConceptClass FLT.Concept
Uses
- CompressionSchemeWithInfo.correct
Used by
- compression_with_info_imp_vcdim_finite
DeclCompressionSchemeWithInfo.correctDeclaration kindtheorem
Correctness: reconstructed hypothesis agrees with every sample point, when the sample is C-realizable
```
∀ {X : Type u} {Y : Type v} {C : ConceptClass X Y} (self : CompressionSchemeWithInfo X Y C) {m : ℕ} (S : Fin m → X × Y),
  (∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) →
    ∀ (i : Fin m), self.reconstruct (self.compress S).1 (self.compress S).2 (S i).1 = (S i).2
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress CompressionSchemeWithInfo.reconstruct ConceptClass FLT.Concept
Used by
- compress_with_info_injective_on_labelings
DeclCompressionSchemeWithInfo.compress_subDeclaration kindtheorem
Compressed set is a subset of the sample
```
∀ {X : Type u} {Y : Type v} {C : ConceptClass X Y} (self : CompressionSchemeWithInfo X Y C) {m : ℕ} (S : Fin m → X × Y),
  ↑(self.compress S).1 ⊆ Set.range S
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress ConceptClass
Used by
- compression_with_info_imp_vcdim_finite
DeclCompressionSchemeWithInfo.compress_smallDeclaration kindtheorem
Compressed set is small
```
∀ {X : Type u} {Y : Type v} {C : ConceptClass X Y} (self : CompressionSchemeWithInfo X Y C) {m : ℕ} (S : Fin m → X × Y),
  (self.compress S).1.card ≤ self.kernelSize
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress CompressionSchemeWithInfo.kernelSize ConceptClass
Used by
- compression_with_info_imp_vcdim_finite
DefinitionCompressionSchemeWithInfostructure
A labeled compression scheme with finite side information. This is the object proved to exist by Moran-Yehudayoff (2016, arXiv:1503.06960).
The current CompressionScheme is strictly stronger: it requires reconstruction from the compressed Finset alone (no side information). See Open_NoInfoCompressionStrengthening for that conjecture.
```
(X : Type u) → (Y : Type v) → ConceptClass X Y → Type (max (max u (u_1 + 1)) v)
```

DefinitionCompressionSchemeWithInfo.Infodef

The side information type

{X : Type u} → {Y : Type v} → {C : ConceptClass X Y} → CompressionSchemeWithInfo X Y C → Type u_1

DefinitionCompressionSchemeWithInfo.compressdef

Compression: extract ≤ kernelSize labeled examples + side information

{X : Type u} →
  {Y : Type v} →
    {C : ConceptClass X Y} →
      (self : CompressionSchemeWithInfo X Y C) → {m : ℕ} → (Fin m → X × Y) → Finset (X × Y) × self.Info

DefinitionCompressionSchemeWithInfo.info_finitedef

Side information is finite

{X : Type u} → {Y : Type v} → {C : ConceptClass X Y} → (self : CompressionSchemeWithInfo X Y C) → Fintype self.Info

DefinitionCompressionSchemeWithInfo.kernelSizedef

Kernel size bound

{X : Type u} → {Y : Type v} → {C : ConceptClass X Y} → CompressionSchemeWithInfo X Y C → ℕ

DefinitionCompressionSchemeWithInfo.reconstructdef

Reconstruction: produce hypothesis from compressed subset AND side information

{X : Type u} →
  {Y : Type v} → {C : ConceptClass X Y} → (self : CompressionSchemeWithInfo X Y C) → Finset (X × Y) → self.Info → X → Y

DefinitionCompressionSchemeWithInfo.sizedef
Total size of a compression scheme with side information: kernel size + number of side information states. (The paper uses k + log₂(|I|+1); we use the simpler k + |I| which is an upper bound and avoids importing Real.log.)
```
{X : Type u} → {Y : Type v} → {C : ConceptClass X Y} → CompressionSchemeWithInfo X Y C → ℕ
```
DefinitionCompressionSchemeWithInfo0def
Fix the hidden Info universe parameter of CompressionSchemeWithInfo to 0. This resolves the universe elaboration obstruction: Fin T → Finset (Fin K) is Type 0, while CompressionSchemeWithInfo X Bool C with X : Type u infers Info : Type u. Pinning to .{u, 0, 0} allows Type 0 Info directly.
```
(X : Type u) → (Y : Type) → ConceptClass X Y → Type (max (max u 1) 0)
```
DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```

DefinitionEmpiricalErrordef

Empirical error: average loss on a finite sample.

(X : Type u) → (Y : Type v) → Concept X Y → {m : ℕ} → (Fin m → X × Y) → LossFunction Y → ℝ

DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionFinitePMFstructure
A probability mass function over a finite type. Named FinitePMF to avoid conflict with Mathlib's PMF.
```
(H : Type u_1) → [Fintype H] → Type u_1
```

DefinitionFinitePMF.probdef

{H : Type u_1} → [inst : Fintype H] → FinitePMF H → H → ℝ

DefinitionFinitePMF.toPMFdef

{H : Type u_1} → [inst : Fintype H] → FinitePMF H → PMF H

DefinitionFinset.boolVCDimdef
VC dimension of a finite Bool-valued family, computed via the set-system image boolFamilyToFinsetFamily and Mathlib's Finset.vcDim. Declared noncomputable because the underlying vcDim is.
```
{H : Type u_1} → [Fintype H] → [DecidableEq H] → Finset (H → Bool) → ℕ
```
DefinitionGrowthFunctiondef
Growth function (shattering coefficient): π_C(m) = max_{|S|=m} |{c|_S : c ∈ C}|. For each m-element set S, counts the number of distinct restrictions of C to S, then takes the supremum over all such S.
```
(X : Type u) → ConceptClass X Bool → ℕ → ℕ
```
DefinitionIncidenceInfodef
Concrete side information for the MY construction: each of the T recovered blocks is represented by the set of kernel positions it uses.
```
ℕ → ℕ → Type
```
DefinitionMWUConfigstructure
MWU config: weight vector with positivity proof.
```
(C : Type u_1) → [Fintype C] → Type u_1
```

DefinitionMWUConfig.potentialdef

Potential = sum of weights.

{C : Type u_1} → [inst : Fintype C] → MWUConfig C → ℝ

DefinitionMWUConfig.toPMFdef

Normalize config to PMF.

{C : Type u_1} → [inst : Fintype C] → [Nonempty C] → MWUConfig C → FinitePMF C

DefinitionMWUConfig.weightsdef

{C : Type u_1} → [inst : Fintype C] → MWUConfig C → C → ℝ

DefinitionProperFiniteSupportLearnerstructure
A proper finite-support learner for a concept class C. This structure captures the existence of a bounded-support ERM with error at most 1/3 for any C-realizable finite distribution. CORRECTED: good_on_support returns Finset X (not Fin k → X).
```
(X : Type u) → ConceptClass X Bool → Type u
```

DefinitionProperFiniteSupportLearner.learndef

{X : Type u} → {C : ConceptClass X Bool} → ProperFiniteSupportLearner X C → {m : ℕ} → (Fin m → X × Bool) → X → Bool

DefinitionProperFiniteSupportLearner.sampleBounddef

{X : Type u} → {C : ConceptClass X Bool} → ProperFiniteSupportLearner X C → ℕ

DefinitionShattersdefYaël Dillies
A set S ⊆ X is shattered by concept class C if every labeling of S is realized by some concept in C.
```
(X : Type u) → ConceptClass X Bool → Finset X → Prop
```
DefinitionSignVectordef
```
ℕ → Type
```
DefinitionTrueErrordef
True error (0-1 loss, realizable case): D-probability of disagreement. This is what PACLearnable's success event measures.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ENNReal
```
DefinitionTrueErrorRealdef
True error in ℝ: for use in bounds involving subtraction/absolute value. COUNTER-1 of TrueError. The toReal bridge loses information when the measure is ⊤.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ℝ
```
DefinitionVCDimdef
VC dimension of a concept class: the size of the largest shattered set. Returns ℕ∞ = WithTop ℕ.
```
(X : Type u) → ConceptClass X Bool → WithTop ℕ
```
DefinitionagreeTestdef
Per-point agreement test: for a fixed point x ∈ Y and concept c, maps hypothesis h to whether h(x) = c(x).
```
{X : Type u} → (X → Bool) → X → (HY : Finset (X → Bool)) → ↥HY → Bool
```

DefinitionagreeTestsdef

The family of agreement tests over all points in Y.

{X : Type u} → (X → Bool) → Finset X → (HY : Finset (X → Bool)) → Finset (↥HY → Bool)

DefinitionboolFamilyToFinsetFamilydef
Maps a finite family of Bool-valued functions to its image as a family of accepting sets. The set-system view is what Mathlib's Finset.Shatters and Finset.vcDim consume, so this is the entry point from the function-class view to the combinatorial VC machinery.
```
{H : Type u_1} → [Fintype H] → [DecidableEq H] → Finset (H → Bool) → Finset (Finset H)
```

DefinitionboolGamePayoffdef

Expected payoff of distribution p against column c in a Boolean game.

{R : Type u_1} → {C : Type u_2} → [inst : Fintype R] → (R → C → Bool) → FinitePMF R → C → ℝ

DefinitionboolTestExpectationdef
Expected value of a Bool-valued test under a finite distribution, via the indicator embedding if f h then 1 else 0. The central quantity of the finite-VC approximation layer: a TV bound on distributions translates to a uniform bound on test expectations via expectation_approx_of_tv.
```
{H : Type u_1} → [inst : Fintype H] → FinitePMF H → (H → Bool) → ℝ
```
DefinitionboolToSigndef
Convert Bool labels to ±1 reals. true ↦ 1, false ↦ -1.
```
Bool → ℝ
```
DefinitionboundedSubsamplesdef
Bounded subsamples: all subsets of Y with cardinality ≤ s.
```
{X : Type u} → Finset X → ℕ → Finset (Finset X)
```
DefinitiondecodeWitnessLabeldef
Decode labels from the kernel. This is exactly the current MY reconstruction convention in your file.
```
{X : Type u} → [DecidableEq X] → Finset (X × Bool) → X → Bool
```
DefinitiondecodeWitnessXCoordsdef
Decode the X-coordinates of a block from kernel positions. This matches the current blockHyp shape.
```
{X : Type u} → Finset (X × Bool) → {K : ℕ} → Finset (Fin K) → Finset X
```
DefinitiondisagreementFamilydef
The disagreement family: for each h ∈ C, the test y ↦ decide(h(y) ≠ c(y)) restricted to Y. Used for the VC approximation step in the proper learner proof.
```
{X : Type u} → ConceptClass X Bool → (X → Bool) → (Y : Finset X) → Finset (↥Y → Bool)
```

DefinitionempiricalPMFdef

Build FinitePMF from empirical frequencies of a finite sequence.

{α : Type u_1} → [inst : Fintype α] → [DecidableEq α] → {T : ℕ} → 0 < T → (Fin T → α) → FinitePMF α

DefinitionencodeWitnessInfodef
Encode a witness set W as the set of kernel positions of the pairs (x, c x). The bound kernel.card ≤ K is fed into the encoding through the if branch, so the result has the same shape as the current compressCore code.
```
{X : Type u} → [DecidableEq X] → Finset (X × Bool) → (X → Bool) → (K : ℕ) → Finset X → Finset (Fin K)
```

DefinitionextendBooldef

{H : Type u_1} → (H → Bool) → H ⊕ ℕ → Bool

DefinitionhypothesisEnvelopedef
The hypothesis envelope: the finite set of all possible learner outputs on bounded subsamples of Y, labeled by concept c.
```
{X : Type u} → {C : ConceptClass X Bool} → ProperFiniteSupportLearner X C → (X → Bool) → Finset X → Finset (X → Bool)
```
DefinitionlabeledSampleOfFinsetdef
Build a labeled sample from a Finset of points and a concept.
```
{X : Type u} → (X → Bool) → (Z : Finset X) → Fin Z.card → X × Bool
```

DefinitionliftClassdef

{H : Type u_1} → Finset (H → Bool) → ConceptClass (H ⊕ ℕ) Bool

DefinitionmkIncidenceSchemeOfMajoritydef

The actual final closure helper. Packages the majority-vote construction. If decoded hypotheses agree with reference hypotheses on sample points, and majority of reference hypotheses agree with each label, then majority-vote reconstruction is correct.

{X : Type u} →
  {C : ConceptClass X Bool} →
    (T K : ℕ) →
      (compressCore : {m : ℕ} → (Fin m → X × Bool) → Finset (X × Bool) × IncidenceInfo T K) →
        (blockHyp : Finset (X × Bool) → IncidenceInfo T K → Fin T → X → Bool) →
          (rowHyp :
              {m : ℕ} → (S : Fin m → X × Bool) → (∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) → Fin T → X → Bool) →
            0 < T →
              (∀ {m : ℕ} (S : Fin m → X × Bool), (compressCore S).1.card ≤ K) →
                (∀ {m : ℕ} (S : Fin m → X × Bool), ↑(compressCore S).1 ⊆ Set.range S) →
                  (∀ {m : ℕ} (S : Fin m → X × Bool) (hreal : ∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) (i : Fin m)
                      (t : Fin T),
                      blockHyp (compressCore S).1 (compressCore S).2 t (S i).1 = rowHyp S hreal t (S i).1) →
                    (∀ {m : ℕ} (S : Fin m → X × Bool) (hreal : ∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) (i : Fin m),
                        (∑ t, if rowHyp S hreal t (S i).1 = (S i).2 then 1 else 0) / ↑T > 1 / 2) →
                      CompressionSchemeWithInfo0 X Bool C

DefinitionmwuConfigdef

The MWU config after T steps.

{R : Type u_1} →
  {C : Type u_2} →
    [Fintype R] →
      [inst : Fintype C] →
        [Nonempty C] →
          (M : R → C → Bool) →
            (η : ℝ) →
              η < 1 →
                (v : ℝ) →
                  (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) → ℕ → MWUConfig C

DefinitionmwuHitCountdef

Count how many rounds hit a fixed column, aligned to the recursion of mwuRun.

{R : Type u_1} →
  {C : Type u_2} →
    [Fintype R] →
      [inst : Fintype C] →
        [Nonempty C] →
          (M : R → C → Bool) →
            (η : ℝ) →
              η < 1 →
                (v : ℝ) → (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) → ℕ → C → ℕ

DefinitionmwuInitdef

Initial config: all weights = 1.

(C : Type u_1) → [inst : Fintype C] → MWUConfig C

DefinitionmwuRowsdef

The MWU row sequence after T steps.

{R : Type u_1} →
  {C : Type u_2} →
    [Fintype R] →
      [inst : Fintype C] →
        [Nonempty C] →
          (M : R → C → Bool) →
            (η : ℝ) →
              η < 1 →
                (v : ℝ) →
                  (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) → (T : ℕ) → Fin T → R

DefinitionmwuRundef

MWU run: iterate T steps, returning final config and row sequence.

{R : Type u_1} →
  {C : Type u_2} →
    [Fintype R] →
      [inst : Fintype C] →
        [Nonempty C] →
          (M : R → C → Bool) →
            (η : ℝ) →
              η < 1 →
                (v : ℝ) →
                  (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) →
                    (T : ℕ) → MWUConfig C × (Fin T → R)

DefinitionmwuUpdateWeightsdef

One MWU update step on weights.

{C : Type u_1} → [inst : Fintype C] → {R : Type u_2} → (R → C → Bool) → (η : ℝ) → η < 1 → MWUConfig C → R → MWUConfig C

DefinitionpointSupportdef
Extract the domain points from a labeled sample.
```
{X : Type u} → {m : ℕ} → (Fin m → X × Bool) → Finset X
```

DefinitionsupportErrordef

Weighted error of hypothesis h vs concept c over a FinitePMF on Y.

{X : Type u} → (Y : Finset X) → FinitePMF ↥Y → (X → Bool) → (X → Bool) → ℝ

DefinitionuniformPMFdef

Uniform PMF over a nonempty Fintype.

(C : Type u_1) → [inst : Fintype C] → [Nonempty C] → FinitePMF C

DefinitionzeroOneLossdef
The 0-1 loss for classification.
```
(Y : Type v) → [DecidableEq Y] → LossFunction Y
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

Littlestone characterization: C is online-learnable iff LittlestoneDim(C) < ∞.

Decllittlestone_characterization

∀ (X : Type) (C : ConceptClass X Bool), OnlineLearnable X Bool C ↔ LittlestoneDim X C < ⊤

ThesisStepDefinition

Decllittlestone_characterizationDeclaration kindtheorem
```
∀ (X : Type) (C : ConceptClass X Bool), OnlineLearnable X Bool C ↔ LittlestoneDim X C < ⊤
```
ConceptClass LittlestoneDim OnlineLearnable
Uses
- backward_direction
- forward_direction
Declforward_directionDeclaration kindtheorem
Forward direction: OnlineLearnable → LittlestoneDim < ⊤
```
∀ (X : Type) (C : ConceptClass X Bool), OnlineLearnable X Bool C → LittlestoneDim X C < ⊤
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim MistakeBounded OnlineLearnable OnlineLearner OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakesFrom
Uses
Used by
- littlestone_characterization
Decladversary_coreDeclaration kindtheorem
Core adversary lemma.
```
∀ {X : Type} (L : OnlineLearner X Bool) (s : L.State) {C : ConceptClass X Bool} {n : ℕ} (T : LTree X n),
  LTree.isShattered C T → Set.Nonempty C → ∃ seq, ∃ c ∈ C, L.mistakesFrom s c seq = n
```
ConceptClass FLT.Concept LTree LTree.isShattered OnlineLearner OnlineLearner.State OnlineLearner.mistakesFrom OnlineLearner.predict OnlineLearner.update
Used by
- forward_direction
Declbackward_directionDeclaration kindtheorem
Backward direction: LittlestoneDim < ⊤ → OnlineLearnable.
```
∀ (X : Type) (C : ConceptClass X Bool), LittlestoneDim X C < ⊤ → OnlineLearnable X Bool C
```
ConceptClass FLT.Concept LittlestoneDim MistakeBounded OnlineLearnable OnlineLearner OnlineLearner.State OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakesFrom SOA versionSpace
Uses
Used by
- littlestone_characterization
Declsoa_mistakes_boundedDeclaration kindtheorem
SOA mistakes from a given state are bounded by the Ldim of the version space. This is the core M-Potential argument.
```
∀ {X : Type} {C : ConceptClass X Bool},
 ∀ c ∈ C,
 ∀ (history : List (X × Bool)),
 (∀ p ∈ history, c p.1 = p.2) →
 ∀ (d : ℕ),
 LittlestoneDim X (versionSpace C history) ≤ ↑↑d →
 LittlestoneDim X (versionSpace C history) < ⊤ → ∀ (seq : List X), (SOA X C).mistakesFrom history c seq ≤ d
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim OnlineLearner.mistakesFrom OnlineLearner.predict SOA versionSpace
Uses
Used by
- backward_direction

DeclversionSpace_appendDeclaration kindtheorem

Extending history restricts the version space.

∀ {X : Type} {C : ConceptClass X Bool} {history : List (X × Bool)} {x : X} {y : Bool},
  versionSpace C (history ++ [(x, y)]) ⊆ versionSpace C history

ConceptClass FLT.Concept versionSpace

Used by

soa_mistakes_bounded

Decltarget_in_versionSpaceDeclaration kindtheorem

Target stays in version space.

∀ {X : Type} {C : ConceptClass X Bool} {c : X → Bool},
  c ∈ C → ∀ {history : List (X × Bool)}, (∀ p ∈ history, c p.1 = p.2) → c ∈ versionSpace C history

ConceptClass FLT.Concept versionSpace

Used by

soa_mistakes_bounded

Declldim_strict_decrease_on_mistakeDeclaration kindtheorem
On an SOA mistake, the Ldim of the version space strictly decreases.
```
∀ {X : Type} {C : ConceptClass X Bool} {history : List (X × Bool)} {x : X} {c : X → Bool},
 c ∈ versionSpace C history →
 (SOA X C).predict history x ≠ c x →
 LittlestoneDim X (versionSpace C history) < ⊤ →
 LittlestoneDim X (versionSpace C (history ++ [(x, c x)])) < LittlestoneDim X (versionSpace C history)
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim OnlineLearner.predict SOA versionSpace
Uses
Used by
- soa_mistakes_bounded

Declsoa_predict_specDeclaration kindtheorem

SOA predicts the label whose side has higher Ldim.

∀ {X : Type} (C : ConceptClass X Bool) (history : List (X × Bool)) (x : X),
  have V := versionSpace C history;
  have b := (SOA X C).predict history x;
  LittlestoneDim X {c | c ∈ V ∧ c x = b} ≥ LittlestoneDim X {c | c ∈ V ∧ c x = !b}

ConceptClass FLT.Concept LittlestoneDim OnlineLearner.predict SOA versionSpace

Used by

ldim_strict_decrease_on_mistake

Declldim_zero_all_agreeDeclaration kindtheorem
When Ldim(V) = 0 (↑↑0), all concepts in V agree on every point. Key lemma for M-VersionSpaceCollapse.
```
∀ {X : Type} {V : ConceptClass X Bool},
  LittlestoneDim X V = ↑0 → Set.Nonempty V → ∀ (x : X) (c₁ c₂ : X → Bool), c₁ ∈ V → c₂ ∈ V → c₁ x = c₂ x
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim
Used by
- ldim_strict_decrease_on_mistake

Declldim_branch_lower_boundDeclaration kindtheorem

Build a tree of depth k+1 from shattered subtrees on both sides. Parametrized over b : Bool so we don't need to case-split in the caller.

∀ {X : Type} {V : ConceptClass X Bool} {x : X} {k : ℕ} {b : Bool},
  (∃ Tb, LTree.isShattered {c | c ∈ V ∧ c x = b} Tb) →
    (∃ Tnb, LTree.isShattered {c | c ∈ V ∧ c x = !b} Tnb) →
      (∃ c ∈ V, c x = b) → (∃ c ∈ V, c x = !b) → LittlestoneDim X V ≥ ↑↑(k + 1)

ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim

Used by

ldim_strict_decrease_on_mistake

Declexists_shattered_of_ldim_geDeclaration kindtheorem
From Ldim ≥ d, extract a shattered tree of depth exactly d.
```
∀ {X : Type} {C : ConceptClass X Bool} {d : ℕ}, LittlestoneDim X C ≥ ↑↑d → ∃ T, LTree.isShattered C T
```
ConceptClass FLT.Concept LTree LTree.isShattered LTree.truncate LittlestoneDim
Uses
- LTree.isShattered_truncate
- LTree.nonempty_of_isShattered
Used by
- ldim_strict_decrease_on_mistake
DeclLTree.isShattered_truncateDeclaration kindtheorem
A truncated tree is shattered if the original is.
```
∀ {X : Type} {C : ConceptClass X Bool} {m : ℕ} (T : LTree X m),
  LTree.isShattered C T → ∀ {n : ℕ} (h : n ≤ m), LTree.isShattered C (LTree.truncate h T)
```
ConceptClass FLT.Concept LTree LTree.isShattered LTree.truncate
Uses
- LTree.nonempty_of_isShattered
Used by
- exists_shattered_of_ldim_ge
DeclLTree.nonempty_of_isShatteredDeclaration kindtheorem
Helper: shattering implies the concept class is nonempty.
```
∀ {X : Type} {C : ConceptClass X Bool} {n : ℕ} (T : LTree X n), LTree.isShattered C T → Set.Nonempty C
```
ConceptClass FLT.Concept LTree LTree.isShattered
Used by
DeclWithBot_WithTop_lt_succ_leDeclaration kindtheorem
In WithBot (WithTop ℕ), a < ↑↑(n+1) → a ≤ ↑↑n. Reusable lattice fact.
```
∀ {a : WithBot (WithTop ℕ)} {n : ℕ}, a < ↑↑(n + 1) → a ≤ ↑↑n
```
Used by
- soa_mistakes_bounded

DeclSOA_mistakesFrom_consDeclaration kindtheorem

SOA mistakesFrom cons: unfold one step using the interface.

∀ (X : Type) (C : ConceptClass X Bool) (history : List (X × Bool)) (c : X → Bool) (x : X) (xs : List X),
  (SOA X C).mistakesFrom history c (x :: xs) =
    (if (SOA X C).predict history x ≠ c x then 1 else 0) + (SOA X C).mistakesFrom (history ++ [(x, c x)]) c xs

ConceptClass OnlineLearner.mistakesFrom OnlineLearner.predict SOA

Used by

soa_mistakes_bounded

DeclLTree.isShattered_monoDeclaration kindtheorem
Shattering is upward-monotone in the concept class.
```
∀ {X : Type} {n : ℕ} (T : LTree X n) {C C' : ConceptClass X Bool},
  C ⊆ C' → LTree.isShattered C T → LTree.isShattered C' T
```
ConceptClass FLT.Concept LTree LTree.isShattered
Used by
- ldim_strict_decrease_on_mistake
- soa_mistakes_bounded
DeclmistakesFrom_init_eqDeclaration kindtheorem
Relate mistakesFrom to the original mistakes function.
```
∀ {X : Type} (L : OnlineLearner X Bool) (c : X → Bool) (seq : List X), L.mistakesFrom L.init c seq = L.mistakes c seq
```
OnlineLearner OnlineLearner.State OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakes.go OnlineLearner.mistakesFrom OnlineLearner.predict OnlineLearner.update
Used by
- backward_direction
- forward_direction
DeclSOA_init_eqDeclaration kindtheorem
SOA init state is empty history.
```
∀ (X : Type) (C : ConceptClass X Bool), (SOA X C).init = []
```
ConceptClass OnlineLearner.State OnlineLearner.init SOA
Used by
- backward_direction
DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```
DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionLTreeinductive
A complete binary Littlestone tree of depth n.
```
Type → ℕ → Type
```
DefinitionLTree.isShattereddef
Path-wise shattering for complete trees. Path B: leaf case requires C.Nonempty (NA₁₀).
```
{X : Type} → {n : ℕ} → ConceptClass X Bool → LTree X n → Prop
```
DefinitionLTree.truncatedef
Truncate a complete tree to a smaller depth.
```
{X : Type} → {n m : ℕ} → n ≤ m → LTree X m → LTree X n
```
DefinitionLittlestoneDimdef
Littlestone dimension: the maximum depth of a complete shattered tree. Path B: returns WithBot (WithTop ℕ) so Ldim(∅) = ⊥ (NA₁₀).
```
(X : Type) → ConceptClass X Bool → WithBot (WithTop ℕ)
```
DefinitionMistakeBoundeddef
Mistake-bounded learning: the learner makes at most M mistakes on ANY sequence. No distribution assumption. Characterized by Littlestone dimension.
```
(X : Type u) → (Y : Type v) → [DecidableEq Y] → ConceptClass X Y → ℕ → Prop
```
DefinitionOnlineLearnabledef
Online learnable: there exists a finite mistake bound.
```
(X : Type u) → (Y : Type v) → [DecidableEq Y] → ConceptClass X Y → Prop
```
DefinitionOnlineLearnerstructure
An online learner: receives instances one at a time, makes predictions sequentially.
```
Type u → Type v → Type (max (max 1 u) v)
```

DefinitionOnlineLearner.Statedef

Internal state type

{X : Type u} → {Y : Type v} → OnlineLearner X Y → Type

DefinitionOnlineLearner.initdef

Initial state

{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State

DefinitionOnlineLearner.mistakesdef

Helper: run an online learner on a sequence, counting mistakes.

{X : Type u} → {Y : Type v} → [DecidableEq Y] → OnlineLearner X Y → Concept X Y → List X → ℕ

DefinitionOnlineLearner.mistakes.godef

{X : Type u} → {Y : Type v} → [DecidableEq Y] → (L : OnlineLearner X Y) → Concept X Y → L.State → List X → ℕ → ℕ

DefinitionOnlineLearner.mistakesFromdef

Count mistakes starting from state s.

{X : Type} → (L : OnlineLearner X Bool) → L.State → (X → Bool) → List X → ℕ

DefinitionOnlineLearner.predictdef
Predict: given current state and new instance, output a prediction
```
{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State → X → Y
```
DefinitionOnlineLearner.updatedef
Update: given current state, instance, and revealed true label, update state
```
{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State → X → Y → self.State
```

DefinitionSOAdef

The Standard Optimal Algorithm (SOA).

(X : Type) → ConceptClass X Bool → OnlineLearner X Bool

DefinitionversionSpacedef

Version space after observing a history.

{X : Type} → ConceptClass X Bool → List (X × Bool) → ConceptClass X Bool

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

The optimal mistake bound equals the Littlestone dimension (for nonempty C). Path B: OptimalMistakeBound : WithTop ℕ, LittlestoneDim : WithBot (WithTop ℕ). For nonempty C, LittlestoneDim ≥ 0, so the coercion ↑(OptimalMistakeBound) works.

Decloptimal_mistake_bound_eq_ldim

∀ (X : Type) (C : ConceptClass X Bool), Set.Nonempty C → ↑(OptimalMistakeBound X C) = LittlestoneDim X C

ThesisStepHypothesisDefinition

Decloptimal_mistake_bound_eq_ldimDeclaration kindtheorem
```
∀ (X : Type) (C : ConceptClass X Bool), Set.Nonempty C → ↑(OptimalMistakeBound X C) = LittlestoneDim X C
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim MistakeBounded OnlineLearnable OnlineLearner OnlineLearner.State OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakesFrom OptimalMistakeBound SOA versionSpace
Uses
Declbackward_directionDeclaration kindtheorem
Backward direction: LittlestoneDim < ⊤ → OnlineLearnable.
```
∀ (X : Type) (C : ConceptClass X Bool), LittlestoneDim X C < ⊤ → OnlineLearnable X Bool C
```
ConceptClass FLT.Concept LittlestoneDim MistakeBounded OnlineLearnable OnlineLearner OnlineLearner.State OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakesFrom SOA versionSpace
Uses
Used by
- optimal_mistake_bound_eq_ldim
Declsoa_mistakes_boundedDeclaration kindtheorem
SOA mistakes from a given state are bounded by the Ldim of the version space. This is the core M-Potential argument.
```
∀ {X : Type} {C : ConceptClass X Bool},
 ∀ c ∈ C,
 ∀ (history : List (X × Bool)),
 (∀ p ∈ history, c p.1 = p.2) →
 ∀ (d : ℕ),
 LittlestoneDim X (versionSpace C history) ≤ ↑↑d →
 LittlestoneDim X (versionSpace C history) < ⊤ → ∀ (seq : List X), (SOA X C).mistakesFrom history c seq ≤ d
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim OnlineLearner.mistakesFrom OnlineLearner.predict SOA versionSpace
Uses
Used by
- backward_direction
- optimal_mistake_bound_eq_ldim

DeclversionSpace_appendDeclaration kindtheorem

Extending history restricts the version space.

∀ {X : Type} {C : ConceptClass X Bool} {history : List (X × Bool)} {x : X} {y : Bool},
  versionSpace C (history ++ [(x, y)]) ⊆ versionSpace C history

ConceptClass FLT.Concept versionSpace

Used by

soa_mistakes_bounded

Decltarget_in_versionSpaceDeclaration kindtheorem

Target stays in version space.

∀ {X : Type} {C : ConceptClass X Bool} {c : X → Bool},
  c ∈ C → ∀ {history : List (X × Bool)}, (∀ p ∈ history, c p.1 = p.2) → c ∈ versionSpace C history

ConceptClass FLT.Concept versionSpace

Used by

soa_mistakes_bounded

Declldim_strict_decrease_on_mistakeDeclaration kindtheorem
On an SOA mistake, the Ldim of the version space strictly decreases.
```
∀ {X : Type} {C : ConceptClass X Bool} {history : List (X × Bool)} {x : X} {c : X → Bool},
 c ∈ versionSpace C history →
 (SOA X C).predict history x ≠ c x →
 LittlestoneDim X (versionSpace C history) < ⊤ →
 LittlestoneDim X (versionSpace C (history ++ [(x, c x)])) < LittlestoneDim X (versionSpace C history)
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim OnlineLearner.predict SOA versionSpace
Uses
Used by
- soa_mistakes_bounded

Declsoa_predict_specDeclaration kindtheorem

SOA predicts the label whose side has higher Ldim.

∀ {X : Type} (C : ConceptClass X Bool) (history : List (X × Bool)) (x : X),
  have V := versionSpace C history;
  have b := (SOA X C).predict history x;
  LittlestoneDim X {c | c ∈ V ∧ c x = b} ≥ LittlestoneDim X {c | c ∈ V ∧ c x = !b}

ConceptClass FLT.Concept LittlestoneDim OnlineLearner.predict SOA versionSpace

Used by

ldim_strict_decrease_on_mistake

Declldim_zero_all_agreeDeclaration kindtheorem
When Ldim(V) = 0 (↑↑0), all concepts in V agree on every point. Key lemma for M-VersionSpaceCollapse.
```
∀ {X : Type} {V : ConceptClass X Bool},
  LittlestoneDim X V = ↑0 → Set.Nonempty V → ∀ (x : X) (c₁ c₂ : X → Bool), c₁ ∈ V → c₂ ∈ V → c₁ x = c₂ x
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim
Used by
- ldim_strict_decrease_on_mistake

Declldim_branch_lower_boundDeclaration kindtheorem

Build a tree of depth k+1 from shattered subtrees on both sides. Parametrized over b : Bool so we don't need to case-split in the caller.

∀ {X : Type} {V : ConceptClass X Bool} {x : X} {k : ℕ} {b : Bool},
  (∃ Tb, LTree.isShattered {c | c ∈ V ∧ c x = b} Tb) →
    (∃ Tnb, LTree.isShattered {c | c ∈ V ∧ c x = !b} Tnb) →
      (∃ c ∈ V, c x = b) → (∃ c ∈ V, c x = !b) → LittlestoneDim X V ≥ ↑↑(k + 1)

ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim

Used by

ldim_strict_decrease_on_mistake

Declexists_shattered_of_ldim_geDeclaration kindtheorem
From Ldim ≥ d, extract a shattered tree of depth exactly d.
```
∀ {X : Type} {C : ConceptClass X Bool} {d : ℕ}, LittlestoneDim X C ≥ ↑↑d → ∃ T, LTree.isShattered C T
```
ConceptClass FLT.Concept LTree LTree.isShattered LTree.truncate LittlestoneDim
Uses
- LTree.isShattered_truncate
- LTree.nonempty_of_isShattered
Used by
- ldim_strict_decrease_on_mistake
DeclLTree.isShattered_truncateDeclaration kindtheorem
A truncated tree is shattered if the original is.
```
∀ {X : Type} {C : ConceptClass X Bool} {m : ℕ} (T : LTree X m),
  LTree.isShattered C T → ∀ {n : ℕ} (h : n ≤ m), LTree.isShattered C (LTree.truncate h T)
```
ConceptClass FLT.Concept LTree LTree.isShattered LTree.truncate
Uses
- LTree.nonempty_of_isShattered
Used by
- exists_shattered_of_ldim_ge
DeclWithBot_WithTop_lt_succ_leDeclaration kindtheorem
In WithBot (WithTop ℕ), a < ↑↑(n+1) → a ≤ ↑↑n. Reusable lattice fact.
```
∀ {a : WithBot (WithTop ℕ)} {n : ℕ}, a < ↑↑(n + 1) → a ≤ ↑↑n
```
Used by
- soa_mistakes_bounded

DeclSOA_mistakesFrom_consDeclaration kindtheorem

SOA mistakesFrom cons: unfold one step using the interface.

∀ (X : Type) (C : ConceptClass X Bool) (history : List (X × Bool)) (c : X → Bool) (x : X) (xs : List X),
  (SOA X C).mistakesFrom history c (x :: xs) =
    (if (SOA X C).predict history x ≠ c x then 1 else 0) + (SOA X C).mistakesFrom (history ++ [(x, c x)]) c xs

ConceptClass OnlineLearner.mistakesFrom OnlineLearner.predict SOA

Used by

soa_mistakes_bounded

DeclLTree.isShattered_monoDeclaration kindtheorem
Shattering is upward-monotone in the concept class.
```
∀ {X : Type} {n : ℕ} (T : LTree X n) {C C' : ConceptClass X Bool},
  C ⊆ C' → LTree.isShattered C T → LTree.isShattered C' T
```
ConceptClass FLT.Concept LTree LTree.isShattered
Used by
- ldim_strict_decrease_on_mistake
- soa_mistakes_bounded
Decladversary_lower_boundDeclaration kindtheorem
Adversary lower bound (M-InfSup reusable primitive): If a tree of depth n is shattered by C, then any mistake-bounded learner must allow at least n mistakes. This is the "inf ≥ sup" half of minimax.
```
∀ {X : Type} {C : ConceptClass X Bool} {n : ℕ} (T : LTree X n),
  LTree.isShattered C T → ∀ {M : ℕ}, MistakeBounded X Bool C M → n ≤ M
```
ConceptClass FLT.Concept LTree LTree.isShattered MistakeBounded OnlineLearner OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakesFrom
Uses
Used by
- optimal_mistake_bound_eq_ldim
DeclmistakesFrom_init_eqDeclaration kindtheorem
Relate mistakesFrom to the original mistakes function.
```
∀ {X : Type} (L : OnlineLearner X Bool) (c : X → Bool) (seq : List X), L.mistakesFrom L.init c seq = L.mistakes c seq
```
OnlineLearner OnlineLearner.State OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakes.go OnlineLearner.mistakesFrom OnlineLearner.predict OnlineLearner.update
Used by
Decladversary_coreDeclaration kindtheorem
Core adversary lemma.
```
∀ {X : Type} (L : OnlineLearner X Bool) (s : L.State) {C : ConceptClass X Bool} {n : ℕ} (T : LTree X n),
  LTree.isShattered C T → Set.Nonempty C → ∃ seq, ∃ c ∈ C, L.mistakesFrom s c seq = n
```
ConceptClass FLT.Concept LTree LTree.isShattered OnlineLearner OnlineLearner.State OnlineLearner.mistakesFrom OnlineLearner.predict OnlineLearner.update
Used by
- adversary_lower_bound
DeclLTree.nonempty_of_isShatteredDeclaration kindtheorem
Helper: shattering implies the concept class is nonempty.
```
∀ {X : Type} {C : ConceptClass X Bool} {n : ℕ} (T : LTree X n), LTree.isShattered C T → Set.Nonempty C
```
ConceptClass FLT.Concept LTree LTree.isShattered
Used by
DeclSOA_init_eqDeclaration kindtheorem
SOA init state is empty history.
```
∀ (X : Type) (C : ConceptClass X Bool), (SOA X C).init = []
```
ConceptClass OnlineLearner.State OnlineLearner.init SOA
Used by
- backward_direction
- optimal_mistake_bound_eq_ldim
Hypothesishne
```
Set.Nonempty C
```
DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```
DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionLTreeinductive
A complete binary Littlestone tree of depth n.
```
Type → ℕ → Type
```
DefinitionLTree.isShattereddef
Path-wise shattering for complete trees. Path B: leaf case requires C.Nonempty (NA₁₀).
```
{X : Type} → {n : ℕ} → ConceptClass X Bool → LTree X n → Prop
```
DefinitionLTree.truncatedef
Truncate a complete tree to a smaller depth.
```
{X : Type} → {n m : ℕ} → n ≤ m → LTree X m → LTree X n
```
DefinitionLittlestoneDimdef
Littlestone dimension: the maximum depth of a complete shattered tree. Path B: returns WithBot (WithTop ℕ) so Ldim(∅) = ⊥ (NA₁₀).
```
(X : Type) → ConceptClass X Bool → WithBot (WithTop ℕ)
```
DefinitionMistakeBoundeddef
Mistake-bounded learning: the learner makes at most M mistakes on ANY sequence. No distribution assumption. Characterized by Littlestone dimension.
```
(X : Type u) → (Y : Type v) → [DecidableEq Y] → ConceptClass X Y → ℕ → Prop
```
DefinitionOnlineLearnabledef
Online learnable: there exists a finite mistake bound.
```
(X : Type u) → (Y : Type v) → [DecidableEq Y] → ConceptClass X Y → Prop
```
DefinitionOnlineLearnerstructure
An online learner: receives instances one at a time, makes predictions sequentially.
```
Type u → Type v → Type (max (max 1 u) v)
```

DefinitionOnlineLearner.Statedef

Internal state type

{X : Type u} → {Y : Type v} → OnlineLearner X Y → Type

DefinitionOnlineLearner.initdef

Initial state

{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State

DefinitionOnlineLearner.mistakesdef

Helper: run an online learner on a sequence, counting mistakes.

{X : Type u} → {Y : Type v} → [DecidableEq Y] → OnlineLearner X Y → Concept X Y → List X → ℕ

DefinitionOnlineLearner.mistakes.godef

{X : Type u} → {Y : Type v} → [DecidableEq Y] → (L : OnlineLearner X Y) → Concept X Y → L.State → List X → ℕ → ℕ

DefinitionOnlineLearner.mistakesFromdef

Count mistakes starting from state s.

{X : Type} → (L : OnlineLearner X Bool) → L.State → (X → Bool) → List X → ℕ

DefinitionOnlineLearner.predictdef
Predict: given current state and new instance, output a prediction
```
{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State → X → Y
```
DefinitionOnlineLearner.updatedef
Update: given current state, instance, and revealed true label, update state
```
{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State → X → Y → self.State
```
DefinitionOptimalMistakeBounddef
Mistake bound: minimum worst-case mistakes for online learning of C.
```
(X : Type u) → ConceptClass X Bool → WithTop ℕ
```

DefinitionSOAdef

The Standard Optimal Algorithm (SOA).

(X : Type) → ConceptClass X Bool → OnlineLearner X Bool

DefinitionversionSpacedef

Version space after observing a history.

{X : Type} → ConceptClass X Bool → List (X × Bool) → ConceptClass X Bool

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

Universal learnable → PAC learnable. Proof sketch: UniversalLearnable gives learner L with rate → 0 and Pr[error ≤ rate(m)] ≥ 2/3. Two components: 1. Event containment: rate(m) < ε ⟹ {error ≤ rate(m)} ⊆ {error ≤ ε} (monotonicity). 2. Confidence boosting: 2/3 → 1-δ via median-of-means (Γ₆₇, sorry'd in boost_two_thirds_to_pac). Routes through boost_two_thirds_to_pac which encapsulates the Chernoff-based boosting.

Decluniversal_imp_pac

∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) [MeasurableHypotheses X C],
  (∀ (L : BatchLearner X Bool), LearnEvalMeasurable L) → UniversalLearnable X C → PACLearnable X C

ThesisStepHypothesisDefinition

Decluniversal_imp_pacDeclaration kindtheorem
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) [MeasurableHypotheses X C],
  (∀ (L : BatchLearner X Bool), LearnEvalMeasurable L) → UniversalLearnable X C → PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept LearnEvalMeasurable MeasurableHypotheses PACLearnable UniversalLearnable
Uses
- MeasurableHypotheses.mem_measurable
- boost_two_thirds_to_pac
Declboost_two_thirds_to_pacDeclaration kindtheorem
Boosting lemma: given a learner with success probability ≥ 2/3 under D^m, construct a boosted learner with success probability ≥ 1-δ for any δ > 0. Standard technique: run L independently k times on independent samples of size m₀, take majority vote.
Construction:
- kmin = ⌈9/δ⌉ + 2 (enough blocks for Chebyshev concentration)
- m₀ from hrate(ε/kmin) so that rate(m₀) < ε/kmin
- n = max m₀ (kmin - 1). Then k = n + 1 ≥ kmin.
- Total samples: (n + 1) * n, with Nat.sqrt((n+1)*n) = n.
- At sample size m = (n+1)*n, L' recovers k = n+1 blocks of size n.
- Event containment: when > k/2 blocks have D-error ≤ rate(n) < ε/kmin, majority D-error ≤ k · rate(n) < k/kmin · ε ≤ ε via union bound.
Γ₆₇: sorry — the full measure-theoretic proof requires: (a) block_extract : (Fin (kn) → X) → Fin k → (Fin n → X) (b) iIndepFun for block extractions under product measure D^(kn) (c) chebyshev_majority_bound for i.i.d. Bernoulli(≥2/3) events (d) block extraction marginal = D^n (e) majority vote D-error analysis via union bound
None of this infrastructure currently exists in the codebase. The sorry is A4-compliant (the conclusion PACLearnable X C is non-trivially-true: it requires genuine concentration + majority analysis) and A5-compliant (the proof strategy is structurally complete, only infrastructure is missing).
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) [MeasurableHypotheses X C] (L : BatchLearner X Bool)
 [MeasurableBatchLearner X L] (rate : ℕ → ℝ),
 (∀ ε > 0, ∃ m₀, ∀ m ≥ m₀, rate m < ε) →
 (∀ (D : MeasureTheory.Measure X),
 MeasureTheory.IsProbabilityMeasure D →
 ∀ c ∈ C,
 ∀ (m : ℕ),
 (MeasureTheory.Measure.pi fun x => D)
 {xs | D {x | L.learn (fun i => (xs i, c (xs i))) x ≠ c x} ≤ ENNReal.ofReal (rate m)} ≥
 ENNReal.ofReal (2 / 3)) →
 PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept LearnEvalMeasurable MeasurableBatchLearner MeasurableHypotheses PACLearnable block_extract boosted_majority goodBlockEvent
Uses
Used by
- universal_imp_pac

DecliIndepSet_goodBlockEventsDeclaration kindtheorem

T5: The goodBlockEvents are independent under the product measure.

∀ {X : Type u} [inst : MeasurableSpace X] (L : BatchLearner X Bool) [MeasurableBatchLearner X L]
  (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D] (c : Concept X Bool),
  Measurable c →
    ∀ (rate : ℕ → ℝ) (k n : ℕ),
      ProbabilityTheory.iIndepSet (goodBlockEvent✝ L D c rate k n) (MeasureTheory.Measure.pi fun x => D)

BatchLearner BatchLearner.learn FLT.Concept MeasurableBatchLearner block_extract goodBlockEvent

Uses

iIndepFun_block_extract
measurableSet_goodBlock_A

Used by

boost_two_thirds_to_pac

DecliIndepFun_block_extractDeclaration kindtheorem

Block extractions are independent under the product measure. Key infrastructure for boosting (D4) and probability amplification.

∀ {X : Type u_1} [inst : MeasurableSpace X] (k m : ℕ) (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D],
  ProbabilityTheory.iIndepFun (fun j ω => block_extract k m ω j) (MeasureTheory.Measure.pi fun x => D)

block_extract

Used by

iIndepSet_goodBlockEvents

DeclgoodBlockEvent_prob_ge_two_thirdsDeclaration kindtheorem

T4: Each block's good event has probability ≥ 2/3, transported from the base learner guarantee.

∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) (L : BatchLearner X Bool)
  [MeasurableBatchLearner X L] (rate : ℕ → ℝ),
  (∀ (D : MeasureTheory.Measure X),
      MeasureTheory.IsProbabilityMeasure D →
        ∀ c ∈ C,
          ∀ (m : ℕ),
            (MeasureTheory.Measure.pi fun x => D)
                {xs | D {x | L.learn (fun i => (xs i, c (xs i))) x ≠ c x} ≤ ENNReal.ofReal (rate m)} ≥
              ENNReal.ofReal (2 / 3)) →
    ∀ (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D],
      ∀ c ∈ C,
        Measurable c →
          ∀ (k n : ℕ) (j : Fin k),
            (MeasureTheory.Measure.pi fun x => D) (goodBlockEvent✝ L D c rate k n j) ≥ ENNReal.ofReal (2 / 3)

BatchLearner BatchLearner.learn ConceptClass FLT.Concept LearnEvalMeasurable MeasurableBatchLearner block_extract goodBlockEvent

Uses

MeasurableBatchLearner.eval_measurable
block_extract_measurable
map_block_extract_eq_pi
measurableSet_goodBlock_A

Used by

boost_two_thirds_to_pac

DeclmeasurableSet_goodBlock_ADeclaration kindtheorem

T0: Shared helper — measurability of the "good training set" event for a single block.

∀ {X : Type u} [inst : MeasurableSpace X] (L : BatchLearner X Bool) [MeasurableBatchLearner X L]
  (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D] (c : Concept X Bool),
  Measurable c →
    ∀ (rate : ℕ → ℝ) (n : ℕ),
      MeasurableSet {xs | D {x | L.learn (fun i => (xs i, c (xs i))) x ≠ c x} ≤ ENNReal.ofReal (rate n)}

BatchLearner BatchLearner.learn FLT.Concept LearnEvalMeasurable MeasurableBatchLearner

Uses

MeasurableBatchLearner.eval_measurable

Used by

goodBlockEvent_prob_ge_two_thirds
iIndepSet_goodBlockEvents

Declmap_block_extract_eq_piDeclaration kindtheorem

T3: Block extraction pushforward of product measure equals product measure.

∀ {X : Type u} [inst : MeasurableSpace X] (k n : ℕ) (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (j : Fin k),
  MeasureTheory.Measure.map (fun ω => block_extract k n ω j) (MeasureTheory.Measure.pi fun x => D) =
    MeasureTheory.Measure.pi fun x => D

block_extract

Used by

goodBlockEvent_prob_ge_two_thirds

DeclgoodBlockEvent_measurableDeclaration kindtheorem
T2: goodBlockEvent is measurable for each block index j.
```
∀ {X : Type u} [inst : MeasurableSpace X] (L : BatchLearner X Bool) [MeasurableBatchLearner X L]
  (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D] (c : Concept X Bool),
  Measurable c → ∀ (rate : ℕ → ℝ) (k n : ℕ) (j : Fin k), MeasurableSet (goodBlockEvent✝ L D c rate k n j)
```
BatchLearner BatchLearner.learn FLT.Concept LearnEvalMeasurable MeasurableBatchLearner block_extract goodBlockEvent
Uses
- MeasurableBatchLearner.eval_measurable
- block_extract_measurable
Used by
- boost_two_thirds_to_pac
Declblock_extract_measurableDeclaration kindtheorem
Block extraction is measurable: extracting block j from a pi-type is measurable.
```
∀ {X : Type u_1} [inst : MeasurableSpace X] (k m : ℕ) (j : Fin k), Measurable fun ω => block_extract k m ω j
```
block_extract
Used by
- goodBlockEvent_measurable
- goodBlockEvent_prob_ge_two_thirds

Declchebyshev_seven_twelfths_boundDeclaration kindtheorem

T6: Chebyshev concentration for 7/12 threshold — when k ≥ 36/δ independent events each have probability ≥ 2/3, the fraction exceeding 7/12 is ≥ 1-δ.

∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ] {k : ℕ}
  {δ : ℝ},
  0 < δ →
    36 / δ ≤ ↑k →
      ∀ (events : Fin k → Set Ω),
        (∀ (j : Fin k), MeasurableSet (events j)) →
          ProbabilityTheory.iIndepSet (fun j => events j) μ →
            (∀ (j : Fin k), μ (events j) ≥ ENNReal.ofReal (2 / 3)) →
              μ {ω | 7 * k ≤ 12 * {j | ω ∈ events j}.card} ≥ ENNReal.ofReal (1 - δ)

Used by

boost_two_thirds_to_pac

Declboosted_sample_error_le_of_good_blocksDeclaration kindtheorem

T8: If ≥ 7/12 of blocks are good, the boosted hypothesis has D-error ≤ 7·max(rate(n),0).

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (c : Concept X Bool),
  Measurable c →
    ∀ (L : BatchLearner X Bool) [MeasurableBatchLearner X L] (rate : ℕ → ℝ) (k n : ℕ) (ω : Fin (k * n) → X),
      0 < k →
        7 * k ≤ 12 * {j | ω ∈ goodBlockEvent✝ L D c rate k n j}.card →
          D
              {x |
                (boosted_majority✝ k fun j =>
                    L.learn (fun i => (block_extract k n ω j i, c (block_extract k n ω j i))) x) ≠
                  c x} ≤
            ENNReal.ofReal (7 * max (rate n) 0)

BatchLearner BatchLearner.learn FLT.Concept LearnEvalMeasurable MeasurableBatchLearner block_extract boosted_majority goodBlockEvent

Uses

MeasurableBatchLearner.eval_measurable
learn_measurable_fixed
majority_error_le_seven_rate_of_good_fraction

Used by

boost_two_thirds_to_pac

Declmajority_error_le_seven_rate_of_good_fractionDeclaration kindtheorem

T7: If ≥ 7/12 of the hypotheses have D-error ≤ ρ, majority vote has D-error ≤ 7ρ.

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D] {k : ℕ},
  0 < k →
    ∀ (c : Concept X Bool),
      Measurable c →
        ∀ (hs : Fin k → Concept X Bool),
          (∀ (j : Fin k), Measurable (hs j)) →
            ∀ (good : Finset (Fin k)),
              7 * k ≤ 12 * good.card →
                ∀ (ρ : ℝ),
                  0 ≤ ρ →
                    (∀ j ∈ good, D {x | hs j x ≠ c x} ≤ ENNReal.ofReal ρ) →
                      D {x | (boosted_majority✝ k fun j => hs j x) ≠ c x} ≤ ENNReal.ofReal (7 * ρ)

FLT.Concept boosted_majority

Used by

boosted_sample_error_le_of_good_blocks

Decllearn_measurable_fixedDeclaration kindtheorem
T1: A learner with joint measurability gives measurable hypotheses for fixed training data.
```
∀ {X : Type u} [inst : MeasurableSpace X] (L : BatchLearner X Bool) [MeasurableBatchLearner X L] {m : ℕ}
  (S : Fin m → X × Bool), Measurable (L.learn S)
```
BatchLearner BatchLearner.learn LearnEvalMeasurable MeasurableBatchLearner
Uses
- MeasurableBatchLearner.eval_measurable
Used by
- boosted_sample_error_le_of_good_blocks
DeclMeasurableBatchLearner.eval_measurableDeclaration kindtheorem
Joint measurability of the evaluation map
```
∀ {X : Type u} {inst : MeasurableSpace X} {L : BatchLearner X Bool} [self : MeasurableBatchLearner X L] (m : ℕ),
  Measurable fun p => L.learn p.1 p.2
```
BatchLearner BatchLearner.learn MeasurableBatchLearner
Used by
DeclMeasurableHypotheses.mem_measurableDeclaration kindtheorem
```
∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : MeasurableHypotheses X C],
  ∀ h ∈ C, Measurable h
```
ConceptClass FLT.Concept MeasurableHypotheses
Used by
- boost_two_thirds_to_pac
- universal_imp_pac

HypothesishL_meas

∀ (L : BatchLearner X Bool), LearnEvalMeasurable L

Hypothesishul
```
UniversalLearnable X C
```
DefinitionBatchLearnerstructure
A batch learner (PAC paradigm): takes a finite sample, returns a hypothesis.
```
Type u → Type v → Type (max u v)
```

DefinitionBatchLearner.learndef

The learning algorithm: given a sample, produce a hypothesis

{X : Type u} → {Y : Type v} → BatchLearner X Y → {m : ℕ} → (Fin m → X × Y) → Concept X Y

DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```
DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionLearnEvalMeasurabledef
Joint measurability of a batch learner's evaluation map.
```
{X : Type u} → [MeasurableSpace X] → BatchLearner X Bool → Prop
```
DefinitionMeasurableBatchLearnerstructure
A batch learner whose evaluation map is jointly measurable.
The condition: for each sample size m, the map (S, x) ↦ L.learn S x from (Fin m → X × Bool) × X to Bool is Measurable.
This is the minimal regularity that makes the PAC success event {S | D{x | L.learn(S)(x) ≠ c(x)} ≤ ε} a MeasurableSet (via measurable_measure_prod_mk_left).
Equivalent to LearnEvalMeasurable (Separation.lean) and AdviceEvalMeasurable (Extended.lean) for the non-advice case.
```
(X : Type u) → [MeasurableSpace X] → BatchLearner X Bool → Prop
```
DefinitionMeasurableHypothesesstructure
Every concept in C is a measurable function. Krapp-Wirth precondition: Γ(h) ∈ Σ_Z for all h ∈ H.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionPACLearnabledef
PAC (Probably Approximately Correct) learning. The central definition of computational learning theory.
Sample space: Fin m → X with i.i.d. product measure D^m. Labels: derived deterministically from target concept c (realizable case). Error: D-probability of disagreement between learner output and c.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionUniversalLearnabledef
Universal learning: distribution-free convergence rates. Strictly stronger than PAC.
Sample space: Fin m → X with i.i.d. product measure D^m (matching PACLearnable). Labels: derived deterministically from target concept c (realizable case). The rate function converges to 0, and for every m, with probability ≥ 2/3 over D^m, the learner's error is at most rate(m).
Γ₄₈ fix: changed from existential Dm to Measure.pi (CNA₁₁ definition repair).
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
Definitionblock_extractdef
Extract block j from a flat array of k*m elements, using finProdFinEquiv.
```
{α : Type u_1} → (k m : ℕ) → (Fin (k * m) → α) → Fin k → Fin m → α
```
Definitionboosted_majoritydef
Majority vote: returns true iff strictly more than half the votes are true.
```
(k : ℕ) → (Fin k → Bool) → Bool
```

DefinitiongoodBlockEventdef

The event that block j produces a hypothesis with D-error ≤ rate(n).

{X : Type u} →
  [inst : MeasurableSpace X] →
    BatchLearner X Bool → MeasureTheory.Measure X → Concept X Bool → (ℕ → ℝ) → (k n : ℕ) → Fin k → Set (Fin (k * n) → X)

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

The Krapp–Wirth measurable-target separation holds unconditionally: the analytic non-Borel witness discharges the hypothesis of analytic_nonborel_set_gives_measTarget_separation.

DeclkrappWirthSeparationMeasTarget_holds

KrappWirthSeparationMeasTarget

ThesisStepDefinition

DeclkrappWirthSeparationMeasTarget_holdsDeclaration kindtheorem
```
KrappWirthSeparationMeasTarget
```
KrappWirthSeparationMeasTarget
Uses
- MeasureTheory.exists_analyticSet_not_measurableSet_real
- analytic_nonborel_set_gives_measTarget_separation
Declanalytic_nonborel_set_gives_measTarget_separationDeclaration kindtheorem
Main separation theorem. Given any analytic non-Borel set A ⊆ ℝ, the concept class obtained by parameterising singletonConcept (plus zeroConcept) over A is a concrete witness that WellBehavedVCMeasTarget is strictly weaker than the Krapp-Wirth Borel condition. The class is constructed as Set.range e for an evaluation map e : Bool × β → Concept ℝ Bool built from a Polish parameterisation of A; post-construction, Set.range e equals singletonClassOn (Set.range g) where g realises A.
The class satisfies:
- MeasurableHypotheses: every individual hypothesis is Borel (singletonClassOn_measurable).
- WellBehavedVCMeasTarget: the bad event is analytic (planarWitnessEvent_analytic lifted via singleton_badEvent_eq_preimage_planar), hence NullMeasurableSet by the Choquet bridge.
- NOT KrappWirthWellBehaved: the bad event is not Borel (singleton_badEvent_not_measurable).
The separation is realised by passing through the standard Borel space ℝ as the parameter space; the construction reuses no problem-specific fact beyond the existence of an analytic non-Borel subset of ℝ (Souslin's classical result), supplied in exists_measTarget_separation. The witness shows that the measurable-target variant proved in this kernel is a genuine improvement over the existing literature, not a restatement.
```
∀ (A : Set ℝ), MeasureTheory.AnalyticSet A → ¬MeasurableSet A → KrappWirthSeparationMeasTarget
```
ConceptClass EmpiricalError FLT.Concept GhostPairs1 KrappWirthSeparationMeasTarget KrappWirthWellBehaved MeasurableHypotheses WellBehavedVCMeasTarget ghostGapGrid ghostGapSup singletonBadEvent singletonClassOn singletonConcept zeroConcept zeroOneLoss
Uses
Used by
- krappWirthSeparationMeasTarget_holds
Declsingleton_badEvent_not_measurableDeclaration kindtheorem
For A non-Borel, the singleton bad event is non-Borel. Combine singleton_badEvent_eq_preimage_planar with planarWitnessEvent_not_measurable: the preimage of a non-Borel set under a measurable surjection cannot itself be Borel.
```
∀ (A : Set ℝ), ¬MeasurableSet A → ¬MeasurableSet (singletonBadEvent A)
```
GhostPairs1 planarWitnessEvent samplePair1ToPlane singletonBadEvent
Uses
- planarWitnessEvent_not_measurable
- singleton_badEvent_eq_preimage_planar
Used by
- analytic_nonborel_set_gives_measTarget_separation
Declsingleton_badEvent_eq_preimage_planarDeclaration kindtheorem
The singleton bad event equals samplePair1ToPlane ⁻¹' planarWitnessEvent. The set equality that transports both analyticity and non-Borelness from the planar witness to the learning-theoretic bad event.
```
∀ (A : Set ℝ), singletonBadEvent A = samplePair1ToPlane ⁻¹' planarWitnessEvent A
```
EmpiricalError FLT.Concept GhostPairs1 planarWitnessEvent samplePair1ToPlane singletonBadEvent singletonConcept zeroConcept zeroOneLoss
Used by
- singleton_badEvent_not_measurable
DeclplanarWitnessEvent_not_measurableDeclaration kindtheorem
For A non-Borel, planarWitnessEvent A is non-Borel. The proof picks some a ∉ A and shows the vertical section y ↦ (a, y) pulls the planar event back to A itself: if the planar event were Borel, its preimage under this measurable map would be Borel too, contradicting the hypothesis on A.
```
∀ (A : Set ℝ), ¬MeasurableSet A → ¬MeasurableSet (planarWitnessEvent A)
```
planarWitnessEvent
Used by
- singleton_badEvent_not_measurable
DecloneSidedGhostGap_mem_gridDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (h c : Concept X Bool) (m : ℕ) (p : (Fin m → X) × (Fin m → X)),
  oneSidedGhostGap h c m p ∈ ghostGapGrid m
```
EmpiricalError FLT.Concept empErrGrid ghostGapGrid oneSidedGhostGap zeroOneLoss
Uses
- empiricalError_mem_empErrGrid
Used by
- analytic_nonborel_set_gives_measTarget_separation

DeclempiricalError_mem_empErrGridDeclaration kindtheorem

∀ {X : Type u} [MeasurableSpace X] (h : Concept X Bool) {m : ℕ} (S : Fin m → X × Bool),
  EmpiricalError X Bool h S (zeroOneLoss Bool) ∈ empErrGrid m

EmpiricalError FLT.Concept empErrGrid zeroOneLoss

Used by

oneSidedGhostGap_mem_grid

Declborel_param_wellBehavedVCMeasTargetDeclaration kindtheorem
Class-level corollary: every Borel-parameterized concept class with a measurable evaluation map satisfies WellBehavedVCMeasTarget. Composes borel_param_nullMeasurableSet_bad_event over all measurable targets c. The measurable-target variant of WellBehavedVC is what the kernel actually proves; the unrestricted variant remains open and is the subject of the Borel-analytic separation witness in Theorem/BorelAnalyticSeparation.lean.
```
∀ {X : Type u} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [PolishSpace X] [BorelSpace X] {Θ : Type u_1}
  [inst_4 : MeasurableSpace Θ] [StandardBorelSpace Θ] (e : Θ → Concept X Bool),
  (Measurable fun p => e p.1 p.2) → WellBehavedVCMeasTarget X (Set.range e)
```
ConceptClass EmpiricalError FLT.Concept GhostPairs WellBehavedVCMeasTarget paramBadEvent zeroOneLoss
Uses
- borel_param_nullMeasurableSet_bad_event
Used by
- analytic_nonborel_set_gives_measTarget_separation
Declborel_param_nullMeasurableSet_bad_eventDeclaration kindtheorem
Positive bridge. If a concept class is parameterized by a Borel measurable map Θ → Concept X from a standard Borel space Θ, then the symmetrization bad event is analytic, hence NullMeasurableSet. The bad event is a Suslin projection of a Borel witness set (the projection along Θ of {(θ, p) | gap(eval θ, p) ≥ ε / 2}), and projections of Borel sets are analytic by definition. This is the entry point through which Borel parameterization implies the regularity required by the fundamental theorem.
```
∀ {X : Type u} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [PolishSpace X] [BorelSpace X] {Θ : Type u_1}
  [inst_4 : MeasurableSpace Θ] [StandardBorelSpace Θ] (e : Θ → Concept X Bool),
  (Measurable fun p => e p.1 p.2) →
    ∀ (c : Concept X Bool),
      Measurable c →
        ∀ (m : ℕ) (ε : ℝ) (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D],
          MeasureTheory.NullMeasurableSet (paramBadEvent e c m ε) (GhostPairMeasure D m)
```
FLT.Concept GhostPairMeasure GhostPairs paramBadEvent
Uses
- analyticSet_nullMeasurableSet_ghostPairs
- borel_param_badEvent_analytic
Used by
- borel_param_wellBehavedVCMeasTarget
Declborel_param_badEvent_analyticDeclaration kindtheorem
The bad event (projection of witness set) is analytic. Projection of a Borel set from a StandardBorelSpace is analytic (Suslin). This is the key step: existential quantification over parameters produces an analytic (Σ₁¹) set, which may not be Borel.
```
∀ {X : Type u} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] [BorelSpace X] [PolishSpace X] {Θ : Type u_1}
  [inst_4 : MeasurableSpace Θ] [StandardBorelSpace Θ] (e : Θ → Concept X Bool),
  (Measurable fun p => e p.1 p.2) →
    ∀ (c : Concept X Bool), Measurable c → ∀ (m : ℕ) (ε : ℝ), MeasureTheory.AnalyticSet (paramBadEvent e c m ε)
```
FLT.Concept GhostPairs paramBadEvent paramWitnessSet
Uses
- paramWitnessSet_measurable
Used by
- borel_param_nullMeasurableSet_bad_event
DeclparamWitnessSet_measurableDeclaration kindtheorem
The witness set {(θ, p) | ghost-gap ≥ ε/2} is MeasurableSet when the evaluation map e and target c are measurable. This is the Borel half of the Borel-analytic bridge.
```
∀ {X : Type u} [inst : MeasurableSpace X] {Θ : Type u_1} [inst_1 : MeasurableSpace Θ] (e : Θ → Concept X Bool),
  (Measurable fun p => e p.1 p.2) →
    ∀ (c : Concept X Bool), Measurable c → ∀ (m : ℕ) (ε : ℝ), MeasurableSet (paramWitnessSet e c m ε)
```
EmpiricalError FLT.Concept GhostPairs paramWitnessSet zeroOneLoss
Used by
- borel_param_badEvent_analytic
DeclanalyticSet_nullMeasurableSet_ghostPairsDeclaration kindtheorem
Analytic subsets of the ghost sample space (Fin m → X) × (Fin m → X) are NullMeasurableSet under the product probability measure. A specialisation of analyticSet_nullMeasurableSet from PureMath/AnalyticMeasurability.lean to the type the symmetrization argument actually consumes.
```
∀ {X : Type u} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] [BorelSpace X] [PolishSpace X] {m : ℕ}
  {s : Set ((Fin m → X) × (Fin m → X))},
  MeasureTheory.AnalyticSet s →
    ∀ (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D],
      MeasureTheory.NullMeasurableSet s (GhostPairMeasure D m)
```
GhostPairMeasure
Uses
- analyticSet_nullMeasurableSet
Used by
- borel_param_nullMeasurableSet_bad_event
DeclanalyticSet_nullMeasurableSetDeclaration kindtheorem
Analytic sets are null-measurable for finite Borel measures on Polish spaces. FLT-facing alias of the ZPM-canonical MeasureTheory.AnalyticSet.nullMeasurableSet.
```
∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] [PolishSpace α]
  {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] {s : Set α},
  MeasureTheory.AnalyticSet s → MeasureTheory.NullMeasurableSet s μ
```
Uses
- MeasureTheory.AnalyticSet.nullMeasurableSet
Used by
- analyticSet_nullMeasurableSet_ghostPairs
DeclMeasureTheory.AnalyticSet.nullMeasurableSetDeclaration kindtheorem
Analytic sets are null-measurable. For any finite Borel measure on a Polish space, every analytic set is NullMeasurableSet. Proof inner- approximates the analytic set by compacts, takes the union of approximators (a Borel set), and shows the difference is contained in a Borel null set.
This is the abstract bridge that the entire Borel-analytic measurability layer of downstream learning-theory kernels rests on.
```
∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] [PolishSpace α]
  {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] {s : Set α},
  MeasureTheory.AnalyticSet s → MeasureTheory.NullMeasurableSet s μ
```
Uses
- MeasureTheory.AnalyticSet.exists_isCompact_measureReal_gt
Used by
- analyticSet_nullMeasurableSet
DeclMeasureTheory.AnalyticSet.exists_isCompact_measureReal_gtDeclaration kindtheorem
Inner regularity for analytic sets: any analytic subset of a Polish space can be approximated from inside by a compact subset in measure, by any slack ε > 0. Specialisation of Choquet capacitability (Kechris 30.13) to the measure-as-capacity instance.
```
∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] [PolishSpace α]
 {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] {s : Set α},
 MeasureTheory.AnalyticSet s → ∀ ε > 0, ∃ K, IsCompact K ∧ K ⊆ s ∧ μ.real s < μ.real K + ε
```
MeasureTheory.compactCap
Uses
- MeasureTheory.AnalyticSet.compactCap_eq
Used by
- MeasureTheory.AnalyticSet.nullMeasurableSet
DeclMeasureTheory.AnalyticSet.compactCap_eqDeclaration kindtheorem
For analytic sets, compact capacity equals measure.
```
∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] [PolishSpace α]
  {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] {s : Set α},
  MeasureTheory.AnalyticSet s → MeasureTheory.compactCap μ s = μ s
```
MeasureTheory.compactCap
Uses
Used by
- MeasureTheory.AnalyticSet.exists_isCompact_measureReal_gt

DeclcompactCap_eq_iSup_isCompactDeclaration kindtheorem

∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] (μ : MeasureTheory.Measure α) (s : Set α),
  MeasureTheory.compactCap μ s = ⨆ K, ⨆ (_ : IsCompact K), ⨆ (_ : K ⊆ s), μ K

MeasureTheory.compactCap

Used by

MeasureTheory.AnalyticSet.compactCap_eq

DeclMeasureTheory.measure_isChoquetCapacityDeclaration kindtheorem

Every finite Borel measure on a Polish space is a Choquet capacity.

∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] [PolishSpace α]
  (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ], MeasureTheory.IsChoquetCapacity fun s => μ s

MeasureTheory.IsChoquetCapacity

Used by

MeasureTheory.AnalyticSet.compactCap_eq

DeclMeasureTheory.AnalyticSet.cap_eq_iSup_isCompactDeclaration kindtheorem
Choquet capacitability. For analytic sets, capacity equals the supremum over compact subsets (Kechris 30.13).
```
∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] [PolishSpace α]
  {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap →
    ∀ {s : Set α}, MeasureTheory.AnalyticSet s → cap s = ⨆ K, ⨆ (_ : IsCompact K), ⨆ (_ : K ⊆ s), cap K
```
Bnd Cyl MeasureTheory.IsChoquetCapacity
Uses
Used by
- MeasureTheory.AnalyticSet.compactCap_eq
Declmonotone_cyl_splitDeclaration kindtheorem
```
∀ (N : ℕ → ℕ) (n : ℕ), Monotone fun k => Cyl N n ∩ {g | g (n + 1) ≤ k}
```
Cyl
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact
DecliInter_closure_image_cyl_eqDeclaration kindtheorem
The intersection of closures of cylinder images equals the compact image. Key lemma for the capacitability proof: uses truncation and sequential compactness.
```
∀ {α : Type u_1} [inst : TopologicalSpace α] [PolishSpace α] {f : (ℕ → ℕ) → α},
  Continuous f → ∀ (N : ℕ → ℕ), ⋂ n, closure (f '' Cyl N n) = f '' Bnd N
```
Bnd Cyl choquetTruncate
Uses
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact
Decltruncate_mem_bndDeclaration kindtheorem
```
∀ (N g : ℕ → ℕ), choquetTruncate N g ∈ Bnd N
```
Bnd choquetTruncate
Used by
- iInter_closure_image_cyl_eq
Decltruncate_agree_on_cylDeclaration kindtheorem
```
∀ (N : ℕ → ℕ) (n : ℕ), ∀ g ∈ Cyl N n, ∀ i ≤ n, choquetTruncate N g i = g i
```
Cyl choquetTruncate
Used by
- iInter_closure_image_cyl_eq
DeclisCompact_bndDeclaration kindtheorem
```
∀ (N : ℕ → ℕ), IsCompact (Bnd N)
```
Bnd
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact
- iInter_closure_image_cyl_eq
Declbnd_subset_cylDeclaration kindtheorem
```
∀ (N : ℕ → ℕ) (n : ℕ), Bnd N ⊆ Cyl N n
```
Bnd Cyl
Used by
- iInter_closure_image_cyl_eq
Declcyl_succ_eqDeclaration kindtheorem
```
∀ (N : ℕ → ℕ) (n : ℕ), Cyl N n = ⋃ k, Cyl N n ∩ {g | g (n + 1) ≤ k}
```
Cyl
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

Declcyl_inter_eq_cyl_updateDeclaration kindtheorem

∀ (N : ℕ → ℕ) (n k : ℕ), Cyl N n ∩ {g | g (n + 1) ≤ k} = Cyl (Function.update N (n + 1) k) (n + 1)

Cyl

Used by

MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

Declcyl_extDeclaration kindtheorem
```
∀ (N N' : ℕ → ℕ) (n : ℕ), (∀ i ≤ n, N i = N' i) → Cyl N n = Cyl N' n
```
Cyl
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

DeclMeasureTheory.IsChoquetCapacity.monoDeclaration kindtheorem

∀ {α : Type u_1} [inst : TopologicalSpace α] {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap → ∀ {s t : Set α}, s ⊆ t → cap s ≤ cap t

MeasureTheory.IsChoquetCapacity

Used by

MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

DeclMeasureTheory.IsChoquetCapacity.iUnion_natDeclaration kindtheorem

∀ {α : Type u_1} [inst : TopologicalSpace α] {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap → ∀ (f : ℕ → Set α), Monotone f → cap (⋃ n, f n) = ⨆ n, cap (f n)

MeasureTheory.IsChoquetCapacity

Used by

MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

DeclMeasureTheory.IsChoquetCapacity.iInter_closedDeclaration kindtheorem

∀ {α : Type u_1} [inst : TopologicalSpace α] {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap →
    ∀ (f : ℕ → Set α), Antitone f → (∀ (n : ℕ), IsClosed (f n)) → cap (⋂ n, f n) = ⨅ n, cap (f n)

MeasureTheory.IsChoquetCapacity

Used by

MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

DeclKrappWirthWellBehaved.V_measurableDeclaration kindtheorem
```
∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : KrappWirthWellBehaved X C], KrappWirthV X C
```
ConceptClass KrappWirthV KrappWirthWellBehaved
Used by
- analytic_nonborel_set_gives_measTarget_separation
DeclMeasureTheory.exists_analyticSet_not_measurableSet_realDeclaration kindtheorem
An analytic non-Borel subset of ℝ: the image of the Baire-space witness under the continuous injection. Analyticity transfers along the continuous image; non-Borelness transfers back along the injective preimage.
```
∃ A, MeasureTheory.AnalyticSet A ∧ ¬MeasurableSet A
```
MeasureTheory.embedBaireReal
Uses
Used by
- krappWirthSeparationMeasTarget_holds
DeclMeasureTheory.exists_analyticSet_not_measurableSetDeclaration kindtheorem
An analytic non-Borel subset of Baire space: the projection of the diagonal witness.
```
∃ A, MeasureTheory.AnalyticSet A ∧ ¬MeasurableSet A
```
Uses
- MeasureTheory.exists_closed_proj_not_measurableSet
Used by
- MeasureTheory.exists_analyticSet_not_measurableSet_real
DeclMeasureTheory.exists_closed_proj_not_measurableSetDeclaration kindtheorem
A closed set with a non-Borel projection. Diagonalize the universal closed set of (ℕ → ℕ) × (ℕ → ℕ): were the projection Borel, its complement would be analytic, hence the projection of a closed set, hence a section of the universal set — and evaluating that section at its own parameter is contradictory.
```
∃ D, IsClosed D ∧ ¬MeasurableSet {x | ∃ y, (x, y) ∈ D}
```
Uses
- MeasureTheory.exists_closed_universal_sections
Used by
- MeasureTheory.exists_analyticSet_not_measurableSet
DeclMeasureTheory.exists_closed_universal_sectionsDeclaration kindtheorem
A universal closed set. Every second-countable space X carries a closed subset of X × (ℕ → ℕ) whose sections run through all closed subsets of X: enumerate a countable basis together with ∅, and let the parameter select which basis elements to exclude.
```
∀ (X : Type u_1) [inst : TopologicalSpace X] [SecondCountableTopology X],
  ∃ S, IsClosed S ∧ ∀ (C : Set X), IsClosed C → ∃ y, {x | (x, y) ∈ S} = C
```
Used by
- MeasureTheory.exists_closed_proj_not_measurableSet
DeclMeasureTheory.embedBaireReal_injectiveDeclaration kindtheorem
```
Function.Injective MeasureTheory.embedBaireReal
```
MeasureTheory.baireMarkerBits MeasureTheory.embedBaireReal
Uses
- MeasureTheory.baireMarkerBits_injective
Used by
- MeasureTheory.exists_analyticSet_not_measurableSet_real
DeclMeasureTheory.baireMarkerBits_injectiveDeclaration kindtheorem
```
Function.Injective MeasureTheory.baireMarkerBits
```
MeasureTheory.baireMarkerBits MeasureTheory.baireMarkers
Uses
- MeasureTheory.baireMarkers_strictMono
Used by
- MeasureTheory.embedBaireReal_injective
DeclMeasureTheory.baireMarkers_strictMonoDeclaration kindtheorem
```
∀ (x : ℕ → ℕ), StrictMono (MeasureTheory.baireMarkers x)
```
MeasureTheory.baireMarkers
Used by
- MeasureTheory.baireMarkerBits_injective
DeclMeasureTheory.continuous_embedBaireRealDeclaration kindtheorem
```
Continuous MeasureTheory.embedBaireReal
```
MeasureTheory.baireMarkerBits MeasureTheory.embedBaireReal
Uses
- MeasureTheory.continuous_baireMarkerBits
- MeasureTheory.continuous_cantorFunction_oneThird
Used by
- MeasureTheory.exists_analyticSet_not_measurableSet_real
DeclMeasureTheory.continuous_cantorFunction_oneThirdDeclaration kindtheorem
```
Continuous (Cardinal.cantorFunction (1 / 3))
```
Used by
- MeasureTheory.continuous_embedBaireReal
DeclMeasureTheory.continuous_baireMarkerBitsDeclaration kindtheorem
```
Continuous MeasureTheory.baireMarkerBits
```
MeasureTheory.baireMarkerBits MeasureTheory.baireMarkers
Used by
- MeasureTheory.continuous_embedBaireReal
DefinitionBnddef
Bounded functions set: {g : ℕ → ℕ | ∀ i, g i ≤ N i}.
```
(ℕ → ℕ) → Set (ℕ → ℕ)
```
DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```
DefinitionCyldef
Cylinder set: {g : ℕ → ℕ | ∀ i ≤ n, g i ≤ N i}.
```
(ℕ → ℕ) → ℕ → Set (ℕ → ℕ)
```

DefinitionEmpiricalErrordef

Empirical error: average loss on a finite sample.

(X : Type u) → (Y : Type v) → Concept X Y → {m : ℕ} → (Fin m → X × Y) → LossFunction Y → ℝ

DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```

DefinitionGhostPairMeasuredef

{X : Type u} →
  [inst : MeasurableSpace X] → MeasureTheory.Measure X → (m : ℕ) → MeasureTheory.Measure ((Fin m → X) × (Fin m → X))

DefinitionGhostPairsdef
Ghost sample pairs: two independent samples of size m.
```
Type u → ℕ → Type u
```
DefinitionGhostPairs1def
The ghost sample space at sample size m = 1: (Fin 1 → ℝ) × (Fin 1 → ℝ). The smallest sample size at which the singleton-class obstruction is already visible.
```
Type
```
DefinitionKrappWirthSeparationMeasTargetdef
OPEN QUESTION (measurable-target version): Does WellBehavedVCMeasTarget separate from KrappWirthWellBehaved? The Borel-analytic bridge (BorelAnalyticBridge.lean) closes this.
```
Prop
```
DefinitionKrappWirthVdef
V-measurability (one-sided): the ghost gap sup map is measurable.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionKrappWirthWellBehavedstructure
Krapp-Wirth well-behavedness: measurable hypotheses + V + U. Extends MeasurableHypotheses (L1). Strictly stronger than MeasurableConceptClass (our condition).
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionMeasurableHypothesesstructure
Every concept in C is a measurable function. Krapp-Wirth precondition: Γ(h) ∈ Σ_Z for all h ∈ H.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionMeasureTheory.IsChoquetCapacitystructure
Bundled record of the three Choquet capacity axioms: monotonicity, sequential continuity from below along increasing unions, and sequential continuity from above along decreasing intersections of closed sets. The third axiom distinguishes a capacity from a general outer measure.
```
{α : Type u_1} → [TopologicalSpace α] → (Set α → ENNReal) → Prop
```
DefinitionMeasureTheory.baireMarkerBitsdef
The marker bits: the indicator stream of the marker set.
```
(ℕ → ℕ) → ℕ → Bool
```
DefinitionMeasureTheory.baireMarkersdef
The marker sequence of x : ℕ → ℕ: the strictly increasing sequence n + 1 + ∑_{k ≤ n} x k, whose successive gaps encode x.
```
(ℕ → ℕ) → ℕ → ℕ
```
DefinitionMeasureTheory.compactCapdef
Compact capacity of a set s relative to a measure μ: the supremum of μ K over compact subsets K ⊆ s. The inner-regularity functional whose equality with μ s characterises measurability for analytic sets.
```
{α : Type u_1} → [TopologicalSpace α] → [inst : MeasurableSpace α] → MeasureTheory.Measure α → Set α → ENNReal
```
DefinitionMeasureTheory.embedBaireRealdef
The embedding of Baire space into ℝ: marker bits into the base-3 expansion.
```
(ℕ → ℕ) → ℝ
```
DefinitionWellBehavedVCMeasTargetdef
WellBehavedVC restricted to measurable targets. This is the correct target for the Borel-analytic positive bridge: Borel parameterization ⇒ analytic bad event ⇒ NullMeasurableSet, but only when c is measurable (so the ghost-gap map is measurable).
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionchoquetTruncatedef
Truncation: replace g i by min (g i) (N i) to bring any g into the bounded set.
```
(ℕ → ℕ) → (ℕ → ℕ) → ℕ → ℕ
```
DefinitionempErrGriddef
```
ℕ → Finset ℝ
```
DefinitionghostGapGriddef
```
ℕ → Finset ℝ
```

DefinitionghostGapSupdef

{X : Type u} → [MeasurableSpace X] → ConceptClass X Bool → Concept X Bool → (m : ℕ) → (Fin m → X) × (Fin m → X) → ℝ

DefinitiononeSidedGhostGapdef

{X : Type u} → [MeasurableSpace X] → Concept X Bool → Concept X Bool → (m : ℕ) → (Fin m → X) × (Fin m → X) → ℝ

DefinitionparamBadEventdef
The bad event in sample space: projection of the witness set. Existential over the parameter: {p | ∃ θ, gap(θ, p) ≥ ε/2}. This is analytic when the witness set is Borel (Theorem B).
```
{X : Type u} →
  [MeasurableSpace X] →
    {Θ : Type u_1} → [MeasurableSpace Θ] → (Θ → Concept X Bool) → Concept X Bool → (m : ℕ) → ℝ → Set (GhostPairs X m)
```
DefinitionparamWitnessSetdef
The witness set in parameter × sample space: {(θ, p) | EmpErr(h_θ, ghost, c) - EmpErr(h_θ, train, c) ≥ ε/2}. This is Borel when e and c are measurable (Theorem A).
```
{X : Type u} →
  [MeasurableSpace X] →
    {Θ : Type u_1} →
      [MeasurableSpace Θ] → (Θ → Concept X Bool) → Concept X Bool → (m : ℕ) → ℝ → Set (Θ × GhostPairs X m)
```
DefinitionplanarWitnessEventdef
The planar witness {(x, y) ∈ ℝ × ℝ | y ∈ A ∧ x ≠ y}. For A analytic non-Borel, this set is itself analytic non-Borel. The geometric core of the separation: the learning-theoretic bad event below is a measurable preimage of this planar set.
```
Set ℝ → Set (ℝ × ℝ)
```
DefinitionsamplePair1ToPlanedef
The projection GhostPairs1 → ℝ × ℝ, p ↦ (p.1 0, p.2 0). Surjective and measurable; non-Borelness of a target set transfers to non-Borelness of its preimage under a measurable surjection.
```
GhostPairs1 → ℝ × ℝ
```
DefinitionsingletonBadEventdef
The symmetrization bad event for the singleton class at sample size m = 1, target concept zeroConcept, and threshold 1/2. Equals the preimage of planarWitnessEvent under samplePair1ToPlane (see singleton_badEvent_eq_preimage_planar), and inherits both analyticity and non-Borelness from the planar set when A is analytic non-Borel.
```
Set ℝ → Set GhostPairs1
```
DefinitionsingletonClassOndef
The singleton class over A ⊆ ℝ: {zeroConcept} ∪ {singletonConcept a | a ∈ A}. The zeroConcept disjunct is the target concept against which the symmetrization bad event is measured. For A analytic non-Borel, this is the witness used to separate WellBehavedVCMeasTarget from the Krapp-Wirth Borel condition.
```
Set ℝ → ConceptClass ℝ Bool
```
DefinitionsingletonConceptdef
The point indicator singletonConcept a x = (x = a). Each singletonConcept a is itself Borel measurable; non-Borelness in the singleton-class witness comes from quantifying over a ∈ A for A analytic non-Borel, not from any individual concept.
```
ℝ → Concept ℝ Bool
```
DefinitionzeroConceptdef
The constantly false concept. The base hypothesis of the singleton class, serving both as the target concept and as the zeroConcept disjunct of singletonClassOn.
```
Concept ℝ Bool
```
DefinitionzeroOneLossdef
The 0-1 loss for classification.
```
(Y : Type v) → [DecidableEq Y] → LossFunction Y
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

The Ambainis composition lock, at every depth: the product partition of the (d+1)-fold Ambainis iterate — the construction giving the multiplicative upper bound on the partition number — is not the leaf partition of any deterministic protocol, for every depth d. Index 0 is the base partition itself (a kernel-checked eight-rectangle monochromatic partition of the base game); index 1 is the 64-rectangle object of the depth-two frontier.

DeclKWLock.ambainis_tower_locked

∀ (d : ℕ),
  ¬∃ t,
      KWLock.Realizes (KWLock.onesOf (KWLock.Fd 4 KWLock.fA (d + 1))) (KWLock.zerosOf (KWLock.Fd 4 KWLock.fA (d + 1)))
        (KWLock.towerP 4 KWLock.fA KWLock.pA d) t

ThesisStepDefinition

DeclKWLock.ambainis_tower_lockedDeclaration kindtheorem
```
∀ (d : ℕ),
  ¬∃ t,
      KWLock.Realizes (KWLock.onesOf (KWLock.Fd 4 KWLock.fA (d + 1))) (KWLock.zerosOf (KWLock.Fd 4 KWLock.fA (d + 1)))
        (KWLock.towerP 4 KWLock.fA KWLock.pA d) t
```
KWLock.Fd KWLock.Lab KWLock.Protocol KWLock.Realizes KWLock.Sp KWLock.fA KWLock.instDecidableEqSp KWLock.instFintypeSp KWLock.onesOf KWLock.pA KWLock.towerP KWLock.zerosOf
Uses
- KWLock.ambainis_towerHyp
- KWLock.tower_not_protocolizable
DeclKWLock.tower_not_protocolizableDeclaration kindtheorem
The composition lock. Under the base hypotheses, the product partition of the (d+1)-fold iterate is not the leaf partition of any deterministic protocol, for every depth.
```
∀ (k : ℕ) (f : (Fin k → Bool) → Bool) (P₀ : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))),
  KWLock.TowerHyp k f P₀ →
    ∀ (d : ℕ),
      ¬∃ t,
          KWLock.Realizes (KWLock.onesOf (KWLock.Fd k f (d + 1))) (KWLock.zerosOf (KWLock.Fd k f (d + 1)))
            (KWLock.towerP k f P₀ d) t
```
KWLock.ColConnected KWLock.Fd KWLock.IsPartition KWLock.KRect KWLock.Lab KWLock.MonoValid KWLock.Protocol KWLock.Realizes KWLock.RowConnected KWLock.Sp KWLock.TowerHyp KWLock.instDecidableEqSp KWLock.instFintypeSp KWLock.onesOf KWLock.towerP KWLock.vval KWLock.zerosOf
Uses
Used by
- KWLock.ambainis_tower_locked
DeclKWLock.tower_goodDeclaration kindtheorem
Everything transfers up the tower: at every depth the product partition is a valid, monochromatic partition of the iterate's game, with both overlap graphs connected and two distinct members.
```
∀ (k : ℕ) (f : (Fin k → Bool) → Bool) (P₀ : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))),
  KWLock.TowerHyp k f P₀ →
    ∀ (d : ℕ),
      KWLock.IsPartition (KWLock.onesOf (KWLock.Fd k f (d + 1))) (KWLock.zerosOf (KWLock.Fd k f (d + 1)))
          (KWLock.towerP k f P₀ d) ∧
        KWLock.MonoValid (KWLock.vval k d) (KWLock.vval k d) (KWLock.towerP k f P₀ d) ∧
          KWLock.RowConnected (KWLock.towerP k f P₀ d) ∧
            KWLock.ColConnected (KWLock.towerP k f P₀ d) ∧
              ∃ r ∈ KWLock.towerP k f P₀ d, ∃ s ∈ KWLock.towerP k f P₀ d, r ≠ s
```
KWLock.ColConnected KWLock.Fd KWLock.IsPartition KWLock.KRect KWLock.Lab KWLock.MonoValid KWLock.RowConnected KWLock.Sp KWLock.TowerHyp KWLock.compFun KWLock.compPartition KWLock.instDecidableEqSp KWLock.instFintypeSp KWLock.onesOf KWLock.towerP KWLock.vval KWLock.zerosOf
Uses
Used by
- KWLock.tower_not_protocolizable
DeclKWLock.zerosOf_congrDeclaration kindtheorem
Pointwise-equal Boolean functions have equal zeros.
```
∀ {α : Type} [inst : Fintype α] {h₁ h₂ : α → Bool}, (∀ (x : α), h₁ x = h₂ x) → KWLock.zerosOf h₁ = KWLock.zerosOf h₂
```
KWLock.zerosOf
Uses
- KWLock.mem_zerosOf
Used by
- KWLock.tower_good
DeclKWLock.onesOf_congrDeclaration kindtheorem
Pointwise-equal Boolean functions have equal ones.
```
∀ {α : Type} [inst : Fintype α] {h₁ h₂ : α → Bool}, (∀ (x : α), h₁ x = h₂ x) → KWLock.onesOf h₁ = KWLock.onesOf h₂
```
KWLock.onesOf
Uses
- KWLock.mem_onesOf
Used by
- KWLock.tower_good

DeclKWLock.comp_rowConnectedDeclaration kindtheorem

The connectivity transfer, rows. Outer connectivity plus block connectivity (both graphs of every block partition) yields row connectivity of the product.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) (f : (Fin k → Bool) → Bool)
  {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.IsPartition (KWLock.onesOf f) (KWLock.zerosOf f) Po →
      KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
        (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
          KWLock.RowConnected Po →
            (∀ (i : Fin k), KWLock.RowConnected (Q i)) →
              (∀ (i : Fin k), KWLock.ColConnected (Q i)) → KWLock.RowConnected (KWLock.compPartition g Po Q)

KWLock.ColConnected KWLock.IsPartition KWLock.KRect KWLock.KRect.label KWLock.MonoValid KWLock.RowConnected KWLock.RowTouch KWLock.TStep KWLock.compPartition KWLock.compRect KWLock.onesOf KWLock.zerosOf

Uses

KWLock.cluster_linked_row
KWLock.comp_Q_ne_nil
KWLock.cross_step_row
KWLock.linked_all_mem
KWLock.mem_compPartition

Used by

KWLock.tower_good

DeclKWLock.cross_step_rowDeclaration kindtheorem

The hop. Outer rectangles sharing a row yield touching composed rectangles: directly across distinct blocks, and through a common block rectangle when the blocks coincide (in which case the shared pattern forces equal orientations).

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
      (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
        (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
          ∀ {Ro So : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)},
            Ro ∈ Po →
              So ∈ Po →
                KWLock.RowTouch Ro So →
                  ∀ {q : KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label)},
                    q ∈ Q Ro.label → ∃ p ∈ Q So.label, KWLock.RowTouch (KWLock.compRect g Ro q) (KWLock.compRect g So p)

KWLock.IsPartition KWLock.KRect KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.MonoValid KWLock.RowTouch KWLock.blockPat KWLock.compRect KWLock.onesOf KWLock.rowSideSel KWLock.zerosOf

Uses

KWLock.IsPartition.contained
KWLock.IsPartition.nonempty
KWLock.comp_Q_ne_nil
KWLock.exists_point
KWLock.exists_point₂
KWLock.mem_rows_compRect
KWLock.rowSideSel_nonempty
KWLock.rowSideSel_val

Used by

KWLock.comp_rowConnected

DeclKWLock.cluster_linked_rowDeclaration kindtheorem

Within one outer rectangle, composed rectangles over linked block rectangles are linked: the cluster inherits the block partition's row graph in the standard orientation and its column graph in the reversed one.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) (f : (Fin k → Bool) → Bool)
  {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.IsPartition (KWLock.onesOf f) (KWLock.zerosOf f) Po →
      KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
        (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
          (∀ (i : Fin k), KWLock.RowConnected (Q i)) →
            (∀ (i : Fin k), KWLock.ColConnected (Q i)) →
              ∀ {Ro : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)},
                Ro ∈ Po →
                  ∀ {q q' : KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label)},
                    q ∈ Q Ro.label →
                      q' ∈ Q Ro.label →
                        Relation.ReflTransGen (KWLock.TStep KWLock.RowTouch (KWLock.compPartition g Po Q))
                          (KWLock.compRect g Ro q) (KWLock.compRect g Ro q')

KWLock.ColConnected KWLock.ColTouch KWLock.IsPartition KWLock.KRect KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.MonoValid KWLock.RowConnected KWLock.RowTouch KWLock.TStep KWLock.compPartition KWLock.compRect KWLock.onesOf KWLock.rowSideSel KWLock.zerosOf

Uses

KWLock.IsPartition.nonempty
KWLock.comp_rowTouch_same
KWLock.linked_all_mem
KWLock.mem_compPartition

Used by

KWLock.comp_rowConnected

DeclKWLock.comp_rowTouch_sameDeclaration kindtheorem

Same-outer composed rectangles sharing a side value share a row.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
      (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
        ∀ {Ro : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)},
          Ro ∈ Po →
            Ro.rows.Nonempty →
              ∀ {q q' : KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label)},
                q ∈ Q Ro.label →
                  ∀ {v₀ : V Ro.label},
                    v₀ ∈ KWLock.rowSideSel Ro.orient q →
                      v₀ ∈ KWLock.rowSideSel Ro.orient q' →
                        KWLock.RowTouch (KWLock.compRect g Ro q) (KWLock.compRect g Ro q')

Uses

KWLock.IsPartition.contained
KWLock.exists_point
KWLock.mem_rows_compRect
KWLock.rowSideSel_val

Used by

KWLock.cluster_linked_row

DeclKWLock.comp_monoValidDeclaration kindtheorem

Labels transfer. The composed partition is monochromatic at its physical coordinates, under the composed valuation.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))} (vκ : (i : Fin k) → V i → κ i → Bool),
  (∀ (i : Fin k), KWLock.MonoValid (vκ i) (vκ i) (Q i)) →
    KWLock.MonoValid (fun w s => vκ s.fst (w s.fst) s.snd) (fun w s => vκ s.fst (w s.fst) s.snd)
      (KWLock.compPartition g Po Q)

KWLock.KRect KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.MonoValid KWLock.blockPat KWLock.colSideSel KWLock.compPartition KWLock.compRect KWLock.rowSideSel

Uses

KWLock.mem_cols_compRect
KWLock.mem_compPartition
KWLock.mem_rows_compRect

Used by

KWLock.tower_good

DeclKWLock.comp_distinctDeclaration kindtheorem

Distinctness transfers: children of two distinct outer rectangles are distinct, because their cells are nonempty and outer-disjoint.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) (f : (Fin k → Bool) → Bool)
  {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.IsPartition (KWLock.onesOf f) (KWLock.zerosOf f) Po →
      KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
        (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
          (∃ r ∈ Po, ∃ s ∈ Po, r ≠ s) → ∃ r ∈ KWLock.compPartition g Po Q, ∃ s ∈ KWLock.compPartition g Po Q, r ≠ s

KWLock.IsPartition KWLock.KRect KWLock.KRect.Cell KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.MonoValid KWLock.blockPat KWLock.colSideSel KWLock.compFun KWLock.compPartition KWLock.compRect KWLock.onesOf KWLock.rowSideSel KWLock.zerosOf

Uses

KWLock.IsPartition.disjoint
KWLock.IsPartition.nonempty
KWLock.comp_Q_ne_nil
KWLock.comp_isPartition
KWLock.mem_cols_compRect
KWLock.mem_compPartition
KWLock.mem_rows_compRect
KWLock.pairwise_disjoint_of_ne

Used by

KWLock.tower_good

DeclKWLock.pairwise_disjoint_of_neDeclaration kindtheorem

Extract pairwise cell-disjointness for two distinct members.

∀ {X Y ι : Type} {P : List (KWLock.KRect X Y ι)},
  List.Pairwise (fun r s => ∀ (x : X) (y : Y), ¬(r.Cell x y ∧ s.Cell x y)) P →
    ∀ {r s : KWLock.KRect X Y ι}, r ∈ P → s ∈ P → r ≠ s → ∀ (x : X) (y : Y), ¬(r.Cell x y ∧ s.Cell x y)

KWLock.KRect KWLock.KRect.Cell

Used by

KWLock.comp_distinct

DeclKWLock.comp_isPartitionDeclaration kindtheorem
Validity transfers. The product of a valid labeled outer partition with valid block partitions is a valid partition of the composed game.
```
∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) (f : (Fin k → Bool) → Bool)
  {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  KWLock.IsPartition (KWLock.onesOf f) (KWLock.zerosOf f) Po →
    KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
      (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
        (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
          KWLock.IsPartition (KWLock.onesOf (KWLock.compFun g f)) (KWLock.zerosOf (KWLock.compFun g f))
            (KWLock.compPartition g Po Q)
```
KWLock.IsPartition KWLock.KRect KWLock.KRect.Cell KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.MonoValid KWLock.blockPat KWLock.colSideSel KWLock.compFun KWLock.compPartition KWLock.compRect KWLock.onesOf KWLock.rowSideSel KWLock.zerosOf
Uses
Used by
- KWLock.comp_distinct
- KWLock.tower_good
DeclKWLock.rowSideSel_valDeclaration kindtheorem
A value on the row side of a block rectangle evaluates, under the block function, to the orientation — provided the block partition is contained in its game.
```
∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → Fintype (V i)] {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool)
  {a : Fin k} {q : KWLock.KRect (V a) (V a) (κ a)},
  q.rows ⊆ KWLock.onesOf (g a) →
    q.cols ⊆ KWLock.zerosOf (g a) → ∀ (o : Bool) {v : V a}, v ∈ KWLock.rowSideSel o q → g a v = o
```
KWLock.KRect KWLock.KRect.cols KWLock.KRect.rows KWLock.onesOf KWLock.rowSideSel KWLock.zerosOf
Uses
- KWLock.mem_onesOf
- KWLock.mem_zerosOf
Used by
DeclKWLock.rowSideSel_nonemptyDeclaration kindtheorem
Row sides of members of a valid block partition are nonempty.
```
∀ {k : ℕ} {V κ : Fin k → Type} {a : Fin k} {q : KWLock.KRect (V a) (V a) (κ a)},
  q.rows.Nonempty ∧ q.cols.Nonempty → ∀ (o : Bool), (KWLock.rowSideSel o q).Nonempty
```
KWLock.KRect KWLock.KRect.cols KWLock.KRect.rows KWLock.rowSideSel
Used by
- KWLock.comp_isPartition
- KWLock.cross_step_row

DeclKWLock.comp_pairwiseDeclaration kindtheorem

Pairwise cell-disjointness transfers to the product: a shared composed cell projects to a shared outer cell (across outer rectangles) or a shared block cell in the orientation's order (within one outer rectangle).

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  List.Pairwise (fun r s => ∀ (x y : Fin k → Bool), ¬(r.Cell x y ∧ s.Cell x y)) Po →
    (∀ (i : Fin k), List.Pairwise (fun r s => ∀ (x y : V i), ¬(r.Cell x y ∧ s.Cell x y)) (Q i)) →
      List.Pairwise (fun r s => ∀ (x y : (i : Fin k) → V i), ¬(r.Cell x y ∧ s.Cell x y)) (KWLock.compPartition g Po Q)

KWLock.KRect KWLock.KRect.Cell KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.blockPat KWLock.colSideSel KWLock.compPartition KWLock.compRect KWLock.rowSideSel

Uses

KWLock.mem_cols_compRect
KWLock.mem_compPartition
KWLock.mem_rows_compRect

Used by

KWLock.comp_isPartition

DeclKWLock.mem_rows_compRectDeclaration kindtheorem

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Ro : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)}
  {q : KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label)} {w : (i : Fin k) → V i},
  w ∈ (KWLock.compRect g Ro q).rows ↔ KWLock.blockPat g w ∈ Ro.rows ∧ w Ro.label ∈ KWLock.rowSideSel Ro.orient q

KWLock.KRect KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.blockPat KWLock.compRect KWLock.rowSideSel

Used by

KWLock.comp_distinct
KWLock.comp_isPartition
KWLock.comp_monoValid
KWLock.comp_pairwise
KWLock.comp_rowTouch_same
KWLock.cross_step_row

DeclKWLock.IsPartition.disjointDeclaration kindtheorem

∀ {X Y ι : Type} {RX : Finset X} {CY : Finset Y} {P : List (KWLock.KRect X Y ι)},
  KWLock.IsPartition RX CY P → List.Pairwise (fun r s => ∀ (x : X) (y : Y), ¬(r.Cell x y ∧ s.Cell x y)) P

KWLock.IsPartition KWLock.KRect KWLock.KRect.Cell

Used by

KWLock.comp_distinct
KWLock.comp_isPartition

DeclKWLock.comp_colConnectedDeclaration kindtheorem

The connectivity transfer, columns.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) (f : (Fin k → Bool) → Bool)
  {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.IsPartition (KWLock.onesOf f) (KWLock.zerosOf f) Po →
      KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
        (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
          KWLock.ColConnected Po →
            (∀ (i : Fin k), KWLock.RowConnected (Q i)) →
              (∀ (i : Fin k), KWLock.ColConnected (Q i)) → KWLock.ColConnected (KWLock.compPartition g Po Q)

KWLock.ColConnected KWLock.ColTouch KWLock.IsPartition KWLock.KRect KWLock.KRect.label KWLock.MonoValid KWLock.RowConnected KWLock.TStep KWLock.compPartition KWLock.compRect KWLock.onesOf KWLock.zerosOf

Uses

KWLock.cluster_linked_col
KWLock.comp_Q_ne_nil
KWLock.cross_step_col
KWLock.linked_all_mem
KWLock.mem_compPartition

Used by

KWLock.tower_good

DeclKWLock.cross_step_colDeclaration kindtheorem

The column mirror of cross_step_row.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
      (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
        (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
          ∀ {Ro So : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)},
            Ro ∈ Po →
              So ∈ Po →
                KWLock.ColTouch Ro So →
                  ∀ {q : KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label)},
                    q ∈ Q Ro.label → ∃ p ∈ Q So.label, KWLock.ColTouch (KWLock.compRect g Ro q) (KWLock.compRect g So p)

KWLock.ColTouch KWLock.IsPartition KWLock.KRect KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.MonoValid KWLock.blockPat KWLock.colSideSel KWLock.compRect KWLock.onesOf KWLock.zerosOf

Uses

KWLock.IsPartition.contained
KWLock.IsPartition.nonempty
KWLock.colSideSel_nonempty
KWLock.colSideSel_val
KWLock.comp_Q_ne_nil
KWLock.exists_point
KWLock.exists_point₂
KWLock.mem_cols_compRect

Used by

KWLock.comp_colConnected

DeclKWLock.exists_point₂Declaration kindtheorem

Build a composed point with a prescribed block pattern and prescribed values at two distinct blocks.

∀ {k : ℕ} {V : Fin k → Type} (g : (i : Fin k) → V i → Bool),
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    ∀ (u : Fin k → Bool) {a₁ a₂ : Fin k},
      a₁ ≠ a₂ →
        ∀ (v₁ : V a₁) (v₂ : V a₂),
          g a₁ v₁ = u a₁ → g a₂ v₂ = u a₂ → ∃ w, KWLock.blockPat g w = u ∧ w a₁ = v₁ ∧ w a₂ = v₂

KWLock.blockPat

Used by

KWLock.cross_step_col
KWLock.cross_step_row

DeclKWLock.colSideSel_nonemptyDeclaration kindtheorem
Column sides of members of a valid block partition are nonempty.
```
∀ {k : ℕ} {V κ : Fin k → Type} {a : Fin k} {q : KWLock.KRect (V a) (V a) (κ a)},
  q.rows.Nonempty ∧ q.cols.Nonempty → ∀ (o : Bool), (KWLock.colSideSel o q).Nonempty
```
KWLock.KRect KWLock.KRect.cols KWLock.KRect.rows KWLock.colSideSel
Used by
- KWLock.comp_isPartition
- KWLock.cross_step_col

DeclKWLock.comp_Q_ne_nilDeclaration kindtheorem

Block partitions of a game with a surjective block function are nonempty lists.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → Fintype (V i)] {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool)
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) → ∀ (i : Fin k), Q i ≠ []

KWLock.IsPartition KWLock.KRect KWLock.onesOf KWLock.zerosOf

Uses

KWLock.mem_onesOf
KWLock.mem_zerosOf
KWLock.partition_ne_nil

Used by

KWLock.comp_colConnected
KWLock.comp_distinct
KWLock.comp_rowConnected
KWLock.cross_step_col
KWLock.cross_step_row

DeclKWLock.partition_ne_nilDeclaration kindtheorem
A valid nonempty-sided partition of a nonempty product is a nonempty list.
```
∀ {X Y ι : Type} {RX : Finset X} {CY : Finset Y} {P : List (KWLock.KRect X Y ι)},
  KWLock.IsPartition RX CY P → RX.Nonempty → CY.Nonempty → P ≠ []
```
KWLock.IsPartition KWLock.KRect KWLock.KRect.Cell
Uses
- KWLock.IsPartition.covers
Used by
- KWLock.comp_Q_ne_nil

DeclKWLock.IsPartition.coversDeclaration kindtheorem

∀ {X Y ι : Type} {RX : Finset X} {CY : Finset Y} {P : List (KWLock.KRect X Y ι)},
  KWLock.IsPartition RX CY P → ∀ x ∈ RX, ∀ y ∈ CY, ∃ r ∈ P, r.Cell x y

KWLock.IsPartition KWLock.KRect KWLock.KRect.Cell

Used by

KWLock.comp_isPartition
KWLock.partition_ne_nil

DeclKWLock.cluster_linked_colDeclaration kindtheorem

The column mirror of cluster_linked_row.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) (f : (Fin k → Bool) → Bool)
  {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.IsPartition (KWLock.onesOf f) (KWLock.zerosOf f) Po →
      KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
        (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
          (∀ (i : Fin k), KWLock.RowConnected (Q i)) →
            (∀ (i : Fin k), KWLock.ColConnected (Q i)) →
              ∀ {Ro : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)},
                Ro ∈ Po →
                  ∀ {q q' : KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label)},
                    q ∈ Q Ro.label →
                      q' ∈ Q Ro.label →
                        Relation.ReflTransGen (KWLock.TStep KWLock.ColTouch (KWLock.compPartition g Po Q))
                          (KWLock.compRect g Ro q) (KWLock.compRect g Ro q')

KWLock.ColConnected KWLock.ColTouch KWLock.IsPartition KWLock.KRect KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.MonoValid KWLock.RowConnected KWLock.RowTouch KWLock.TStep KWLock.colSideSel KWLock.compPartition KWLock.compRect KWLock.onesOf KWLock.zerosOf

Uses

KWLock.IsPartition.nonempty
KWLock.comp_colTouch_same
KWLock.linked_all_mem
KWLock.mem_compPartition

Used by

KWLock.comp_colConnected

DeclKWLock.mem_compPartitionDeclaration kindtheorem

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))}
  {r : KWLock.KRect ((i : Fin k) → V i) ((i : Fin k) → V i) ((i : Fin k) × κ i)},
  r ∈ KWLock.compPartition g Po Q ↔ ∃ Ro ∈ Po, ∃ q ∈ Q Ro.label, r = KWLock.compRect g Ro q

KWLock.KRect KWLock.KRect.label KWLock.compPartition KWLock.compRect

Used by

KWLock.cluster_linked_col
KWLock.cluster_linked_row
KWLock.comp_colConnected
KWLock.comp_distinct
KWLock.comp_isPartition
KWLock.comp_monoValid
KWLock.comp_pairwise
KWLock.comp_rowConnected

DeclKWLock.linked_all_memDeclaration kindtheorem
Along linkage from a member, every node is a member.
```
∀ {X Y ι : Type} (T : KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop) {P : List (KWLock.KRect X Y ι)}
  {r s : KWLock.KRect X Y ι}, r ∈ P → Relation.ReflTransGen (KWLock.TStep T P) r s → s ∈ P
```
KWLock.KRect KWLock.TStep
Used by

DeclKWLock.comp_colTouch_sameDeclaration kindtheorem

Same-outer composed rectangles sharing a side value share a column.

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Po : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))}
  {Q : (i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))},
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    KWLock.MonoValid (fun u i => u i) (fun u i => u i) Po →
      (∀ (i : Fin k), KWLock.IsPartition (KWLock.onesOf (g i)) (KWLock.zerosOf (g i)) (Q i)) →
        ∀ {Ro : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)},
          Ro ∈ Po →
            Ro.cols.Nonempty →
              ∀ {q q' : KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label)},
                q ∈ Q Ro.label →
                  ∀ {v₀ : V Ro.label},
                    v₀ ∈ KWLock.colSideSel Ro.orient q →
                      v₀ ∈ KWLock.colSideSel Ro.orient q' →
                        KWLock.ColTouch (KWLock.compRect g Ro q) (KWLock.compRect g Ro q')

Uses

KWLock.IsPartition.contained
KWLock.colSideSel_val
KWLock.exists_point
KWLock.mem_cols_compRect

Used by

KWLock.cluster_linked_col

DeclKWLock.mem_cols_compRectDeclaration kindtheorem

∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → DecidableEq (V i)] [inst_1 : (i : Fin k) → Fintype (V i)]
  {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool) {Ro : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)}
  {q : KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label)} {w : (i : Fin k) → V i},
  w ∈ (KWLock.compRect g Ro q).cols ↔ KWLock.blockPat g w ∈ Ro.cols ∧ w Ro.label ∈ KWLock.colSideSel Ro.orient q

KWLock.KRect KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.blockPat KWLock.colSideSel KWLock.compRect

Used by

KWLock.comp_colTouch_same
KWLock.comp_distinct
KWLock.comp_isPartition
KWLock.comp_monoValid
KWLock.comp_pairwise
KWLock.cross_step_col

DeclKWLock.exists_pointDeclaration kindtheorem
Build a composed point with a prescribed block pattern and a prescribed value at one block, from surjectivity of the block functions.
```
∀ {k : ℕ} {V : Fin k → Type} (g : (i : Fin k) → V i → Bool),
  (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) →
    ∀ (u : Fin k → Bool) (a : Fin k) (v : V a), g a v = u a → ∃ w, KWLock.blockPat g w = u ∧ w a = v
```
KWLock.blockPat
Used by
DeclKWLock.colSideSel_valDeclaration kindtheorem
A value on the column side of a block rectangle evaluates to the negated orientation.
```
∀ {k : ℕ} {V : Fin k → Type} [inst : (i : Fin k) → Fintype (V i)] {κ : Fin k → Type} (g : (i : Fin k) → V i → Bool)
  {a : Fin k} {q : KWLock.KRect (V a) (V a) (κ a)},
  q.rows ⊆ KWLock.onesOf (g a) →
    q.cols ⊆ KWLock.zerosOf (g a) → ∀ (o : Bool) {v : V a}, v ∈ KWLock.colSideSel o q → g a v = !o
```
KWLock.KRect KWLock.KRect.cols KWLock.KRect.rows KWLock.colSideSel KWLock.onesOf KWLock.zerosOf
Uses
- KWLock.mem_onesOf
- KWLock.mem_zerosOf
Used by
DeclKWLock.mem_zerosOfDeclaration kindtheorem
```
∀ {α : Type} [inst : Fintype α] {h : α → Bool} {x : α}, x ∈ KWLock.zerosOf h ↔ h x = false
```
KWLock.zerosOf
Used by
DeclKWLock.mem_onesOfDeclaration kindtheorem
```
∀ {α : Type} [inst : Fintype α] {h : α → Bool} {x : α}, x ∈ KWLock.onesOf h ↔ h x = true
```
KWLock.onesOf
Used by
DeclKWLock.IsPartition.containedDeclaration kindtheorem
```
∀ {X Y ι : Type} {RX : Finset X} {CY : Finset Y} {P : List (KWLock.KRect X Y ι)},
  KWLock.IsPartition RX CY P → ∀ r ∈ P, r.rows ⊆ RX ∧ r.cols ⊆ CY
```
KWLock.IsPartition KWLock.KRect KWLock.KRect.cols KWLock.KRect.rows
Used by

DeclKWLock.TowerHyp.rowcDeclaration kindtheorem

∀ {k : ℕ} {f : (Fin k → Bool) → Bool} {P₀ : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))},
  KWLock.TowerHyp k f P₀ → KWLock.RowConnected P₀

KWLock.KRect KWLock.RowConnected KWLock.TowerHyp

Used by

KWLock.tower_good

DeclKWLock.TowerHyp.partDeclaration kindtheorem

∀ {k : ℕ} {f : (Fin k → Bool) → Bool} {P₀ : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))},
  KWLock.TowerHyp k f P₀ → KWLock.IsPartition (KWLock.onesOf f) (KWLock.zerosOf f) P₀

KWLock.IsPartition KWLock.KRect KWLock.TowerHyp KWLock.onesOf KWLock.zerosOf

Used by

KWLock.tower_good

DeclKWLock.TowerHyp.ontoDeclaration kindtheorem

∀ {k : ℕ} {f : (Fin k → Bool) → Bool} {P₀ : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))},
  KWLock.TowerHyp k f P₀ → ∀ (b : Bool), ∃ u, f u = b

KWLock.KRect KWLock.TowerHyp

Used by

KWLock.tower_good

DeclKWLock.TowerHyp.monoDeclaration kindtheorem

∀ {k : ℕ} {f : (Fin k → Bool) → Bool} {P₀ : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))},
  KWLock.TowerHyp k f P₀ → KWLock.MonoValid (fun u i => u i) (fun u i => u i) P₀

KWLock.KRect KWLock.MonoValid KWLock.TowerHyp

Used by

KWLock.tower_good

DeclKWLock.TowerHyp.distDeclaration kindtheorem

∀ {k : ℕ} {f : (Fin k → Bool) → Bool} {P₀ : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))},
  KWLock.TowerHyp k f P₀ → ∃ r ∈ P₀, ∃ s ∈ P₀, r ≠ s

KWLock.KRect KWLock.TowerHyp

Used by

KWLock.tower_good

DeclKWLock.TowerHyp.colcDeclaration kindtheorem

∀ {k : ℕ} {f : (Fin k → Bool) → Bool} {P₀ : List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k))},
  KWLock.TowerHyp k f P₀ → KWLock.ColConnected P₀

KWLock.ColConnected KWLock.KRect KWLock.TowerHyp

Used by

KWLock.tower_good

DeclKWLock.Fd_ontoDeclaration kindtheorem

The iterate is surjective at every level.

∀ (k : ℕ) (f : (Fin k → Bool) → Bool),
  (∀ (b : Bool), ∃ u, f u = b) → ∀ (d : ℕ) (b : Bool), ∃ w, KWLock.Fd k f (d + 1) w = b

KWLock.Fd KWLock.Sp

Uses

KWLock.comp_onto

Used by

KWLock.tower_good

DeclKWLock.comp_ontoDeclaration kindtheorem

Surjectivity composes.

∀ {k : ℕ} {V : Fin k → Type} (g : (i : Fin k) → V i → Bool) (f : (Fin k → Bool) → Bool),
  (∀ (b : Bool), ∃ u, f u = b) →
    (∀ (i : Fin k) (b : Bool), ∃ v, g i v = b) → ∀ (b : Bool), ∃ w, KWLock.compFun g f w = b

KWLock.blockPat KWLock.compFun

Used by

KWLock.Fd_onto

DeclKWLock.connected_not_protocolizableDeclaration kindtheorem
The atomicity obstruction. Any list of nonempty-sided rectangles with two distinct members whose row-overlap graph and column-overlap graph are both connected is not the leaf list of any deterministic protocol — full partition validity is not needed. At the root split, every leaf's live side lies within one half; sharing a row (column) forces the same half; connectivity drags every rectangle to one half; yet both subtrees own a leaf.
```
∀ {X Y ι : Type} [inst : DecidableEq X] [inst_1 : DecidableEq Y] {RX : Finset X} {CY : Finset Y}
  {P : List (KWLock.KRect X Y ι)},
  (∀ r ∈ P, r.rows.Nonempty ∧ r.cols.Nonempty) →
    KWLock.RowConnected P → KWLock.ColConnected P → (∃ r ∈ P, ∃ s ∈ P, r ≠ s) → ¬∃ t, KWLock.Realizes RX CY P t
```
KWLock.ColConnected KWLock.KRect KWLock.KRect.cols KWLock.KRect.rows KWLock.Protocol KWLock.Protocol.Follows KWLock.Protocol.leaves KWLock.Realizes KWLock.RowConnected
Uses
Used by
- KWLock.tower_not_protocolizable
DeclKWLock.row_side_invariantDeclaration kindtheorem
Lying inside a fixed half of a row split is invariant along the row-overlap graph, provided every member of P lies inside one half or the other: a shared row cannot be on both sides.
```
∀ {X Y ι : Type} [inst : DecidableEq X] {P : List (KWLock.KRect X Y ι)} {RX A : Finset X},
  (∀ p ∈ P, p.rows ⊆ RX ∩ A ∨ p.rows ⊆ RX \ A) →
    ∀ {p q : KWLock.KRect X Y ι},
      Relation.ReflTransGen (KWLock.TStep KWLock.RowTouch P) p q → p.rows ⊆ RX ∩ A → q.rows ⊆ RX ∩ A
```
KWLock.KRect KWLock.KRect.rows KWLock.RowTouch KWLock.TStep
Used by
- KWLock.connected_not_protocolizable

DeclKWLock.col_side_invariantDeclaration kindtheorem

The column mirror of row_side_invariant.

∀ {X Y ι : Type} [inst : DecidableEq Y] {P : List (KWLock.KRect X Y ι)} {CY B : Finset Y},
  (∀ p ∈ P, p.cols ⊆ CY ∩ B ∨ p.cols ⊆ CY \ B) →
    ∀ {p q : KWLock.KRect X Y ι},
      Relation.ReflTransGen (KWLock.TStep KWLock.ColTouch P) p q → p.cols ⊆ CY ∩ B → q.cols ⊆ CY ∩ B

KWLock.ColTouch KWLock.KRect KWLock.KRect.cols KWLock.TStep

Used by

KWLock.connected_not_protocolizable

DeclKWLock.Protocol.leaves_ne_nilDeclaration kindtheorem
```
∀ {X Y ι : Type} (t : KWLock.Protocol X Y ι), t.leaves ≠ []
```
KWLock.KRect KWLock.Protocol KWLock.Protocol.brecOn.go KWLock.Protocol.leaves
Used by
- KWLock.connected_not_protocolizable
DeclKWLock.Protocol.follows_leaf_subDeclaration kindtheorem
Every leaf of a following protocol sits inside the current rectangle.
```
∀ {X Y ι : Type} [inst : DecidableEq X] [inst_1 : DecidableEq Y] {RX : Finset X} {CY : Finset Y}
  (t : KWLock.Protocol X Y ι), KWLock.Protocol.Follows RX CY t → ∀ r ∈ t.leaves, r.rows ⊆ RX ∧ r.cols ⊆ CY
```
KWLock.KRect KWLock.KRect.cols KWLock.KRect.rows KWLock.Protocol KWLock.Protocol.Follows KWLock.Protocol.brecOn.go KWLock.Protocol.leaves
Used by
- KWLock.connected_not_protocolizable
DeclKWLock.IsPartition.nonemptyDeclaration kindtheorem
```
∀ {X Y ι : Type} {RX : Finset X} {CY : Finset Y} {P : List (KWLock.KRect X Y ι)},
  KWLock.IsPartition RX CY P → ∀ r ∈ P, r.rows.Nonempty ∧ r.cols.Nonempty
```
KWLock.IsPartition KWLock.KRect KWLock.KRect.cols KWLock.KRect.rows
Used by
DeclKWLock.ambainis_towerHypDeclaration kindtheorem
The Ambainis base satisfies every tower hypothesis.
```
KWLock.TowerHyp 4 KWLock.fA KWLock.pA
```
KWLock.TowerHyp KWLock.fA KWLock.pA
Uses
Used by
- KWLock.ambainis_tower_locked
DeclKWLock.pA_rowConnectedDeclaration kindtheorem
The row-overlap graph is connected: an explicit spanning walk.
```
KWLock.RowConnected KWLock.pA
```
KWLock.IsWalk KWLock.KRect KWLock.RowConnected KWLock.RowTouch KWLock.instDecidableEqKRect KWLock.instDecidableIsWalk KWLock.instDecidableRowTouchOfDecidableEq KWLock.pA KWLock.rA1 KWLock.rA2 KWLock.rA3 KWLock.rA4 KWLock.rA5 KWLock.rA6 KWLock.rA7 KWLock.rA8
Uses
- KWLock.RowTouch.symm
- KWLock.connectedVia_of_walk
Used by
- KWLock.ambainis_towerHyp
DeclKWLock.RowTouch.symmDeclaration kindtheorem
```
∀ {X Y ι : Type} {r s : KWLock.KRect X Y ι}, KWLock.RowTouch r s → KWLock.RowTouch s r
```
KWLock.KRect KWLock.KRect.rows KWLock.RowTouch
Used by
- KWLock.pA_rowConnected
DeclKWLock.pA_monoDeclaration kindtheorem
Kernel re-check: every rectangle is monochromatic at its label, in its orientation.
```
KWLock.MonoValid (fun u i => u i) (fun u i => u i) KWLock.pA
```
KWLock.KRect KWLock.KRect.cols KWLock.KRect.label KWLock.KRect.orient KWLock.KRect.rows KWLock.MonoValid KWLock.pA
Used by
- KWLock.ambainis_towerHyp
DeclKWLock.pA_isPartitionDeclaration kindtheorem
Kernel re-check: the eight rectangles form a valid partition of the Ambainis game.
```
KWLock.IsPartition (KWLock.onesOf KWLock.fA) (KWLock.zerosOf KWLock.fA) KWLock.pA
```
KWLock.IsPartition KWLock.KRect KWLock.KRect.Cell KWLock.KRect.cols KWLock.KRect.rows KWLock.fA KWLock.instDecidableCellOfDecidableEq KWLock.onesOf KWLock.pA KWLock.zerosOf
Used by
- KWLock.ambainis_towerHyp
DeclKWLock.pA_distinctDeclaration kindtheorem
Two distinct members.
```
∃ r ∈ KWLock.pA, ∃ s ∈ KWLock.pA, r ≠ s
```
KWLock.KRect KWLock.instDecidableEqKRect KWLock.pA
Used by
- KWLock.ambainis_towerHyp
DeclKWLock.pA_colConnectedDeclaration kindtheorem
The column-overlap graph is connected: an explicit spanning walk.
```
KWLock.ColConnected KWLock.pA
```
KWLock.ColConnected KWLock.ColTouch KWLock.IsWalk KWLock.KRect KWLock.instDecidableColTouchOfDecidableEq KWLock.instDecidableEqKRect KWLock.instDecidableIsWalk KWLock.pA KWLock.rA1 KWLock.rA2 KWLock.rA3 KWLock.rA4 KWLock.rA5 KWLock.rA6 KWLock.rA7 KWLock.rA8
Uses
- KWLock.ColTouch.symm
- KWLock.connectedVia_of_walk
Used by
- KWLock.ambainis_towerHyp

DeclKWLock.connectedVia_of_walkDeclaration kindtheorem

A spanning walk — inside P, visiting every member — yields connectivity.

∀ {X Y ι : Type} (T : KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop),
  (∀ {r s : KWLock.KRect X Y ι}, T r s → T s r) →
    ∀ {P w : List (KWLock.KRect X Y ι)},
      w ≠ [] → KWLock.IsWalk T w → (∀ r ∈ w, r ∈ P) → (∀ r ∈ P, r ∈ w) → KWLock.ConnectedVia T P

KWLock.ConnectedVia KWLock.IsWalk KWLock.KRect KWLock.TStep

Uses

KWLock.linked_mem_symm
KWLock.linked_of_walk

Used by

KWLock.pA_colConnected
KWLock.pA_rowConnected

DeclKWLock.linked_of_walkDeclaration kindtheorem

The head of a walk inside P links to every element of the walk.

∀ {X Y ι : Type} (T : KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop) {P : List (KWLock.KRect X Y ι)}
  {a : KWLock.KRect X Y ι} {l : List (KWLock.KRect X Y ι)},
  KWLock.IsWalk T (a :: l) → (∀ r ∈ a :: l, r ∈ P) → ∀ b ∈ a :: l, Relation.ReflTransGen (KWLock.TStep T P) a b

KWLock.IsWalk KWLock.KRect KWLock.TStep

Used by

KWLock.connectedVia_of_walk

DeclKWLock.linked_mem_symmDeclaration kindtheorem

From a member of P, every linked rectangle is a member, and the linkage reverses when the touch relation is symmetric.

∀ {X Y ι : Type} (T : KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop),
  (∀ {r s : KWLock.KRect X Y ι}, T r s → T s r) →
    ∀ {P : List (KWLock.KRect X Y ι)} {r s : KWLock.KRect X Y ι},
      r ∈ P → Relation.ReflTransGen (KWLock.TStep T P) r s → s ∈ P ∧ Relation.ReflTransGen (KWLock.TStep T P) s r

KWLock.KRect KWLock.TStep

Used by

KWLock.connectedVia_of_walk

DeclKWLock.ColTouch.symmDeclaration kindtheorem
```
∀ {X Y ι : Type} {r s : KWLock.KRect X Y ι}, KWLock.ColTouch r s → KWLock.ColTouch s r
```
KWLock.ColTouch KWLock.KRect KWLock.KRect.cols
Used by
- KWLock.pA_colConnected
DeclKWLock.fA_ontoDeclaration kindtheorem
The base function is surjective.
```
∀ (b : Bool), ∃ u, KWLock.fA u = b
```
KWLock.fA
Used by
- KWLock.ambainis_towerHyp

DefinitionKWLock.ColConnecteddef

Column connectivity.

{X Y ι : Type} → List (KWLock.KRect X Y ι) → Prop

DefinitionKWLock.ColTouchdef
Two rectangles touch on columns when some column lies in both column sets.
```
{X Y ι : Type} → KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop
```

DefinitionKWLock.ConnectedViadef

The touch graph of P is connected.

{X Y ι : Type} → (KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop) → List (KWLock.KRect X Y ι) → Prop

DefinitionKWLock.Fddef

The d-th iterate of the base function.

(k : ℕ) → ((Fin k → Bool) → Bool) → (d : ℕ) → KWLock.Sp k d → Bool

DefinitionKWLock.IsPartitionstructure
A valid partition of the product RX × CY into nonempty rectangles: contained, pairwise cell-disjoint, covering.
```
{X Y ι : Type} → Finset X → Finset Y → List (KWLock.KRect X Y ι) → Prop
```

DefinitionKWLock.IsWalkdef

A walk: consecutive elements touch.

{X Y ι : Type} → (KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop) → List (KWLock.KRect X Y ι) → Prop

DefinitionKWLock.KRectstructure
A labeled rectangle: row and column sets, a coordinate label, and the rectangle's orientation (true when rows carry value true at the label). The atomicity results never read label/orient; the composition and validity results do.
```
Type → Type → Type → Type
```

DefinitionKWLock.KRect.Celldef

Cell membership.

{X Y ι : Type} → KWLock.KRect X Y ι → X → Y → Prop

DefinitionKWLock.KRect.colsdef

{X Y ι : Type} → KWLock.KRect X Y ι → Finset Y

DefinitionKWLock.KRect.labeldef

{X Y ι : Type} → KWLock.KRect X Y ι → ι

DefinitionKWLock.KRect.orientdef

{X Y ι : Type} → KWLock.KRect X Y ι → Bool

DefinitionKWLock.KRect.rowsdef

{X Y ι : Type} → KWLock.KRect X Y ι → Finset X

DefinitionKWLock.Labdef
Physical coordinates at depth d: paths of blocks ending in a base coordinate.
```
ℕ → ℕ → Type
```
DefinitionKWLock.MonoValiddef
Per-rectangle monochromaticity relative to valuations: rows carry the rectangle's orientation at its label, columns the negation.
```
{X Y ι : Type} → (X → ι → Bool) → (Y → ι → Bool) → List (KWLock.KRect X Y ι) → Prop
```
DefinitionKWLock.Protocolinductive
A deterministic protocol tree: the row player splits the current row set, the column player the current column set; leaves announce rectangles.
```
Type → Type → Type → Type
```
DefinitionKWLock.Protocol.Followsdef
The protocol respects the current rectangle (RX, CY): each split partitions the live side, and every leaf rectangle sits inside its branch's constraints.
```
{X Y ι : Type} → [DecidableEq X] → [DecidableEq Y] → Finset X → Finset Y → KWLock.Protocol X Y ι → Prop
```

DefinitionKWLock.Protocol.brecOn.godef

{X Y ι : Type} →
  {motive : KWLock.Protocol X Y ι → Sort u} →
    (t : KWLock.Protocol X Y ι) →
      ((t : KWLock.Protocol X Y ι) → KWLock.Protocol.below t → motive t) → motive t ×' KWLock.Protocol.below t

DefinitionKWLock.Protocol.leavesdef

The leaves of a protocol tree.

{X Y ι : Type} → KWLock.Protocol X Y ι → List (KWLock.KRect X Y ι)

DefinitionKWLock.Realizesdef

t realizes the partition P on (RX, CY): it follows the tree constraints and its leaves are exactly the members of P.

{X Y ι : Type} →
  [DecidableEq X] → [DecidableEq Y] → Finset X → Finset Y → List (KWLock.KRect X Y ι) → KWLock.Protocol X Y ι → Prop

DefinitionKWLock.RowConnecteddef

Row connectivity.

{X Y ι : Type} → List (KWLock.KRect X Y ι) → Prop

DefinitionKWLock.RowTouchdef
Two rectangles touch on rows when some row lies in both row sets.
```
{X Y ι : Type} → KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop
```
DefinitionKWLock.Spdef
The input space of the d-th iterate: Sp 1 is the base pattern space.
```
ℕ → ℕ → Type
```

DefinitionKWLock.TStepdef

One linkage step inside P: the target is a member and the rectangles touch.

{X Y ι : Type} →
  (KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop) →
    List (KWLock.KRect X Y ι) → KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop

DefinitionKWLock.TowerHypstructure
The base hypotheses of the tower: a valid, monochromatic, doubly-connected base partition with two distinct members, over a surjective base function.
```
(k : ℕ) → ((Fin k → Bool) → Bool) → List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)) → Prop
```

DefinitionKWLock.blockPatdef

The block pattern of a composed point: the vector of block outputs.

{k : ℕ} → {V : Fin k → Type} → ((i : Fin k) → V i → Bool) → ((i : Fin k) → V i) → Fin k → Bool

DefinitionKWLock.colSideSeldef

The column side of a block rectangle, in a given orientation.

{k : ℕ} → {V κ : Fin k → Type} → Bool → {a : Fin k} → KWLock.KRect (V a) (V a) (κ a) → Finset (V a)

DefinitionKWLock.compFundef

The composed function.

{k : ℕ} → {V : Fin k → Type} → ((i : Fin k) → V i → Bool) → ((Fin k → Bool) → Bool) → ((i : Fin k) → V i) → Bool

DefinitionKWLock.compPartitiondef

The product partition of the composed game.

{k : ℕ} →
  {V : Fin k → Type} →
    [(i : Fin k) → DecidableEq (V i)] →
      [(i : Fin k) → Fintype (V i)] →
        {κ : Fin k → Type} →
          ((i : Fin k) → V i → Bool) →
            List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)) →
              ((i : Fin k) → List (KWLock.KRect (V i) (V i) (κ i))) →
                List (KWLock.KRect ((i : Fin k) → V i) ((i : Fin k) → V i) ((i : Fin k) × κ i))

DefinitionKWLock.compRectdef

The composed rectangle: outer patterns from the outer rectangle, the active block constrained to the block rectangle's side in the outer orientation, other blocks free. The label is the physical coordinate; the orientation composes.

{k : ℕ} →
  {V : Fin k → Type} →
    [(i : Fin k) → DecidableEq (V i)] →
      [(i : Fin k) → Fintype (V i)] →
        {κ : Fin k → Type} →
          ((i : Fin k) → V i → Bool) →
            (Ro : KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)) →
              KWLock.KRect (V Ro.label) (V Ro.label) (κ Ro.label) →
                KWLock.KRect ((i : Fin k) → V i) ((i : Fin k) → V i) ((i : Fin k) × κ i)

DefinitionKWLock.fAdef
The four-variable Ambainis function, in Ueno's ten-leaf form (truth table 0xd18b: exactly the monotone four-bit sequences evaluate to one).
```
(Fin 4 → Bool) → Bool
```

DefinitionKWLock.instDecidableCellOfDecidableEqdef

{X Y ι : Type} →
  [DecidableEq X] → [DecidableEq Y] → (r : KWLock.KRect X Y ι) → (x : X) → (y : Y) → Decidable (r.Cell x y)

DefinitionKWLock.instDecidableColTouchOfDecidableEqdef

{X Y ι : Type} → [DecidableEq Y] → (r s : KWLock.KRect X Y ι) → Decidable (KWLock.ColTouch r s)

DefinitionKWLock.instDecidableEqKRectdef

{X Y ι : Type} → [DecidableEq X] → [DecidableEq Y] → [DecidableEq ι] → DecidableEq (KWLock.KRect X Y ι)

DefinitionKWLock.instDecidableEqSpdef

(k d : ℕ) → DecidableEq (KWLock.Sp k d)

DefinitionKWLock.instDecidableIsWalkdef

{X Y ι : Type} →
  (T : KWLock.KRect X Y ι → KWLock.KRect X Y ι → Prop) →
    [(r s : KWLock.KRect X Y ι) → Decidable (T r s)] → (w : List (KWLock.KRect X Y ι)) → Decidable (KWLock.IsWalk T w)

DefinitionKWLock.instDecidableRowTouchOfDecidableEqdef

{X Y ι : Type} → [DecidableEq X] → (r s : KWLock.KRect X Y ι) → Decidable (KWLock.RowTouch r s)

DefinitionKWLock.instFintypeSpdef
```
(k d : ℕ) → Fintype (KWLock.Sp k d)
```
DefinitionKWLock.onesOfdef
The ones of a Boolean function, as a finite set.
```
{α : Type} → [Fintype α] → (α → Bool) → Finset α
```

DefinitionKWLock.pAdef

The witness partition.

List (KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4))

DefinitionKWLock.rA1def
The eight-rectangle base partition, found by exact search and re-verified by the kernel below: eight monochromatic rectangles of eight cells each, in mixed orientations.
```
KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4)
```

DefinitionKWLock.rA2def

KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4)

DefinitionKWLock.rA3def

KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4)

DefinitionKWLock.rA4def

KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4)

DefinitionKWLock.rA5def

KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4)

DefinitionKWLock.rA6def

KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4)

DefinitionKWLock.rA7def

KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4)

DefinitionKWLock.rA8def

KWLock.KRect (Fin 4 → Bool) (Fin 4 → Bool) (Fin 4)

DefinitionKWLock.rowSideSeldef
The row side of a block rectangle, in a given orientation (the transposed side for the reversed orientation).
```
{k : ℕ} → {V κ : Fin k → Type} → Bool → {a : Fin k} → KWLock.KRect (V a) (V a) (κ a) → Finset (V a)
```

DefinitionKWLock.towerPdef

The tower of product partitions: depth 0 is the base partition; each next depth composes the base as the outer partition with the previous depth at every block.

(k : ℕ) →
  ((Fin k → Bool) → Bool) →
    List (KWLock.KRect (Fin k → Bool) (Fin k → Bool) (Fin k)) →
      (d : ℕ) → List (KWLock.KRect (KWLock.Sp k (d + 1)) (KWLock.Sp k (d + 1)) (KWLock.Lab k d))

DefinitionKWLock.vvaldef
The valuation of an iterate point at a physical coordinate.
```
(k d : ℕ) → KWLock.Sp k (d + 1) → KWLock.Lab k d → Bool
```
DefinitionKWLock.zerosOfdef
The zeros of a Boolean function, as a finite set.
```
{α : Type} → [Fintype α] → (α → Bool) → Finset α
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

If every candidate's loss is measurable and a.e. valued in [a, b] under Q, every training-generated trajectory is admissible for F, and the resulting uniform-deviation failure event is measurable, then on an i.i.d. panel of size n drawn from Q, measured cumulative empirical-loss progress exceeds population-loss progress by more than 2 · deltaFiniteExperts (card ι) n (b - a) δ with probability at most ENNReal.ofReal δ.

DeclAuditCP.auditBlind_finiteTrajectory_goodhart

∀ {Ωtrain : Type u_1} {Z : Type u_2} {ι : Type u_3} [inst : MeasurableSpace Ωtrain] [inst_1 : MeasurableSpace Z]
  [inst_2 : Fintype ι] [Nonempty ι] (μtrain : AuditCP.AuditSampleLaw Ωtrain) [MeasureTheory.IsProbabilityMeasure μtrain]
  (Q : AuditCP.AuditSampleLaw Z) [MeasureTheory.IsProbabilityMeasure Q] (n : ℕ),
  0 < n →
    ∀ (a b : ℝ),
      a < b →
        ∀ (δ : ℝ),
          0 < δ →
            δ ≤ 1 →
              ∀ (loss : ι → Z → ℝ),
                (∀ (i : ι), Measurable (loss i)) →
                  (∀ (i : ι), ∀ᵐ (z : Z) ∂Q, loss i z ∈ Set.Icc a b) →
                    ∀ (F : Ωtrain → AuditCP.AuditEnvelope ι) (g : Ωtrain → AuditCP.AuditTrajectory ι),
                      (∀ (t : Ωtrain), AuditCP.Admissible (g t) (F t)) →
                        MeasurableSet
                            {p |
                              ¬AuditCP.UniformDev (F p.1) (fun i => AuditCP.empiricalLoss loss i p.2)
                                  (fun i => AuditCP.populationLoss Q loss i)
                                  (AuditCP.deltaFiniteExperts (Fintype.card ι) n (b - a) δ)} →
                          ∀ (T : ℕ),
                            (MeasureTheory.Measure.prod μtrain (MeasureTheory.Measure.pi fun x => Q))
                                {p |
                                  AuditCP.cumCP (fun i => AuditCP.empiricalLoss loss i p.2) (g p.1) T >
                                    AuditCP.cumCP (fun i => AuditCP.populationLoss Q loss i) (g p.1) T +
                                      2 * AuditCP.deltaFiniteExperts (Fintype.card ι) n (b - a) δ} ≤
                              ENNReal.ofReal δ

ThesisStepHypothesisDefinition

DeclAuditCP.auditBlind_finiteTrajectory_goodhartDeclaration kindtheorem

∀ {Ωtrain : Type u_1} {Z : Type u_2} {ι : Type u_3} [inst : MeasurableSpace Ωtrain] [inst_1 : MeasurableSpace Z]
  [inst_2 : Fintype ι] [Nonempty ι] (μtrain : AuditCP.AuditSampleLaw Ωtrain) [MeasureTheory.IsProbabilityMeasure μtrain]
  (Q : AuditCP.AuditSampleLaw Z) [MeasureTheory.IsProbabilityMeasure Q] (n : ℕ),
  0 < n →
    ∀ (a b : ℝ),
      a < b →
        ∀ (δ : ℝ),
          0 < δ →
            δ ≤ 1 →
              ∀ (loss : ι → Z → ℝ),
                (∀ (i : ι), Measurable (loss i)) →
                  (∀ (i : ι), ∀ᵐ (z : Z) ∂Q, loss i z ∈ Set.Icc a b) →
                    ∀ (F : Ωtrain → AuditCP.AuditEnvelope ι) (g : Ωtrain → AuditCP.AuditTrajectory ι),
                      (∀ (t : Ωtrain), AuditCP.Admissible (g t) (F t)) →
                        MeasurableSet
                            {p |
                              ¬AuditCP.UniformDev (F p.1) (fun i => AuditCP.empiricalLoss loss i p.2)
                                  (fun i => AuditCP.populationLoss Q loss i)
                                  (AuditCP.deltaFiniteExperts (Fintype.card ι) n (b - a) δ)} →
                          ∀ (T : ℕ),
                            (MeasureTheory.Measure.prod μtrain (MeasureTheory.Measure.pi fun x => Q))
                                {p |
                                  AuditCP.cumCP (fun i => AuditCP.empiricalLoss loss i p.2) (g p.1) T >
                                    AuditCP.cumCP (fun i => AuditCP.populationLoss Q loss i) (g p.1) T +
                                      2 * AuditCP.deltaFiniteExperts (Fintype.card ι) n (b - a) δ} ≤
                              ENNReal.ofReal δ

AuditCP.Admissible AuditCP.AuditEnvelope AuditCP.AuditSampleLaw AuditCP.AuditTrajectory AuditCP.UniformDev AuditCP.cumCP AuditCP.deltaFiniteExperts AuditCP.empiricalLoss AuditCP.populationLoss

Uses

AuditCP.auditBlind_randomTrajectory_goodhart
AuditCP.finite_experts_iid_badEvent_le

DeclAuditCP.finite_experts_iid_badEvent_leDeclaration kindtheorem

Under the hypotheses of finite_experts_iid_uniformDev, the ENNReal-valued probability that the panel fails uniform deviation is at most ENNReal.ofReal δ.

∀ {Z : Type u_1} {ι : Type u_2} [inst : MeasurableSpace Z] [inst_1 : Fintype ι] [Nonempty ι]
  (Q : AuditCP.AuditSampleLaw Z) [MeasureTheory.IsProbabilityMeasure Q] (n : ℕ),
  0 < n →
    ∀ (a b : ℝ),
      a < b →
        ∀ (δ : ℝ),
          0 < δ →
            δ ≤ 1 →
              ∀ (loss : ι → Z → ℝ),
                (∀ (i : ι), Measurable (loss i)) →
                  (∀ (i : ι), ∀ᵐ (z : Z) ∂Q, loss i z ∈ Set.Icc a b) →
                    (MeasureTheory.Measure.pi fun x => Q)
                        {panel |
                          ¬AuditCP.UniformDev Set.univ (fun i => AuditCP.empiricalLoss loss i panel)
                              (fun i => AuditCP.populationLoss Q loss i)
                              (AuditCP.deltaFiniteExperts (Fintype.card ι) n (b - a) δ)} ≤
                      ENNReal.ofReal δ

AuditCP.AuditSampleLaw AuditCP.UniformDev AuditCP.deltaFiniteExperts AuditCP.empiricalLoss AuditCP.populationLoss

Uses

AuditCP.finite_experts_iid_uniformDev

Used by

AuditCP.auditBlind_finiteTrajectory_goodhart

DeclAuditCP.finite_experts_iid_uniformDevDeclaration kindtheorem

If every candidate's loss is measurable and a.e. valued in [a, b] under Q, then on an i.i.d. panel of size n drawn from Q, with probability at least 1 − δ the empirical loss empiricalLoss loss i panel and the population loss populationLoss Q loss i agree within deltaFiniteExperts (card ι) n (b - a) δ for every candidate i (hoeffding1963; cesabianchi2006).

∀ {Z : Type u_1} {ι : Type u_2} [inst : MeasurableSpace Z] [inst_1 : Fintype ι] [Nonempty ι]
  (Q : AuditCP.AuditSampleLaw Z) [MeasureTheory.IsProbabilityMeasure Q] (n : ℕ),
  0 < n →
    ∀ (a b : ℝ),
      a < b →
        ∀ (δ : ℝ),
          0 < δ →
            δ ≤ 1 →
              ∀ (loss : ι → Z → ℝ),
                (∀ (i : ι), Measurable (loss i)) →
                  (∀ (i : ι), ∀ᵐ (z : Z) ∂Q, loss i z ∈ Set.Icc a b) →
                    1 - δ ≤
                      (MeasureTheory.Measure.pi fun x => Q).real
                        {panel |
                          AuditCP.UniformDev Set.univ (fun i => AuditCP.empiricalLoss loss i panel)
                            (fun i => AuditCP.populationLoss Q loss i)
                            (AuditCP.deltaFiniteExperts (Fintype.card ι) n (b - a) δ)}

AuditCP.AuditSampleLaw AuditCP.UniformDev AuditCP.deltaFiniteExperts AuditCP.empiricalLoss AuditCP.populationLoss

Uses

AuditCP.finite_experts_subgaussian_uniformDev

Used by

AuditCP.finite_experts_iid_badEvent_le

DeclAuditCP.finite_experts_subgaussian_uniformDevDeclaration kindtheorem

If each Y i j is μ-sub-Gaussian with proxy (L/2)² and, for each candidate i, independent across panel positions j, then with probability at least 1 − δ the panel means (∑ⱼ Y i j) / n all lie within deltaFiniteExperts (card ι) n L δ of 0 (hoeffding1963).

∀ {Ω : Type u_1} {ι : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : Fintype ι] [Nonempty ι]
  (μ : AuditCP.AuditSampleLaw Ω) [MeasureTheory.IsProbabilityMeasure μ] (n : ℕ),
  0 < n →
    ∀ (L : ℝ),
      0 < L →
        ∀ (δ : ℝ),
          0 < δ →
            δ ≤ 1 →
              ∀ (Y : ι → Fin n → Ω → ℝ),
                (∀ (i : ι) (j : Fin n), ProbabilityTheory.HasSubgaussianMGF (Y i j) ((‖L‖₊ / 2) ^ 2) μ) →
                  (∀ (i : ι), ProbabilityTheory.iIndepFun (Y i) μ) →
                    1 - δ ≤
                      MeasureTheory.Measure.real μ
                        {ω |
                          AuditCP.UniformDev Set.univ (fun i => (∑ j, Y i j ω) / ↑n) (fun x => 0)
                            (AuditCP.deltaFiniteExperts (Fintype.card ι) n L δ)}

AuditCP.AuditSampleLaw AuditCP.UniformDev AuditCP.deltaFiniteExperts

Used by

AuditCP.finite_experts_iid_uniformDev

DeclAuditCP.auditBlind_randomTrajectory_goodhartDeclaration kindtheorem

If every training-generated trajectory g t is admissible for F t, the uniform-deviation failure event is measurable, and its audit fiber has probability at most δ for μtrain-almost every training history, then measured cumulative compression progress exceeds true progress by more than 2Δ with probability at most δ under μtrain.prod μaudit.

∀ {Ωtrain : Type u_1} {Ωaudit : Type u_2} {ι : Type u_3} [inst : MeasurableSpace Ωtrain]
  [inst_1 : MeasurableSpace Ωaudit] (μtrain : AuditCP.AuditSampleLaw Ωtrain) [MeasureTheory.IsProbabilityMeasure μtrain]
  (μaudit : AuditCP.AuditSampleLaw Ωaudit) [MeasureTheory.IsProbabilityMeasure μaudit]
  (F : Ωtrain → AuditCP.AuditEnvelope ι) (g : Ωtrain → AuditCP.AuditTrajectory ι)
  (Ehat : Ωaudit → AuditCP.AuditPotential ι) (E : AuditCP.AuditPotential ι) (Δ : ℝ) (δ : ENNReal),
  (∀ (t : Ωtrain), AuditCP.Admissible (g t) (F t)) →
    MeasurableSet {p | ¬AuditCP.UniformDev (F p.1) (Ehat p.2) E Δ} →
      (∀ᵐ (t : Ωtrain) ∂μtrain, μaudit {a | ¬AuditCP.UniformDev (F t) (Ehat a) E Δ} ≤ δ) →
        ∀ (T : ℕ),
          (MeasureTheory.Measure.prod μtrain μaudit)
              {p | AuditCP.cumCP (Ehat p.2) (g p.1) T > AuditCP.cumCP E (g p.1) T + 2 * Δ} ≤
            δ

AuditCP.Admissible AuditCP.AuditEnvelope AuditCP.AuditPotential AuditCP.AuditSampleLaw AuditCP.AuditTrajectory AuditCP.UniformDev AuditCP.cumCP

Uses

AuditCP.auditBlind_randomClass_badEvent_le
AuditCP.finite_audit_goodhart

Used by

AuditCP.auditBlind_finiteTrajectory_goodhart

DeclAuditCP.finite_audit_goodhartDeclaration kindtheorem
Under UniformDev F Ehat E Δ and Admissible g F, empirical cumulative compression progress is bounded by true cumulative progress plus 2Δ at every horizon T: cumCP Ehat g T ≤ cumCP E g T + 2Δ.
```
∀ {ι : Type u_1} {F : AuditCP.AuditEnvelope ι} {Ehat E : AuditCP.AuditPotential ι} {Δ : ℝ},
  AuditCP.UniformDev F Ehat E Δ →
    ∀ {g : AuditCP.AuditTrajectory ι},
      AuditCP.Admissible g F → ∀ (T : ℕ), AuditCP.cumCP Ehat g T ≤ AuditCP.cumCP E g T + 2 * Δ
```
AuditCP.Admissible AuditCP.AuditEnvelope AuditCP.AuditPotential AuditCP.AuditTrajectory AuditCP.UniformDev AuditCP.cumCP
Uses
- AuditCP.cumCP_telescope
Used by
- AuditCP.auditBlind_randomTrajectory_goodhart
DeclAuditCP.cumCP_telescopeDeclaration kindtheorem
Cumulative signed compression progress telescopes: cumCP E g T = E (g 0) - E (g T).
```
∀ {ι : Type u_1} (E : AuditCP.AuditPotential ι) (g : AuditCP.AuditTrajectory ι) (T : ℕ),
  AuditCP.cumCP E g T = E (g 0) - E (g T)
```
AuditCP.AuditPotential AuditCP.AuditTrajectory AuditCP.cumCP
Used by
- AuditCP.finite_audit_goodhart

DeclAuditCP.auditBlind_randomClass_badEvent_leDeclaration kindtheorem

If the event {p | Bad (Γ p.1) p.2} is measurable and its audit fiber {a | Bad (Γ t) a} has μaudit-probability at most δ for μtrain-almost every training history t, then its probability under the product law μtrain.prod μaudit is at most δ.

∀ {Ωtrain : Type u_1} {Ωaudit : Type u_2} {ι : Type u_3} [inst : MeasurableSpace Ωtrain]
  [inst_1 : MeasurableSpace Ωaudit] (μtrain : AuditCP.AuditSampleLaw Ωtrain) [MeasureTheory.IsProbabilityMeasure μtrain]
  (μaudit : AuditCP.AuditSampleLaw Ωaudit) [MeasureTheory.IsProbabilityMeasure μaudit]
  (Γ : Ωtrain → AuditCP.AuditEnvelope ι) (Bad : AuditCP.AuditEnvelope ι → Ωaudit → Prop) (δ : ENNReal),
  MeasurableSet {p | Bad (Γ p.1) p.2} →
    (∀ᵐ (t : Ωtrain) ∂μtrain, μaudit {a | Bad (Γ t) a} ≤ δ) →
      (MeasureTheory.Measure.prod μtrain μaudit) {p | Bad (Γ p.1) p.2} ≤ δ

AuditCP.AuditEnvelope AuditCP.AuditSampleLaw

Used by

AuditCP.auditBlind_randomTrajectory_goodhart

Hypothesishn
```
0 < n
```
Hypothesishab
```
a < b
```
Hypothesishδ0
```
0 < δ
```
Hypothesishδ1
```
δ ≤ 1
```
Hypothesishmeas
```
∀ (i : ι), Measurable (loss i)
```

Hypothesishbdd

∀ (i : ι), ∀ᵐ (z : Z) ∂Q, loss i z ∈ Set.Icc a b

Hypothesishadm

∀ (t : Ωtrain), AuditCP.Admissible (g t) (F t)

HypothesishBad

MeasurableSet
  {p |
    ¬AuditCP.UniformDev (F p.1) (fun i => AuditCP.empiricalLoss loss i p.2) (fun i => AuditCP.populationLoss Q loss i)
        (AuditCP.deltaFiniteExperts (Fintype.card ι) n (b - a) δ)}

DefinitionAuditCP.Admissibledef

Every stage of the trajectory g lies in the envelope F.

{ι : Type u_1} → AuditCP.AuditTrajectory ι → AuditCP.AuditEnvelope ι → Prop

DefinitionAuditCP.AuditEnvelopedef
B4 — AuditEnvelope ι is the type of subsets Set ι of the index ι.
```
AuditCP.AuditIndex → Type u
```
DefinitionAuditCP.AuditPotentialdef
B2 — AuditPotential ι is the type of real-valued readings ι → ℝ of the index ι.
```
AuditCP.AuditIndex → Type u
```
DefinitionAuditCP.AuditSampleLawdef
B7 — AuditSampleLaw Ω is MeasureTheory.Measure Ω, a σ-additive probability law on the measurable space Ω.
```
(Ω : AuditCP.AuditIndex) → [MeasurableSpace Ω] → Type u
```
DefinitionAuditCP.AuditTrajectorydef
B3 — AuditTrajectory ι is the type of stage-indexed selections ℕ → ι of the index ι.
```
AuditCP.AuditIndex → Type u
```

DefinitionAuditCP.UniformDevdef

The potentials Ehat and E agree to within Δ at every point of the envelope F.

{ι : Type u_1} → AuditCP.AuditEnvelope ι → AuditCP.AuditPotential ι → AuditCP.AuditPotential ι → ℝ → Prop

DefinitionAuditCP.cumCPdef
Cumulative signed compression progress of a potential E read along a trajectory g over T stages, ∑_{t < T} (E(g t) − E(g(t+1))) (schmidhuber1991; schmidhuber2010).
```
{ι : Type u_1} → AuditCP.AuditPotential ι → AuditCP.AuditTrajectory ι → ℕ → ℝ
```
DefinitionAuditCP.deltaFiniteExpertsdef
The finite-experts uniform-deviation radius, L·√(log(2N/δ)/(2n)), for N candidates, panel size n, loss range L, and failure probability δ (hoeffding1963).
```
ℕ → ℕ → ℝ → ℝ → ℝ
```
DefinitionAuditCP.empiricalLossdef
The empirical mean loss of candidate i on the panel, (∑ⱼ loss i (panel j)) / n.
```
{Z : Type u_1} → {ι : Type u_2} → {n : ℕ} → (ι → Z → ℝ) → ι → (Fin n → Z) → ℝ
```

DefinitionAuditCP.populationLossdef

The population loss of candidate i under the law Q, ∫ loss i z ∂Q.

{Z : Type u_1} → {ι : Type u_2} → [inst : MeasurableSpace Z] → AuditCP.AuditSampleLaw Z → (ι → Z → ℝ) → ι → ℝ

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

F2 — given A nonempty, BlackwellEquivalent (learnerExperiment K) publicOnlyExperiment ↔ AuditSealed K (blackwell1953).

DeclAuditCP.blackwellEquivalent_publicOnly_iff_auditSealed

∀ {S : Type uS} {A : Type uA} {Y : Type uY} [Nonempty A] (K : AuditCP.AuditChannel S A Y),
  AuditCP.BlackwellEquivalent (AuditCP.learnerExperiment K) AuditCP.publicOnlyExperiment ↔ AuditCP.AuditSealed K

ThesisStepDefinition

DeclAuditCP.blackwellEquivalent_publicOnly_iff_auditSealedDeclaration kindtheorem
```
∀ {S : Type uS} {A : Type uA} {Y : Type uY} [Nonempty A] (K : AuditCP.AuditChannel S A Y),
  AuditCP.BlackwellEquivalent (AuditCP.learnerExperiment K) AuditCP.publicOnlyExperiment ↔ AuditCP.AuditSealed K
```
AuditCP.AuditChannel AuditCP.AuditSealed AuditCP.BlackwellBelow AuditCP.BlackwellEquivalent AuditCP.learnerExperiment AuditCP.publicOnlyExperiment
Uses
- AuditCP.learner_blackwellBelow_publicOnly_iff_auditSealed
- AuditCP.publicOnly_blackwellBelow_learner
DeclAuditCP.publicOnly_blackwellBelow_learnerDeclaration kindtheorem
F2a — public information is Blackwell-below the complete learner view: BlackwellBelow publicOnlyExperiment (learnerExperiment K).
```
∀ {S : Type uS} {A : Type uA} {Y : Type uY} (K : AuditCP.AuditChannel S A Y),
  AuditCP.BlackwellBelow AuditCP.publicOnlyExperiment (AuditCP.learnerExperiment K)
```
AuditCP.AuditChannel AuditCP.AuditExperiment AuditCP.BlackwellBelow AuditCP.learnerExperiment AuditCP.publicOnlyExperiment
Used by
- AuditCP.blackwellEquivalent_publicOnly_iff_auditSealed
DeclAuditCP.learner_blackwellBelow_publicOnly_iff_auditSealedDeclaration kindtheorem
F2b — given A nonempty, BlackwellBelow (learnerExperiment K) publicOnlyExperiment ↔ AuditSealed K (blackwell1953).
```
∀ {S : Type uS} {A : Type uA} {Y : Type uY} [Nonempty A] (K : AuditCP.AuditChannel S A Y),
  AuditCP.BlackwellBelow (AuditCP.learnerExperiment K) AuditCP.publicOnlyExperiment ↔ AuditCP.AuditSealed K
```
AuditCP.AuditChannel AuditCP.AuditExperiment AuditCP.AuditSealed AuditCP.BlackwellBelow AuditCP.FactorsThroughPublic AuditCP.learnerExperiment AuditCP.publicOnlyExperiment
Uses
- AuditCP.auditSealed_iff_factorsThroughPublic
- AuditCP.pmf_map_publicTag_injective
Used by
- AuditCP.blackwellEquivalent_publicOnly_iff_auditSealed
DeclAuditCP.pmf_map_publicTag_injectiveDeclaration kindtheorem
Pushing a PMF on Y through the tag y ↦ (s, y) is injective.
```
∀ {S : Type uS} {Y : Type uY} (s : S), Function.Injective fun p => PMF.map (fun y => (s, y)) p
```
Used by
- AuditCP.learner_blackwellBelow_publicOnly_iff_auditSealed
DeclAuditCP.auditSealed_iff_factorsThroughPublicDeclaration kindtheorem
F1 — given A nonempty, AuditSealed K ↔ FactorsThroughPublic K.
```
∀ {S : Type uS} {A : Type uA} {Y : Type uY} [Nonempty A] (K : AuditCP.AuditChannel S A Y),
  AuditCP.AuditSealed K ↔ AuditCP.FactorsThroughPublic K
```
AuditCP.AuditChannel AuditCP.AuditExperiment AuditCP.AuditSealed AuditCP.FactorsThroughPublic
Used by
- AuditCP.learner_blackwellBelow_publicOnly_iff_auditSealed
DefinitionAuditCP.AuditChanneldef
B6 — AuditChannel S A Y is AuditExperiment (S × A) Y, an experiment whose parameter is split into a public coordinate S and an audit coordinate A.
```
AuditCP.AuditIndex → AuditCP.AuditIndex → AuditCP.AuditIndex → Type (max u v w)
```
DefinitionAuditCP.AuditExperimentdef
B5 — AuditExperiment Θ X is the type of parameter-indexed discrete observation laws Θ → PMF X.
```
AuditCP.AuditIndex → AuditCP.AuditIndex → Type (max u v)
```
DefinitionAuditCP.AuditSealeddef
The channel K is audit-sealed: its output law at fixed public state s does not depend on the audit state a.
```
{S : Type uS} → {A : Type uA} → {Y : Type uY} → AuditCP.AuditChannel S A Y → Prop
```
DefinitionAuditCP.BlackwellBelowdef
E₀ is Blackwell-below E₁ when some garbling G of E₁'s output reproduces E₀: ∃ G, ∀ θ, E₀ θ = (E₁ θ).bind G (blackwell1953).
```
{Θ : Type uΘ} → {X₀ : Type uX₀} → {X₁ : Type uX₁} → AuditCP.AuditExperiment Θ X₀ → AuditCP.AuditExperiment Θ X₁ → Prop
```

DefinitionAuditCP.BlackwellEquivalentdef

E₀ and E₁ are Blackwell-equivalent when each is Blackwell-below the other (blackwell1953).

{Θ : Type uΘ} → {X₀ : Type uX₀} → {X₁ : Type uX₁} → AuditCP.AuditExperiment Θ X₀ → AuditCP.AuditExperiment Θ X₁ → Prop

DefinitionAuditCP.FactorsThroughPublicdef
The channel K factors through the public coordinate: ∃ H, ∀ s a, K (s, a) = H s.
```
{S : Type uS} → {A : Type uA} → {Y : Type uY} → AuditCP.AuditChannel S A Y → Prop
```
DefinitionAuditCP.learnerExperimentdef
The channel revealing the public state together with K's output, fun sa => (K sa).map (fun y => (sa.1, y)).
```
{S : Type uS} → {A : Type uA} → {Y : Type uY} → AuditCP.AuditChannel S A Y → AuditCP.AuditChannel S A (S × Y)
```
DefinitionAuditCP.publicOnlyExperimentdef
The channel revealing exactly the public state s and nothing else, fun (s, a) => PMF.pure s.
```
{S : Type uS} → {A : Type uA} → AuditCP.AuditChannel S A S
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

F3 — AuditSealed K ↔ ∀ s a a', equalPriorBayesError (K (s, a)) (K (s, a')) = 1/2.

DeclAuditCP.auditSealed_iff_no_binary_decision_advantage

∀ {S : Type uS} {A : Type uA} {Y : Type uY} [inst : Fintype Y] (K : AuditCP.AuditChannel S A Y),
  AuditCP.AuditSealed K ↔ ∀ (s : S) (a a' : A), AuditCP.equalPriorBayesError (K (s, a)) (K (s, a')) = 1 / 2

ThesisStepDefinition

DeclAuditCP.auditSealed_iff_no_binary_decision_advantageDeclaration kindtheorem

∀ {S : Type uS} {A : Type uA} {Y : Type uY} [inst : Fintype Y] (K : AuditCP.AuditChannel S A Y),
  AuditCP.AuditSealed K ↔ ∀ (s : S) (a a' : A), AuditCP.equalPriorBayesError (K (s, a)) (K (s, a')) = 1 / 2

AuditCP.AuditChannel AuditCP.AuditSealed AuditCP.equalPriorBayesError

Uses

AuditCP.equalPriorBayesError_eq_half_iff

DeclAuditCP.equalPriorBayesError_eq_half_iffDeclaration kindtheorem
F3b — equalPriorBayesError p q = 1/2 ↔ p = q.
```
∀ {Y : Type uY} [inst : Fintype Y] (p q : PMF Y), AuditCP.equalPriorBayesError p q = 1 / 2 ↔ p = q
```
AuditCP.equalPriorBayesError AuditCP.finiteTotalVariation
Uses
- AuditCP.equalPriorBayesError_eq_half_one_sub_tv
- AuditCP.finiteTotalVariation_eq_zero_iff
Used by
- AuditCP.auditSealed_iff_no_binary_decision_advantage
DeclAuditCP.finiteTotalVariation_eq_zero_iffDeclaration kindtheorem
finiteTotalVariation p q = 0 ↔ p = q.
```
∀ {Y : Type uY} [inst : Fintype Y] (p q : PMF Y), AuditCP.finiteTotalVariation p q = 0 ↔ p = q
```
AuditCP.finiteTotalVariation AuditCP.pmfMass
Used by
- AuditCP.equalPriorBayesError_eq_half_iff
DeclAuditCP.equalPriorBayesError_eq_half_one_sub_tvDeclaration kindtheorem
F3a — equalPriorBayesError p q = (1 - finiteTotalVariation p q) / 2.
```
∀ {Y : Type uY} [inst : Fintype Y] (p q : PMF Y),
  AuditCP.equalPriorBayesError p q = (1 - AuditCP.finiteTotalVariation p q) / 2
```
AuditCP.equalPriorBayesError AuditCP.finiteTotalVariation AuditCP.pmfMass
Uses
- AuditCP.min_eq_add_sub_abs_div_two
- AuditCP.sum_pmfMass_eq_one
Used by
- AuditCP.equalPriorBayesError_eq_half_iff
DeclAuditCP.sum_pmfMass_eq_oneDeclaration kindtheorem
On a finite type, the real point masses of p sum to 1.
```
∀ {Y : Type uY} [inst : Fintype Y] (p : PMF Y), ∑ y, AuditCP.pmfMass p y = 1
```
AuditCP.pmfMass
Used by
- AuditCP.equalPriorBayesError_eq_half_one_sub_tv
DeclAuditCP.min_eq_add_sub_abs_div_twoDeclaration kindtheorem
min x y = (x + y - |x - y|) / 2.
```
∀ (x y : ℝ), min x y = (x + y - |x - y|) / 2
```
Used by
- AuditCP.equalPriorBayesError_eq_half_one_sub_tv
DefinitionAuditCP.AuditChanneldef
B6 — AuditChannel S A Y is AuditExperiment (S × A) Y, an experiment whose parameter is split into a public coordinate S and an audit coordinate A.
```
AuditCP.AuditIndex → AuditCP.AuditIndex → AuditCP.AuditIndex → Type (max u v w)
```
DefinitionAuditCP.AuditSealeddef
The channel K is audit-sealed: its output law at fixed public state s does not depend on the audit state a.
```
{S : Type uS} → {A : Type uA} → {Y : Type uY} → AuditCP.AuditChannel S A Y → Prop
```
DefinitionAuditCP.equalPriorBayesErrordef
The equal-prior Bayes error between p and q, (1/2) * ∑ y, min (pmfMass p y) (pmfMass q y).
```
{Y : Type uY} → [Fintype Y] → PMF Y → PMF Y → ℝ
```
DefinitionAuditCP.finiteTotalVariationdef
The total variation distance between p and q, half the ℓ¹ distance of their point masses, (1/2) * ∑ y, |pmfMass p y - pmfMass q y|.
```
{Y : Type uY} → [Fintype Y] → PMF Y → PMF Y → ℝ
```
DefinitionAuditCP.pmfMassdef
The real-valued point mass of y under the Mathlib PMF p, (p y).toReal.
```
{Y : Type uY} → PMF Y → Y → ℝ
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

Choquet capacitability. For analytic sets, capacity equals the supremum over compact subsets (Kechris 30.13).

DeclMeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] [PolishSpace α]
  {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap →
    ∀ {s : Set α}, MeasureTheory.AnalyticSet s → cap s = ⨆ K, ⨆ (_ : IsCompact K), ⨆ (_ : K ⊆ s), cap K

ThesisStepHypothesisDefinition

DeclMeasureTheory.AnalyticSet.cap_eq_iSup_isCompactDeclaration kindtheorem
```
∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] [PolishSpace α]
  {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap →
    ∀ {s : Set α}, MeasureTheory.AnalyticSet s → cap s = ⨆ K, ⨆ (_ : IsCompact K), ⨆ (_ : K ⊆ s), cap K
```
Bnd Cyl MeasureTheory.IsChoquetCapacity
Uses
Declmonotone_cyl_splitDeclaration kindtheorem
```
∀ (N : ℕ → ℕ) (n : ℕ), Monotone fun k => Cyl N n ∩ {g | g (n + 1) ≤ k}
```
Cyl
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact
DecliInter_closure_image_cyl_eqDeclaration kindtheorem
The intersection of closures of cylinder images equals the compact image. Key lemma for the capacitability proof: uses truncation and sequential compactness.
```
∀ {α : Type u_1} [inst : TopologicalSpace α] [PolishSpace α] {f : (ℕ → ℕ) → α},
  Continuous f → ∀ (N : ℕ → ℕ), ⋂ n, closure (f '' Cyl N n) = f '' Bnd N
```
Bnd Cyl choquetTruncate
Uses
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact
Decltruncate_mem_bndDeclaration kindtheorem
```
∀ (N g : ℕ → ℕ), choquetTruncate N g ∈ Bnd N
```
Bnd choquetTruncate
Used by
- iInter_closure_image_cyl_eq
Decltruncate_agree_on_cylDeclaration kindtheorem
```
∀ (N : ℕ → ℕ) (n : ℕ), ∀ g ∈ Cyl N n, ∀ i ≤ n, choquetTruncate N g i = g i
```
Cyl choquetTruncate
Used by
- iInter_closure_image_cyl_eq
DeclisCompact_bndDeclaration kindtheorem
```
∀ (N : ℕ → ℕ), IsCompact (Bnd N)
```
Bnd
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact
- iInter_closure_image_cyl_eq
Declbnd_subset_cylDeclaration kindtheorem
```
∀ (N : ℕ → ℕ) (n : ℕ), Bnd N ⊆ Cyl N n
```
Bnd Cyl
Used by
- iInter_closure_image_cyl_eq
Declcyl_succ_eqDeclaration kindtheorem
```
∀ (N : ℕ → ℕ) (n : ℕ), Cyl N n = ⋃ k, Cyl N n ∩ {g | g (n + 1) ≤ k}
```
Cyl
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

Declcyl_inter_eq_cyl_updateDeclaration kindtheorem

∀ (N : ℕ → ℕ) (n k : ℕ), Cyl N n ∩ {g | g (n + 1) ≤ k} = Cyl (Function.update N (n + 1) k) (n + 1)

Cyl

Used by

MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

Declcyl_extDeclaration kindtheorem
```
∀ (N N' : ℕ → ℕ) (n : ℕ), (∀ i ≤ n, N i = N' i) → Cyl N n = Cyl N' n
```
Cyl
Used by
- MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

DeclMeasureTheory.IsChoquetCapacity.monoDeclaration kindtheorem

∀ {α : Type u_1} [inst : TopologicalSpace α] {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap → ∀ {s t : Set α}, s ⊆ t → cap s ≤ cap t

MeasureTheory.IsChoquetCapacity

Used by

MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

DeclMeasureTheory.IsChoquetCapacity.iUnion_natDeclaration kindtheorem

∀ {α : Type u_1} [inst : TopologicalSpace α] {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap → ∀ (f : ℕ → Set α), Monotone f → cap (⋃ n, f n) = ⨆ n, cap (f n)

MeasureTheory.IsChoquetCapacity

Used by

MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

DeclMeasureTheory.IsChoquetCapacity.iInter_closedDeclaration kindtheorem

∀ {α : Type u_1} [inst : TopologicalSpace α] {cap : Set α → ENNReal},
  MeasureTheory.IsChoquetCapacity cap →
    ∀ (f : ℕ → Set α), Antitone f → (∀ (n : ℕ), IsClosed (f n)) → cap (⋂ n, f n) = ⨅ n, cap (f n)

MeasureTheory.IsChoquetCapacity

Used by

MeasureTheory.AnalyticSet.cap_eq_iSup_isCompact

Hypothesishcap
```
MeasureTheory.IsChoquetCapacity cap
```
Hypothesishs
```
MeasureTheory.AnalyticSet s
```
DefinitionBnddef
Bounded functions set: {g : ℕ → ℕ | ∀ i, g i ≤ N i}.
```
(ℕ → ℕ) → Set (ℕ → ℕ)
```
DefinitionCyldef
Cylinder set: {g : ℕ → ℕ | ∀ i ≤ n, g i ≤ N i}.
```
(ℕ → ℕ) → ℕ → Set (ℕ → ℕ)
```
DefinitionMeasureTheory.IsChoquetCapacitystructure
Bundled record of the three Choquet capacity axioms: monotonicity, sequential continuity from below along increasing unions, and sequential continuity from above along decreasing intersections of closed sets. The third axiom distinguishes a capacity from a general outer measure.
```
{α : Type u_1} → [TopologicalSpace α] → (Set α → ENNReal) → Prop
```
DefinitionchoquetTruncatedef
Truncation: replace g i by min (g i) (N i) to bring any g into the bounded set.
```
(ℕ → ℕ) → (ℕ → ℕ) → ℕ → ℕ
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

The discrete Vorob'ev theorem: a cover's base structure is acyclic exactly when local pairwise consistency always forces a global structure, i.e. every pairwise-consistent family of nonempty local relations on it glues.

DeclHiddenChannelCapacity.acyclic_iff_forall_consistent_glues

∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : Fintype ι] (𝒞 : Finset (Finset ι)),
  HiddenChannelCapacity.Acyclic 𝒞 ↔
    ∀ (fam : List (HiddenChannelCapacity.LocalStruct ι fun x => ZMod 2)),
      List.map (fun x => x.team) fam = 𝒞.toList →
        HiddenChannelCapacity.Consistent fam → (∀ L ∈ fam, L.rel.Nonempty) → HiddenChannelCapacity.Glues fam

ThesisStepDefinition

DeclHiddenChannelCapacity.acyclic_iff_forall_consistent_gluesDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : Fintype ι] (𝒞 : Finset (Finset ι)),
  HiddenChannelCapacity.Acyclic 𝒞 ↔
    ∀ (fam : List (HiddenChannelCapacity.LocalStruct ι fun x => ZMod 2)),
      List.map (fun x => x.team) fam = 𝒞.toList →
        HiddenChannelCapacity.Consistent fam → (∀ L ∈ fam, L.rel.Nonempty) → HiddenChannelCapacity.Glues fam
```
HiddenChannelCapacity.Acyclic HiddenChannelCapacity.Consistent HiddenChannelCapacity.Glues HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.decidableAcyclic
Uses
- HiddenChannelCapacity.exists_consistent_not_glues_of_not_acyclic
- HiddenChannelCapacity.glues_of_acyclic
DeclHiddenChannelCapacity.glues_of_acyclicDeclaration kindtheorem
The order-free amalgamation theorem: an acyclic cover forces every pairwise-consistent family with duplicate-free teams to glue. The base structure, acyclicity, is decidable, so the sufficiency is machine-checkable.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {X : ι → Type u_2} [inst_1 : (i : ι) → DecidableEq (X i)] [inst_2 : Fintype ι]
  [(i : ι) → Fintype (X i)] [∀ (i : ι), Nonempty (X i)] (fam : List (HiddenChannelCapacity.LocalStruct ι X)),
  HiddenChannelCapacity.Consistent fam →
    (List.map (fun x => x.team) fam).Nodup →
      HiddenChannelCapacity.Acyclic (List.map (fun x => x.team) fam).toFinset → HiddenChannelCapacity.Glues fam
```
HiddenChannelCapacity.Acyclic HiddenChannelCapacity.Consistent HiddenChannelCapacity.Glues HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.RIP HiddenChannelCapacity.RIPCover
Uses
Used by
- HiddenChannelCapacity.acyclic_iff_forall_consistent_glues
DeclHiddenChannelCapacity.rip_iff_ripCoverDeclaration kindtheorem
The family-level running intersection property reads only the teams.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {X : ι → Type u_2} (fam : List (HiddenChannelCapacity.LocalStruct ι X)),
  HiddenChannelCapacity.RIP fam ↔ HiddenChannelCapacity.RIPCover (List.map (fun x => x.team) fam)
```
HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.RIP HiddenChannelCapacity.RIPCover HiddenChannelCapacity.famCover HiddenChannelCapacity.listCover
Uses
- HiddenChannelCapacity.famCover_eq_listCover
Used by
- HiddenChannelCapacity.glues_of_acyclic
DeclHiddenChannelCapacity.famCover_eq_listCoverDeclaration kindtheorem
```
∀ {ι : Type u_1} {X : ι → Type u_2} [inst : DecidableEq ι] (fam : List (HiddenChannelCapacity.LocalStruct ι X)),
  HiddenChannelCapacity.famCover fam = HiddenChannelCapacity.listCover (List.map (fun x => x.team) fam)
```
HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.famCover HiddenChannelCapacity.listCover
Used by
- HiddenChannelCapacity.rip_iff_ripCover
DeclHiddenChannelCapacity.glues_of_ripDeclaration kindtheorem
The amalgamation leg: over a running-intersection cover, a pairwise-consistent family glues: the base geometry forces the global structure.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {X : ι → Type u_2} [inst_1 : (i : ι) → DecidableEq (X i)] [inst_2 : Fintype ι]
  [(i : ι) → Fintype (X i)] [∀ (i : ι), Nonempty (X i)] (fam : List (HiddenChannelCapacity.LocalStruct ι X)),
  HiddenChannelCapacity.RIP fam → HiddenChannelCapacity.Consistent fam → HiddenChannelCapacity.Glues fam
```
HiddenChannelCapacity.Consistent HiddenChannelCapacity.Glues HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.RIP HiddenChannelCapacity.joinFam HiddenChannelCapacity.projS
Uses
- HiddenChannelCapacity.projS_joinFam
Used by
- HiddenChannelCapacity.glues_of_acyclic
DeclHiddenChannelCapacity.projS_joinFamDeclaration kindtheorem
The amalgamation theorem (positive Vorob'ev, certificate form): once the cover carries the running intersection property, the natural join of any pairwise-consistent family realizes every member exactly, so the base geometry licenses the global structure.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {X : ι → Type u_2} [inst_1 : (i : ι) → DecidableEq (X i)] [inst_2 : Fintype ι]
  [inst_3 : (i : ι) → Fintype (X i)] [∀ (i : ι), Nonempty (X i)] (fam : List (HiddenChannelCapacity.LocalStruct ι X)),
  HiddenChannelCapacity.RIP fam →
    HiddenChannelCapacity.Consistent fam →
      ∀ L ∈ fam, HiddenChannelCapacity.projS (HiddenChannelCapacity.joinFam fam) L.team = L.rel
```
HiddenChannelCapacity.Consistent HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.imarg HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.RIP HiddenChannelCapacity.famCover HiddenChannelCapacity.joinFam HiddenChannelCapacity.projS
Uses
Used by
- HiddenChannelCapacity.glues_of_rip

DeclHiddenChannelCapacity.team_subset_famCoverDeclaration kindtheorem

∀ {ι : Type u_1} [inst : DecidableEq ι] {X : ι → Type u_2} {fam : List (HiddenChannelCapacity.LocalStruct ι X)}
  {L : HiddenChannelCapacity.LocalStruct ι X}, L ∈ fam → L.team ⊆ HiddenChannelCapacity.famCover fam

HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.famCover

Used by

HiddenChannelCapacity.projS_joinFam

DeclHiddenChannelCapacity.projS_image_restrict₂Declaration kindtheorem
The presheaf law: the restriction map carries the T-marginal onto the S-marginal. This is the compatibility any Čech-type complex over the marginal family consumes.
```
∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → DecidableEq (X i)] (κ : Finset ((i : ι) → X i)) {S T : Finset ι}
  (hST : S ⊆ T), Finset.image (Finset.restrict₂ hST) (HiddenChannelCapacity.projS κ T) = HiddenChannelCapacity.projS κ S
```
HiddenChannelCapacity.projS
Used by
- HiddenChannelCapacity.projS_joinFam

DeclHiddenChannelCapacity.mem_joinFamDeclaration kindtheorem

∀ {ι : Type u_1} [inst : DecidableEq ι] {X : ι → Type u_2} [inst_1 : (i : ι) → DecidableEq (X i)] [inst_2 : Fintype ι]
  [inst_3 : (i : ι) → Fintype (X i)] {fam : List (HiddenChannelCapacity.LocalStruct ι X)} {f : (i : ι) → X i},
  f ∈ HiddenChannelCapacity.joinFam fam ↔ ∀ L ∈ fam, L.team.restrict f ∈ L.rel

HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.joinFam

Used by

HiddenChannelCapacity.projS_joinFam

DeclHiddenChannelCapacity.exists_restrict_eqDeclaration kindtheorem
Any local configuration extends to a global one, on nonempty parts.
```
∀ {ι : Type u_1} {X : ι → Type u_2} [∀ (i : ι), Nonempty (X i)] (T : Finset ι) (g : (i : ↥T) → X ↑i),
  ∃ f, T.restrict f = g
```
Used by
- HiddenChannelCapacity.projS_joinFam
DeclHiddenChannelCapacity.LocalStruct.imarg_imageDeclaration kindtheorem
Sub-marginalizing an interface marginal composes.
```
∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → DecidableEq (X i)] (L : HiddenChannelCapacity.LocalStruct ι X)
  {S T : Finset ι} (hS : S ⊆ T) (hT : T ⊆ L.team), Finset.image (Finset.restrict₂ hS) (L.imarg hT) = L.imarg ⋯
```
HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.imarg HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team
Used by
- HiddenChannelCapacity.projS_joinFam
DeclHiddenChannelCapacity.glues_of_permDeclaration kindtheorem
Gluing is permutation-invariant.
```
∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → DecidableEq (X i)] [inst_1 : Fintype ι] [(i : ι) → Fintype (X i)]
  {fam fam' : List (HiddenChannelCapacity.LocalStruct ι X)},
  fam'.Perm fam → HiddenChannelCapacity.Glues fam' → HiddenChannelCapacity.Glues fam
```
HiddenChannelCapacity.Glues HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.projS
Used by
- HiddenChannelCapacity.glues_of_acyclic
DeclHiddenChannelCapacity.exists_perm_map_eqDeclaration kindtheorem
A permutation of a mapped list lifts along the map.
```
∀ {α : Type u_3} {β : Type u_4} {g : α → β} {σ : List β} {l : List α},
  σ.Perm (List.map g l) → ∃ l', l'.Perm l ∧ List.map g l' = σ
```
Used by
- HiddenChannelCapacity.glues_of_acyclic

DeclHiddenChannelCapacity.consistent_of_permDeclaration kindtheorem

Pairwise consistency is permutation-invariant.

∀ {ι : Type u_1} [inst : DecidableEq ι] {X : ι → Type u_2} [inst_1 : (i : ι) → DecidableEq (X i)]
  {fam fam' : List (HiddenChannelCapacity.LocalStruct ι X)},
  fam'.Perm fam → HiddenChannelCapacity.Consistent fam → HiddenChannelCapacity.Consistent fam'

HiddenChannelCapacity.Consistent HiddenChannelCapacity.LocalStruct

Used by

HiddenChannelCapacity.glues_of_acyclic

DeclHiddenChannelCapacity.exists_consistent_not_glues_of_not_acyclicDeclaration kindtheorem
The CAPSTONE: a non-acyclic cover hosts a pairwise-consistent family of nonempty local relations that no global structure realizes: the base structure carries what local consistency cannot.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : Fintype ι] (𝒞 : Finset (Finset ι)),
  ¬HiddenChannelCapacity.Acyclic 𝒞 →
    ∃ fam,
      List.map (fun x => x.team) fam = 𝒞.toList ∧
        HiddenChannelCapacity.Consistent fam ∧ (∀ L ∈ fam, L.rel.Nonempty) ∧ ¬HiddenChannelCapacity.Glues fam
```
HiddenChannelCapacity.Acyclic HiddenChannelCapacity.Consistent HiddenChannelCapacity.EarFree HiddenChannelCapacity.Glues HiddenChannelCapacity.GrahamReducible HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team
Uses
Used by
- HiddenChannelCapacity.acyclic_iff_forall_consistent_glues
DeclHiddenChannelCapacity.earFree_dichotomyDeclaration kindtheorem
The ear-free dichotomy: an ear-free cover is non-conformal or contains a chordless cycle. Dirac's lemma on the shared vertices produces a simplicial shared vertex, and the one-step GYO collapse turns it into an ear.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (𝒞 : Finset (Finset ι)),
  HiddenChannelCapacity.EarFree 𝒞 → ¬HiddenChannelCapacity.Conformal 𝒞 ∨ ∃ l, HiddenChannelCapacity.IsChordlessCycle 𝒞 l
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.Conformal HiddenChannelCapacity.EarFree HiddenChannelCapacity.IsChordlessCycle HiddenChannelCapacity.IsEarOf HiddenChannelCapacity.SimpIn HiddenChannelCapacity.shared
Uses
Used by
- HiddenChannelCapacity.exists_consistent_not_glues_of_not_acyclic
DeclHiddenChannelCapacity.shared_nonempty_of_earFreeDeclaration kindtheorem
An ear-free cover has a shared vertex: every team has nonempty boundary.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)},
  HiddenChannelCapacity.EarFree 𝒞 → (HiddenChannelCapacity.shared 𝒞).Nonempty
```
HiddenChannelCapacity.EarFree HiddenChannelCapacity.IsEarOf HiddenChannelCapacity.coverU HiddenChannelCapacity.shared
Uses
- HiddenChannelCapacity.bndry_eq_inter_shared
Used by
- HiddenChannelCapacity.earFree_dichotomy
DeclHiddenChannelCapacity.isEarOf_of_simplicialDeclaration kindtheorem
The one-step GYO collapse: in a conformal cover, a simplicial shared vertex yields an ear — every team containing it has boundary inside the team covering its closed shared neighborhood.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)},
  HiddenChannelCapacity.Conformal 𝒞 →
    ∀ {v : ι},
      v ∈ HiddenChannelCapacity.shared 𝒞 →
        (∀ x ∈ HiddenChannelCapacity.shared 𝒞,
            ∀ y ∈ HiddenChannelCapacity.shared 𝒞,
              HiddenChannelCapacity.Adj 𝒞 v x →
                HiddenChannelCapacity.Adj 𝒞 v y → x ≠ y → HiddenChannelCapacity.Adj 𝒞 x y) →
          ∃ T ∈ 𝒞, HiddenChannelCapacity.IsEarOf 𝒞 T
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.Conformal HiddenChannelCapacity.Covered HiddenChannelCapacity.IsClique HiddenChannelCapacity.IsEarOf HiddenChannelCapacity.coverU HiddenChannelCapacity.instDecidableAdj HiddenChannelCapacity.shared
Uses
Used by
- HiddenChannelCapacity.earFree_dichotomy
DeclHiddenChannelCapacity.bndry_eq_inter_sharedDeclaration kindtheorem
A team's boundary is its shared part.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)} {T : Finset ι},
  T ∈ 𝒞 → T ∩ HiddenChannelCapacity.coverU (𝒞.erase T) = T ∩ HiddenChannelCapacity.shared 𝒞
```
HiddenChannelCapacity.coverU HiddenChannelCapacity.shared
Uses
- HiddenChannelCapacity.mem_coverU
- HiddenChannelCapacity.mem_shared
Used by
- HiddenChannelCapacity.isEarOf_of_simplicial
- HiddenChannelCapacity.shared_nonempty_of_earFree
DeclHiddenChannelCapacity.mem_sharedDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)} {v : ι},
  v ∈ HiddenChannelCapacity.shared 𝒞 ↔ ∃ T ∈ 𝒞, ∃ T' ∈ 𝒞, T ≠ T' ∧ v ∈ T ∧ v ∈ T'
```
HiddenChannelCapacity.coverU HiddenChannelCapacity.shared
Uses
- HiddenChannelCapacity.mem_coverU
Used by
- HiddenChannelCapacity.bndry_eq_inter_shared
- HiddenChannelCapacity.isEarOf_of_simplicial
DeclHiddenChannelCapacity.dirac_strongDeclaration kindtheorem
Dirac's lemma, strong form: in a chordless-cycle-free adjacency structure, every vertex set is a clique or contains two nonadjacent simplicial vertices.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (𝒞 : Finset (Finset ι)),
  (¬∃ l, HiddenChannelCapacity.IsChordlessCycle 𝒞 l) →
    ∀ (S : Finset ι),
      (∀ x ∈ S, ∀ y ∈ S, x ≠ y → HiddenChannelCapacity.Adj 𝒞 x y) ∨
        ∃ u w,
          HiddenChannelCapacity.SimpIn 𝒞 S u ∧
            HiddenChannelCapacity.SimpIn 𝒞 S w ∧ u ≠ w ∧ ¬HiddenChannelCapacity.Adj 𝒞 u w
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsChordlessCycle HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn HiddenChannelCapacity.SimpIn HiddenChannelCapacity.instDecidableAdj
Uses
Used by
- HiddenChannelCapacity.earFree_dichotomy

DeclHiddenChannelCapacity.sep_clique_stepDeclaration kindtheorem

The assembled-cycle contradiction: two length-minimal x-y connectors through disjoint, mutually non-adjacent sides cannot coexist with chordless-cycle-freeness when x and y are non-adjacent.

∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)},
  (¬∃ l, HiddenChannelCapacity.IsChordlessCycle 𝒞 l) →
    ∀ {QA QB : ι → Prop} {x y : ι},
      x ≠ y →
        ¬HiddenChannelCapacity.Adj 𝒞 x y →
          ¬QB x →
            ¬QB y →
              (∀ (v : ι), QA v → QB v → False) →
                (∀ (u v : ι), QA u → QB v → ¬HiddenChannelCapacity.Adj 𝒞 u v) →
                  ∀ (pA : List ι),
                    List.IsChain (HiddenChannelCapacity.Adj 𝒞) pA →
                      pA.Nodup →
                        pA.head? = some x →
                          pA.getLast? = some y →
                            (∀ v ∈ pA, v = x ∨ v = y ∨ QA v) →
                              (∀ (q : List ι),
                                  (List.IsChain (HiddenChannelCapacity.Adj 𝒞) q ∧
                                      q.Nodup ∧
                                        q.head? = some x ∧ q.getLast? = some y ∧ ∀ v ∈ q, v = x ∨ v = y ∨ QA v) →
                                    pA.length ≤ q.length) →
                                ∀ (pB : List ι),
                                  List.IsChain (HiddenChannelCapacity.Adj 𝒞) pB →
                                    pB.Nodup →
                                      pB.head? = some x →
                                        pB.getLast? = some y →
                                          (∀ v ∈ pB, v = x ∨ v = y ∨ QB v) →
                                            (∀ (q : List ι),
                                                (List.IsChain (HiddenChannelCapacity.Adj 𝒞) q ∧
                                                    q.Nodup ∧
                                                      q.head? = some x ∧
                                                        q.getLast? = some y ∧ ∀ v ∈ q, v = x ∨ v = y ∨ QB v) →
                                                  pB.length ≤ q.length) →
                                              False

HiddenChannelCapacity.Adj HiddenChannelCapacity.IsChordlessCycle HiddenChannelCapacity.cyclePairs

Uses

HiddenChannelCapacity.Adj.symm'
HiddenChannelCapacity.getElem_cyclePairs
HiddenChannelCapacity.getLast_getElem
HiddenChannelCapacity.head_getElem
HiddenChannelCapacity.length_cyclePairs
HiddenChannelCapacity.mod_succ_cases
HiddenChannelCapacity.no_chord_of_minimal

Used by

HiddenChannelCapacity.dirac_strong

DeclHiddenChannelCapacity.no_chord_of_minimalDeclaration kindtheorem

Minimality kills chords: a length-minimal constrained x-y path has no adjacency between positions at distance ≥ 2.

∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {Q : ι → Prop} {x y : ι} {p : List ι},
  List.IsChain (HiddenChannelCapacity.Adj 𝒞) p →
    p.head? = some x →
      p.getLast? = some y →
        (∀ v ∈ p, v = x ∨ v = y ∨ Q v) →
          (∀ (q : List ι),
              (List.IsChain (HiddenChannelCapacity.Adj 𝒞) q ∧
                  q.Nodup ∧ q.head? = some x ∧ q.getLast? = some y ∧ ∀ v ∈ q, v = x ∨ v = y ∨ Q v) →
                p.length ≤ q.length) →
            p.Nodup →
              ∀ {i j : ℕ} (hi : i < p.length) (hj : j < p.length), i + 2 ≤ j → ¬HiddenChannelCapacity.Adj 𝒞 p[i] p[j]

HiddenChannelCapacity.Adj

Uses

HiddenChannelCapacity.isChain_drop
HiddenChannelCapacity.isChain_take

Used by

HiddenChannelCapacity.sep_clique_step

DeclHiddenChannelCapacity.getLast_getElemDeclaration kindtheorem

∀ {ι : Type u_1} {p : List ι} {y : ι}, p.getLast? = some y → ∀ (h0 : 0 < p.length), p[p.length - 1] = y

Used by

HiddenChannelCapacity.sep_clique_step

DeclHiddenChannelCapacity.reachOn_transDeclaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u v w : ι},
  HiddenChannelCapacity.ReachOn 𝒞 P u v → HiddenChannelCapacity.ReachOn 𝒞 P v w → HiddenChannelCapacity.ReachOn 𝒞 P u w
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.reachOn_of_walk
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_symmDeclaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u v : ι},
  HiddenChannelCapacity.ReachOn 𝒞 P u v → HiddenChannelCapacity.ReachOn 𝒞 P v u
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.Adj.symm'
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_reflDeclaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u : ι}, P u → HiddenChannelCapacity.ReachOn 𝒞 P u u
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_of_mem_walkDeclaration kindtheorem
Every vertex on a walk is reachable from its head.
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u v : ι} {p : List ι},
  HiddenChannelCapacity.IsWalkOn 𝒞 P p → p.head? = some u → v ∈ p → HiddenChannelCapacity.ReachOn 𝒞 P u v
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.isChain_take
- HiddenChannelCapacity.reachOn_of_walk
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_extendDeclaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u v w : ι},
  HiddenChannelCapacity.ReachOn 𝒞 P u v → HiddenChannelCapacity.Adj 𝒞 v w → P w → HiddenChannelCapacity.ReachOn 𝒞 P u w
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.reachOn_of_walk
Used by
- HiddenChannelCapacity.dirac_strong

DeclHiddenChannelCapacity.exists_min_pathDeclaration kindtheorem

∀ {ι : Type u_1} {Q : List ι → Prop}, (∃ p, Q p) → ∃ p, Q p ∧ ∀ (q : List ι), Q q → p.length ≤ q.length

Used by

HiddenChannelCapacity.dirac_strong

DeclHiddenChannelCapacity.exists_connectorDeclaration kindtheorem

A connector: an x-y path with interior inside Q, from adjacent entry points and interior reachability.

∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {Q : ι → Prop} {x y u₁ u₂ : ι},
  x ≠ y →
    HiddenChannelCapacity.Adj 𝒞 x u₁ →
      HiddenChannelCapacity.Adj 𝒞 y u₂ →
        HiddenChannelCapacity.ReachOn 𝒞 Q u₁ u₂ →
          ¬Q x →
            ¬Q y →
              ∃ p,
                List.IsChain (HiddenChannelCapacity.Adj 𝒞) p ∧
                  p.Nodup ∧ p.head? = some x ∧ p.getLast? = some y ∧ ∀ v ∈ p, v = x ∨ v = y ∨ Q v

HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn

Uses

HiddenChannelCapacity.Adj.symm'

Used by

HiddenChannelCapacity.dirac_strong

DeclHiddenChannelCapacity.erase_separatesDeclaration kindtheorem
If x has no neighbor reachable from a off the separator, then erasing x still separates: the first x-occurrence on any violating path has its predecessor reachable from a and adjacent to x.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)} {S Sep : Finset ι} {a b x : ι},
  x ≠ a →
    (∀ (u : ι),
        u ∈ S \ Sep ∧ HiddenChannelCapacity.ReachOn 𝒞 (fun v => v ∈ S \ Sep) a u → ¬HiddenChannelCapacity.Adj 𝒞 x u) →
      ¬HiddenChannelCapacity.ReachOn 𝒞 (fun v => v ∈ S \ Sep) a b →
        ¬HiddenChannelCapacity.ReachOn 𝒞 (fun v => v ∈ S \ Sep.erase x) a b
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_of_walkDeclaration kindtheorem
Every chained walk contains a duplicate-free path with the same endpoints and vertices.
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} (p : List ι),
  HiddenChannelCapacity.IsWalkOn 𝒞 P p →
    ∀ {u v : ι}, p.head? = some u → p.getLast? = some v → HiddenChannelCapacity.ReachOn 𝒞 P u v
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.isChain_drop
- HiddenChannelCapacity.isChain_take
Used by
DeclHiddenChannelCapacity.isChain_dropDeclaration kindtheorem
```
∀ {ι : Type u_1} {R : ι → ι → Prop} {p : List ι}, List.IsChain R p → ∀ (n : ℕ), List.IsChain R (List.drop n p)
```
Used by
- HiddenChannelCapacity.no_chord_of_minimal
- HiddenChannelCapacity.reachOn_of_walk
DeclHiddenChannelCapacity.isChain_takeDeclaration kindtheorem
```
∀ {ι : Type u_1} {R : ι → ι → Prop} {p : List ι}, List.IsChain R p → ∀ (n : ℕ), List.IsChain R (List.take n p)
```
Used by
DeclHiddenChannelCapacity.head_getElemDeclaration kindtheorem
Positional form of the head.
```
∀ {ι : Type u_1} {p : List ι} {x : ι}, p.head? = some x → ∀ (h0 : 0 < p.length), p[0] = x
```
Used by
- HiddenChannelCapacity.erase_separates
- HiddenChannelCapacity.sep_clique_step

DeclHiddenChannelCapacity.gcast_listDeclaration kindtheorem

∀ {ι : Type u_1} (l : List ι) {s t : ℕ} (hs : s < l.length) (ht : t < l.length), s = t → l[s] = l[t]

Used by

HiddenChannelCapacity.erase_separates

DeclHiddenChannelCapacity.Adj.symm'Declaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {u v : ι}, HiddenChannelCapacity.Adj 𝒞 u v → HiddenChannelCapacity.Adj 𝒞 v u
```
HiddenChannelCapacity.Adj
Used by
DeclHiddenChannelCapacity.capstone_of_dichotomyDeclaration kindtheorem
The capstone, modulo the dichotomy: once every ear-free core is non-conformal or has a chordless cycle (the Dirac edge, URS D26 L6), every non-Graham-reducible cover hosts the base structure that licenses the verdict: a pairwise-consistent family of nonempty local relations that no global structure realizes.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : Fintype ι] (𝒞 : Finset (Finset ι)),
  ¬HiddenChannelCapacity.GrahamReducible 𝒞 →
    (∀ 𝒞' ⊆ 𝒞,
        HiddenChannelCapacity.EarFree 𝒞' →
          ¬HiddenChannelCapacity.Conformal 𝒞' ∨ ∃ l, HiddenChannelCapacity.IsChordlessCycle 𝒞' l) →
      ∃ fam,
        List.map (fun x => x.team) fam = 𝒞.toList ∧
          HiddenChannelCapacity.Consistent fam ∧ (∀ L ∈ fam, L.rel.Nonempty) ∧ ¬HiddenChannelCapacity.Glues fam
```
HiddenChannelCapacity.Conformal HiddenChannelCapacity.Consistent HiddenChannelCapacity.EarFree HiddenChannelCapacity.Glues HiddenChannelCapacity.GrahamReducible HiddenChannelCapacity.IsChordlessCycle HiddenChannelCapacity.IsEarOf HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.coverU HiddenChannelCapacity.xorSum
Uses
Used by
- HiddenChannelCapacity.exists_consistent_not_glues_of_not_acyclic
DeclHiddenChannelCapacity.exists_earFree_core_chainDeclaration kindtheorem
Chain extraction: a non-Graham-reducible cover has an ear-free core such that any vertex set inside the core's cover hosted anywhere in the cover is hosted inside the core.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (𝒞 : Finset (Finset ι)),
  ¬HiddenChannelCapacity.GrahamReducible 𝒞 →
    ∃ 𝒞' ⊆ 𝒞,
      HiddenChannelCapacity.EarFree 𝒞' ∧ ∀ w ⊆ HiddenChannelCapacity.coverU 𝒞', (∃ V ∈ 𝒞, w ⊆ V) → ∃ W ∈ 𝒞', w ⊆ W
```
HiddenChannelCapacity.EarFree HiddenChannelCapacity.GrahamN HiddenChannelCapacity.GrahamReducible HiddenChannelCapacity.IsEarOf HiddenChannelCapacity.coverU HiddenChannelCapacity.decidableIsEarOf
Used by
- HiddenChannelCapacity.capstone_of_dichotomy
DeclHiddenChannelCapacity.clean_system_of_uncovered_cliqueDeclaration kindtheorem
The clique datum: a cardinality-minimal non-covered clique yields a clean system. Minimality covers the erase-sets; non-coveredness is cleanliness; parity closes by counting.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (𝒞 : Finset (Finset ι)),
  𝒞.Nonempty →
    ¬HiddenChannelCapacity.Conformal 𝒞 →
      ∃ 𝒲,
        𝒲.Nonempty ∧
          (∀ w ∈ 𝒲, w ≠ ∅) ∧
            (∀ w ∈ 𝒲, ∃ T ∈ 𝒞, w ⊆ T) ∧
              (∀ V ∈ 𝒞, ∀ w₁ ∈ 𝒲, ∀ w₂ ∈ 𝒲, w₁ ⊆ V → w₂ ⊆ V → w₁ = w₂) ∧ HiddenChannelCapacity.xorSum 𝒲 = ∅
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.Conformal HiddenChannelCapacity.Covered HiddenChannelCapacity.IsClique HiddenChannelCapacity.coverU HiddenChannelCapacity.instDecidableCovered HiddenChannelCapacity.instDecidableIsClique HiddenChannelCapacity.xorSum HiddenChannelCapacity.xorSumL
Uses
Used by
- HiddenChannelCapacity.capstone_of_dichotomy
DeclHiddenChannelCapacity.xorSum_eq_empty_iffDeclaration kindtheorem
An F2 sum vanishes iff every incidence count is even.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {D : Finset (Finset ι)},
  HiddenChannelCapacity.xorSum D = ∅ ↔ ∀ (i : ι), ¬Odd {x ∈ D | i ∈ x}.card
```
HiddenChannelCapacity.xorSum
Uses
- HiddenChannelCapacity.mem_xorSum
Used by
- HiddenChannelCapacity.clean_system_of_uncovered_clique
DeclHiddenChannelCapacity.mem_xorSumDeclaration kindtheorem
Membership in an F2 sum is odd incidence.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {D : Finset (Finset ι)} {i : ι},
  i ∈ HiddenChannelCapacity.xorSum D ↔ Odd {x ∈ D | i ∈ x}.card
```
HiddenChannelCapacity.xorSum
Used by
- HiddenChannelCapacity.xorSum_eq_empty_iff
DeclHiddenChannelCapacity.erase_union_eraseDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {K : Finset ι} {i j : ι}, i ≠ j → K.erase i ∪ K.erase j = K
```
Used by
- HiddenChannelCapacity.clean_system_of_uncovered_clique
DeclHiddenChannelCapacity.covered_of_card_le_twoDeclaration kindtheorem
Small cliques are covered: the empty set (nonempty cover), singletons, edges.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)},
  𝒞.Nonempty →
    ∀ {K : Finset ι},
      K ⊆ HiddenChannelCapacity.coverU 𝒞 →
        HiddenChannelCapacity.IsClique 𝒞 K → K.card ≤ 2 → HiddenChannelCapacity.Covered 𝒞 K
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.Covered HiddenChannelCapacity.IsClique HiddenChannelCapacity.coverU
Uses
- HiddenChannelCapacity.mem_coverU
Used by
- HiddenChannelCapacity.clean_system_of_uncovered_clique
DeclHiddenChannelCapacity.mem_coverUDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)} {v : ι},
  v ∈ HiddenChannelCapacity.coverU 𝒞 ↔ ∃ T ∈ 𝒞, v ∈ T
```
HiddenChannelCapacity.coverU
Used by
DeclHiddenChannelCapacity.clean_system_of_chordlessCycleDeclaration kindtheorem
The clean system of a chordless cycle, in finder form.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)} {l : List ι},
  HiddenChannelCapacity.IsChordlessCycle 𝒞 l →
    ∃ 𝒲,
      𝒲.Nonempty ∧
        (∀ w ∈ 𝒲, w ≠ ∅) ∧
          (∀ w ∈ 𝒲, ∃ T ∈ 𝒞, w ⊆ T) ∧
            (∀ V ∈ 𝒞, ∀ w₁ ∈ 𝒲, ∀ w₂ ∈ 𝒲, w₁ ⊆ V → w₂ ⊆ V → w₁ = w₂) ∧ HiddenChannelCapacity.xorSum 𝒲 = ∅
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsChordlessCycle HiddenChannelCapacity.cyclePairs HiddenChannelCapacity.xorSum HiddenChannelCapacity.xorSumL
Uses
Used by
- HiddenChannelCapacity.capstone_of_dichotomy
DeclHiddenChannelCapacity.xorSumL_cyclePairsDeclaration kindtheorem
The cycle sum telescopes: consecutive pairs of a duplicate-free cyclic list sum to ∅ over F2 — every vertex lies in exactly two pairs.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (l : List ι),
  l.Nodup → 2 ≤ l.length → HiddenChannelCapacity.xorSumL (HiddenChannelCapacity.cyclePairs l) = ∅
```
HiddenChannelCapacity.cyclePairs HiddenChannelCapacity.xorSumL
Uses
Used by
- HiddenChannelCapacity.clean_system_of_chordlessCycle

DeclHiddenChannelCapacity.xorSumL_zipWith_symmDiffDeclaration kindtheorem

∀ {ι : Type u_1} [inst : DecidableEq ι] (l₁ l₂ : List (Finset ι)),
  l₁.length = l₂.length →
    HiddenChannelCapacity.xorSumL (List.zipWith (fun x1 x2 => symmDiff x1 x2) l₁ l₂) =
      symmDiff (HiddenChannelCapacity.xorSumL l₁) (HiddenChannelCapacity.xorSumL l₂)

HiddenChannelCapacity.xorSumL

Uses

HiddenChannelCapacity.symmDiff_empty
HiddenChannelCapacity.xorSumL_cons
HiddenChannelCapacity.xorSumL_nil

Used by

HiddenChannelCapacity.xorSumL_cyclePairs

DeclHiddenChannelCapacity.xorSumL_permDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {l₁ l₂ : List (Finset ι)},
  l₁.Perm l₂ → HiddenChannelCapacity.xorSumL l₁ = HiddenChannelCapacity.xorSumL l₂
```
HiddenChannelCapacity.xorSumL
Uses
- HiddenChannelCapacity.xorSumL_cons
Used by
- HiddenChannelCapacity.xorSumL_cyclePairs
DeclHiddenChannelCapacity.pair_eq_symmDiffDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {a b : ι}, a ≠ b → {a, b} = symmDiff {a} {b}
```
Used by
- HiddenChannelCapacity.xorSumL_cyclePairs
DeclHiddenChannelCapacity.getElem_ne_nextDeclaration kindtheorem
```
∀ {ι : Type u_1} (l : List ι), l.Nodup → ∀ (h2 : 2 ≤ l.length) (i : ℕ) (hi : i < l.length), l[i] ≠ l[(i + 1) % l.length]
```
Uses
- HiddenChannelCapacity.mod_succ_cases
Used by
- HiddenChannelCapacity.xorSumL_cyclePairs
DeclHiddenChannelCapacity.nodup_cyclePairsDeclaration kindtheorem
Distinct positions carry distinct pairs: the pair list is duplicate-free.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (l : List ι),
  l.Nodup → 3 ≤ l.length → (HiddenChannelCapacity.cyclePairs l).Nodup
```
HiddenChannelCapacity.cyclePairs
Uses
Used by
- HiddenChannelCapacity.clean_system_of_chordlessCycle
DeclHiddenChannelCapacity.cyclePairs_ne_emptyDeclaration kindtheorem
Members of the cycle-pair list are nonempty.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {l : List ι},
 0 < l.length → ∀ {w : Finset ι}, w ∈ HiddenChannelCapacity.cyclePairs l → w ≠ ∅
```
HiddenChannelCapacity.cyclePairs
Uses
- HiddenChannelCapacity.getElem_cyclePairs
- HiddenChannelCapacity.length_cyclePairs
Used by
- HiddenChannelCapacity.clean_system_of_chordlessCycle
DeclHiddenChannelCapacity.clean_of_chordlessCycleDeclaration kindtheorem
Chordlessness is cleanliness: no team hosts two distinct pairs of a chordless cycle.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)} {l : List ι},
  HiddenChannelCapacity.IsChordlessCycle 𝒞 l →
    ∀ V ∈ 𝒞,
      ∀ w₁ ∈ HiddenChannelCapacity.cyclePairs l, ∀ w₂ ∈ HiddenChannelCapacity.cyclePairs l, w₁ ⊆ V → w₂ ⊆ V → w₁ = w₂
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsChordlessCycle HiddenChannelCapacity.cyclePairs
Uses
Used by
- HiddenChannelCapacity.clean_system_of_chordlessCycle
DeclHiddenChannelCapacity.mod_succ_casesDeclaration kindtheorem
```
∀ (n i : ℕ), i < n → (i + 1) % n = i + 1 ∧ i + 1 < n ∨ (i + 1) % n = 0 ∧ i + 1 = n
```
Used by
DeclHiddenChannelCapacity.getElem_cyclePairsDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (l : List ι) (h0 : 0 < l.length) (i : ℕ)
 (h : i < (HiddenChannelCapacity.cyclePairs l).length),
 (HiddenChannelCapacity.cyclePairs l)[i] = {l[i], l[(i + 1) % l.length]}
```
HiddenChannelCapacity.cyclePairs
Uses
- HiddenChannelCapacity.length_cyclePairs
Used by
DeclHiddenChannelCapacity.length_cyclePairsDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (l : List ι), (HiddenChannelCapacity.cyclePairs l).length = l.length
```
HiddenChannelCapacity.cyclePairs
Used by
DeclHiddenChannelCapacity.adj_or_eq_of_cohostedDeclaration kindtheorem
Co-hosted vertices are adjacent or equal.
```
∀ {ι : Type u_1} [DecidableEq ι] {𝒞 : Finset (Finset ι)} {V : Finset ι},
  V ∈ 𝒞 → ∀ {u v : ι}, u ∈ V → v ∈ V → HiddenChannelCapacity.Adj 𝒞 u v ∨ u = v
```
HiddenChannelCapacity.Adj
Used by
- HiddenChannelCapacity.clean_of_chordlessCycle

DeclHiddenChannelCapacity.capstone_of_coreDeclaration kindtheorem

The transfer: a clean system on a chained ear-free core is a clean system on the full cover — any team hosting two members routes them into a single core team.

∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : Fintype ι] (𝒞 𝒞' : Finset (Finset ι)),
  𝒞' ⊆ 𝒞 →
    (∀ w ⊆ HiddenChannelCapacity.coverU 𝒞', (∃ V ∈ 𝒞, w ⊆ V) → ∃ W ∈ 𝒞', w ⊆ W) →
      ∀ (𝒲 : Finset (Finset ι)),
        𝒲.Nonempty →
          (∀ w ∈ 𝒲, w ≠ ∅) →
            (∀ w ∈ 𝒲, ∃ T ∈ 𝒞', w ⊆ T) →
              (∀ V ∈ 𝒞', ∀ w₁ ∈ 𝒲, ∀ w₂ ∈ 𝒲, w₁ ⊆ V → w₂ ⊆ V → w₁ = w₂) →
                HiddenChannelCapacity.xorSum 𝒲 = ∅ →
                  ∃ fam,
                    List.map (fun x => x.team) fam = 𝒞.toList ∧
                      HiddenChannelCapacity.Consistent fam ∧
                        (∀ L ∈ fam, L.rel.Nonempty) ∧ ¬HiddenChannelCapacity.Glues fam

HiddenChannelCapacity.Consistent HiddenChannelCapacity.Glues HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.coverU HiddenChannelCapacity.xorSum

Uses

HiddenChannelCapacity.clean_system_obstruction

Used by

HiddenChannelCapacity.capstone_of_dichotomy

DeclHiddenChannelCapacity.clean_system_obstructionDeclaration kindtheorem
The clean-system obstruction, the unified consumption theorem of C-ENGINE: a base-side clean system (a nonempty hosted family of distinct nonempty supports with vanishing F2 sum, no team hosting two) licenses a verdict on local measurement, a pairwise-consistent family of nonempty local relations over the whole cover that no global structure realizes. Every witness rung (chordless cycles, even boundary data, landings, the H_k clique parities) differs only as a FINDER of such a base system.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : Fintype ι] (𝒞 𝒲 : Finset (Finset ι)),
  𝒲.Nonempty →
    (∀ w ∈ 𝒲, w ≠ ∅) →
      (∀ w ∈ 𝒲, ∃ V ∈ 𝒞, w ⊆ V) →
        (∀ V ∈ 𝒞, ∀ w₁ ∈ 𝒲, ∀ w₂ ∈ 𝒲, w₁ ⊆ V → w₂ ⊆ V → w₁ = w₂) →
          HiddenChannelCapacity.xorSum 𝒲 = ∅ →
            ∃ fam,
              List.map (fun x => x.team) fam = 𝒞.toList ∧
                HiddenChannelCapacity.Consistent fam ∧ (∀ L ∈ fam, L.rel.Nonempty) ∧ ¬HiddenChannelCapacity.Glues fam
```
HiddenChannelCapacity.ClosedAt HiddenChannelCapacity.CoherentAt HiddenChannelCapacity.Consistent HiddenChannelCapacity.Glues HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.affFam HiddenChannelCapacity.affLocal HiddenChannelCapacity.xorSum
Uses
- HiddenChannelCapacity.affine_obstruction
- HiddenChannelCapacity.symmDiff_empty
Used by
- HiddenChannelCapacity.capstone_of_core
DeclHiddenChannelCapacity.affine_obstructionDeclaration kindtheorem
The affine obstruction engine, packaged: from a base-side hosted odd dependency (over a closed coherent system) follows a verdict on local measurement, a family of nonempty local relations that is pairwise consistent yet realizes no global structure.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : Fintype ι] {teams : List (Finset ι)} {𝒲 : Finset (Finset ι)}
  {c : Finset ι → ZMod 2},
  teams ≠ [] →
    (∀ V ∈ teams, HiddenChannelCapacity.ClosedAt 𝒲 V) →
      (∀ V ∈ teams, HiddenChannelCapacity.CoherentAt 𝒲 c V) →
        ∀ D ⊆ 𝒲,
          HiddenChannelCapacity.xorSum D = ∅ →
            ∑ w ∈ D, c w = 1 →
              (∀ w ∈ D, ∃ V ∈ teams, w ⊆ V) →
                HiddenChannelCapacity.Consistent (HiddenChannelCapacity.affFam teams 𝒲 c) ∧
                  (∀ L ∈ HiddenChannelCapacity.affFam teams 𝒲 c, L.rel.Nonempty) ∧
                    ¬HiddenChannelCapacity.Glues (HiddenChannelCapacity.affFam teams 𝒲 c)
```
HiddenChannelCapacity.ClosedAt HiddenChannelCapacity.CoherentAt HiddenChannelCapacity.Consistent HiddenChannelCapacity.Glues HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.affFam HiddenChannelCapacity.affLocal HiddenChannelCapacity.xorSum
Uses
Used by
- HiddenChannelCapacity.clean_system_obstruction
DeclHiddenChannelCapacity.not_glues_affFamDeclaration kindtheorem
The obstruction theorem: a hosted odd dependency (a base-side witness) forecloses every global structure; any global realizing all the local relations would satisfy every hosted constraint, and the dependency sums those satisfactions to 0 = 1.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : Fintype ι] {teams : List (Finset ι)} {𝒲 : Finset (Finset ι)}
  {c : Finset ι → ZMod 2},
  teams ≠ [] →
    (∀ V ∈ teams, HiddenChannelCapacity.CoherentAt 𝒲 c V) →
      ∀ D ⊆ 𝒲,
        HiddenChannelCapacity.xorSum D = ∅ →
          ∑ w ∈ D, c w = 1 →
            (∀ w ∈ D, ∃ V ∈ teams, w ⊆ V) → ¬HiddenChannelCapacity.Glues (HiddenChannelCapacity.affFam teams 𝒲 c)
```
HiddenChannelCapacity.CoherentAt HiddenChannelCapacity.Glues HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.affFam HiddenChannelCapacity.affLocal HiddenChannelCapacity.parityOn HiddenChannelCapacity.projS HiddenChannelCapacity.wsum HiddenChannelCapacity.xorSum
Uses
Used by
- HiddenChannelCapacity.affine_obstruction
DeclHiddenChannelCapacity.parityOn_xorSumDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (D : Finset (Finset ι)) (f : ι → ZMod 2),
  HiddenChannelCapacity.parityOn (HiddenChannelCapacity.xorSum D) f = ∑ w ∈ D, HiddenChannelCapacity.parityOn w f
```
HiddenChannelCapacity.parityOn HiddenChannelCapacity.xorSum
Uses
- HiddenChannelCapacity.parityOn_symmDiff
Used by
- HiddenChannelCapacity.not_glues_affFam
DeclHiddenChannelCapacity.consistent_affFamDeclaration kindtheorem
Closed coherent affine families are pairwise consistent: both interface marginals ARE the interface's visible system.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {teams : List (Finset ι)} {𝒲 : Finset (Finset ι)} {c : Finset ι → ZMod 2},
  (∀ V ∈ teams, HiddenChannelCapacity.ClosedAt 𝒲 V) →
    (∀ V ∈ teams, HiddenChannelCapacity.CoherentAt 𝒲 c V) →
      HiddenChannelCapacity.Consistent (HiddenChannelCapacity.affFam teams 𝒲 c)
```
HiddenChannelCapacity.ClosedAt HiddenChannelCapacity.CoherentAt HiddenChannelCapacity.Consistent HiddenChannelCapacity.LocalStruct HiddenChannelCapacity.LocalStruct.imarg HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.affFam HiddenChannelCapacity.affLocal
Uses
- HiddenChannelCapacity.imarg_affLocal
Used by
- HiddenChannelCapacity.affine_obstruction
DeclHiddenChannelCapacity.imarg_affLocalDeclaration kindtheorem
The exact marginal computation: the interface marginal of a closed coherent local structure is exactly the local structure of the interface — the interface sees precisely the visible constraints.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {V S : Finset ι} {𝒲 : Finset (Finset ι)} {c : Finset ι → ZMod 2} (hS : S ⊆ V),
  HiddenChannelCapacity.ClosedAt 𝒲 V →
    HiddenChannelCapacity.CoherentAt 𝒲 c V →
      (HiddenChannelCapacity.affLocal V 𝒲 c).imarg hS = (HiddenChannelCapacity.affLocal S 𝒲 c).rel
```
HiddenChannelCapacity.ClosedAt HiddenChannelCapacity.CoherentAt HiddenChannelCapacity.LocalStruct.imarg HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.affLocal HiddenChannelCapacity.hostedList HiddenChannelCapacity.parityOn HiddenChannelCapacity.wsum
Uses
Used by
- HiddenChannelCapacity.consistent_affFam
DeclHiddenChannelCapacity.wsum_restrict₂Declaration kindtheorem
Transport of team parities along nested restriction: the value only reads the support.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {V S w : Finset ι} (hS : S ⊆ V),
  w ⊆ S → ∀ (F : ↥V → ZMod 2), HiddenChannelCapacity.wsum S w (Finset.restrict₂ hS F) = HiddenChannelCapacity.wsum V w F
```
HiddenChannelCapacity.parityOn HiddenChannelCapacity.wsum
Uses
- HiddenChannelCapacity.wsum_restrict
Used by
- HiddenChannelCapacity.imarg_affLocal
DeclHiddenChannelCapacity.sysCoherent_pinnedDeclaration kindtheorem
The pinned system: hosted constraints of V plus a singleton pin at every S-coordinate of a visible-constraint-satisfying trace. Coherent, by closedness.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {V S : Finset ι} {𝒲 : Finset (Finset ι)} {c : Finset ι → ZMod 2},
  HiddenChannelCapacity.ClosedAt 𝒲 V →
    HiddenChannelCapacity.CoherentAt 𝒲 c V →
      ∀ (g₀ : ι → ZMod 2),
        (∀ w ∈ 𝒲, w ⊆ S → HiddenChannelCapacity.parityOn w g₀ = c w) →
          HiddenChannelCapacity.SysCoherent
            (HiddenChannelCapacity.hostedList✝ V 𝒲 c ++ List.map (fun i => ({i}, g₀ i)) S.toList)
```
HiddenChannelCapacity.ClosedAt HiddenChannelCapacity.CoherentAt HiddenChannelCapacity.SysCoherent HiddenChannelCapacity.hostedList HiddenChannelCapacity.parityOn HiddenChannelCapacity.xorSum HiddenChannelCapacity.xorSumL
Uses
Used by
- HiddenChannelCapacity.imarg_affLocal

DeclHiddenChannelCapacity.xorSum_subsetDeclaration kindtheorem

∀ {ι : Type u_1} [inst : DecidableEq ι] {V : Finset ι} {𝒲 D : Finset (Finset ι)},
  D ⊆ {x ∈ 𝒲 | x ⊆ V} → HiddenChannelCapacity.xorSum D ⊆ V

HiddenChannelCapacity.xorSum

Used by

HiddenChannelCapacity.sysCoherent_pinned

DeclHiddenChannelCapacity.xorSumL_singletonsDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {l : List ι},
  l.Nodup → HiddenChannelCapacity.xorSumL (List.map (fun x => {x}) l) = l.toFinset
```
HiddenChannelCapacity.xorSumL
Uses
- HiddenChannelCapacity.xorSumL_cons
Used by
- HiddenChannelCapacity.sysCoherent_pinned
DeclHiddenChannelCapacity.xorSumL_appendDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (a b : List (Finset ι)),
  HiddenChannelCapacity.xorSumL (a ++ b) = symmDiff (HiddenChannelCapacity.xorSumL a) (HiddenChannelCapacity.xorSumL b)
```
HiddenChannelCapacity.xorSumL
Uses
- HiddenChannelCapacity.xorSumL_cons
- HiddenChannelCapacity.xorSumL_nil
Used by
- HiddenChannelCapacity.sysCoherent_pinned
DeclHiddenChannelCapacity.xorSumL_nilDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι], HiddenChannelCapacity.xorSumL [] = ∅
```
HiddenChannelCapacity.xorSumL
Used by

DeclHiddenChannelCapacity.map_snd_pinDeclaration kindtheorem

∀ {ι : Type u_1} (g₀ : ι → ZMod 2) (l : List ι), List.map Prod.snd (List.map (fun i => ({i}, g₀ i)) l) = List.map g₀ l

Used by

HiddenChannelCapacity.sysCoherent_pinned

DeclHiddenChannelCapacity.map_fst_pinDeclaration kindtheorem

∀ {ι : Type u_1} (g₀ : ι → ZMod 2) (l : List ι),
  List.map Prod.fst (List.map (fun i => ({i}, g₀ i)) l) = List.map (fun x => {x}) l

Used by

HiddenChannelCapacity.sysCoherent_pinned

DeclHiddenChannelCapacity.affLocal_nonemptyDeclaration kindtheorem
Every local relation of a coherent system is nonempty.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {V : Finset ι} {𝒲 : Finset (Finset ι)} {c : Finset ι → ZMod 2},
  HiddenChannelCapacity.CoherentAt 𝒲 c V → (HiddenChannelCapacity.affLocal V 𝒲 c).rel.Nonempty
```
HiddenChannelCapacity.CoherentAt HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.affLocal HiddenChannelCapacity.hostedList HiddenChannelCapacity.parityOn HiddenChannelCapacity.wsum
Uses
Used by
- HiddenChannelCapacity.affine_obstruction
- HiddenChannelCapacity.not_glues_affFam
DeclHiddenChannelCapacity.wsum_restrictDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {V w : Finset ι},
  w ⊆ V → ∀ (f : ι → ZMod 2), HiddenChannelCapacity.wsum V w (V.restrict f) = HiddenChannelCapacity.parityOn w f
```
HiddenChannelCapacity.parityOn HiddenChannelCapacity.wsum
Used by
DeclHiddenChannelCapacity.sysCoherent_hostedListDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {V : Finset ι} {𝒲 : Finset (Finset ι)} {c : Finset ι → ZMod 2},
  HiddenChannelCapacity.CoherentAt 𝒲 c V → HiddenChannelCapacity.SysCoherent (HiddenChannelCapacity.hostedList✝ V 𝒲 c)
```
HiddenChannelCapacity.CoherentAt HiddenChannelCapacity.SysCoherent HiddenChannelCapacity.hostedList HiddenChannelCapacity.xorSum HiddenChannelCapacity.xorSumL
Uses
Used by
- HiddenChannelCapacity.affLocal_nonempty
DeclHiddenChannelCapacity.xorSumL_eq_xorSumDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {l : List (Finset ι)},
  l.Nodup → HiddenChannelCapacity.xorSumL l = HiddenChannelCapacity.xorSum l.toFinset
```
HiddenChannelCapacity.xorSum HiddenChannelCapacity.xorSumL
Uses
- HiddenChannelCapacity.xorSumL_cons
Used by
DeclHiddenChannelCapacity.map_snd_pairDeclaration kindtheorem
```
∀ {ι : Type u_1} (c : Finset ι → ZMod 2) (l : List (Finset ι)),
  List.map Prod.snd (List.map (fun w => (w, c w)) l) = List.map c l
```
Used by
- HiddenChannelCapacity.sysCoherent_hostedList
- HiddenChannelCapacity.sysCoherent_pinned
DeclHiddenChannelCapacity.map_fst_pairDeclaration kindtheorem
```
∀ {ι : Type u_1} (c : Finset ι → ZMod 2) (l : List (Finset ι)), List.map Prod.fst (List.map (fun w => (w, c w)) l) = l
```
Used by
- HiddenChannelCapacity.sysCoherent_hostedList
- HiddenChannelCapacity.sysCoherent_pinned
DeclHiddenChannelCapacity.mem_affLocal_relDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {V : Finset ι} {𝒲 : Finset (Finset ι)} {c : Finset ι → ZMod 2}
  {F : ↥V → ZMod 2},
  F ∈ (HiddenChannelCapacity.affLocal V 𝒲 c).rel ↔ ∀ w ∈ 𝒲, w ⊆ V → HiddenChannelCapacity.wsum V w F = c w
```
HiddenChannelCapacity.LocalStruct.rel HiddenChannelCapacity.LocalStruct.team HiddenChannelCapacity.affLocal HiddenChannelCapacity.wsum
Used by
DeclHiddenChannelCapacity.exists_parity_solutionDeclaration kindtheorem
The solvability core: a coherent list-presented parity system has a solution. Elementary Gaussian elimination, by induction on the list.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (L : List (Finset ι × ZMod 2)),
  HiddenChannelCapacity.SysCoherent L → ∃ f, ∀ p ∈ L, HiddenChannelCapacity.parityOn p.1 f = p.2
```
HiddenChannelCapacity.SysCoherent HiddenChannelCapacity.parityOn HiddenChannelCapacity.xorSumL
Uses
Used by
- HiddenChannelCapacity.affLocal_nonempty
- HiddenChannelCapacity.imarg_affLocal
DeclHiddenChannelCapacity.xorSumL_consDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (w : Finset ι) (l : List (Finset ι)),
  HiddenChannelCapacity.xorSumL (w :: l) = symmDiff w (HiddenChannelCapacity.xorSumL l)
```
HiddenChannelCapacity.xorSumL
Used by

DeclHiddenChannelCapacity.transform_bookkeepingDeclaration kindtheorem

The Gaussian transform bookkeeping: transforming the x-containing entries by ∆ w₀ shifts the F2 sum by w₀ per transformed entry, and the constants by c₀ likewise.

∀ {ι : Type u_1} [inst : DecidableEq ι] (x : ι) (w₀ : Finset ι) (c₀ : ZMod 2) (sub : List (Finset ι × ZMod 2)),
  HiddenChannelCapacity.xorSumL
        (List.map Prod.fst (List.map (fun p => if x ∈ p.1 then (symmDiff p.1 w₀, p.2 + c₀) else p) sub)) =
      symmDiff (HiddenChannelCapacity.xorSumL (List.map Prod.fst sub))
        (if List.countP (fun p => decide (x ∈ p.1)) sub % 2 = 1 then w₀ else ∅) ∧
    (List.map Prod.snd (List.map (fun p => if x ∈ p.1 then (symmDiff p.1 w₀, p.2 + c₀) else p) sub)).sum =
      (List.map Prod.snd sub).sum + if List.countP (fun p => decide (x ∈ p.1)) sub % 2 = 1 then c₀ else 0

HiddenChannelCapacity.xorSumL

Uses

HiddenChannelCapacity.symmDiff_empty
HiddenChannelCapacity.zmod2_add_self

Used by

HiddenChannelCapacity.exists_parity_solution

DeclHiddenChannelCapacity.symmDiff_emptyDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (a : Finset ι), symmDiff a ∅ = a
```
Used by
DeclHiddenChannelCapacity.parityOn_symmDiffDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (w w' : Finset ι) (f : ι → ZMod 2),
  HiddenChannelCapacity.parityOn (symmDiff w w') f =
    HiddenChannelCapacity.parityOn w f + HiddenChannelCapacity.parityOn w' f
```
HiddenChannelCapacity.parityOn
Uses
- HiddenChannelCapacity.zmod2_add_self
Used by
- HiddenChannelCapacity.exists_parity_solution
- HiddenChannelCapacity.parityOn_xorSum
DeclHiddenChannelCapacity.zmod2_add_selfDeclaration kindtheorem
```
∀ (a : ZMod 2), a + a = 0
```
Used by
DeclHiddenChannelCapacity.acyclic_iff_grahamReducibleDeclaration kindtheorem
The Graham bridge: acyclicity is exactly Graham reducibility.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (𝒞 : Finset (Finset ι)),
  HiddenChannelCapacity.Acyclic 𝒞 ↔ HiddenChannelCapacity.GrahamReducible 𝒞
```
HiddenChannelCapacity.Acyclic HiddenChannelCapacity.GrahamN HiddenChannelCapacity.GrahamReducible HiddenChannelCapacity.RIPCover
Uses
- HiddenChannelCapacity.exists_ripCover_of_grahamN
- HiddenChannelCapacity.grahamN_of_ripCover
Used by
- HiddenChannelCapacity.exists_consistent_not_glues_of_not_acyclic
DeclHiddenChannelCapacity.grahamN_of_ripCoverDeclaration kindtheorem
An RIP order eliminates from the front: its head is an ear and the tail remains RIP.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (order : List (Finset ι)),
  order.Nodup → HiddenChannelCapacity.RIPCover order → HiddenChannelCapacity.GrahamN order.length order.toFinset
```
HiddenChannelCapacity.GrahamN HiddenChannelCapacity.IsEarOf HiddenChannelCapacity.RIPCover HiddenChannelCapacity.coverU HiddenChannelCapacity.listCover
Uses
- HiddenChannelCapacity.listCover_eq_coverU
Used by
- HiddenChannelCapacity.acyclic_iff_grahamReducible
DeclHiddenChannelCapacity.exists_ripCover_of_grahamNDeclaration kindtheorem
An elimination run is a running-intersection order read forward.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (n : ℕ) (𝒞 : Finset (Finset ι)),
  HiddenChannelCapacity.GrahamN n 𝒞 → ∃ order, order.Nodup ∧ order.toFinset = 𝒞 ∧ HiddenChannelCapacity.RIPCover order
```
HiddenChannelCapacity.GrahamN HiddenChannelCapacity.IsEarOf HiddenChannelCapacity.RIPCover HiddenChannelCapacity.coverU HiddenChannelCapacity.listCover
Uses
- HiddenChannelCapacity.listCover_eq_coverU
Used by
- HiddenChannelCapacity.acyclic_iff_grahamReducible
DeclHiddenChannelCapacity.listCover_eq_coverUDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (l : List (Finset ι)),
  HiddenChannelCapacity.listCover l = HiddenChannelCapacity.coverU l.toFinset
```
HiddenChannelCapacity.coverU HiddenChannelCapacity.listCover
Used by
- HiddenChannelCapacity.exists_ripCover_of_grahamN
- HiddenChannelCapacity.grahamN_of_ripCover
DefinitionHiddenChannelCapacity.Acyclicdef
Order-free acyclicity: some duplicate-free enumeration of the cover is a running-intersection order.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Prop
```
DefinitionHiddenChannelCapacity.Adjdef
Primal adjacency: distinct co-hosted vertices.
```
{ι : Type u_1} → Finset (Finset ι) → ι → ι → Prop
```
DefinitionHiddenChannelCapacity.ClosedAtdef
Intra-team span closure: subset sums of the constraints hosted by V vanish or stay in the system.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Finset ι → Prop
```
DefinitionHiddenChannelCapacity.CoherentAtdef
Intra-team coherence: constants vanish on the dependencies hosted by V.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → (Finset ι → ZMod 2) → Finset ι → Prop
```
DefinitionHiddenChannelCapacity.Conformaldef
Conformality: every clique inside the cover is covered.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Prop
```

DefinitionHiddenChannelCapacity.Consistentdef

Pairwise consistency: any two members expose the same interface marginal.

{ι : Type u_1} →
  [DecidableEq ι] →
    {X : ι → Type u_2} → [(i : ι) → DecidableEq (X i)] → List (HiddenChannelCapacity.LocalStruct ι X) → Prop

DefinitionHiddenChannelCapacity.Covereddef
A vertex set covered by a single team.
```
{ι : Type u_1} → Finset (Finset ι) → Finset ι → Prop
```
DefinitionHiddenChannelCapacity.EarFreedef
An ear-free nonempty cover: the stuck core condition.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Prop
```

DefinitionHiddenChannelCapacity.Gluesdef

Gluing: some global structure realizes every member exactly.

{ι : Type u_1} →
  {X : ι → Type u_2} → [(i : ι) → DecidableEq (X i)] → [Fintype ι] → List (HiddenChannelCapacity.LocalStruct ι X) → Prop

DefinitionHiddenChannelCapacity.GrahamNdef
Nondeterministic ear elimination, fueled.
```
{ι : Type u_1} → [DecidableEq ι] → ℕ → Finset (Finset ι) → Prop
```
DefinitionHiddenChannelCapacity.GrahamReducibledef
Graham reducibility: ear elimination empties the cover; the cover's size is fuel enough since every elimination removes exactly one team.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Prop
```
DefinitionHiddenChannelCapacity.IsChordlessCycledef
A chordless cycle: duplicate-free, length ≥ 4, consecutive pairs hosted, and the only adjacencies among its vertices are the cyclically consecutive ones.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → List ι → Prop
```
DefinitionHiddenChannelCapacity.IsCliquedef
A clique of the primal graph.
```
{ι : Type u_1} → Finset (Finset ι) → Finset ι → Prop
```
DefinitionHiddenChannelCapacity.IsEarOfdef
The ear condition: the team meets the union of the others inside a single other team (or there are no others).
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Finset ι → Prop
```
DefinitionHiddenChannelCapacity.IsWalkOndef
A walk constrained to P: chained adjacencies, every vertex satisfies P.
```
{ι : Type u_1} → Finset (Finset ι) → (ι → Prop) → List ι → Prop
```
DefinitionHiddenChannelCapacity.LocalStructstructure
A local structure: a team of parts together with an ignorance structure on the team's marginal type.
```
(ι : Type u_3) → (ι → Type u_4) → Type (max u_3 u_4)
```

DefinitionHiddenChannelCapacity.LocalStruct.imargdef

The interface marginal of a local structure over a sub-team.

{ι : Type u_1} →
  {X : ι → Type u_2} →
    [(i : ι) → DecidableEq (X i)] →
      (L : HiddenChannelCapacity.LocalStruct ι X) → {S : Finset ι} → S ⊆ L.team → Finset ((i : ↥S) → X ↑i)

DefinitionHiddenChannelCapacity.LocalStruct.reldef

The admissible local configurations.

{ι : Type u_3} → {X : ι → Type u_4} → (self : HiddenChannelCapacity.LocalStruct ι X) → Finset ((i : ↥self.team) → X ↑i)

DefinitionHiddenChannelCapacity.LocalStruct.teamdef
The team of parts this local structure constrains.
```
{ι : Type u_3} → {X : ι → Type u_4} → HiddenChannelCapacity.LocalStruct ι X → Finset ι
```
DefinitionHiddenChannelCapacity.RIPdef
Running intersection property: each member meets the union of the later members inside a single later member (the head is the last-eliminated team).
```
{ι : Type u_1} → [DecidableEq ι] → {X : ι → Type u_2} → List (HiddenChannelCapacity.LocalStruct ι X) → Prop
```
DefinitionHiddenChannelCapacity.RIPCoverdef
Team-level running intersection property: each team meets the union of the later teams inside a single later team.
```
{ι : Type u_1} → [DecidableEq ι] → List (Finset ι) → Prop
```
DefinitionHiddenChannelCapacity.ReachOndef
Reachability within P: a duplicate-free walk with the given endpoints.
```
{ι : Type u_1} → Finset (Finset ι) → (ι → Prop) → ι → ι → Prop
```
DefinitionHiddenChannelCapacity.SimpIndef
v is simplicial within the vertex set S: it lies in S and its 𝒞-neighbors inside S are pairwise adjacent.
```
{ι : Type u_1} → Finset (Finset ι) → Finset ι → ι → Prop
```
DefinitionHiddenChannelCapacity.SysCoherentdef
Coherence of a list-presented parity system: constants vanish on every dependency.
```
{ι : Type u_1} → [DecidableEq ι] → List (Finset ι × ZMod 2) → Prop
```

DefinitionHiddenChannelCapacity.affFamdef

The affine family over a cover: every team with its fitting constraints.

{ι : Type u_1} →
  [DecidableEq ι] →
    List (Finset ι) →
      Finset (Finset ι) → (Finset ι → ZMod 2) → List (HiddenChannelCapacity.LocalStruct ι fun x => ZMod 2)

DefinitionHiddenChannelCapacity.affLocaldef

The team V with every constraint of the system that fits inside it: the uniform replication rule.

{ι : Type u_1} →
  [DecidableEq ι] →
    Finset ι → Finset (Finset ι) → (Finset ι → ZMod 2) → HiddenChannelCapacity.LocalStruct ι fun x => ZMod 2

DefinitionHiddenChannelCapacity.coverUdef
The union of a finite set of teams.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Finset ι
```
DefinitionHiddenChannelCapacity.cyclePairsdef
The consecutive-pair supports of a cyclic vertex list.
```
{ι : Type u_1} → [DecidableEq ι] → List ι → List (Finset ι)
```

DefinitionHiddenChannelCapacity.decidableAcyclicdef

Acyclicity is decidable — the payoff of the bridge.

{ι : Type u_1} → [inst : DecidableEq ι] → (𝒞 : Finset (Finset ι)) → Decidable (HiddenChannelCapacity.Acyclic 𝒞)

DefinitionHiddenChannelCapacity.decidableIsEarOfdef

{ι : Type u_1} →
  [inst : DecidableEq ι] → (𝒞 : Finset (Finset ι)) → (T : Finset ι) → Decidable (HiddenChannelCapacity.IsEarOf 𝒞 T)

DefinitionHiddenChannelCapacity.famCoverdef

The union of a family's teams.

{ι : Type u_1} → [DecidableEq ι] → {X : ι → Type u_2} → List (HiddenChannelCapacity.LocalStruct ι X) → Finset ι

DefinitionHiddenChannelCapacity.hostedListdef

The hosted constraints of V, as a list system.

{ι : Type u_1} → [DecidableEq ι] → Finset ι → Finset (Finset ι) → (Finset ι → ZMod 2) → List (Finset ι × ZMod 2)

DefinitionHiddenChannelCapacity.instDecidableAdjdef

{ι : Type u_1} → [DecidableEq ι] → (𝒞 : Finset (Finset ι)) → (u v : ι) → Decidable (HiddenChannelCapacity.Adj 𝒞 u v)

DefinitionHiddenChannelCapacity.instDecidableCovereddef

{ι : Type u_1} →
  [DecidableEq ι] → (𝒞 : Finset (Finset ι)) → (K : Finset ι) → Decidable (HiddenChannelCapacity.Covered 𝒞 K)

DefinitionHiddenChannelCapacity.instDecidableIsCliquedef

{ι : Type u_1} →
  [DecidableEq ι] → (𝒞 : Finset (Finset ι)) → (K : Finset ι) → Decidable (HiddenChannelCapacity.IsClique 𝒞 K)

DefinitionHiddenChannelCapacity.joinFamdef

The natural join of a family: all global configurations passing every local test.

{ι : Type u_1} →
  [DecidableEq ι] →
    {X : ι → Type u_2} →
      [(i : ι) → DecidableEq (X i)] →
        [Fintype ι] → [(i : ι) → Fintype (X i)] → List (HiddenChannelCapacity.LocalStruct ι X) → Finset ((i : ι) → X i)

DefinitionHiddenChannelCapacity.listCoverdef
The union of a list of teams.
```
{ι : Type u_1} → [DecidableEq ι] → List (Finset ι) → Finset ι
```
DefinitionHiddenChannelCapacity.parityOndef
Parity of a global configuration over a support.
```
{ι : Type u_1} → Finset ι → (ι → ZMod 2) → ZMod 2
```

DefinitionHiddenChannelCapacity.projSdef

The marginal of a multipartite relation over a sub-team S: the image under Finset.restrict.

{ι : Type u_1} →
  {X : ι → Type u_2} →
    [(i : ι) → DecidableEq (X i)] → Finset ((i : ι) → X i) → (S : Finset ι) → Finset ((i : ↥S) → X ↑i)

DefinitionHiddenChannelCapacity.shareddef

The shared vertices of a cover.

{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Finset ι

DefinitionHiddenChannelCapacity.wsumdef

Parity of a team configuration over the team part of a support.

{ι : Type u_1} → [DecidableEq ι] → (V : Finset ι) → Finset ι → (↥V → ZMod 2) → ZMod 2

DefinitionHiddenChannelCapacity.xorSumdef
F2 sum of a finite collection of supports.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → Finset ι
```

DefinitionHiddenChannelCapacity.xorSumLdef

F2 sum of a list of supports.

{ι : Type u_1} → [DecidableEq ι] → List (Finset ι) → Finset ι

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

Dirac's lemma, strong form: in a chordless-cycle-free adjacency structure, every vertex set is a clique or contains two nonadjacent simplicial vertices.

DeclHiddenChannelCapacity.dirac_strong

∀ {ι : Type u_1} [inst : DecidableEq ι] (𝒞 : Finset (Finset ι)),
  (¬∃ l, HiddenChannelCapacity.IsChordlessCycle 𝒞 l) →
    ∀ (S : Finset ι),
      (∀ x ∈ S, ∀ y ∈ S, x ≠ y → HiddenChannelCapacity.Adj 𝒞 x y) ∨
        ∃ u w,
          HiddenChannelCapacity.SimpIn 𝒞 S u ∧
            HiddenChannelCapacity.SimpIn 𝒞 S w ∧ u ≠ w ∧ ¬HiddenChannelCapacity.Adj 𝒞 u w

ThesisStepHypothesisDefinition

DeclHiddenChannelCapacity.dirac_strongDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (𝒞 : Finset (Finset ι)),
  (¬∃ l, HiddenChannelCapacity.IsChordlessCycle 𝒞 l) →
    ∀ (S : Finset ι),
      (∀ x ∈ S, ∀ y ∈ S, x ≠ y → HiddenChannelCapacity.Adj 𝒞 x y) ∨
        ∃ u w,
          HiddenChannelCapacity.SimpIn 𝒞 S u ∧
            HiddenChannelCapacity.SimpIn 𝒞 S w ∧ u ≠ w ∧ ¬HiddenChannelCapacity.Adj 𝒞 u w
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsChordlessCycle HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn HiddenChannelCapacity.SimpIn HiddenChannelCapacity.instDecidableAdj
Uses

DeclHiddenChannelCapacity.sep_clique_stepDeclaration kindtheorem

The assembled-cycle contradiction: two length-minimal x-y connectors through disjoint, mutually non-adjacent sides cannot coexist with chordless-cycle-freeness when x and y are non-adjacent.

∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)},
  (¬∃ l, HiddenChannelCapacity.IsChordlessCycle 𝒞 l) →
    ∀ {QA QB : ι → Prop} {x y : ι},
      x ≠ y →
        ¬HiddenChannelCapacity.Adj 𝒞 x y →
          ¬QB x →
            ¬QB y →
              (∀ (v : ι), QA v → QB v → False) →
                (∀ (u v : ι), QA u → QB v → ¬HiddenChannelCapacity.Adj 𝒞 u v) →
                  ∀ (pA : List ι),
                    List.IsChain (HiddenChannelCapacity.Adj 𝒞) pA →
                      pA.Nodup →
                        pA.head? = some x →
                          pA.getLast? = some y →
                            (∀ v ∈ pA, v = x ∨ v = y ∨ QA v) →
                              (∀ (q : List ι),
                                  (List.IsChain (HiddenChannelCapacity.Adj 𝒞) q ∧
                                      q.Nodup ∧
                                        q.head? = some x ∧ q.getLast? = some y ∧ ∀ v ∈ q, v = x ∨ v = y ∨ QA v) →
                                    pA.length ≤ q.length) →
                                ∀ (pB : List ι),
                                  List.IsChain (HiddenChannelCapacity.Adj 𝒞) pB →
                                    pB.Nodup →
                                      pB.head? = some x →
                                        pB.getLast? = some y →
                                          (∀ v ∈ pB, v = x ∨ v = y ∨ QB v) →
                                            (∀ (q : List ι),
                                                (List.IsChain (HiddenChannelCapacity.Adj 𝒞) q ∧
                                                    q.Nodup ∧
                                                      q.head? = some x ∧
                                                        q.getLast? = some y ∧ ∀ v ∈ q, v = x ∨ v = y ∨ QB v) →
                                                  pB.length ≤ q.length) →
                                              False

HiddenChannelCapacity.Adj HiddenChannelCapacity.IsChordlessCycle HiddenChannelCapacity.cyclePairs

Uses

HiddenChannelCapacity.Adj.symm'
HiddenChannelCapacity.getElem_cyclePairs
HiddenChannelCapacity.getLast_getElem
HiddenChannelCapacity.head_getElem
HiddenChannelCapacity.length_cyclePairs
HiddenChannelCapacity.mod_succ_cases
HiddenChannelCapacity.no_chord_of_minimal

Used by

HiddenChannelCapacity.dirac_strong

DeclHiddenChannelCapacity.no_chord_of_minimalDeclaration kindtheorem

Minimality kills chords: a length-minimal constrained x-y path has no adjacency between positions at distance ≥ 2.

∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {Q : ι → Prop} {x y : ι} {p : List ι},
  List.IsChain (HiddenChannelCapacity.Adj 𝒞) p →
    p.head? = some x →
      p.getLast? = some y →
        (∀ v ∈ p, v = x ∨ v = y ∨ Q v) →
          (∀ (q : List ι),
              (List.IsChain (HiddenChannelCapacity.Adj 𝒞) q ∧
                  q.Nodup ∧ q.head? = some x ∧ q.getLast? = some y ∧ ∀ v ∈ q, v = x ∨ v = y ∨ Q v) →
                p.length ≤ q.length) →
            p.Nodup →
              ∀ {i j : ℕ} (hi : i < p.length) (hj : j < p.length), i + 2 ≤ j → ¬HiddenChannelCapacity.Adj 𝒞 p[i] p[j]

HiddenChannelCapacity.Adj

Uses

HiddenChannelCapacity.isChain_drop
HiddenChannelCapacity.isChain_take

Used by

HiddenChannelCapacity.sep_clique_step

DeclHiddenChannelCapacity.mod_succ_casesDeclaration kindtheorem
```
∀ (n i : ℕ), i < n → (i + 1) % n = i + 1 ∧ i + 1 < n ∨ (i + 1) % n = 0 ∧ i + 1 = n
```
Used by
- HiddenChannelCapacity.sep_clique_step

DeclHiddenChannelCapacity.getLast_getElemDeclaration kindtheorem

∀ {ι : Type u_1} {p : List ι} {y : ι}, p.getLast? = some y → ∀ (h0 : 0 < p.length), p[p.length - 1] = y

Used by

HiddenChannelCapacity.sep_clique_step

DeclHiddenChannelCapacity.getElem_cyclePairsDeclaration kindtheorem

∀ {ι : Type u_1} [inst : DecidableEq ι] (l : List ι) (h0 : 0 < l.length) (i : ℕ)
  (h : i < (HiddenChannelCapacity.cyclePairs l).length),
  (HiddenChannelCapacity.cyclePairs l)[i] = {l[i], l[(i + 1) % l.length]}

HiddenChannelCapacity.cyclePairs

Uses

HiddenChannelCapacity.length_cyclePairs

Used by

HiddenChannelCapacity.sep_clique_step

DeclHiddenChannelCapacity.length_cyclePairsDeclaration kindtheorem
```
∀ {ι : Type u_1} [inst : DecidableEq ι] (l : List ι), (HiddenChannelCapacity.cyclePairs l).length = l.length
```
HiddenChannelCapacity.cyclePairs
Used by
- HiddenChannelCapacity.getElem_cyclePairs
- HiddenChannelCapacity.sep_clique_step
DeclHiddenChannelCapacity.reachOn_transDeclaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u v w : ι},
  HiddenChannelCapacity.ReachOn 𝒞 P u v → HiddenChannelCapacity.ReachOn 𝒞 P v w → HiddenChannelCapacity.ReachOn 𝒞 P u w
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.reachOn_of_walk
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_symmDeclaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u v : ι},
  HiddenChannelCapacity.ReachOn 𝒞 P u v → HiddenChannelCapacity.ReachOn 𝒞 P v u
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.Adj.symm'
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_reflDeclaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u : ι}, P u → HiddenChannelCapacity.ReachOn 𝒞 P u u
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_of_mem_walkDeclaration kindtheorem
Every vertex on a walk is reachable from its head.
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u v : ι} {p : List ι},
  HiddenChannelCapacity.IsWalkOn 𝒞 P p → p.head? = some u → v ∈ p → HiddenChannelCapacity.ReachOn 𝒞 P u v
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.isChain_take
- HiddenChannelCapacity.reachOn_of_walk
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_extendDeclaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} {u v w : ι},
  HiddenChannelCapacity.ReachOn 𝒞 P u v → HiddenChannelCapacity.Adj 𝒞 v w → P w → HiddenChannelCapacity.ReachOn 𝒞 P u w
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.reachOn_of_walk
Used by
- HiddenChannelCapacity.dirac_strong

DeclHiddenChannelCapacity.exists_min_pathDeclaration kindtheorem

∀ {ι : Type u_1} {Q : List ι → Prop}, (∃ p, Q p) → ∃ p, Q p ∧ ∀ (q : List ι), Q q → p.length ≤ q.length

Used by

HiddenChannelCapacity.dirac_strong

DeclHiddenChannelCapacity.exists_connectorDeclaration kindtheorem

A connector: an x-y path with interior inside Q, from adjacent entry points and interior reachability.

∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {Q : ι → Prop} {x y u₁ u₂ : ι},
  x ≠ y →
    HiddenChannelCapacity.Adj 𝒞 x u₁ →
      HiddenChannelCapacity.Adj 𝒞 y u₂ →
        HiddenChannelCapacity.ReachOn 𝒞 Q u₁ u₂ →
          ¬Q x →
            ¬Q y →
              ∃ p,
                List.IsChain (HiddenChannelCapacity.Adj 𝒞) p ∧
                  p.Nodup ∧ p.head? = some x ∧ p.getLast? = some y ∧ ∀ v ∈ p, v = x ∨ v = y ∨ Q v

HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn

Uses

HiddenChannelCapacity.Adj.symm'

Used by

HiddenChannelCapacity.dirac_strong

DeclHiddenChannelCapacity.erase_separatesDeclaration kindtheorem
If x has no neighbor reachable from a off the separator, then erasing x still separates: the first x-occurrence on any violating path has its predecessor reachable from a and adjacent to x.
```
∀ {ι : Type u_1} [inst : DecidableEq ι] {𝒞 : Finset (Finset ι)} {S Sep : Finset ι} {a b x : ι},
  x ≠ a →
    (∀ (u : ι),
        u ∈ S \ Sep ∧ HiddenChannelCapacity.ReachOn 𝒞 (fun v => v ∈ S \ Sep) a u → ¬HiddenChannelCapacity.Adj 𝒞 x u) →
      ¬HiddenChannelCapacity.ReachOn 𝒞 (fun v => v ∈ S \ Sep) a b →
        ¬HiddenChannelCapacity.ReachOn 𝒞 (fun v => v ∈ S \ Sep.erase x) a b
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
Used by
- HiddenChannelCapacity.dirac_strong
DeclHiddenChannelCapacity.reachOn_of_walkDeclaration kindtheorem
Every chained walk contains a duplicate-free path with the same endpoints and vertices.
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {P : ι → Prop} (p : List ι),
  HiddenChannelCapacity.IsWalkOn 𝒞 P p →
    ∀ {u v : ι}, p.head? = some u → p.getLast? = some v → HiddenChannelCapacity.ReachOn 𝒞 P u v
```
HiddenChannelCapacity.Adj HiddenChannelCapacity.IsWalkOn HiddenChannelCapacity.ReachOn
Uses
- HiddenChannelCapacity.isChain_drop
- HiddenChannelCapacity.isChain_take
Used by
DeclHiddenChannelCapacity.isChain_dropDeclaration kindtheorem
```
∀ {ι : Type u_1} {R : ι → ι → Prop} {p : List ι}, List.IsChain R p → ∀ (n : ℕ), List.IsChain R (List.drop n p)
```
Used by
- HiddenChannelCapacity.no_chord_of_minimal
- HiddenChannelCapacity.reachOn_of_walk
DeclHiddenChannelCapacity.isChain_takeDeclaration kindtheorem
```
∀ {ι : Type u_1} {R : ι → ι → Prop} {p : List ι}, List.IsChain R p → ∀ (n : ℕ), List.IsChain R (List.take n p)
```
Used by
DeclHiddenChannelCapacity.head_getElemDeclaration kindtheorem
Positional form of the head.
```
∀ {ι : Type u_1} {p : List ι} {x : ι}, p.head? = some x → ∀ (h0 : 0 < p.length), p[0] = x
```
Used by
- HiddenChannelCapacity.erase_separates
- HiddenChannelCapacity.sep_clique_step

DeclHiddenChannelCapacity.gcast_listDeclaration kindtheorem

∀ {ι : Type u_1} (l : List ι) {s t : ℕ} (hs : s < l.length) (ht : t < l.length), s = t → l[s] = l[t]

Used by

HiddenChannelCapacity.erase_separates

DeclHiddenChannelCapacity.Adj.symm'Declaration kindtheorem
```
∀ {ι : Type u_1} {𝒞 : Finset (Finset ι)} {u v : ι}, HiddenChannelCapacity.Adj 𝒞 u v → HiddenChannelCapacity.Adj 𝒞 v u
```
HiddenChannelCapacity.Adj
Used by

Hypothesishchord

¬∃ l, HiddenChannelCapacity.IsChordlessCycle 𝒞 l

DefinitionHiddenChannelCapacity.Adjdef
Primal adjacency: distinct co-hosted vertices.
```
{ι : Type u_1} → Finset (Finset ι) → ι → ι → Prop
```
DefinitionHiddenChannelCapacity.IsChordlessCycledef
A chordless cycle: duplicate-free, length ≥ 4, consecutive pairs hosted, and the only adjacencies among its vertices are the cyclically consecutive ones.
```
{ι : Type u_1} → [DecidableEq ι] → Finset (Finset ι) → List ι → Prop
```
DefinitionHiddenChannelCapacity.IsWalkOndef
A walk constrained to P: chained adjacencies, every vertex satisfies P.
```
{ι : Type u_1} → Finset (Finset ι) → (ι → Prop) → List ι → Prop
```
DefinitionHiddenChannelCapacity.ReachOndef
Reachability within P: a duplicate-free walk with the given endpoints.
```
{ι : Type u_1} → Finset (Finset ι) → (ι → Prop) → ι → ι → Prop
```
DefinitionHiddenChannelCapacity.SimpIndef
v is simplicial within the vertex set S: it lies in S and its 𝒞-neighbors inside S are pairwise adjacent.
```
{ι : Type u_1} → Finset (Finset ι) → Finset ι → ι → Prop
```
DefinitionHiddenChannelCapacity.cyclePairsdef
The consecutive-pair supports of a cyclic vertex list.
```
{ι : Type u_1} → [DecidableEq ι] → List ι → List (Finset ι)
```

DefinitionHiddenChannelCapacity.instDecidableAdjdef

{ι : Type u_1} → [DecidableEq ι] → (𝒞 : Finset (Finset ι)) → (u v : ι) → Decidable (HiddenChannelCapacity.Adj 𝒞 u v)

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesAlex Meiburg

The two-clique quantum junction tree theorem (Lauritzen–Zwiernik, arXiv:2605.19453, Theorem 3.1): over the acyclic two-clique base, the base's compatibility datum decides base-side reconstruction. For strictly positive consistent marginals, a quantum Markov completion exists iff Tr T(R) = 1; the completion is then unique and equals the normalized logarithmic candidate σ(R) = T(R)/Tr T(R). Together with trC_le_one (the trace bound) this is the full theorem.

DeclHiddenChannelCapacity.lz_theorem_3_1

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [inst_5 : Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b]
  [inst_8 : Nonempty b] {ρAC : MState (a × c)} {ρCB : MState (c × b)},
  ρAC.m.PosDef →
    ρCB.m.PosDef →
      ρAC.traceLeft = ρCB.traceRight →
        (HiddenChannelCapacity.trC ρAC ρCB = 1 ↔ ∃ ω, HiddenChannelCapacity.IsMarkovCompletion ρAC ρCB ω) ∧
          ∀ (ω : MState (a × c × b)),
            HiddenChannelCapacity.IsMarkovCompletion ρAC ρCB ω → ω = HiddenChannelCapacity.sigT ρAC ρCB

ThesisStepHypothesisDefinition

DeclHiddenChannelCapacity.lz_theorem_3_1Declaration kindtheorem

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [inst_5 : Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b]
  [inst_8 : Nonempty b] {ρAC : MState (a × c)} {ρCB : MState (c × b)},
  ρAC.m.PosDef →
    ρCB.m.PosDef →
      ρAC.traceLeft = ρCB.traceRight →
        (HiddenChannelCapacity.trC ρAC ρCB = 1 ↔ ∃ ω, HiddenChannelCapacity.IsMarkovCompletion ρAC ρCB ω) ∧
          ∀ (ω : MState (a × c × b)),
            HiddenChannelCapacity.IsMarkovCompletion ρAC ρCB ω → ω = HiddenChannelCapacity.sigT ρAC ρCB

HiddenChannelCapacity.IsMarkovCompletion HiddenChannelCapacity.sigT HiddenChannelCapacity.trC

Uses

HiddenChannelCapacity.markov_completion_eq_sigT
HiddenChannelCapacity.sigT_markov_of_trC_eq_one

DeclHiddenChannelCapacity.sigT_markov_of_trC_eq_oneDeclaration kindtheorem
LZ Theorem 3.1, existence direction: if Tr T(R) = 1 then the normalized candidate IS a quantum Markov completion (extraction of Δ_R = 0 via DPI and the faithfulness of relative entropy, in the order recorded in the QJT_URS front-load).
```
∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [inst_5 : Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b]
  [inst_8 : Nonempty b] {ρAC : MState (a × c)} {ρCB : MState (c × b)},
  ρAC.m.PosDef →
    ρCB.m.PosDef →
      ρAC.traceLeft = ρCB.traceRight →
        HiddenChannelCapacity.trC ρAC ρCB = 1 →
          HiddenChannelCapacity.IsMarkovCompletion ρAC ρCB (HiddenChannelCapacity.sigT ρAC ρCB)
```
HiddenChannelCapacity.IsCompletion HiddenChannelCapacity.IsMarkovCompletion HiddenChannelCapacity.margAC HiddenChannelCapacity.margC HiddenChannelCapacity.margCB HiddenChannelCapacity.qDivR HiddenChannelCapacity.sigT HiddenChannelCapacity.trC
Uses
Used by
- HiddenChannelCapacity.lz_theorem_3_1
DeclHiddenChannelCapacity.markov_completion_eq_sigTDeclaration kindtheorem
LZ Theorem 3.1, uniqueness direction: any quantum Markov completion forces Tr T(R) = 1 and equals the normalized candidate σ(R).
```
∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [inst_5 : Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b]
  [inst_8 : Nonempty b] {ρAC : MState (a × c)} {ρCB : MState (c × b)},
  ρAC.m.PosDef →
    ρCB.m.PosDef →
      ρAC.traceLeft = ρCB.traceRight →
        ∀ (ω : MState (a × c × b)),
          HiddenChannelCapacity.IsMarkovCompletion ρAC ρCB ω →
            HiddenChannelCapacity.trC ρAC ρCB = 1 ∧ ω = HiddenChannelCapacity.sigT ρAC ρCB
```
HiddenChannelCapacity.IsCompletion HiddenChannelCapacity.IsMarkovCompletion HiddenChannelCapacity.margAC HiddenChannelCapacity.margC HiddenChannelCapacity.margCB HiddenChannelCapacity.qDivR HiddenChannelCapacity.sigT HiddenChannelCapacity.trC
Uses
Used by
- HiddenChannelCapacity.lz_theorem_3_1
DeclHiddenChannelCapacity.trC_le_oneDeclaration kindtheorem
LZ Theorem 3.1, the trace bound: Tr T(R) ≤ 1. Proved WITHOUT Lieb's three-matrix inequality, by the eq. 13 route specialized to two cliques (Lemma 3.2 at ω = σ(R) plus SSA and DPI); see the QJT_URS L2a front-load.
```
∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b] [Nonempty b]
  {ρAC : MState (a × c)} {ρCB : MState (c × b)}, ρAC.m.PosDef → ρCB.m.PosDef → HiddenChannelCapacity.trC ρAC ρCB ≤ 1
```
HiddenChannelCapacity.margAC HiddenChannelCapacity.margC HiddenChannelCapacity.margCB HiddenChannelCapacity.qDivR HiddenChannelCapacity.sigT HiddenChannelCapacity.trC
Uses
Used by
- HiddenChannelCapacity.markov_completion_eq_sigT

DeclHiddenChannelCapacity.deltaR_nonnegDeclaration kindtheorem

Δ_R(ω) ≥ 0: one DPI application plus Klein nonnegativity (LZ Lem 3.2's nonnegativity clause, via Prop A.7 imported through the vendored channel DPI).

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [inst_5 : Fintype b] [inst_6 : DecidableEq b] {ρAC : MState (a × c)}
  {ρCB : MState (c × b)},
  ρAC.m.PosDef →
    ρCB.m.PosDef →
      ∀ (ω : MState (a × c × b)),
        0 ≤
          HiddenChannelCapacity.qDivR (HiddenChannelCapacity.margAC ω) ρAC +
              HiddenChannelCapacity.qDivR (HiddenChannelCapacity.margCB ω) ρCB -
            HiddenChannelCapacity.qDivR (HiddenChannelCapacity.margC ω) ρAC.traceLeft

HiddenChannelCapacity.margAC HiddenChannelCapacity.margC HiddenChannelCapacity.margCB HiddenChannelCapacity.qDivR

Uses

HiddenChannelCapacity.posDef_traceLeft
HiddenChannelCapacity.qDivR_dpi_traceLeft
HiddenChannelCapacity.qDivR_nonneg

Used by

HiddenChannelCapacity.sigT_markov_of_trC_eq_one
HiddenChannelCapacity.trC_le_one

DeclHiddenChannelCapacity.qDivR_dpi_traceLeftDeclaration kindtheorem
DPI for the real divergence under the left partial trace (monotonicity of relative entropy, LZ Prop A.7; imported from the vendored channel DPI sandwichedRenyiEntropy_DPI_eq_one at the partial-trace channel).
```
∀ {d₁ : Type u_5} {d₂ : Type u_6} [inst : Fintype d₁] [inst_1 : DecidableEq d₁] [inst_2 : Fintype d₂]
  [inst_3 : DecidableEq d₂] (ρ σ : MState (d₁ × d₂)),
  σ.m.PosDef →
    σ.traceLeft.m.PosDef → HiddenChannelCapacity.qDivR ρ.traceLeft σ.traceLeft ≤ HiddenChannelCapacity.qDivR ρ σ
```
HiddenChannelCapacity.qDivR
Uses
- HiddenChannelCapacity.qDivR_eq_toReal
Used by
- HiddenChannelCapacity.deltaR_nonneg
- HiddenChannelCapacity.sigT_markov_of_trC_eq_one
DeclHiddenChannelCapacity.qDivR_eq_toRealDeclaration kindtheorem
The single ENNReal-to-ℝ seam: qDivR equals the vendored relative entropy. (LZ p. 5; vendored qRelativeEnt_rank.)
```
∀ {d : Type u_4} [inst : Fintype d] [inst_1 : DecidableEq d] {ρ σ : MState d},
  σ.m.PosDef → HiddenChannelCapacity.qDivR ρ σ = 𝐃(ρ‖σ).toReal
```
HiddenChannelCapacity.qDivR
Uses
- HiddenChannelCapacity.toReal_bridge
Used by
- HiddenChannelCapacity.qDivR_dpi_traceLeft
DeclHiddenChannelCapacity.toReal_bridgeDeclaration kindtheorem
```
∀ {x : ENNReal} {r : ℝ}, x ≠ ⊤ → ↑x = ↑r → x.toReal = r
```
Used by
- HiddenChannelCapacity.qDivR_eq_toReal
DeclHiddenChannelCapacity.posDef_traceLeftDeclaration kindtheorem
The partial trace of a strictly positive state is strictly positive (marginals of elements of S₁⁺ stay in S₁⁺, LZ p. 4).
```
∀ {d₁ : Type u_1} {d₂ : Type u_2} [inst : Fintype d₁] [inst_1 : DecidableEq d₁] [Nonempty d₁] [inst_3 : Fintype d₂]
  [inst_4 : DecidableEq d₂] {σ : MState (d₁ × d₂)}, σ.m.PosDef → σ.traceLeft.m.PosDef
```
Used by
- HiddenChannelCapacity.deltaR_nonneg
- HiddenChannelCapacity.sigT_markov_of_trC_eq_one

DeclHiddenChannelCapacity.sigT_posDefDeclaration kindtheorem

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [inst_5 : Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b]
  [inst_8 : Nonempty b] (ρAC : MState (a × c)) (ρCB : MState (c × b)), (HiddenChannelCapacity.sigT ρAC ρCB).m.PosDef

HiddenChannelCapacity.TR HiddenChannelCapacity.Tmat HiddenChannelCapacity.sigT HiddenChannelCapacity.trC

Uses

HiddenChannelCapacity.trC_pos

Used by

HiddenChannelCapacity.markov_completion_eq_sigT

DeclHiddenChannelCapacity.qDivR_selfDeclaration kindtheorem
```
∀ {d : Type u_4} [inst : Fintype d] [inst_1 : DecidableEq d] (ρ : MState d), HiddenChannelCapacity.qDivR ρ ρ = 0
```
HiddenChannelCapacity.qDivR
Used by
DeclHiddenChannelCapacity.qDivR_nonnegDeclaration kindtheorem
Klein nonnegativity in real form (vendored core: inner_log_sub_log_nonneg).
```
∀ {d : Type u_4} [inst : Fintype d] [inst_1 : DecidableEq d] {ρ σ : MState d},
  σ.m.PosDef → 0 ≤ HiddenChannelCapacity.qDivR ρ σ
```
HiddenChannelCapacity.qDivR
Uses
- HiddenChannelCapacity.ker_le_of_posDef
Used by

DeclHiddenChannelCapacity.ker_le_of_posDefDeclaration kindtheorem

∀ {d : Type u_4} [inst : Fintype d] [inst_1 : DecidableEq d] {ρ σ : MState d}, σ.m.PosDef → (↑σ).ker ≤ (↑ρ).ker

Used by

HiddenChannelCapacity.qDivR_nonneg

DeclHiddenChannelCapacity.lem_3_2Declaration kindtheorem
LZ Lemma 3.2, normalized form: for EVERY state ω, D(ω‖σ(R)) − log Tr T(R) = I(A:B|C)_ω + Δ_R(ω) with Δ_R(ω) := D(ω_AC‖ρ_AC) + D(ω_CB‖ρ_CB) − D(ω_C‖ρ_C). This is the paper's divergence identity (p. 8) restated against the NORMALIZED candidate via log T(R) = log Tr T(R) + log σ(R) (the presentation variant recorded in QJT_URS; pure real algebra over the duality, no positivity hypotheses).
```
∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [inst_5 : Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b]
  [inst_8 : Nonempty b] (ρAC : MState (a × c)) (ρCB : MState (c × b)) (ω : MState (a × c × b)),
  HiddenChannelCapacity.qDivR ω (HiddenChannelCapacity.sigT ρAC ρCB) - Real.log (HiddenChannelCapacity.trC ρAC ρCB) =
    qcmi ω +
      (HiddenChannelCapacity.qDivR (HiddenChannelCapacity.margAC ω) ρAC +
          HiddenChannelCapacity.qDivR (HiddenChannelCapacity.margCB ω) ρCB -
        HiddenChannelCapacity.qDivR (HiddenChannelCapacity.margC ω) ρAC.traceLeft)
```
HiddenChannelCapacity.Tmat HiddenChannelCapacity.embedAC HiddenChannelCapacity.embedC HiddenChannelCapacity.embedCB HiddenChannelCapacity.margAC HiddenChannelCapacity.margC HiddenChannelCapacity.margCB HiddenChannelCapacity.qDivR HiddenChannelCapacity.sigT HiddenChannelCapacity.trC
Uses
Used by

DeclHiddenChannelCapacity.log_sigTDeclaration kindtheorem

The log of the normalized candidate splits into the trace constant and the embedded-log sum (log T(R) = log Tr T(R) + log σ(R), the normalization step of the LZ eq. 13 route).

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [inst_5 : Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b]
  [inst_8 : Nonempty b] (ρAC : MState (a × c)) (ρCB : MState (c × b)),
  (↑(HiddenChannelCapacity.sigT ρAC ρCB)).log =
    Real.log (HiddenChannelCapacity.trC ρAC ρCB)⁻¹ • 1 + HiddenChannelCapacity.Tmat ρAC ρCB

HiddenChannelCapacity.TR HiddenChannelCapacity.Tmat HiddenChannelCapacity.sigT HiddenChannelCapacity.trC

Uses

HiddenChannelCapacity.exp_log_id
HiddenChannelCapacity.trC_pos

Used by

HiddenChannelCapacity.lem_3_2

DeclHiddenChannelCapacity.trC_posDeclaration kindtheorem

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [Nonempty a]
  [inst_3 : Fintype c] [inst_4 : DecidableEq c] [Nonempty c] [inst_6 : Fintype b] [inst_7 : DecidableEq b] [Nonempty b]
  (ρAC : MState (a × c)) (ρCB : MState (c × b)), 0 < HiddenChannelCapacity.trC ρAC ρCB

HiddenChannelCapacity.TR HiddenChannelCapacity.Tmat HiddenChannelCapacity.trC

Used by

HiddenChannelCapacity.log_sigT
HiddenChannelCapacity.markov_completion_eq_sigT
HiddenChannelCapacity.sigT_posDef

DeclHiddenChannelCapacity.exp_log_idDeclaration kindtheorem
exp then log is the identity on Hermitian matrices (unconditionally: both are cfc transports and Real.log ∘ Real.exp = id).
```
∀ {d : Type u_4} [inst : Fintype d] [inst_1 : DecidableEq d] (A : HermitianMat d ℂ), A.exp.log = A
```
Used by
- HiddenChannelCapacity.log_sigT
DeclHiddenChannelCapacity.inner_embedCDeclaration kindtheorem
Duality for the C-embedding (two-step pull-out; uses the marginal coherence margC_eq_CBright, LZ Lem 2.2).
```
∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Fintype c]
  [inst_3 : DecidableEq c] [inst_4 : Fintype b] [inst_5 : DecidableEq b] (ω : MState (a × c × b))
  (L : HermitianMat c ℂ), inner ℝ (↑ω) (HiddenChannelCapacity.embedC L) = inner ℝ (↑(HiddenChannelCapacity.margC ω)) L
```
HiddenChannelCapacity.embedC HiddenChannelCapacity.embedCB HiddenChannelCapacity.margC HiddenChannelCapacity.margCB
Uses
Used by
- HiddenChannelCapacity.lem_3_2
DeclHiddenChannelCapacity.margC_eq_CBrightDeclaration kindtheorem
Coherence of the two separator-marginal routes (iterated marginalization, LZ Lem 2.2): tracing a then b is tracing b then a.
```
∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Fintype c]
  [inst_3 : DecidableEq c] [inst_4 : Fintype b] [inst_5 : DecidableEq b] (ω : MState (a × c × b)),
  HiddenChannelCapacity.margC ω = (HiddenChannelCapacity.margCB ω).traceRight
```
HiddenChannelCapacity.margAC HiddenChannelCapacity.margC HiddenChannelCapacity.margCB
Uses
- HiddenChannelCapacity.assoc'_eq_relabel
Used by

DeclHiddenChannelCapacity.inner_kron_oneDeclaration kindtheorem

Duality for a right-identity Kronecker factor on any bipartite carrier.

∀ {d₁ : Type u_4} {d₂ : Type u_5} [inst : Fintype d₁] [inst_1 : DecidableEq d₁] [inst_2 : Fintype d₂]
  [inst_3 : DecidableEq d₂] (X : MState (d₁ × d₂)) (L : HermitianMat d₁ ℂ),
  inner ℝ (↑X) (L.kronecker 1) = inner ℝ (↑X.traceRight) L

Uses

Matrix.traceRight_mul_kron_one

Used by

HiddenChannelCapacity.inner_embedC

DeclMatrix.traceRight_mul_kron_oneDeclaration kindtheorem

Pull-out for the right partial trace, right-multiplication form: Tr_B(ρ (M ⊗ 1_B)) = Tr_B(ρ) · M.

∀ {R : Type u_1} [inst : NonAssocSemiring R] {d : Type u_2} {d₁ : Type u_3} {d₂ : Type u_4} {d₃ : Type u_5}
  [inst_1 : Fintype d] [inst_2 : Fintype d₂] [inst_3 : DecidableEq d] (ρ : Matrix (d₁ × d) (d₂ × d) R)
  (M : Matrix d₂ d₃ R), Matrix.traceRight (ρ * Matrix.kroneckerMap (fun x1 x2 => x1 * x2) M 1) = ρ.traceRight * M

Used by

HiddenChannelCapacity.inner_kron_one

DeclHiddenChannelCapacity.inner_embedCBDeclaration kindtheorem

Duality for the C∪B-embedding: testing the state against an embedded observable is testing the marginal (LZ eq. 2).

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Fintype c]
  [inst_3 : DecidableEq c] [inst_4 : Fintype b] [inst_5 : DecidableEq b] (ω : MState (a × c × b))
  (L : HermitianMat (c × b) ℂ),
  inner ℝ (↑ω) (HiddenChannelCapacity.embedCB L) = inner ℝ (↑(HiddenChannelCapacity.margCB ω)) L

HiddenChannelCapacity.embedCB HiddenChannelCapacity.margCB

Uses

Matrix.traceLeft_mul_one_kron

Used by

HiddenChannelCapacity.inner_embedC
HiddenChannelCapacity.lem_3_2

DeclMatrix.traceLeft_mul_one_kronDeclaration kindtheorem

Pull-out, right-multiplication form: Tr_A(ρ (1_A ⊗ M)) = Tr_A(ρ) · M.

∀ {R : Type u_1} [inst : NonAssocSemiring R] {d : Type u_2} {d₁ : Type u_3} {d₂ : Type u_4} {d₃ : Type u_5}
  [inst_1 : Fintype d] [inst_2 : Fintype d₂] [inst_3 : DecidableEq d] (ρ : Matrix (d × d₁) (d × d₂) R)
  (M : Matrix d₂ d₃ R), Matrix.traceLeft (ρ * Matrix.kroneckerMap (fun x1 x2 => x1 * x2) 1 M) = ρ.traceLeft * M

Used by

HiddenChannelCapacity.inner_embedCB

DeclHiddenChannelCapacity.inner_embedACDeclaration kindtheorem

Duality for the A∪C-embedding (via the L0 primitive traceAlong_duality).

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Fintype c]
  [inst_3 : DecidableEq c] [inst_4 : Fintype b] [inst_5 : DecidableEq b] (ω : MState (a × c × b))
  (L : HermitianMat (a × c) ℂ),
  inner ℝ (↑ω) (HiddenChannelCapacity.embedAC L) = inner ℝ (↑(HiddenChannelCapacity.margAC ω)) L

HiddenChannelCapacity.embedAC HiddenChannelCapacity.margAC MState.traceAlong Matrix.embedAlong

Uses

HiddenChannelCapacity.margAC_eq_traceAlong
MState.traceAlong_duality

Used by

HiddenChannelCapacity.lem_3_2

DeclMState.traceAlong_dualityDeclaration kindtheorem
The partial-trace duality (LZ eq (2), the defining property of the partial trace, split-indexed): testing the marginal against an observable is testing the state against the embedded observable, Tr(embedAlong e M · ρ) = Tr(M · traceAlong e ρ).
```
∀ {d : Type u_1} {a : Type u_2} {b : Type u_3} [inst : Fintype d] [inst_1 : DecidableEq d] [inst_2 : Fintype a]
  [inst_3 : DecidableEq a] [inst_4 : Fintype b] [inst_5 : DecidableEq b] (ρ : MState d) (e : d ≃ a × b)
  (M : Matrix a a ℂ), (Matrix.embedAlong e M * ρ.m).trace = (M * (ρ.traceAlong e).m).trace
```
MState.traceAlong Matrix.embedAlong
Uses
- Matrix.traceRight_kron_one_mul
- Matrix.trace_submatrix_equiv
Used by
- HiddenChannelCapacity.inner_embedAC

DeclMatrix.trace_submatrix_equivDeclaration kindtheorem

The trace is invariant under simultaneous reindexing by an equivalence.

∀ {R : Type u_1} [inst : NonAssocSemiring R] {n : Type u_6} {m : Type u_7} [inst_1 : Fintype n] [inst_2 : Fintype m]
  (A : Matrix m m R) (e : n ≃ m), (A.submatrix ⇑e ⇑e).trace = A.trace

Used by

MState.traceAlong_duality

DeclMatrix.traceRight_kron_one_mulDeclaration kindtheorem

Pull-out for the right partial trace, left-multiplication form: Tr_B((M ⊗ 1_B) ρ) = M · Tr_B(ρ).

∀ {R : Type u_1} [inst : NonAssocSemiring R] {d : Type u_2} {d₁ : Type u_3} {d₂ : Type u_4} {d₃ : Type u_5}
  [inst_1 : Fintype d] [inst_2 : Fintype d₂] [inst_3 : DecidableEq d] (M : Matrix d₁ d₂ R)
  (ρ : Matrix (d₂ × d) (d₃ × d) R),
  Matrix.traceRight (Matrix.kroneckerMap (fun x1 x2 => x1 * x2) M 1 * ρ) = M * ρ.traceRight

Used by

MState.traceAlong_duality

DeclHiddenChannelCapacity.margAC_eq_traceAlongDeclaration kindtheorem

The AC-marginal in traceAlong form (the L0 primitive).

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Fintype c]
  [inst_3 : DecidableEq c] [inst_4 : Fintype b] [inst_5 : DecidableEq b] (ω : MState (a × c × b)),
  HiddenChannelCapacity.margAC ω = ω.traceAlong (Equiv.prodAssoc a c b).symm

HiddenChannelCapacity.margAC MState.traceAlong

Uses

HiddenChannelCapacity.assoc'_eq_relabel

Used by

HiddenChannelCapacity.inner_embedAC

DeclHiddenChannelCapacity.assoc'_eq_relabelDeclaration kindtheorem

The vendored associator is the plain prodAssoc relabel.

∀ {a : Type u_1} {c : Type u_2} {b : Type u_3} [inst : Fintype a] [inst_1 : DecidableEq a] [inst_2 : Fintype c]
  [inst_3 : DecidableEq c] [inst_4 : Fintype b] [inst_5 : DecidableEq b] (ω : MState (a × c × b)),
  ω.assoc' = ω.relabel (Equiv.prodAssoc a c b)

Used by

HiddenChannelCapacity.margAC_eq_traceAlong
HiddenChannelCapacity.margC_eq_CBright

DeclHiddenChannelCapacity.inner_log_faithfulDeclaration kindtheorem
Faithfulness of quantum relative entropy (the equality case of Klein's inequality, LZ p. 5, Ruskai 2002 Thm 3; not present in the vendored corpus): for a state ρ and a STRICTLY POSITIVE state σ, Tr[ρ(log ρ − log σ)] = 0 forces ρ = σ.
```
∀ {d : Type u_1} [inst : Fintype d] [inst_1 : DecidableEq d] (ρ σ : MState d),
  σ.m.PosDef → inner ℝ (↑ρ) ((↑ρ).log - (↑σ).log) = 0 → ρ = σ
```
HiddenChannelCapacity.kleinTerm
Uses
Used by
- HiddenChannelCapacity.markov_completion_eq_sigT
- HiddenChannelCapacity.sigT_markov_of_trC_eq_one
DeclHiddenChannelCapacity.kleinTerm_nonnegDeclaration kindtheorem
```
∀ {x y : ℝ}, 0 ≤ x → 0 < y → 0 ≤ HiddenChannelCapacity.kleinTerm x y
```
HiddenChannelCapacity.kleinTerm
Used by
- HiddenChannelCapacity.inner_log_faithful
DeclHiddenChannelCapacity.kleinTerm_eq_zero_iffDeclaration kindtheorem
```
∀ {x y : ℝ}, 0 ≤ x → 0 < y → (HiddenChannelCapacity.kleinTerm x y = 0 ↔ x = y)
```
HiddenChannelCapacity.kleinTerm
Used by
- HiddenChannelCapacity.inner_log_faithful

DeclHermitianMat.overlap_row_sumDeclaration kindtheorem

Rows of the shared-basis kernel sum to one (C is unitary).

∀ {d : Type u_1} [inst : Fintype d] [inst_1 : DecidableEq d] (A B : HermitianMat d ℂ) (i : d),
  ∑ j, ‖((↑⋯.eigenvectorUnitary).conjTranspose * ↑⋯.eigenvectorUnitary) i j‖ ^ 2 = 1

Used by

HiddenChannelCapacity.inner_log_faithful

DeclHermitianMat.overlap_col_sumDeclaration kindtheorem

Columns of the shared-basis kernel sum to one.

∀ {d : Type u_1} [inst : Fintype d] [inst_1 : DecidableEq d] (A B : HermitianMat d ℂ) (j : d),
  ∑ i, ‖((↑⋯.eigenvectorUnitary).conjTranspose * ↑⋯.eigenvectorUnitary) i j‖ ^ 2 = 1

Used by

HiddenChannelCapacity.inner_log_faithful

DeclHermitianMat.log_eq_cfcDeclaration kindtheorem
A.log is cfc at Real.log, definitionally (QuantumInfo LogExp.lean).
```
∀ {d : Type u_1} [inst : Fintype d] [inst_1 : DecidableEq d] (A : HermitianMat d ℂ), A.log = A.cfc Real.log
```
Used by
- HiddenChannelCapacity.inner_log_faithful
DeclHermitianMat.inner_cfc_cfcDeclaration kindtheorem
The shared-basis double sum (generalizing the vendored inner_eq_doubly_stochastic_sum from (A, B) to (A.cfc f, B.cfc g) with the SAME overlap kernel): the inner product of two matrix functions expands over the pair of eigenbases with weights ‖C i j‖², C = U_A† U_B. All four divergence pairings of the faithfulness argument are instances of this one lemma at a single shared kernel.
```
∀ {d : Type u_1} [inst : Fintype d] [inst_1 : DecidableEq d] (A B : HermitianMat d ℂ) (f g : ℝ → ℝ),
  inner ℝ (A.cfc f) (B.cfc g) =
    ∑ i,
      ∑ j,
        f (⋯.eigenvalues i) * g (⋯.eigenvalues j) *
          ‖((↑⋯.eigenvectorUnitary).conjTranspose * ↑⋯.eigenvectorUnitary) i j‖ ^ 2
```
Uses
- HermitianMat.trace_single_conj
Used by
- HiddenChannelCapacity.inner_log_faithful

DeclHermitianMat.trace_single_conjDeclaration kindtheorem

∀ {d : Type u_1} [inst : Fintype d] [inst_1 : DecidableEq d] (C : Matrix d d ℂ) (i j : d),
  (Matrix.single i i 1 * C * Matrix.single j j 1 * C.conjTranspose).trace = C i j * star (C i j)

Uses

HermitianMat.trace_single_mul

Used by

HermitianMat.inner_cfc_cfc

DeclHermitianMat.trace_single_mulDeclaration kindtheorem

∀ {d : Type u_1} [inst : Fintype d] [inst_1 : DecidableEq d] (X : Matrix d d ℂ) (i : d),
  (Matrix.single i i 1 * X).trace = X i i

Used by

HermitianMat.trace_single_conj

HypothesishAC
```
ρAC.m.PosDef
```
HypothesishCB
```
ρCB.m.PosDef
```
Hypothesishcons
```
ρAC.traceLeft = ρCB.traceRight
```

DefinitionHiddenChannelCapacity.IsCompletiondef

A completion: a global state with the prescribed marginals (LZ M(R), p. 7).

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [inst_2 : Fintype c] →
            [inst_3 : DecidableEq c] →
              [inst_4 : Fintype b] →
                [inst_5 : DecidableEq b] → MState (a × c) → MState (c × b) → MState (a × c × b) → Prop

DefinitionHiddenChannelCapacity.IsMarkovCompletiondef

A quantum Markov completion: a completion with I(A:B|C) = 0 (LZ Def 2.4 quantum conditional independence + the Markov completion of p. 7).

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [inst_2 : Fintype c] →
            [inst_3 : DecidableEq c] →
              [inst_4 : Fintype b] →
                [inst_5 : DecidableEq b] → MState (a × c) → MState (c × b) → MState (a × c × b) → Prop

DefinitionHiddenChannelCapacity.TRdef

The logarithmic candidate T(R) = exp(log ρ_{AC} + log ρ_{CB} − log ρ_C) (LZ eq. 5). A Hermitian matrix, NOT a priori a state: its trace deficit is the subject of the theorem.

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [inst_2 : Fintype c] →
            [inst_3 : DecidableEq c] →
              [inst_4 : Fintype b] →
                [inst_5 : DecidableEq b] → MState (a × c) → MState (c × b) → HermitianMat (a × c × b) ℂ

DefinitionHiddenChannelCapacity.Tmatdef

The Hermitian exponent of the logarithmic candidate: the sum of the embedded logarithms of the marginals (log ρ_{AC} + log ρ_{CB} − log ρ_C, every operator embedded BEFORE exp; LZ eq. 5 with the p. 23 embedding convention; the separator marginal is taken from the AC side).

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [inst_2 : Fintype c] →
            [inst_3 : DecidableEq c] →
              [inst_4 : Fintype b] →
                [inst_5 : DecidableEq b] → MState (a × c) → MState (c × b) → HermitianMat (a × c × b) ℂ

DefinitionHiddenChannelCapacity.embedACdef

Embed an A∪C-local operator into the global system.

{a : Type u_1} → {c : Type u_2} → {b : Type u_3} → [DecidableEq b] → HermitianMat (a × c) ℂ → HermitianMat (a × c × b) ℂ

DefinitionHiddenChannelCapacity.embedCdef

Embed a C-local operator into the global system.

{a : Type u_1} →
  {c : Type u_2} → {b : Type u_3} → [DecidableEq a] → [DecidableEq b] → HermitianMat c ℂ → HermitianMat (a × c × b) ℂ

DefinitionHiddenChannelCapacity.embedCBdef

Embed a C∪B-local operator into the global system (tensoring with the identity, LZ p. 23).

{a : Type u_1} → {c : Type u_2} → {b : Type u_3} → [DecidableEq a] → HermitianMat (c × b) ℂ → HermitianMat (a × c × b) ℂ

DefinitionHiddenChannelCapacity.kleinTermdef
The scalar Klein term x log x − x log y − x + y (the integrand of Klein's inequality, LZ p. 5 / Ruskai 2002 Thm 3).
```
ℝ → ℝ → ℝ
```

DefinitionHiddenChannelCapacity.margACdef

The A∪C-marginal of a global state (LZ p. 4: reduced density operator).

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [inst_2 : Fintype c] →
            [inst_3 : DecidableEq c] →
              [inst_4 : Fintype b] → [inst_5 : DecidableEq b] → MState (a × c × b) → MState (a × c)

DefinitionHiddenChannelCapacity.margCdef

The C-marginal (the separator marginal), as the vendor composite the qcmi definition consumes.

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [inst_2 : Fintype c] →
            [inst_3 : DecidableEq c] → [inst_4 : Fintype b] → [inst_5 : DecidableEq b] → MState (a × c × b) → MState c

DefinitionHiddenChannelCapacity.margCBdef

The C∪B-marginal of a global state.

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [inst_2 : Fintype c] →
            [inst_3 : DecidableEq c] →
              [inst_4 : Fintype b] → [inst_5 : DecidableEq b] → MState (a × c × b) → MState (c × b)

DefinitionHiddenChannelCapacity.qDivRdef
The quantum relative entropy in real form, Tr[ρ (log ρ − log σ)] (LZ eq. 4 on density operators; equals the vendored qRelativeEnt by qRelativeEnt_rank when σ is nonsingular).
```
{d : Type u_4} → [inst : Fintype d] → [inst_1 : DecidableEq d] → MState d → MState d → ℝ
```

DefinitionHiddenChannelCapacity.sigTdef

The normalized candidate σ(R) = T(R)/Tr T(R): the state the equivalences of LZ Thm 3.1 are about.

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [Nonempty a] →
            [inst_3 : Fintype c] →
              [inst_4 : DecidableEq c] →
                [Nonempty c] →
                  [inst_6 : Fintype b] →
                    [inst_7 : DecidableEq b] → [Nonempty b] → MState (a × c) → MState (c × b) → MState (a × c × b)

DefinitionHiddenChannelCapacity.trCdef

The trace of the logarithmic candidate.

{a : Type u_1} →
  {c : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype a] →
        [inst_1 : DecidableEq a] →
          [inst_2 : Fintype c] →
            [inst_3 : DecidableEq c] →
              [inst_4 : Fintype b] → [inst_5 : DecidableEq b] → MState (a × c) → MState (c × b) → ℝ

DefinitionMState.traceAlongdef

Trace out the second block of a coordinate split: the abstract partial-trace primitive of the L0 layer.

{d : Type u_1} →
  {a : Type u_2} →
    {b : Type u_3} →
      [inst : Fintype d] →
        [inst_1 : DecidableEq d] →
          [inst_2 : Fintype a] →
            [inst_3 : DecidableEq a] → [Fintype b] → [DecidableEq b] → MState d → d ≃ a × b → MState a

DefinitionMatrix.embedAlongdef
Embed an operator on one block of a coordinate split into the whole space (tensor with the identity, transported along the split): the dual of MState.traceAlong, and the paper's embedding convention ("tensoring with identities BEFORE logs") as a named primitive.
```
{R : Type u_1} →
  [NonAssocSemiring R] →
    {d : Type u_2} → {a : Type u_6} → {b : Type u_7} → [DecidableEq b] → d ≃ a × b → Matrix a a R → Matrix d d R
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

Closed form of the multivariate Gaussian KL divergence (M3b). For positive-definite covariances S₁, S₂, KL(N(m₁,S₁) ‖ N(m₂,S₂)) = ½ ( log(det S₂ / det S₁) + tr(S₂⁻¹ S₁) + ⟪m₁-m₂, S₂⁻¹(m₁-m₂)⟫ - d ).

The whitening reduction (klDivReal_multivariateGaussian_whiten) sends the pair to a KL against the standard Gaussian (klDivReal_multivariateGaussian_stdGaussian); the three scalar invariants of the whitened covariance (det_whitened, trace_whitened, normSq_cfcSqrt_inv_apply) then identify the arguments.

DeclProbabilityTheory.klDivReal_multivariateGaussian

∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (m₁ m₂ : EuclideanSpace ℝ ι) {S₁ S₂ : Matrix ι ι ℝ},
  S₁.PosDef →
    S₂.PosDef →
      InformationTheory.klDivReal (ProbabilityTheory.multivariateGaussian m₁ S₁)
          (ProbabilityTheory.multivariateGaussian m₂ S₂) =
        1 / 2 *
          (Real.log (S₂.det / S₁.det) + (S₂⁻¹ * S₁).trace + (m₁ - m₂).ofLp ⬝ᵥ S₂⁻¹.mulVec (m₁.ofLp - m₂.ofLp) -
            ↑(Fintype.card ι))

ThesisStepHypothesisDefinition

DeclProbabilityTheory.klDivReal_multivariateGaussianDeclaration kindtheorem

∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (m₁ m₂ : EuclideanSpace ℝ ι) {S₁ S₂ : Matrix ι ι ℝ},
  S₁.PosDef →
    S₂.PosDef →
      InformationTheory.klDivReal (ProbabilityTheory.multivariateGaussian m₁ S₁)
          (ProbabilityTheory.multivariateGaussian m₂ S₂) =
        1 / 2 *
          (Real.log (S₂.det / S₁.det) + (S₂⁻¹ * S₁).trace + (m₁ - m₂).ofLp ⬝ᵥ S₂⁻¹.mulVec (m₁.ofLp - m₂.ofLp) -
            ↑(Fintype.card ι))

InformationTheory.klDivReal

Uses

ProbabilityTheory.det_whitened
ProbabilityTheory.klDivReal_multivariateGaussian_stdGaussian
ProbabilityTheory.klDivReal_multivariateGaussian_whiten
ProbabilityTheory.normSq_cfcSqrt_inv_apply
ProbabilityTheory.posDef_whitened
ProbabilityTheory.trace_whitened

DeclProbabilityTheory.trace_whitenedDeclaration kindtheorem
tr C(S₁,S₂) = tr(S₂⁻¹ S₁).
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {S₁ S₂ : Matrix ι ι ℝ},
  S₁.PosDef →
    S₂.PosDef →
      ((CFC.sqrt S₂)⁻¹ * CFC.sqrt S₁ * ((CFC.sqrt S₂)⁻¹ * CFC.sqrt S₁).conjTranspose).trace = (S₂⁻¹ * S₁).trace
```
Uses
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian
DeclProbabilityTheory.posDef_whitenedDeclaration kindtheorem
The whitened covariance (√S₂⁻¹ √S₁)(√S₂⁻¹ √S₁)ᴴ is positive-definite (its factor is invertible).
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {S₁ S₂ : Matrix ι ι ℝ},
  S₁.PosDef → S₂.PosDef → ((CFC.sqrt S₂)⁻¹ * CFC.sqrt S₁ * ((CFC.sqrt S₂)⁻¹ * CFC.sqrt S₁).conjTranspose).PosDef
```
Uses
- ProbabilityTheory.isUnit_det_cfcSqrt
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian
DeclProbabilityTheory.normSq_cfcSqrt_inv_applyDeclaration kindtheorem
The whitening map preserves the quadratic form: ‖√S₂⁻¹ v‖² = ⟪v, S₂⁻¹ v⟫.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {S₂ : Matrix ι ι ℝ},
  S₂.PosDef → ∀ (v : EuclideanSpace ℝ ι), ‖(Matrix.toEuclideanCLM (CFC.sqrt S₂)⁻¹) v‖ ^ 2 = v.ofLp ⬝ᵥ S₂⁻¹.mulVec v.ofLp
```
Uses
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian
DeclProbabilityTheory.conjTranspose_cfcSqrt_invDeclaration kindtheorem
The inverse of a functional-calculus square root is self-adjoint.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (S : Matrix ι ι ℝ),
  (CFC.sqrt S)⁻¹.conjTranspose = (CFC.sqrt S)⁻¹
```
Uses
- ProbabilityTheory.conjTranspose_cfcSqrt
Used by
- ProbabilityTheory.normSq_cfcSqrt_inv_apply
- ProbabilityTheory.trace_whitened
DeclProbabilityTheory.conjTranspose_cfcSqrtDeclaration kindtheorem
The functional-calculus square root of a matrix is self-adjoint.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (S : Matrix ι ι ℝ), (CFC.sqrt S).conjTranspose = CFC.sqrt S
```
Used by
- ProbabilityTheory.conjTranspose_cfcSqrt_inv
- ProbabilityTheory.trace_whitened
DeclProbabilityTheory.cfcSqrt_inv_mul_selfDeclaration kindtheorem
(√S)⁻¹ (√S)⁻¹ = S⁻¹ for positive-definite S.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {S : Matrix ι ι ℝ},
  S.PosDef → (CFC.sqrt S)⁻¹ * (CFC.sqrt S)⁻¹ = S⁻¹
```
Used by
- ProbabilityTheory.normSq_cfcSqrt_inv_apply
- ProbabilityTheory.trace_whitened
DeclProbabilityTheory.klDivReal_multivariateGaussian_whitenDeclaration kindtheorem
Whitening reduction of the multivariate Gaussian KL. For positive-definite S₂, pushing both measures through the whitening equivalence (gaussianAffineEquiv m₂ hS₂).symm reduces the KL divergence of two multivariate Gaussians to a KL against the standard Gaussian, with whitened mean √S₂⁻¹ (m₁ − m₂) and covariance (√S₂⁻¹ √S₁)(√S₂⁻¹ √S₁)ᴴ.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (m₁ m₂ : EuclideanSpace ℝ ι) (S₁ S₂ : Matrix ι ι ℝ),
  S₂.PosDef →
    InformationTheory.klDivReal (ProbabilityTheory.multivariateGaussian m₁ S₁)
        (ProbabilityTheory.multivariateGaussian m₂ S₂) =
      InformationTheory.klDivReal
        (ProbabilityTheory.multivariateGaussian ((Matrix.toEuclideanCLM (CFC.sqrt S₂)⁻¹) (m₁ - m₂))
          ((CFC.sqrt S₂)⁻¹ * CFC.sqrt S₁ * ((CFC.sqrt S₂)⁻¹ * CFC.sqrt S₁).conjTranspose))
        (ProbabilityTheory.stdGaussian (EuclideanSpace ℝ ι))
```
InformationTheory.klDivReal ProbabilityTheory.gaussianAffineEquiv
Uses
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian
DeclProbabilityTheory.multivariateGaussian_eq_map_gaussianAffineEquivDeclaration kindtheorem
multivariateGaussian m S is the pushforward of the standard Gaussian by the affine equivalence gaussianAffineEquiv m hS.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (m : EuclideanSpace ℝ ι) {S : Matrix ι ι ℝ}
  (hS : S.PosDef),
  ProbabilityTheory.multivariateGaussian m S =
    MeasureTheory.Measure.map (⇑(ProbabilityTheory.gaussianAffineEquiv m hS))
      (ProbabilityTheory.stdGaussian (EuclideanSpace ℝ ι))
```
ProbabilityTheory.gaussianAffineEquiv
Uses
- ProbabilityTheory.gaussianAffineEquiv_apply
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian_whiten
DeclProbabilityTheory.gaussianAffineEquiv_applyDeclaration kindtheorem
gaussianAffineEquiv m hS is the affine map z ↦ m + √S z.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (m : EuclideanSpace ℝ ι) {S : Matrix ι ι ℝ} (hS : S.PosDef)
  (z : EuclideanSpace ℝ ι), (ProbabilityTheory.gaussianAffineEquiv m hS) z = m + (Matrix.toEuclideanCLM (CFC.sqrt S)) z
```
ProbabilityTheory.gaussianAffineEquiv ProbabilityTheory.toEuclideanCLE
Uses
- ProbabilityTheory.isUnit_det_cfcSqrt
Used by
- ProbabilityTheory.multivariateGaussian_eq_map_gaussianAffineEquiv
DeclProbabilityTheory.gaussianAffineEquiv_symm_applyDeclaration kindtheorem
The whitening map: the inverse of gaussianAffineEquiv m hS is z ↦ √S⁻¹ (z - m).
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (m : EuclideanSpace ℝ ι) {S : Matrix ι ι ℝ} (hS : S.PosDef)
  (z : EuclideanSpace ℝ ι),
  (ProbabilityTheory.gaussianAffineEquiv m hS).symm z = (Matrix.toEuclideanCLM (CFC.sqrt S)⁻¹) (z - m)
```
ProbabilityTheory.gaussianAffineEquiv ProbabilityTheory.toEuclideanCLE
Uses
- ProbabilityTheory.isUnit_det_cfcSqrt
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian_whiten
DeclProbabilityTheory.klDivReal_multivariateGaussian_stdGaussianDeclaration kindtheorem
Closed form of the multivariate Gaussian KL against the standard Gaussian. For a positive-definite covariance C, klDivReal (N(w, C)) (stdGaussian) = ½ ( -log det C + tr C + ‖w‖² - d ).
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (w : EuclideanSpace ℝ ι) {C : Matrix ι ι ℝ},
  C.PosDef →
    InformationTheory.klDivReal (ProbabilityTheory.multivariateGaussian w C)
        (ProbabilityTheory.stdGaussian (EuclideanSpace ℝ ι)) =
      1 / 2 * (-Real.log C.det + C.trace + ‖w‖ ^ 2 - ↑(Fintype.card ι))
```
InformationTheory.klDivReal ProbabilityTheory.toEuclideanCLE
Uses
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian
DeclProbabilityTheory.normSq_toEuclideanCLM_of_isometryDeclaration kindtheorem
An orthogonal change of variables preserves the Euclidean norm: if Mᴴ M = 1 then ‖toEuclideanCLM M w‖² = ‖w‖².
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {M : Matrix ι ι ℝ},
  M.conjTranspose * M = 1 → ∀ (w : EuclideanSpace ℝ ι), ‖(Matrix.toEuclideanCLM M) w‖ ^ 2 = ‖w‖ ^ 2
```
Uses
- ProbabilityTheory.adjoint_toEuclideanCLM
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian_stdGaussian
DeclProbabilityTheory.map_multivariateGaussian_affineDeclaration kindtheorem
General affine image of a multivariate Gaussian. For positive-semidefinite covariance S, the affine pushforward x ↦ a + B x of multivariateGaussian μ S is the multivariate Gaussian with transported mean a + B μ and congruent covariance B * S * Bᴴ. This is the covariance- transport engine of the diagonalization step: an orthogonal B = Uᵀ sends the whitened covariance to its eigenvalue diagonal Uᵀ S U. Proved by composing the two affine maps and reducing to the standard-Gaussian image map_stdGaussian_affine, using √S · √Sᴴ = √S · √S = S.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (a μ : EuclideanSpace ℝ ι) (B S : Matrix ι ι ℝ),
  S.PosSemidef →
    MeasureTheory.Measure.map (fun x => a + (Matrix.toEuclideanCLM B) x) (ProbabilityTheory.multivariateGaussian μ S) =
      ProbabilityTheory.multivariateGaussian (a + (Matrix.toEuclideanCLM B) μ) (B * S * B.conjTranspose)
```
Uses
- ProbabilityTheory.map_stdGaussian_affine
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian_stdGaussian
DeclProbabilityTheory.klDivReal_multivariateGaussian_diagonal_stdGaussianDeclaration kindtheorem
KL of a diagonal multivariate Gaussian against the standard Gaussian, tensorized. For strictly positive diagonal covariance d > 0, klDivReal (mvG μ (diagonal d)) stdGaussian = ∑ᵢ ½(-log dᵢ + dᵢ + μᵢ² - 1), the coordinatewise sum of the scalar Gaussian-Gaussian KL closed forms. This is the diagonalized-and-tensorized leg of the multivariate Gaussian KL closed form.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (μ : EuclideanSpace ℝ ι) (d : ι → ℝ),
 (∀ (i : ι), 0 < d i) →
 InformationTheory.klDivReal (ProbabilityTheory.multivariateGaussian μ (Matrix.diagonal d))
 (ProbabilityTheory.stdGaussian (EuclideanSpace ℝ ι)) =
 ∑ i, 1 / 2 * (-Real.log (d i) + d i + μ.ofLp i ^ 2 - 1)
```
InformationTheory.klDivReal ProbabilityTheory.toLpMeasurableEquiv
Uses
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian_stdGaussian
DeclProbabilityTheory.multivariateGaussian_diagonal_eq_map_piDeclaration kindtheorem
A diagonal multivariate Gaussian is a pushed-forward product of scalar Gaussians. For d ≥ 0, multivariateGaussian μ (diagonal d) is the image under toLp 2 of the product measure ∏ᵢ gaussianReal μᵢ dᵢ.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (μ : EuclideanSpace ℝ ι) (d : ι → ℝ),
  (∀ (i : ι), 0 ≤ d i) →
    ProbabilityTheory.multivariateGaussian μ (Matrix.diagonal d) =
      MeasureTheory.Measure.map (WithLp.toLp 2)
        (MeasureTheory.Measure.pi fun i => ProbabilityTheory.gaussianReal (μ.ofLp i) (d i).toNNReal)
```
Uses
- ProbabilityTheory.map_stdGaussian_affine
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian_diagonal_stdGaussian
DeclProbabilityTheory.map_stdGaussian_affineDeclaration kindtheorem
The affine image z ↦ a + B z of the standard Gaussian on EuclideanSpace ℝ ι is the multivariate Gaussian with mean a and covariance B * Bᴴ.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (a : EuclideanSpace ℝ ι) (B : Matrix ι ι ℝ),
  MeasureTheory.Measure.map (fun z => a + (Matrix.toEuclideanCLM B) z)
      (ProbabilityTheory.stdGaussian (EuclideanSpace ℝ ι)) =
    ProbabilityTheory.multivariateGaussian a (B * B.conjTranspose)
```
Uses
- ProbabilityTheory.inner_adjoint_toEuclideanCLM
Used by

DeclProbabilityTheory.inner_adjoint_toEuclideanCLMDeclaration kindtheorem

The real inner product of the two adjoint images (toEuclideanCLM B)ᴴ x and (toEuclideanCLM B)ᴴ y equals the quadratic form x ⬝ᵥ (B * Bᴴ) *ᵥ y.

∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (B : Matrix ι ι ℝ) (x y : EuclideanSpace ℝ ι),
  inner ℝ ((ContinuousLinearMap.adjoint (Matrix.toEuclideanCLM B)) x)
      ((ContinuousLinearMap.adjoint (Matrix.toEuclideanCLM B)) y) =
    x.ofLp ⬝ᵥ (B * B.conjTranspose).mulVec y.ofLp

Uses

ProbabilityTheory.adjoint_toEuclideanCLM

Used by

ProbabilityTheory.map_stdGaussian_affine

DeclProbabilityTheory.adjoint_toEuclideanCLMDeclaration kindtheorem
The adjoint of toEuclideanCLM B is toEuclideanCLM Bᴴ: toEuclideanCLM is a star algebra equivalence, so it carries the matrix conjugate transpose to the operator adjoint.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (B : Matrix ι ι ℝ),
  ContinuousLinearMap.adjoint (Matrix.toEuclideanCLM B) = Matrix.toEuclideanCLM B.conjTranspose
```
Used by
DeclInformationTheory.klDiv_gaussianReal_ne_topDeclaration kindtheorem
Finiteness of the one-dimensional Gaussian-Gaussian KL divergence. For variance parameters v₁ ≠ 0, v₂ ≠ 0, the ℝ≥0∞-valued klDiv (N(m₁, v₁)) (N(m₂, v₂)) is finite. This is the integrability side-condition that klDivReal_pi requires per coordinate: the log-likelihood ratio is P-a.e. an explicit quadratic, whose square-integrability against P = N(m₁, v₁) is the finiteness of the second moment.
```
∀ {m₁ m₂ : ℝ} {v₁ v₂ : NNReal},
  v₁ ≠ 0 →
    v₂ ≠ 0 → InformationTheory.klDiv (ProbabilityTheory.gaussianReal m₁ v₁) (ProbabilityTheory.gaussianReal m₂ v₂) ≠ ⊤
```
Uses
- InformationTheory.log_gaussianPDFReal
- InformationTheory.rnDeriv_gaussianReal_ratio
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian_diagonal_stdGaussian

DeclInformationTheory.klDivReal_pi'Declaration kindtheorem

KL tensorization for klDivReal over an arbitrary finite product (general Fintype index): the real-valued analogue of klDiv_pi'.

∀ {ι : Type u_3} [inst : Fintype ι] {X : ι → Type u_4} {mX : (i : ι) → MeasurableSpace (X i)}
  (P Q : (i : ι) → MeasureTheory.Measure (X i)) [∀ (i : ι), MeasureTheory.IsProbabilityMeasure (P i)]
  [∀ (i : ι), MeasureTheory.IsProbabilityMeasure (Q i)],
  (∀ (i : ι), (P i).AbsolutelyContinuous (Q i)) →
    (∀ (i : ι), InformationTheory.klDiv (P i) (Q i) ≠ ⊤) →
      InformationTheory.klDivReal (MeasureTheory.Measure.pi P) (MeasureTheory.Measure.pi Q) =
        ∑ i, InformationTheory.klDivReal (P i) (Q i)

InformationTheory.klDivReal

Uses

InformationTheory.klDivReal_eq_toReal_klDiv
InformationTheory.klDiv_pi'

Used by

ProbabilityTheory.klDivReal_multivariateGaussian_diagonal_stdGaussian

DeclInformationTheory.klDiv_pi'Declaration kindtheorem

KL tensorization over an arbitrary finite product (general Fintype index). Reduces to the Fin-indexed klDiv_pi by reindexing through ι ≃ Fin (card ι).

∀ {ι : Type u_3} [inst : Fintype ι] {X : ι → Type u_4} {mX : (i : ι) → MeasurableSpace (X i)}
  (P Q : (i : ι) → MeasureTheory.Measure (X i)) [∀ (i : ι), MeasureTheory.IsProbabilityMeasure (P i)]
  [∀ (i : ι), MeasureTheory.IsProbabilityMeasure (Q i)],
  InformationTheory.klDiv (MeasureTheory.Measure.pi P) (MeasureTheory.Measure.pi Q) =
    ∑ i, InformationTheory.klDiv (P i) (Q i)

Uses

InformationTheory.klDiv_map_equiv
InformationTheory.klDiv_pi

Used by

InformationTheory.klDivReal_pi'

DeclInformationTheory.klDiv_piDeclaration kindtheorem

KL tensorization over a finite product, indexed by Fin (n+1): klDiv (Measure.pi P) (Measure.pi Q) = ∑ i, klDiv (P i) (Q i).

∀ {n : ℕ} {X : Fin n → Type u_3} {mX : (i : Fin n) → MeasurableSpace (X i)}
  (P Q : (i : Fin n) → MeasureTheory.Measure (X i)) [∀ (i : Fin n), MeasureTheory.IsProbabilityMeasure (P i)]
  [∀ (i : Fin n), MeasureTheory.IsProbabilityMeasure (Q i)],
  InformationTheory.klDiv (MeasureTheory.Measure.pi P) (MeasureTheory.Measure.pi Q) =
    ∑ i, InformationTheory.klDiv (P i) (Q i)

Uses

InformationTheory.klDiv_map_equiv
InformationTheory.klDiv_prod

Used by

InformationTheory.klDiv_pi'

DeclInformationTheory.klDiv_prodDeclaration kindtheorem

Binary KL tensorization. For probability measures, klDiv (μ.prod ν) (μ'.prod ν') = klDiv μ μ' + klDiv ν ν'.

∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ μ' : MeasureTheory.Measure α)
  (ν ν' : MeasureTheory.Measure β) [MeasureTheory.IsProbabilityMeasure μ] [MeasureTheory.IsProbabilityMeasure μ']
  [MeasureTheory.IsProbabilityMeasure ν] [MeasureTheory.IsProbabilityMeasure ν'],
  InformationTheory.klDiv (μ.prod ν) (μ'.prod ν') = InformationTheory.klDiv μ μ' + InformationTheory.klDiv ν ν'

Uses

InformationTheory.klDiv_prod_same_left

Used by

InformationTheory.klDiv_pi

DeclInformationTheory.klDiv_prod_same_leftDeclaration kindtheorem

Two products sharing the same first marginal reduce to the second-coordinate KL: klDiv (μ.prod ν) (μ.prod ν') = klDiv ν ν'.

∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : MeasureTheory.Measure α)
  (ν ν' : MeasureTheory.Measure β) [MeasureTheory.IsProbabilityMeasure μ] [MeasureTheory.IsFiniteMeasure ν]
  [MeasureTheory.IsFiniteMeasure ν'], InformationTheory.klDiv (μ.prod ν) (μ.prod ν') = InformationTheory.klDiv ν ν'

Uses

InformationTheory.klDiv_map_equiv

Used by

InformationTheory.klDiv_prod

DeclInformationTheory.klDiv_map_equivDeclaration kindtheorem
KL invariance under a measurable equivalence (ℝ≥0∞-valued). For finite measures μ, ν and a measurable equivalence e : α ≃ᵐ β, klDiv (μ.map e) (ν.map e) = klDiv μ ν.
```
∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β)
  (μ ν : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] [MeasureTheory.IsFiniteMeasure ν],
  InformationTheory.klDiv (MeasureTheory.Measure.map (⇑e) μ) (MeasureTheory.Measure.map (⇑e) ν) =
    InformationTheory.klDiv μ ν
```
Uses
- InformationTheory.llr_map_equiv
Used by

DeclInformationTheory.llr_map_equivDeclaration kindtheorem

The log-likelihood ratio is invariant (a.e.) under pushforward by a measurable equivalence: llr (μ.map e) (ν.map e) (e x) =ᵐ[ν] llr μ ν x.

∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β)
  (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ] [MeasureTheory.SigmaFinite ν],
  (fun x => MeasureTheory.llr (MeasureTheory.Measure.map (⇑e) μ) (MeasureTheory.Measure.map (⇑e) ν) (e x)) =ᵐ[ν]
    MeasureTheory.llr μ ν

Used by

InformationTheory.klDiv_map_equiv

DeclInformationTheory.klDivReal_eq_toReal_klDivDeclaration kindtheorem
For probability measures with P ≪ Q, the ℝ-valued KL equals (Mathlib.klDiv P Q).toReal. Both measures have total mass 1, so the Mathlib correction term vanishes.
```
∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α) [MeasureTheory.IsProbabilityMeasure P]
  [MeasureTheory.IsProbabilityMeasure Q],
  P.AbsolutelyContinuous Q → InformationTheory.klDivReal P Q = (InformationTheory.klDiv P Q).toReal
```
InformationTheory.klDivReal
Uses
- InformationTheory.integrand_eq_llr
Used by
- InformationTheory.klDivReal_pi'
DeclInformationTheory.integrand_eq_llrDeclaration kindtheorem
The integrand log ((P.rnDeriv Q x).toReal) is definitionally Mathlib's log-likelihood ratio llr P Q x.
```
∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α),
  (fun x => Real.log (P.rnDeriv Q x).toReal) = MeasureTheory.llr P Q
```
Used by
- InformationTheory.klDivReal_eq_toReal_klDiv
DeclInformationTheory.klDivReal_gaussianRealDeclaration kindtheorem
Closed form of the 1-D Gaussian-Gaussian KL divergence. For variance parameters v₁ ≠ 0, v₂ ≠ 0, KL( N(m₁, v₁) ‖ N(m₂, v₂) ) = ½ ( log(v₂/v₁) + (v₁ + (m₁-m₂)²)/v₂ - 1 ).
```
∀ {m₁ m₂ : ℝ} {v₁ v₂ : NNReal},
  v₁ ≠ 0 →
    v₂ ≠ 0 →
      InformationTheory.klDivReal (ProbabilityTheory.gaussianReal m₁ v₁) (ProbabilityTheory.gaussianReal m₂ v₂) =
        1 / 2 * (Real.log (↑v₂ / ↑v₁) + (↑v₁ + (m₁ - m₂) ^ 2) / ↑v₂ - 1)
```
InformationTheory.klDivReal
Uses
Used by
- ProbabilityTheory.klDivReal_multivariateGaussian_diagonal_stdGaussian

DeclInformationTheory.rnDeriv_gaussianReal_ratioDeclaration kindtheorem

The Radon-Nikodym derivative of one real Gaussian w.r.t. another is, volume-a.e., the ratio of their densities.

∀ {m₁ m₂ : ℝ} {v₁ v₂ : NNReal},
  v₁ ≠ 0 →
    v₂ ≠ 0 →
      (ProbabilityTheory.gaussianReal m₁ v₁).rnDeriv (ProbabilityTheory.gaussianReal m₂ v₂) =ᵐ[MeasureTheory.volume]
        fun x => ProbabilityTheory.gaussianPDF m₁ v₁ x / ProbabilityTheory.gaussianPDF m₂ v₂ x

Used by

InformationTheory.klDivReal_gaussianReal
InformationTheory.klDiv_gaussianReal_ne_top

DeclInformationTheory.log_gaussianPDFRealDeclaration kindtheorem
log (gaussianPDFReal m v x) = -½ log(2πv) - (x - m)²/(2v) for v ≠ 0.
```
∀ {m₁ : ℝ} {v₁ : NNReal},
  v₁ ≠ 0 →
    ∀ (x : ℝ),
      Real.log (ProbabilityTheory.gaussianPDFReal m₁ v₁ x) =
        -(1 / 2) * Real.log (2 * Real.pi * ↑v₁) - (x - m₁) ^ 2 / (2 * ↑v₁)
```
Used by
- InformationTheory.klDivReal_gaussianReal
- InformationTheory.klDiv_gaussianReal_ne_top
DeclInformationTheory.integral_sq_sub_constDeclaration kindtheorem
∫ (x - m₂)² ∂gaussianReal m₁ v₁ = v₁ + (m₁ - m₂)² (bias-variance split).
```
∀ {m₁ m₂ : ℝ} {v₁ : NNReal}, ∫ (x : ℝ), (x - m₂) ^ 2 ∂ProbabilityTheory.gaussianReal m₁ v₁ = ↑v₁ + (m₁ - m₂) ^ 2
```
Uses
- InformationTheory.integral_sq_sub_mean_self
- InformationTheory.integral_sub_mean_self
Used by
- InformationTheory.klDivReal_gaussianReal
DeclInformationTheory.integral_sub_mean_selfDeclaration kindtheorem
∫ (x - m₁) ∂gaussianReal m₁ v₁ = 0.
```
∀ {m₁ : ℝ} {v₁ : NNReal}, ∫ (x : ℝ), x - m₁ ∂ProbabilityTheory.gaussianReal m₁ v₁ = 0
```
Used by
- InformationTheory.integral_sq_sub_const
DeclInformationTheory.integral_sq_sub_mean_selfDeclaration kindtheorem
∫ (x - m₁)² ∂gaussianReal m₁ v₁ = v₁.
```
∀ {m₁ : ℝ} {v₁ : NNReal}, ∫ (x : ℝ), (x - m₁) ^ 2 ∂ProbabilityTheory.gaussianReal m₁ v₁ = ↑v₁
```
Used by
- InformationTheory.integral_sq_sub_const
- InformationTheory.klDivReal_gaussianReal
DeclInformationTheory.klDivReal_map_measurableEquivDeclaration kindtheorem
KL invariance under a measurable equivalence. For σ-finite measures P, Q on α and a measurable equivalence e : α ≃ᵐ β, klDivReal (P.map e) (Q.map e) = klDivReal P Q.
```
∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β)
  (P Q : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite P] [MeasureTheory.SigmaFinite Q],
  InformationTheory.klDivReal (MeasureTheory.Measure.map (⇑e) P) (MeasureTheory.Measure.map (⇑e) Q) =
    InformationTheory.klDivReal P Q
```
InformationTheory.klDivReal
Used by

DeclProbabilityTheory.det_whitenedDeclaration kindtheorem

det C(S₁,S₂) = det S₁ / det S₂.

∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {S₁ S₂ : Matrix ι ι ℝ},
  S₁.PosDef →
    S₂.PosDef → ((CFC.sqrt S₂)⁻¹ * CFC.sqrt S₁ * ((CFC.sqrt S₂)⁻¹ * CFC.sqrt S₁).conjTranspose).det = S₁.det / S₂.det

Uses

ProbabilityTheory.isUnit_det_cfcSqrt

Used by

ProbabilityTheory.klDivReal_multivariateGaussian

DeclProbabilityTheory.isUnit_det_cfcSqrtDeclaration kindtheorem
For a positive-definite matrix S, the functional-calculus square root has invertible determinant: (CFC.sqrt S).det ^ 2 = S.det > 0, so the sqrt is itself invertible.
```
∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (S : Matrix ι ι ℝ), S.PosDef → IsUnit (CFC.sqrt S).det
```
Used by
HypothesishS₁
```
S₁.PosDef
```
HypothesishS₂
```
S₂.PosDef
```
DefinitionInformationTheory.klDivRealdef
ℝ-valued KL divergence. Returns 0 when P is not absolutely continuous with respect to Q (by convention; the ℝ≥0∞-valued klDiv returns ⊤ in that case).
```
{α : Type u_1} → [inst : MeasurableSpace α] → MeasureTheory.Measure α → MeasureTheory.Measure α → ℝ
```
DefinitionProbabilityTheory.gaussianAffineEquivdef
The defining affine map z ↦ m + √S z of multivariateGaussian m S, as a measurable equivalence for positive-definite S (whose functional-calculus square root is invertible).
```
{ι : Type u_1} →
  [Fintype ι] →
    [DecidableEq ι] → EuclideanSpace ℝ ι → {S : Matrix ι ι ℝ} → S.PosDef → EuclideanSpace ℝ ι ≃ᵐ EuclideanSpace ℝ ι
```

DefinitionProbabilityTheory.toEuclideanCLEdef

An invertible matrix as a continuous linear equivalence on EuclideanSpace ℝ ι.

{ι : Type u_1} →
  [inst : Fintype ι] →
    [inst_1 : DecidableEq ι] → (M : Matrix ι ι ℝ) → IsUnit M.det → EuclideanSpace ℝ ι ≃L[ℝ] EuclideanSpace ℝ ι

DefinitionProbabilityTheory.toLpMeasurableEquivdef
The Euclidean identification toLp 2 : (ι → ℝ) → EuclideanSpace ℝ ι as a measurable equivalence, used to transport the tensorization of Measure.pi onto EuclideanSpace.
```
{ι : Type u_1} → [Fintype ι] → (ι → ℝ) ≃ᵐ EuclideanSpace ℝ ι
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

An analytic non-Borel subset of ℝ: the image of the Baire-space witness under the continuous injection. Analyticity transfers along the continuous image; non-Borelness transfers back along the injective preimage.

DeclMeasureTheory.exists_analyticSet_not_measurableSet_real

∃ A, MeasureTheory.AnalyticSet A ∧ ¬MeasurableSet A

ThesisStepDefinition

DeclMeasureTheory.exists_analyticSet_not_measurableSet_realDeclaration kindtheorem
```
∃ A, MeasureTheory.AnalyticSet A ∧ ¬MeasurableSet A
```
MeasureTheory.embedBaireReal
Uses
DeclMeasureTheory.exists_analyticSet_not_measurableSetDeclaration kindtheorem
An analytic non-Borel subset of Baire space: the projection of the diagonal witness.
```
∃ A, MeasureTheory.AnalyticSet A ∧ ¬MeasurableSet A
```
Uses
- MeasureTheory.exists_closed_proj_not_measurableSet
Used by
- MeasureTheory.exists_analyticSet_not_measurableSet_real
DeclMeasureTheory.exists_closed_proj_not_measurableSetDeclaration kindtheorem
A closed set with a non-Borel projection. Diagonalize the universal closed set of (ℕ → ℕ) × (ℕ → ℕ): were the projection Borel, its complement would be analytic, hence the projection of a closed set, hence a section of the universal set — and evaluating that section at its own parameter is contradictory.
```
∃ D, IsClosed D ∧ ¬MeasurableSet {x | ∃ y, (x, y) ∈ D}
```
Uses
- MeasureTheory.exists_closed_universal_sections
Used by
- MeasureTheory.exists_analyticSet_not_measurableSet
DeclMeasureTheory.exists_closed_universal_sectionsDeclaration kindtheorem
A universal closed set. Every second-countable space X carries a closed subset of X × (ℕ → ℕ) whose sections run through all closed subsets of X: enumerate a countable basis together with ∅, and let the parameter select which basis elements to exclude.
```
∀ (X : Type u_1) [inst : TopologicalSpace X] [SecondCountableTopology X],
  ∃ S, IsClosed S ∧ ∀ (C : Set X), IsClosed C → ∃ y, {x | (x, y) ∈ S} = C
```
Used by
- MeasureTheory.exists_closed_proj_not_measurableSet
DeclMeasureTheory.embedBaireReal_injectiveDeclaration kindtheorem
```
Function.Injective MeasureTheory.embedBaireReal
```
MeasureTheory.baireMarkerBits MeasureTheory.embedBaireReal
Uses
- MeasureTheory.baireMarkerBits_injective
Used by
- MeasureTheory.exists_analyticSet_not_measurableSet_real
DeclMeasureTheory.baireMarkerBits_injectiveDeclaration kindtheorem
```
Function.Injective MeasureTheory.baireMarkerBits
```
MeasureTheory.baireMarkerBits MeasureTheory.baireMarkers
Uses
- MeasureTheory.baireMarkers_strictMono
Used by
- MeasureTheory.embedBaireReal_injective
DeclMeasureTheory.baireMarkers_strictMonoDeclaration kindtheorem
```
∀ (x : ℕ → ℕ), StrictMono (MeasureTheory.baireMarkers x)
```
MeasureTheory.baireMarkers
Used by
- MeasureTheory.baireMarkerBits_injective
DeclMeasureTheory.continuous_embedBaireRealDeclaration kindtheorem
```
Continuous MeasureTheory.embedBaireReal
```
MeasureTheory.baireMarkerBits MeasureTheory.embedBaireReal
Uses
- MeasureTheory.continuous_baireMarkerBits
- MeasureTheory.continuous_cantorFunction_oneThird
Used by
- MeasureTheory.exists_analyticSet_not_measurableSet_real
DeclMeasureTheory.continuous_cantorFunction_oneThirdDeclaration kindtheorem
```
Continuous (Cardinal.cantorFunction (1 / 3))
```
Used by
- MeasureTheory.continuous_embedBaireReal
DeclMeasureTheory.continuous_baireMarkerBitsDeclaration kindtheorem
```
Continuous MeasureTheory.baireMarkerBits
```
MeasureTheory.baireMarkerBits MeasureTheory.baireMarkers
Used by
- MeasureTheory.continuous_embedBaireReal
DefinitionMeasureTheory.baireMarkerBitsdef
The marker bits: the indicator stream of the marker set.
```
(ℕ → ℕ) → ℕ → Bool
```
DefinitionMeasureTheory.baireMarkersdef
The marker sequence of x : ℕ → ℕ: the strictly increasing sequence n + 1 + ∑_{k ≤ n} x k, whose successive gaps encode x.
```
(ℕ → ℕ) → ℕ → ℕ
```
DefinitionMeasureTheory.embedBaireRealdef
The embedding of Baire space into ℝ: marker bits into the base-3 expansion.
```
(ℕ → ℕ) → ℝ
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

Pinsker's inequality with the sharp constant. tvDistReal P Q ≤ sqrt(klDivReal P Q / 2) for probability measures P ≪ Q with finite KL divergence.

DeclInformationTheory.pinsker_proof

∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α)
  [inst_1 : MeasureTheory.IsProbabilityMeasure P] [inst_2 : MeasureTheory.IsProbabilityMeasure Q],
  P.AbsolutelyContinuous Q →
    MeasureTheory.Integrable (MeasureTheory.llr P Q) P →
      MeasureTheory.tvDistReal P Q ≤ √(InformationTheory.klDivReal P Q / 2)

ThesisStepHypothesisDefinition

DeclInformationTheory.pinsker_proofDeclaration kindtheorem

∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α)
  [inst_1 : MeasureTheory.IsProbabilityMeasure P] [inst_2 : MeasureTheory.IsProbabilityMeasure Q],
  P.AbsolutelyContinuous Q →
    MeasureTheory.Integrable (MeasureTheory.llr P Q) P →
      MeasureTheory.tvDistReal P Q ≤ √(InformationTheory.klDivReal P Q / 2)

InformationTheory.klDivReal MeasureTheory.tvDistReal

Uses

InformationTheory.klDivReal_nonneg
InformationTheory.two_sq_sub_le_klDivReal
MeasureTheory.tvDistReal_set_nonempty

DeclMeasureTheory.tvDistReal_set_nonemptyDeclaration kindtheorem

∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure P]
  [MeasureTheory.IsFiniteMeasure Q], {x | ∃ A, MeasurableSet A ∧ x = |(P A).toReal - (Q A).toReal|}.Nonempty

Used by

InformationTheory.pinsker_proof

DeclInformationTheory.two_sq_sub_le_klDivRealDeclaration kindtheorem
Per-set squared bound. 2 (P(A) − Q(A))² ≤ klDivReal P Q for any measurable set A, given P ≪ Q and finite KL.
```
∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α) [MeasureTheory.IsProbabilityMeasure P]
  [MeasureTheory.IsProbabilityMeasure Q],
  P.AbsolutelyContinuous Q →
    MeasureTheory.Integrable (MeasureTheory.llr P Q) P →
      ∀ (A : Set α), MeasurableSet A → 2 * (P.real A - Q.real A) ^ 2 ≤ InformationTheory.klDivReal P Q
```
InformationTheory.klBin InformationTheory.klDivReal
Uses
Used by
- InformationTheory.pinsker_proof
DeclInformationTheory.klBin_le_klDivRealDeclaration kindtheorem
Data processing inequality for indicators. For probability measures P ≪ Q with finite KL divergence and any measurable set A, the binary KL between the marginals on (A, Aᶜ) is bounded by the full KL: klBin(P(A), Q(A)) ≤ klDivReal P Q.
```
∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α) [MeasureTheory.IsProbabilityMeasure P]
  [MeasureTheory.IsProbabilityMeasure Q],
  P.AbsolutelyContinuous Q →
    MeasureTheory.Integrable (MeasureTheory.llr P Q) P →
      ∀ (A : Set α), MeasurableSet A → InformationTheory.klBin (P.real A) (Q.real A) ≤ InformationTheory.klDivReal P Q
```
InformationTheory.klBin InformationTheory.klDivReal
Uses
Used by
- InformationTheory.two_sq_sub_le_klDivReal

DeclInformationTheory.klFun_integral_ge_of_measurableSetDeclaration kindtheorem

Jensen on a subset. For a finite measure Q and a measurable set A with positive mass, if f and klFun ∘ f are integrable and f ≥ 0 almost everywhere, then Q(A) · klFun((1/Q(A)) · ∫_A f dQ) ≤ ∫_A klFun(f) dQ.

∀ {α : Type u_1} [inst : MeasurableSpace α] {Q : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure Q] (f : α → ℝ),
  MeasureTheory.Integrable f Q →
    MeasureTheory.Integrable (fun x => InformationTheory.klFun (f x)) Q →
      (∀ᵐ (x : α) ∂Q, 0 ≤ f x) →
        ∀ {A : Set α},
          0 < Q.real A →
            Q.real A * InformationTheory.klFun ((Q.real A)⁻¹ * ∫ (x : α) in A, f x ∂Q) ≤
              ∫ (x : α) in A, InformationTheory.klFun (f x) ∂Q

Used by

InformationTheory.klBin_le_klDivReal

DeclInformationTheory.klBin_eq_klFun_sumDeclaration kindtheorem
Algebraic identity. The binary KL factors through klFun: klBin p q = q · klFun(p/q) + (1 − q) · klFun((1 − p)/(1 − q)).
```
∀ (p q : ℝ),
 0 < q →
 q < 1 →
 InformationTheory.klBin p q =
 q * InformationTheory.klFun (p / q) + (1 - q) * InformationTheory.klFun ((1 - p) / (1 - q))
```
InformationTheory.klBin
Used by
- InformationTheory.klBin_le_klDivReal
DeclInformationTheory.binary_pinskerDeclaration kindtheorem
Binary Pinsker inequality. 2 (p − q)² ≤ klBin p q for p ∈ [0, 1], q ∈ (0, 1). Sharp constant 2.
```
∀ (p q : ℝ), 0 ≤ p → p ≤ 1 → 0 < q → q < 1 → 2 * (p - q) ^ 2 ≤ InformationTheory.klBin p q
```
InformationTheory.klBin
Uses
Used by
- InformationTheory.two_sq_sub_le_klDivReal
DeclInformationTheory.two_sq_le_neg_logDeclaration kindtheorem
2 (1 - q)² ≤ -log q for q ∈ (0, 1]. Substitute r = 1 - q into the previous.
```
∀ (q : ℝ), 0 < q → q ≤ 1 → 2 * (1 - q) ^ 2 ≤ -Real.log q
```
Uses
- InformationTheory.two_sq_le_neg_log_one_sub
Used by
- InformationTheory.binary_pinsker
DeclInformationTheory.two_sq_le_neg_log_one_subDeclaration kindtheorem
2 q² ≤ -log(1 - q) for q ∈ [0, 1).
```
∀ (q : ℝ), 0 ≤ q → q < 1 → 2 * q ^ 2 ≤ -Real.log (1 - q)
```
Uses
- InformationTheory.monotoneOn_h_zero
Used by
- InformationTheory.binary_pinsker
- InformationTheory.two_sq_le_neg_log
DeclInformationTheory.monotoneOn_h_zeroDeclaration kindtheorem
h(q) = -log(1-q) - 2 q² is monotone on [0, 1).
```
MonotoneOn (fun q => -Real.log (1 - q) - 2 * q ^ 2) (Set.Ico 0 1)
```
Uses
- InformationTheory.hasDerivAt_h_zero
Used by
- InformationTheory.two_sq_le_neg_log_one_sub
DeclInformationTheory.hasDerivAt_h_zeroDeclaration kindtheorem
Derivative of h(q) = -log(1-q) - 2 q² at q < 1.
```
∀ q < 1, HasDerivAt (fun q => -Real.log (1 - q) - 2 * q ^ 2) ((2 * q - 1) ^ 2 / (1 - q)) q
```
Used by
- InformationTheory.monotoneOn_h_zero
DeclInformationTheory.monotoneOn_gDeclaration kindtheorem
g(q) = klBin p q − 2 (p − q)² is monotone on [p, 1).
```
∀ (p : ℝ), 0 InformationTheory.klBin p q - 2 * (p - q) ^ 2) (Set.Ico p 1)
```
InformationTheory.klBin
Uses
Used by
- InformationTheory.binary_pinsker
DeclInformationTheory.deriv_g_nonneg_of_geDeclaration kindtheorem
On [p, 1): derivative of g is nonnegative.
```
∀ (p q : ℝ), p ≤ q → 0 < q → q < 1 → 0 ≤ (q - p) * (1 - 2 * q) ^ 2 / (q * (1 - q))
```
Uses
- InformationTheory.deriv_factor_nonneg
Used by
- InformationTheory.monotoneOn_g
DeclInformationTheory.continuousOn_g_IcoDeclaration kindtheorem
Continuity of g on Ico p 1.
```
∀ (p : ℝ), 0 InformationTheory.klBin p q - 2 * (p - q) ^ 2) (Set.Ico p 1)
```
InformationTheory.klBin
Uses
- InformationTheory.continuousOn_klBin_Ico
- InformationTheory.continuousOn_sub_sq
Used by
- InformationTheory.monotoneOn_g
DeclInformationTheory.continuousOn_klBin_IcoDeclaration kindtheorem
Continuity of klBin p · on Ico p 1.
```
∀ (p : ℝ), 0 InformationTheory.klBin p q) (Set.Ico p 1)
```
InformationTheory.klBin
Uses
- InformationTheory.hasDerivAt_klBin_q
Used by
- InformationTheory.continuousOn_g_Ico
DeclInformationTheory.klBin_zero_leftDeclaration kindtheorem
Boundary case: klBin 0 q = -log(1 - q).
```
∀ (q : ℝ), InformationTheory.klBin 0 q = -Real.log (1 - q)
```
InformationTheory.klBin
Used by
- InformationTheory.binary_pinsker
DeclInformationTheory.klBin_selfDeclaration kindtheorem
klBin p p = 0 for p ∈ (0, 1).
```
∀ (p : ℝ), 0 < p → p < 1 → InformationTheory.klBin p p = 0
```
InformationTheory.klBin
Used by
- InformationTheory.binary_pinsker
DeclInformationTheory.klBin_one_leftDeclaration kindtheorem
Boundary case: klBin 1 q = -log q.
```
∀ (q : ℝ), InformationTheory.klBin 1 q = -Real.log q
```
InformationTheory.klBin
Used by
- InformationTheory.binary_pinsker
DeclInformationTheory.antitoneOn_gDeclaration kindtheorem
g(q) = klBin p q − 2 (p − q)² is antitone on (0, p].
```
∀ (p : ℝ), 0 InformationTheory.klBin p q - 2 * (p - q) ^ 2) (Set.Ioc 0 p)
```
InformationTheory.klBin
Uses
Used by
- InformationTheory.binary_pinsker
DeclInformationTheory.hasDerivAt_gDeclaration kindtheorem
Factored derivative identity. Derivative of g(q) := klBin(p, q) − 2 (p − q)² has the factored form (q − p) · (1 − 2q)² / (q · (1 − q)), reducing the sign of the derivative to sign(q − p).
```
∀ (p q : ℝ),
 0 InformationTheory.klBin p q - 2 * (p - q) ^ 2)
 ((q - p) * (1 - 2 * q) ^ 2 / (q * (1 - q))) q
```
InformationTheory.klBin
Uses
- InformationTheory.hasDerivAt_klBin_q
- InformationTheory.hasDerivAt_sub_sq
Used by
- InformationTheory.antitoneOn_g
- InformationTheory.monotoneOn_g
DeclInformationTheory.hasDerivAt_sub_sqDeclaration kindtheorem
Derivative of (p − q)² with respect to q.
```
∀ (p q : ℝ), HasDerivAt (fun q => (p - q) ^ 2) (-2 * (p - q)) q
```
Used by
- InformationTheory.hasDerivAt_g
DeclInformationTheory.deriv_g_nonpos_of_leDeclaration kindtheorem
On (0, p]: derivative of g is nonpositive.
```
∀ (p q : ℝ), q ≤ p → 0 < q → q < 1 → (q - p) * (1 - 2 * q) ^ 2 / (q * (1 - q)) ≤ 0
```
Uses
- InformationTheory.deriv_factor_nonneg
Used by
- InformationTheory.antitoneOn_g
DeclInformationTheory.deriv_factor_nonnegDeclaration kindtheorem
The derivative factor (1 − 2q)² / (q (1 − q)) is nonnegative on (0, 1).
```
∀ (q : ℝ), 0 < q → q < 1 → 0 ≤ (1 - 2 * q) ^ 2 / (q * (1 - q))
```
Used by
- InformationTheory.deriv_g_nonneg_of_ge
- InformationTheory.deriv_g_nonpos_of_le
DeclInformationTheory.continuousOn_g_IocDeclaration kindtheorem
Continuity of g on Ioc 0 p.
```
∀ (p : ℝ), 0 InformationTheory.klBin p q - 2 * (p - q) ^ 2) (Set.Ioc 0 p)
```
InformationTheory.klBin
Uses
- InformationTheory.continuousOn_klBin_Ioc
- InformationTheory.continuousOn_sub_sq
Used by
- InformationTheory.antitoneOn_g
DeclInformationTheory.continuousOn_sub_sqDeclaration kindtheorem
Continuity of fun q => (p - q)² on any set.
```
∀ (p : ℝ) (s : Set ℝ), ContinuousOn (fun q => (p - q) ^ 2) s
```
Used by
- InformationTheory.continuousOn_g_Ico
- InformationTheory.continuousOn_g_Ioc
DeclInformationTheory.continuousOn_klBin_IocDeclaration kindtheorem
Continuity of klBin p · on Ioc 0 p.
```
∀ (p : ℝ), 0 InformationTheory.klBin p q) (Set.Ioc 0 p)
```
InformationTheory.klBin
Uses
- InformationTheory.hasDerivAt_klBin_q
Used by
- InformationTheory.continuousOn_g_Ioc
DeclInformationTheory.hasDerivAt_klBin_qDeclaration kindtheorem
Derivative of klBin p · at a point q ∈ (0, 1) with p ∈ (0, 1).
```
∀ (p q : ℝ),
 0 InformationTheory.klBin p q) ((q - p) / (q * (1 - q))) q
```
InformationTheory.klBin
Uses
- InformationTheory.klBin_expand
Used by
DeclInformationTheory.klBin_expandDeclaration kindtheorem
Expanded form: split into constants and q-dependent pieces. Used to compute the derivative via HasDerivAt in the next shard.
```
∀ (p q : ℝ),
 0 < p →
 p < 1 →
 0 < q →
 q < 1 →
 InformationTheory.klBin p q =
 p * Real.log p - p * Real.log q + (1 - p) * Real.log (1 - p) - (1 - p) * Real.log (1 - q)
```
InformationTheory.klBin
Used by
- InformationTheory.hasDerivAt_klBin_q
DeclInformationTheory.klDivReal_nonnegDeclaration kindtheorem
ℝ-valued KL is nonnegative for probability measures.
```
∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α) [MeasureTheory.IsProbabilityMeasure P]
  [MeasureTheory.IsProbabilityMeasure Q], 0 ≤ InformationTheory.klDivReal P Q
```
InformationTheory.klDivReal
Uses
- InformationTheory.klDivReal_eq_toReal_klDiv
Used by
- InformationTheory.pinsker_proof
- InformationTheory.two_sq_sub_le_klDivReal
DeclInformationTheory.klDivReal_eq_toReal_klDivDeclaration kindtheorem
For probability measures with P ≪ Q, the ℝ-valued KL equals (Mathlib.klDiv P Q).toReal. Both measures have total mass 1, so the Mathlib correction term vanishes.
```
∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α) [MeasureTheory.IsProbabilityMeasure P]
  [MeasureTheory.IsProbabilityMeasure Q],
  P.AbsolutelyContinuous Q → InformationTheory.klDivReal P Q = (InformationTheory.klDiv P Q).toReal
```
InformationTheory.klDivReal
Uses
- InformationTheory.integrand_eq_llr
Used by
- InformationTheory.klBin_le_klDivReal
- InformationTheory.klDivReal_nonneg
DeclInformationTheory.integrand_eq_llrDeclaration kindtheorem
The integrand log ((P.rnDeriv Q x).toReal) is definitionally Mathlib's log-likelihood ratio llr P Q x.
```
∀ {α : Type u_1} [inst : MeasurableSpace α] (P Q : MeasureTheory.Measure α),
  (fun x => Real.log (P.rnDeriv Q x).toReal) = MeasureTheory.llr P Q
```
Used by
- InformationTheory.klDivReal_eq_toReal_klDiv
Hypothesishac
```
P.AbsolutelyContinuous Q
```

Hypothesish_int

MeasureTheory.Integrable (MeasureTheory.llr P Q) P

DefinitionInformationTheory.klBindef
Binary KL divergence between Bernoulli(p) and Bernoulli(q).
```
ℝ → ℝ → ℝ
```
DefinitionInformationTheory.klDivRealdef
ℝ-valued KL divergence. Returns 0 when P is not absolutely continuous with respect to Q (by convention; the ℝ≥0∞-valued klDiv returns ⊤ in that case).
```
{α : Type u_1} → [inst : MeasurableSpace α] → MeasureTheory.Measure α → MeasureTheory.Measure α → ℝ
```
DefinitionMeasureTheory.tvDistRealdef
Total variation distance between two probability measures, metric form.
Defined as the supremum of |P(A).toReal - Q(A).toReal| over measurable sets A.
```
{α : Type u_1} →
  [inst : MeasurableSpace α] →
    (P Q : MeasureTheory.Measure α) → [MeasureTheory.IsFiniteMeasure P] → [MeasureTheory.IsFiniteMeasure Q] → ℝ
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

d = 1 universality: every VC-1 class compresses at kernel size one, with no side information. No finiteness, no distinguished member, no chain hypothesis. Twist the class by any member to place ∅ in it; there the VC bound makes co-member points comparable in the membership order, so every label set is a finite chain; anchor at its maximum, reconstruct with interConvention, and transport the scheme back with the same kernels.

DeclStructuralIgnorance.hasKernelScheme_one_of_vcBounded_one

∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Set (Set α)},
  StructuralIgnorance.vcBounded 𝒜 1 → StructuralIgnorance.HasKernelScheme 𝒜 1

ThesisStepHypothesisDefinition

DeclStructuralIgnorance.hasKernelScheme_one_of_vcBounded_oneDeclaration kindtheorem
```
∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Set (Set α)},
  StructuralIgnorance.vcBounded 𝒜 1 → StructuralIgnorance.HasKernelScheme 𝒜 1
```
StructuralIgnorance.Convention StructuralIgnorance.HasKernelScheme StructuralIgnorance.IsKernel StructuralIgnorance.IsSample StructuralIgnorance.interConvention StructuralIgnorance.memOrder StructuralIgnorance.twistClass StructuralIgnorance.vcBounded
Uses
DeclStructuralIgnorance.vcBounded_twistClassDeclaration kindtheorem
VC bounds are twist-invariant (the direction needed for normalization).
```
∀ {α : Type u_1} [DecidableEq α] {𝒜 : Set (Set α)} {d : ℕ},
  StructuralIgnorance.vcBounded 𝒜 d →
    ∀ (S₀ : Set α), StructuralIgnorance.vcBounded (StructuralIgnorance.twistClass 𝒜 S₀) d
```
StructuralIgnorance.SetShatters StructuralIgnorance.twistClass StructuralIgnorance.vcBounded
Uses
- StructuralIgnorance.SetShatters.of_twistClass
Used by
- StructuralIgnorance.hasKernelScheme_one_of_vcBounded_one
DeclStructuralIgnorance.SetShatters.of_twistClassDeclaration kindtheorem
Shattering transports from the twisted class back to the original: the witnesses untwist, and the patterns correspond through the involution C ↦ C ∆ (B ∩ S₀).
```
∀ {α : Type u_1} [DecidableEq α] {𝒜 : Set (Set α)} {S₀ : Set α} {B : Finset α},
  StructuralIgnorance.SetShatters (StructuralIgnorance.twistClass 𝒜 S₀) B → StructuralIgnorance.SetShatters 𝒜 B
```
StructuralIgnorance.SetShatters StructuralIgnorance.baseLabels StructuralIgnorance.twistClass
Uses
- StructuralIgnorance.coe_baseLabels
Used by
- StructuralIgnorance.vcBounded_twistClass
DeclStructuralIgnorance.memOrder_total_of_vcBounded_oneDeclaration kindtheorem
With the empty set in the class, a VC bound of one makes any two points of a common member comparable in the membership order: otherwise the four assembled patterns shatter the pair.
```
∀ {α : Type u_1} [DecidableEq α] {𝒜 : Set (Set α)},
  StructuralIgnorance.vcBounded 𝒜 1 →
    ∅ ∈ 𝒜 →
      ∀ {a b : α}, (∃ S ∈ 𝒜, a ∈ S ∧ b ∈ S) → StructuralIgnorance.memOrder 𝒜 a b ∨ StructuralIgnorance.memOrder 𝒜 b a
```
StructuralIgnorance.SetShatters StructuralIgnorance.memOrder StructuralIgnorance.vcBounded
Uses
- StructuralIgnorance.memOrder_refl
Used by
- StructuralIgnorance.hasKernelScheme_one_of_vcBounded_one
DeclStructuralIgnorance.isKernel_interConvention_anchorDeclaration kindtheorem
The anchor leg of the intersection convention: a maximum of the label set in the membership order is a size-1 kernel. The upper inclusion comes from the realizing member, the lower from maximality.
```
∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Set (Set α)} {A T : Finset α},
  StructuralIgnorance.IsSample 𝒜 A T →
    ∀ {x : α},
      x ∈ T →
        (∀ a ∈ T, StructuralIgnorance.memOrder 𝒜 a x) →
          StructuralIgnorance.IsKernel (StructuralIgnorance.interConvention 𝒜) 1 A T {x}
```
StructuralIgnorance.IsKernel StructuralIgnorance.IsSample StructuralIgnorance.interConvention StructuralIgnorance.memOrder
Uses
- StructuralIgnorance.IsSample.subset
Used by
- StructuralIgnorance.hasKernelScheme_one_of_vcBounded_one
DeclStructuralIgnorance.IsSample.subsetDeclaration kindtheorem
Realizable label patterns are supported inside their window.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {A T : Finset α}, StructuralIgnorance.IsSample 𝒜 A T → T ⊆ A
```
StructuralIgnorance.IsSample
Used by
- StructuralIgnorance.isKernel_interConvention_anchor
DeclStructuralIgnorance.exists_memOrder_max_of_totalDeclaration kindtheorem
A finite nonempty set on which the membership order is total has a maximum.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {T : Finset α},
  (∀ a ∈ T, ∀ b ∈ T, StructuralIgnorance.memOrder 𝒜 a b ∨ StructuralIgnorance.memOrder 𝒜 b a) →
    T.Nonempty → ∃ x ∈ T, ∀ a ∈ T, StructuralIgnorance.memOrder 𝒜 a x
```
StructuralIgnorance.memOrder
Uses
- StructuralIgnorance.memOrder_refl
- StructuralIgnorance.memOrder_trans
Used by
- StructuralIgnorance.hasKernelScheme_one_of_vcBounded_one

DeclStructuralIgnorance.memOrder_transDeclaration kindtheorem

∀ {α : Type u_1} {𝒜 : Set (Set α)} {a b c : α},
  StructuralIgnorance.memOrder 𝒜 a b → StructuralIgnorance.memOrder 𝒜 b c → StructuralIgnorance.memOrder 𝒜 a c

StructuralIgnorance.memOrder

Used by

StructuralIgnorance.exists_memOrder_max_of_total

DeclStructuralIgnorance.memOrder_reflDeclaration kindtheorem
```
∀ {α : Type u_1} (𝒜 : Set (Set α)) (a : α), StructuralIgnorance.memOrder 𝒜 a a
```
StructuralIgnorance.memOrder
Used by
- StructuralIgnorance.exists_memOrder_max_of_total
- StructuralIgnorance.memOrder_total_of_vcBounded_one
DeclStructuralIgnorance.empty_mem_twistClassDeclaration kindtheorem
Twisting by a member places the empty set in the class.
```
∀ {α : Type u_1} {𝒜 : Set (Set α)} {S₀ : Set α}, S₀ ∈ 𝒜 → ∅ ∈ StructuralIgnorance.twistClass 𝒜 S₀
```
StructuralIgnorance.twistClass
Used by
- StructuralIgnorance.hasKernelScheme_one_of_vcBounded_one
DeclStructuralIgnorance.HasKernelScheme.of_twistClassDeclaration kindtheorem
Kernel schemes transport back through a twist, with the same kernels.
```
∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Set (Set α)} {S₀ : Set α} {k : ℕ},
  StructuralIgnorance.HasKernelScheme (StructuralIgnorance.twistClass 𝒜 S₀) k → StructuralIgnorance.HasKernelScheme 𝒜 k
```
StructuralIgnorance.Convention StructuralIgnorance.HasKernelScheme StructuralIgnorance.IsKernel StructuralIgnorance.IsSample StructuralIgnorance.baseLabels StructuralIgnorance.twistClass StructuralIgnorance.twistConvention
Uses
Used by
- StructuralIgnorance.hasKernelScheme_one_of_vcBounded_one
DeclStructuralIgnorance.set_symmDiff_inter_rightDeclaration kindtheorem
```
∀ {α : Type u_1} (s t u : Set α), symmDiff s t ∩ u = symmDiff (s ∩ u) (t ∩ u)
```
Used by
- StructuralIgnorance.HasKernelScheme.of_twistClass
DeclStructuralIgnorance.finset_inter_symmDiffDeclaration kindtheorem
```
∀ {α : Type u_1} [inst : DecidableEq α] (Z T F : Finset α), Z ∩ symmDiff T F = symmDiff (Z ∩ T) (Z ∩ F)
```
Used by
- StructuralIgnorance.HasKernelScheme.of_twistClass
DeclStructuralIgnorance.IsSample.twistDeclaration kindtheorem
Realizability transports through the twist, with the label set twisted inside the window.
```
∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Set (Set α)} {A T : Finset α},
  StructuralIgnorance.IsSample 𝒜 A T →
    ∀ (S₀ : Set α),
      StructuralIgnorance.IsSample (StructuralIgnorance.twistClass 𝒜 S₀) A
        (symmDiff T (StructuralIgnorance.baseLabels S₀ A))
```
StructuralIgnorance.IsSample StructuralIgnorance.baseLabels StructuralIgnorance.twistClass
Uses
- StructuralIgnorance.coe_baseLabels
Used by
- StructuralIgnorance.HasKernelScheme.of_twistClass
DeclStructuralIgnorance.coe_baseLabelsDeclaration kindtheorem
```
∀ {α : Type u_1} (S₀ : Set α) (Z : Finset α), ↑(StructuralIgnorance.baseLabels S₀ Z) = ↑Z ∩ S₀
```
StructuralIgnorance.baseLabels
Used by
Hypothesish
```
StructuralIgnorance.vcBounded 𝒜 1
```
DefinitionStructuralIgnorance.Conventiondef
A reconstruction rule: from a kept labeled pair — kernel points and their 1-labeled part — to a total hypothesis. Total by convention; only values on realizable pairs matter.
```
Type u_2 → Type u_2
```
DefinitionStructuralIgnorance.HasKernelSchemedef
A kernel scheme of size k with no side information: one reconstruction rule under which every realizable sample contains a generating kernel of at most k points (Littlestone–Warmuth 1986, in compression-map-free form).
```
{α : Type u_1} → [DecidableEq α] → Set (Set α) → ℕ → Prop
```
DefinitionStructuralIgnorance.IsKerneldef
ρ regenerates the sample (A, T) from the kernel Z: the kernel is kept inside the sample, has at most k points, and the reconstructed hypothesis meets A in exactly T.
```
{α : Type u_1} → [DecidableEq α] → StructuralIgnorance.Convention α → ℕ → Finset α → Finset α → Finset α → Prop
```
DefinitionStructuralIgnorance.IsSampledef
The labeled window (A, T) is realizable in 𝒜: some member meets A in exactly T. Points of T are labeled 1, points of A \ T are labeled 0 (Littlestone–Warmuth 1986, realizable samples).
```
{α : Type u_1} → Set (Set α) → Finset α → Finset α → Prop
```
DefinitionStructuralIgnorance.SetShattersdef
The class 𝒜 shatters the finite set B: every sub-pattern of B is realized by a member. Set-grammar port of Finset.Shatters (Mathlib Combinatorics.SetFamily.Shatter).
```
{α : Type u_1} → Set (Set α) → Finset α → Prop
```
DefinitionStructuralIgnorance.baseLabelsdef
The part of a finite window lying in the base set.
```
{α : Type u_1} → Set α → Finset α → Finset α
```
DefinitionStructuralIgnorance.interConventiondef
Reconstruction by intersection: the hypothesis is the intersection of all members containing the kernel's 1-labeled part. Improper — the output need not be a member — which is what dense chains require; the kernel's point set is not consulted beyond its labels.
```
{α : Type u_1} → Set (Set α) → StructuralIgnorance.Convention α
```
DefinitionStructuralIgnorance.memOrderdef
The membership order of a class: a lies below b when every member containing b contains a.
```
{α : Type u_1} → Set (Set α) → α → α → Prop
```
DefinitionStructuralIgnorance.twistClassdef
The class relabeled by symmetric difference with a base set.
```
{α : Type u_1} → Set (Set α) → Set α → Set (Set α)
```
DefinitionStructuralIgnorance.twistConventiondef
The conjugated convention: untwist the kernel's labels, reconstruct in the twisted class, twist the hypothesis back.
```
{α : Type u_1} → [DecidableEq α] → Set α → StructuralIgnorance.Convention α → StructuralIgnorance.Convention α
```
DefinitionStructuralIgnorance.vcBoundeddef
VC bound in Set grammar: no shattered set exceeds d points (the port of Finset.vcDim ≤ d, Mathlib Combinatorics.SetFamily.Shatter).
```
{α : Type u_1} → Set (Set α) → ℕ → Prop
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

Fundamental theorem of statistical learning (5-way equivalence, BP₅).

Declfundamental_theorem

∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
  [MeasurableConceptClass X C],
  (PACLearnable X C ↔ VCDim X C < ⊤) ∧
    (VCDim X C < ⊤ ↔ ∃ k cs, CompressionSchemeWithInfo.size cs = k) ∧
      (VCDim X C < ⊤ ↔
          ∀ ε > 0,
            ∃ m₀,
              ∀ (D : MeasureTheory.Measure X),
                MeasureTheory.IsProbabilityMeasure D → ∀ m ≥ m₀, RademacherComplexity X C D m < ε) ∧
        (PACLearnable X C →
            ∃ L mf,
              (∀ (ε δ : ℝ),
                  0 < ε →
                    0 < δ →
                      ∀ (D : MeasureTheory.Measure X),
                        MeasureTheory.IsProbabilityMeasure D →
                          ∀ c ∈ C,
                            (MeasureTheory.Measure.pi fun x => D)
                                {xs | D {x | L.learn (fun i => (xs i, c (xs i))) x ≠ c x} ≤ ENNReal.ofReal ε} ≥
                              ENNReal.ofReal (1 - δ)) ∧
                (∀ (ε δ : ℝ), 0 < ε → 0 < δ → SampleComplexity X C ε δ ≤ mf ε δ) ∧
                  ∀ (d : ℕ),
                    VCDim X C = ↑d →
                      ∀ (ε δ : ℝ),
                        0 < ε →
                          ε ≤ 1 / 4 →
                            0 < δ →
                              δ ≤ 1 →
                                δ ≤ 1 / 7 →
                                  1 ≤ d → ⌈(↑d - 1) / 2⌉₊ ≤ SampleComplexity X C ε δ ∧ ⌈(↑d - 1) / 2⌉₊ ≤ mf ε δ) ∧
          (VCDim X C < ⊤ ↔ ∃ d, ∀ (m : ℕ), d ≤ m → GrowthFunction X C m ≤ ∑ i ∈ Finset.range (d + 1), m.choose i)

ThesisStepDefinition

Declfundamental_theoremDeclaration kindtheorem

∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
  [MeasurableConceptClass X C],
  (PACLearnable X C ↔ VCDim X C < ⊤) ∧
    (VCDim X C < ⊤ ↔ ∃ k cs, CompressionSchemeWithInfo.size cs = k) ∧
      (VCDim X C < ⊤ ↔
          ∀ ε > 0,
            ∃ m₀,
              ∀ (D : MeasureTheory.Measure X),
                MeasureTheory.IsProbabilityMeasure D → ∀ m ≥ m₀, RademacherComplexity X C D m < ε) ∧
        (PACLearnable X C →
            ∃ L mf,
              (∀ (ε δ : ℝ),
                  0 < ε →
                    0 < δ →
                      ∀ (D : MeasureTheory.Measure X),
                        MeasureTheory.IsProbabilityMeasure D →
                          ∀ c ∈ C,
                            (MeasureTheory.Measure.pi fun x => D)
                                {xs | D {x | L.learn (fun i => (xs i, c (xs i))) x ≠ c x} ≤ ENNReal.ofReal ε} ≥
                              ENNReal.ofReal (1 - δ)) ∧
                (∀ (ε δ : ℝ), 0 < ε → 0 < δ → SampleComplexity X C ε δ ≤ mf ε δ) ∧
                  ∀ (d : ℕ),
                    VCDim X C = ↑d →
                      ∀ (ε δ : ℝ),
                        0 < ε →
                          ε ≤ 1 / 4 →
                            0 < δ →
                              δ ≤ 1 →
                                δ ≤ 1 / 7 →
                                  1 ≤ d → ⌈(↑d - 1) / 2⌉₊ ≤ SampleComplexity X C ε δ ∧ ⌈(↑d - 1) / 2⌉₊ ≤ mf ε δ) ∧
          (VCDim X C < ⊤ ↔ ∃ d, ∀ (m : ℕ), d ≤ m → GrowthFunction X C m ≤ ∑ i ∈ Finset.range (d + 1), m.choose i)

BatchLearner BatchLearner.learn CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass FLT.Concept GrowthFunction MeasurableConceptClass PACLearnable RademacherComplexity SampleComplexity VCDim

Uses

fundamental_rademacher
fundamental_vc_compression
growth_bounded_imp_vcdim_finite
pac_sample_complexity_sandwich
vc_characterization
vcdim_finite_imp_growth_bounded

Declvc_characterizationDeclaration kindtheorem
VC characterization: C is PAC-learnable iff VCDim(C) < ∞.
PROOF DECOMPOSITION: This theorem factors through the two directions above: ← : vcdim_finite_imp_uc + uc_imp_pac (in Generalization.lean) → : pac_imp_vcdim_finite (contrapositive via double-sample)
HC at this joint: The ← direction crosses from combinatorics (VCDim, GrowthFunction) to measure theory (Measure.pi, TrueError). The → direction crosses from measure theory back to combinatorics. Both crossings have HC > 0.
UK₈: The ↔ hides an ASYMMETRY: the ← proof is constructive (produces ERM), while the → proof is non-constructive (produces hard distribution).
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
 [MeasurableConceptClass X C], PACLearnable X C ↔ VCDim X C < ⊤
```
ConceptClass MeasurableConceptClass PACLearnable VCDim
Uses
- pac_imp_vcdim_finite
- vcdim_finite_imp_pac
Used by
- fundamental_theorem
Declvcdim_finite_imp_pacDeclaration kindtheorem
Direction ←: finite VCDim implies PAC learnability.
PROOF ROUTE (via new infrastructure in Generalization.lean): Step 1: VCDim < ∞ → HasUniformConvergence (vcdim_finite_imp_uc) Sub-step 1a: Sauer-Shelah gives GrowthFunction bound Sub-step 1b: Symmetrization reduces UC to growth function counting Sub-step 1c: Concentration inequality closes the bound Step 2: HasUniformConvergence → PACLearnable (uc_imp_pac) Sub-step 2a: Construct ERM learner Sub-step 2b: ERM is consistent in realizable case Sub-step 2c: Consistent + UC → low TrueError
KU₁₈: C.Nonempty is needed for ERM but not stated as hypothesis. If C = ∅, then PACLearnable is vacuously true (∀ c ∈ C, ... is vacuous). But ERM needs a fallback hypothesis from C. Is this a genuine gap or does the empty case work out vacuously?
Counterdefinition (COUNTER-4): If the ERM approach fails for computational reasons (ERM is noncomputable, and we need a computable learner for computational learning theory), swap to the compression-based proof: VCDim < ∞ → finite compression scheme (Moran-Yehudayoff 2016) → compression scheme learner is PAC. Swap condition: When proving COMPUTATIONAL PAC learnability (polynomial time).
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool),
 VCDim X C < ⊤ → ∀ [MeasurableConceptClass X C], PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept MeasurableConceptClass PACLearnable VCDim WellBehavedVC
Uses
Used by
- vc_characterization

Declpac_sample_complexity_sandwichDeclaration kindtheorem

Quantitative sample-complexity sandwich attached to any PAC witness. Packages: (1) PAC guarantee, (2) SampleComplexity ≤ mf, (3) NFL/VC lower bound on both SampleComplexity and mf.

∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
  [MeasurableConceptClass X C],
  PACLearnable X C →
    ∃ L mf,
      (∀ (ε δ : ℝ),
          0 < ε →
            0 < δ →
              ∀ (D : MeasureTheory.Measure X),
                MeasureTheory.IsProbabilityMeasure D →
                  ∀ c ∈ C,
                    (MeasureTheory.Measure.pi fun x => D)
                        {xs | D {x | L.learn (fun i => (xs i, c (xs i))) x ≠ c x} ≤ ENNReal.ofReal ε} ≥
                      ENNReal.ofReal (1 - δ)) ∧
        (∀ (ε δ : ℝ), 0 < ε → 0 < δ → SampleComplexity X C ε δ ≤ mf ε δ) ∧
          ∀ (d : ℕ),
            VCDim X C = ↑d →
              ∀ (ε δ : ℝ),
                0 < ε →
                  ε ≤ 1 / 4 →
                    0 < δ →
                      δ ≤ 1 → δ ≤ 1 / 7 → 1 ≤ d → ⌈(↑d - 1) / 2⌉₊ ≤ SampleComplexity X C ε δ ∧ ⌈(↑d - 1) / 2⌉₊ ≤ mf ε δ

BatchLearner BatchLearner.learn ConceptClass FLT.Concept MeasurableConceptClass PACLearnable SampleComplexity VCDim WellBehavedVC

Uses

MeasurableConceptClass.hWB
MeasurableConceptClass.hc_meas
MeasurableConceptClass.hmeas_C
sample_complexity_lower_bound
sample_complexity_upper_of_pac_witness

Used by

fundamental_theorem

Declsample_complexity_upper_of_pac_witnessDeclaration kindtheorem

Any PAC witness (L, mf) gives an upper bound on SampleComplexity: the infimum is at most the witness sample size.

∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) (L : BatchLearner X Bool) (mf : ℝ → ℝ → ℕ),
  (∀ (ε δ : ℝ),
      0 < ε →
        0 < δ →
          ∀ (D : MeasureTheory.Measure X),
            MeasureTheory.IsProbabilityMeasure D →
              ∀ c ∈ C,
                (MeasureTheory.Measure.pi fun x => D)
                    {xs | D {x | L.learn (fun i => (xs i, c (xs i))) x ≠ c x} ≤ ENNReal.ofReal ε} ≥
                  ENNReal.ofReal (1 - δ)) →
    ∀ (ε δ : ℝ), 0 < ε → 0 < δ → SampleComplexity X C ε δ ≤ mf ε δ

BatchLearner BatchLearner.learn ConceptClass FLT.Concept SampleComplexity

Used by

pac_sample_complexity_sandwich

Declsample_complexity_lower_boundDeclaration kindtheorem

Sample complexity lower bound: ⌈(d-1)/2⌉ ≤ SampleComplexity.

∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool) (d : ℕ),
  VCDim X C = ↑d →
    ∀ (ε δ : ℝ),
      0 < ε →
        ε ≤ 1 / 4 →
          0 < δ →
            δ ≤ 1 →
              δ ≤ 1 / 7 →
                1 ≤ d →
                  (∀ h ∈ C, Measurable h) →
                    (∀ (c : Concept X Bool), Measurable c) →
                      WellBehavedVC X C → ⌈(↑d - 1) / 2⌉₊ ≤ SampleComplexity X C ε δ

BatchLearner BatchLearner.learn ConceptClass FLT.Concept PACLearnable SampleComplexity VCDim WellBehavedVC

Uses

pac_lower_bound_member
uc_imp_pac
vcdim_finite_imp_uc'

Used by

pac_sample_complexity_sandwich

Declpac_lower_bound_memberDeclaration kindtheorem
PAC lower bound membership: if m achieves PAC for C with VCDim = d, then m ≥ ⌈(d-1)/(64ε)⌉. This is the core adversarial counting argument factored for PAC.lean assembly. Note: the tight constant is (d-1)/(2ε) (EHKV 1989); see EHKV.lean.
Proof route (double-averaging on shattered set): 1. VCDim = d → ∃ shattered S with |S| = d 2. D = uniform on S (probability measure, each point has weight 1/d) 3. m < ⌈(d-1)/(64ε)⌉ → 2m < d → NFL counting applies 4. Double-averaging over 2^d labelings: E_f[E_xs[error]] ≥ (d-m)/(2d) > 1/4 5. Reversed Markov: ∃ c₀ ∈ C with Pr[error ≤ 1/8] ≤ 6/7 6. For ε ≤ 1/8: Pr[error ≤ ε] ≤ 6/7 = 1 - 1/7, contradicting PAC
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool) (d : ℕ),
 VCDim X C = ↑d →
 ∀ (ε δ : ℝ),
 0 < ε →
 ε ≤ 1 / 4 →
 0 < δ →
 δ ≤ 1 →
 δ ≤ 1 / 7 →
 1 ≤ d →
 ∀
 m ∈
 {m |
 ∃ L,
 ∀ (D : MeasureTheory.Measure X),
 MeasureTheory.IsProbabilityMeasure D →
 ∀ c ∈ C,
 (MeasureTheory.Measure.pi fun x => D)
 {xs | D {x | L.learn (fun i => (xs i, c (xs i))) x ≠ c x} ≤ ENNReal.ofReal ε} ≥
 ENNReal.ofReal (1 - δ)},
 ⌈(↑d - 1) / 2⌉₊ ≤ m
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept Shatters VCDim uniformMeasure
Uses
- nfl_counting_core
- uniformMeasure_isProbability
Used by
- sample_complexity_lower_bound
Declgrowth_bounded_imp_vcdim_finiteDeclaration kindtheorem
Growth function polynomially bounded → VCDim < ⊤. Reverse direction: if GrowthFunction m ≤ ∑_{i≤d} C(m,i) for all m ≥ d, then VCDim ≤ d (otherwise GrowthFunction = 2^m for m = VCDim > d).
```
∀ (X : Type u) (C : ConceptClass X Bool),
 (∃ d, ∀ (m : ℕ), d ≤ m → GrowthFunction X C m ≤ ∑ i ∈ Finset.range (d + 1), m.choose i) → VCDim X C < ⊤
```
ConceptClass FLT.Concept GrowthFunction Shatters VCDim
Used by
- fundamental_theorem
Declfundamental_vc_compressionDeclaration kindtheorem
Fundamental theorem: finite VC dim ↔ finite compression scheme with side information. Moran-Yehudayoff 2016 (arXiv:1503.06960). Sorry-free via Compression.lean. Γ₇₃ RESOLVED: CompressionSchemeWithInfo parameterized by concept class C. The no-side-info version (Littlestone-Warmuth conjecture) remains open.
```
∀ (X : Type u) (C : ConceptClass X Bool), VCDim X C < ⊤ ↔ ∃ k cs, CompressionSchemeWithInfo.size cs = k
```
CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass VCDim
Uses
- fundamental_vc_compression_with_info
Used by
- fundamental_theorem
Declfundamental_vc_compression_with_infoDeclaration kindtheorem
```
∀ (X : Type u) (C : ConceptClass X Bool), VCDim X C < ⊤ ↔ ∃ k cs, CompressionSchemeWithInfo.size cs = k
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass VCDim
Uses
- compression_with_info_imp_vcdim_finite
- vcdim_finite_imp_compression_with_info
Used by
- fundamental_vc_compression
Declvcdim_finite_imp_compression_with_infoDeclaration kindtheorem
The forward direction of the Moran-Yehudayoff theorem: finite VC dimension implies existence of a compression scheme with finite side information.
The construction: 1. Build a proper finite-support learner L from VC + Sauer-Shelah 2. For sample S: extract c, Y = pointSupport S, HY = hypothesis envelope 3. Apply approximate minimax on the agreement game → distribution p on HY 4. Apply VC ε-approximation on agreement tests → T representative hypotheses 5. Kernel = union of witness subsets for T hypotheses 6. Side info = incidence: which hypothesis's witness contains each kernel point 7. Reconstruct by majority vote over T hypotheses
```
∀ (X : Type u) (C : ConceptClass X Bool), VCDim X C < ⊤ → ∃ k cs, CompressionSchemeWithInfo.size cs = k
```
CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.info_finite CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass FLT.Concept ProperFiniteSupportLearner ProperFiniteSupportLearner.sampleBound VCDim
Uses
- moran_yehudayoff_forward_construction
- vcdim_finite_imp_proper_finite_support_learner
Used by
- fundamental_vc_compression_with_info
Declvcdim_finite_imp_proper_finite_support_learnerDeclaration kindtheorem
Finite VC dimension implies existence of a proper finite-support learner. The construction uses ERM + finite_support_vc_approx on the disagreement family.
```
∀ (X : Type u) (C : ConceptClass X Bool), Set.Nonempty C → VCDim X C < ⊤ → ∃ _L, True
```
ConceptClass FLT.Concept FinitePMF Finset.boolVCDim ProperFiniteSupportLearner VCDim boolTestExpectation disagreementFamily empiricalPMF labeledSampleOfFinset supportError
Uses
Used by
- vcdim_finite_imp_compression_with_info
DeclsupportError_eq_boolTestExpectationDeclaration kindtheorem
supportError expressed in terms of boolTestExpectation of a disagreement test.
```
∀ {X : Type u} (Y : Finset X) (q : FinitePMF ↥Y) (h c : X → Bool),
  supportError Y q h c = boolTestExpectation q fun y => decide (h ↑y ≠ c ↑y)
```
FinitePMF FinitePMF.prob boolTestExpectation supportError
Used by
- vcdim_finite_imp_proper_finite_support_learner
DecldisagreementFamily_boolVCDim_leDeclaration kindtheorem
VC dimension of the disagreement family is bounded by VCDim(C). Restriction to Y and xor with c do not increase shattering dimension.
```
∀ {X : Type u} [inst : DecidableEq X] (C : ConceptClass X Bool) (c : X → Bool) (Y : Finset X) {d : ℕ},
  VCDim X C ≤ ↑d → (disagreementFamily✝ C c Y).boolVCDim ≤ d
```
ConceptClass FLT.Concept Finset.boolVCDim Shatters VCDim boolFamilyToFinsetFamily disagreementFamily
Used by
- vcdim_finite_imp_proper_finite_support_learner
Declmoran_yehudayoff_forward_constructionDeclaration kindtheorem
The Moran-Yehudayoff forward construction. Uses finalizeIncidenceScheme to package the majority-vote scheme with universe-correct Info type.
The agent must provide: compressCore, blockHyp, rowHyp, hsmall, hsub, hagree, hmajor. These are the MY wiring.
```
∀ (X : Type u) (C : ConceptClass X Bool),
 Set.Nonempty C →
 ∀ (L : ProperFiniteSupportLearner X C), VCDim X C < ⊤ → ∀ (_K : ℕ), ∃ k cs, CompressionSchemeWithInfo.size cs = k
```
CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass FLT.Concept FinitePMF FinitePMF.prob Finset.boolVCDim IncidenceInfo ProperFiniteSupportLearner ProperFiniteSupportLearner.learn ProperFiniteSupportLearner.sampleBound VCDim agreeTest agreeTests boolGamePayoff boolTestExpectation boundedSubsamples decodeWitnessLabel decodeWitnessXCoords empiricalPMF encodeWitnessInfo hypothesisEnvelope labeledSampleOfFinset pointSupport uniformPMF
Uses
Used by
- vcdim_finite_imp_compression_with_info

Declroundtrip_blockHyp_eq_repDeclaration kindtheorem

Generic roundtrip theorem for the hround sorry.

If:

encodeWitnessInfo is used in compressCore,
decodeWitnessXCoords and decodeWitnessLabel are used in blockHyp, and
the kernel contains the witness pairs with the correct labels,

then the decoded block hypothesis is exactly the representative hypothesis.

∀ {X : Type u} [inst : DecidableEq X] (learn : {m : ℕ} → (Fin m → X × Bool) → X → Bool) (kernel : Finset (X × Bool))
  (c : X → Bool) (K : ℕ) (W : Finset X) (h : X → Bool),
  kernel.card ≤ K →
    (∀ x ∈ W, (x, c x) ∈ kernel) →
      (∀ p ∈ kernel, p.2 = c p.1) →
        learn (labeledSampleOfFinset c W) = h →
          ∀ (x : X),
            have info := encodeWitnessInfo kernel c K W;
            have blockXCoords := decodeWitnessXCoords kernel info;
            have blockLabel := decodeWitnessLabel kernel;
            learn (labeledSampleOfFinset blockLabel blockXCoords) x = h x

decodeWitnessLabel decodeWitnessXCoords encodeWitnessInfo labeledSampleOfFinset

Uses

decodeWitnessLabel_eq_on_encoded
decodeWitnessXCoords_encode_eq
labeledSampleOfFinset_eq_of_eq_on_support

Used by

moran_yehudayoff_forward_construction

DecllabeledSampleOfFinset_eq_of_eq_on_supportDeclaration kindtheorem
If two label functions agree on all points of Z, then the labeled samples they induce on Z.equivFin are equal.
```
∀ {X : Type u} [DecidableEq X] {ℓ₁ ℓ₂ : X → Bool} {Z : Finset X},
  (∀ x ∈ Z, ℓ₁ x = ℓ₂ x) → labeledSampleOfFinset ℓ₁ Z = labeledSampleOfFinset ℓ₂ Z
```
labeledSampleOfFinset
Used by
- roundtrip_blockHyp_eq_rep
DecldecodeWitnessXCoords_encode_eqDeclaration kindtheorem
If every (x, c x) with x ∈ W lies in kernel, and kernel.card ≤ K, then decoding the encoded witness positions gives back exactly W.
```
∀ {X : Type u} [inst : DecidableEq X] (kernel : Finset (X × Bool)) (c : X → Bool) {K : ℕ} (W : Finset X),
  kernel.card ≤ K → (∀ x ∈ W, (x, c x) ∈ kernel) → decodeWitnessXCoords kernel (encodeWitnessInfo kernel c K W) = W
```
decodeWitnessXCoords encodeWitnessInfo
Used by
- roundtrip_blockHyp_eq_rep
DecldecodeWitnessLabel_eq_on_encodedDeclaration kindtheorem
On the encoded witness support, the decoded label function agrees with the true label function c, provided every pair in the kernel has the correct second coordinate.
```
∀ {X : Type u} [inst : DecidableEq X] (kernel : Finset (X × Bool)) (c : X → Bool) (W : Finset X),
  (∀ x ∈ W, (x, c x) ∈ kernel) → (∀ p ∈ kernel, p.2 = c p.1) → ∀ x ∈ W, decodeWitnessLabel kernel x = c x
```
decodeWitnessLabel
Used by
- roundtrip_blockHyp_eq_rep
Declmwu_approx_minimaxDeclaration kindtheorem
Genuine approximate minimax via MWU regret extraction. If every column mixture admits a pure row with expected payoff ≥ v, then there is a row mixture with payoff ≥ v - ε against every column.
```
∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [Nonempty R] [Nonempty C] [DecidableEq R]
 [DecidableEq C] (M : R → C → Bool) (v ε : ℝ),
 0 < ε →
 (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) →
 ∃ p, ∀ (c : C), v - ε ≤ boolGamePayoff M p c
```
FinitePMF FinitePMF.prob MWUConfig.potential MWUConfig.weights boolGamePayoff empiricalPMF mwuConfig mwuHitCount mwuRows uniformPMF
Uses
Used by
- moran_yehudayoff_forward_construction
Declweight_le_potentialDeclaration kindtheorem
A single weight is bounded by the potential.
```
∀ {C : Type u_1} [inst : Fintype C] (cfg : MWUConfig C) (c : C), cfg.weights c ≤ cfg.potential
```
MWUConfig MWUConfig.potential MWUConfig.weights
Uses
- MWUConfig.weights_pos
Used by
- mwu_approx_minimax

Declmwu_weight_eq_pow_hitCountDeclaration kindtheorem

Exact individual-weight tracking: the weight of column c after T rounds is (1-η) to the number of rounds in which c was hit.

∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [inst_2 : Nonempty C] (M : R → C → Bool) (η : ℝ)
  (hη1 : η < 1) (v : ℝ) (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) (T : ℕ)
  (c : C), (mwuConfig M η hη1 v hrow T).weights c = (1 - η) ^ mwuHitCount✝ M η hη1 v hrow T c

FinitePMF FinitePMF.prob MWUConfig MWUConfig.toPMF MWUConfig.weights mwuConfig mwuHitCount mwuRun mwuUpdateWeights

Uses

MWUConfig.mk.congr_simp
MWUConfig.weights_pos

Used by

mwu_approx_minimax

DeclMWUConfig.mk.congr_simpDeclaration kindtheorem

∀ {C : Type u_1} [inst : Fintype C] (weights weights_1 : C → ℝ) (e_weights : weights = weights_1)
  (weights_pos : ∀ (c : C), 0 < weights c),
  { weights := weights, weights_pos := weights_pos } = { weights := weights_1, weights_pos := ⋯ }

MWUConfig

Used by

mwu_weight_eq_pow_hitCount

Declmwu_potential_T_boundDeclaration kindtheorem
Potential bound after T steps: Φ_T ≤ |C| · (1 - ηv)^T.
This is the core MWU guarantee. Combined with individual weight lower bounds (w_T(c) = (1-η)^{losses(c)}), it yields the regret bound.
```
∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [inst_2 : Nonempty C] (M : R → C → Bool)
 (η : ℝ),
 0 ≤ η →
 ∀ (hη1 : η < 1) (v : ℝ) (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0)
 (T : ℕ), (mwuConfig M η hη1 v hrow T).potential ≤ ↑(Fintype.card C) * (1 - η * v) ^ T
```
FinitePMF FinitePMF.prob MWUConfig MWUConfig.potential MWUConfig.toPMF mwuConfig mwuRun mwuUpdateWeights
Uses
Used by
- mwu_approx_minimax

Declpotential_one_step_boundDeclaration kindtheorem

Potential bound after one step: Φ' ≤ Φ · (1 - η·v).

∀ {R : Type u_1} {C : Type u_2} [Fintype R] [inst : Fintype C] [inst_1 : Nonempty C] (M : R → C → Bool) (η : ℝ),
  0 ≤ η →
    ∀ (hη1 : η < 1) (v : ℝ) (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0)
      (cfg : MWUConfig C), (mwuUpdateWeights M η hη1 cfg ⋯.choose).potential ≤ cfg.potential * (1 - η * v)

FinitePMF FinitePMF.prob MWUConfig MWUConfig.potential MWUConfig.toPMF MWUConfig.weights mwuUpdateWeights

Uses

best_response_payoff_weights

Used by

mwu_potential_T_bound

Declbest_response_payoff_weightsDeclaration kindtheorem

Best response payoff ≥ v · Φ in terms of weights.

∀ {R : Type u_1} {C : Type u_2} [Fintype R] [inst : Fintype C] [inst_1 : Nonempty C] (M : R → C → Bool) (v : ℝ)
  (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) (cfg : MWUConfig C),
  v * cfg.potential ≤ ∑ c, cfg.weights c * if M ⋯.choose c = true then 1 else 0

FinitePMF FinitePMF.prob MWUConfig MWUConfig.potential MWUConfig.toPMF MWUConfig.weights

Uses

MWUConfig.potential_pos

Used by

potential_one_step_bound

DeclMWUConfig.potential_posDeclaration kindtheorem
```
∀ {C : Type u_1} [inst : Fintype C] [Nonempty C] (cfg : MWUConfig C), 0 < cfg.potential
```
MWUConfig MWUConfig.potential MWUConfig.weights
Uses
- MWUConfig.weights_pos
Used by
- best_response_payoff_weights
DeclMWUConfig.weights_posDeclaration kindtheorem
```
∀ {C : Type u_1} [inst : Fintype C] (self : MWUConfig C) (c : C), 0 < self.weights c
```
MWUConfig MWUConfig.weights
Used by

DeclmwuUpdateWeights.congr_simpDeclaration kindtheorem

∀ {C : Type u_1} [inst : Fintype C] {R : Type u_2} (M M_1 : R → C → Bool),
  M = M_1 →
    ∀ (η η_1 : ℝ) (e_η : η = η_1) (hη1 : η < 1) (cfg cfg_1 : MWUConfig C),
      cfg = cfg_1 → ∀ (r r_1 : R), r = r_1 → mwuUpdateWeights M η hη1 cfg r = mwuUpdateWeights M_1 η_1 ⋯ cfg_1 r_1

MWUConfig mwuUpdateWeights

Used by

mwu_potential_T_bound

DeclmwuInit_potentialDeclaration kindtheorem
```
∀ (C : Type u_1) [inst : Fintype C], (mwuInit C).potential = ↑(Fintype.card C)
```
MWUConfig.potential MWUConfig.weights mwuInit
Used by
- mwu_potential_T_bound
Declminimax_value_le_oneDeclaration kindtheorem
The minimax value of a Boolean game is at most 1.
```
∀ {R : Type u_1} {C : Type u_2} [Fintype R] [inst : Fintype C] [Nonempty C] (M : R → C → Bool) (v : ℝ),
  (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) → v ≤ 1
```
FinitePMF FinitePMF.prob uniformPMF
Uses
- FinitePMF.prob_nonneg
- FinitePMF.prob_sum_one
Used by
- mwu_approx_minimax
- mwu_potential_T_bound

DeclhitRate_from_potentialDeclaration kindtheorem

Arithmetic core: from the potential bound and sufficiently small η / large T, deduce a per-column hit-rate lower bound. Uses Real.log — exactly 4 Mathlib lemmas.

∀ {N H T : ℕ} {η v ε : ℝ},
  0 < ↑N →
    0 < η →
      η < 1 →
        v ≤ 1 →
          0 < T → (1 - η) ^ H ≤ ↑N * (1 - η * v) ^ T → η ≤ ε / 4 → Real.log ↑N / (η * ↑T) ≤ ε / 4 → v - ε ≤ ↑H / ↑T

Used by

mwu_approx_minimax

DeclboolGamePayoff_nonnegDeclaration kindtheorem
```
∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] (M : R → C → Bool) (p : FinitePMF R) (c : C),
  0 ≤ boolGamePayoff M p c
```
FinitePMF FinitePMF.prob boolGamePayoff
Uses
- FinitePMF.prob_nonneg
Used by
- mwu_approx_minimax

DeclboolGamePayoff_empirical_eq_hitCountDeclaration kindtheorem

Empirical payoff of the MWU row sequence equals the normalized hit count.

∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [inst_2 : Nonempty C] [inst_3 : DecidableEq R]
  (M : R → C → Bool) (η : ℝ) (hη1 : η < 1) (v : ℝ)
  (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) {T : ℕ} (hT : 0 < T) (c : C),
  boolGamePayoff M (empiricalPMF hT (mwuRows M η hη1 v hrow T)) c = ↑(mwuHitCount✝ M η hη1 v hrow T c) / ↑T

FinitePMF FinitePMF.prob boolGamePayoff empiricalPMF mwuHitCount mwuRows

Uses

boolGamePayoff_empirical_eq_avg
mwuHitCount_eq_sum_indicator

Used by

mwu_approx_minimax

DeclmwuHitCount_eq_sum_indicatorDeclaration kindtheorem

The recursive hit counter agrees with the sum of Boolean indicators over the emitted row sequence.

∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : Fintype C] [inst_2 : Nonempty C] (M : R → C → Bool) (η : ℝ)
  (hη1 : η < 1) (v : ℝ) (hrow : ∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) (T : ℕ)
  (c : C), ↑(mwuHitCount✝ M η hη1 v hrow T c) = ∑ t, if M (mwuRows M η hη1 v hrow T t) c = true then 1 else 0

FinitePMF FinitePMF.prob MWUConfig MWUConfig.toPMF mwuConfig mwuHitCount mwuRows mwuRun

Used by

boolGamePayoff_empirical_eq_hitCount

DeclboolGamePayoff_empirical_eq_avgDeclaration kindtheorem

Specialized empirical-payoff identity for ApproxMinimax (avoids cyclic import with FiniteVCApprox).

∀ {R : Type u_1} {C : Type u_2} [inst : Fintype R] [inst_1 : DecidableEq R] {T : ℕ} (hT : 0 < T) (rs : Fin T → R)
  (M : R → C → Bool) (c : C), boolGamePayoff M (empiricalPMF hT rs) c = (∑ t, if M (rs t) c = true then 1 else 0) / ↑T

FinitePMF.prob boolGamePayoff empiricalPMF

Used by

boolGamePayoff_empirical_eq_hitCount

DeclhypothesisEnvelope_subDeclaration kindtheorem
Every hypothesis in the envelope is in C.
```
∀ {X : Type u} {C : ConceptClass X Bool} (L : ProperFiniteSupportLearner X C) (c : X → Bool) (Y : Finset X),
  ∀ h ∈ hypothesisEnvelope L c Y, h ∈ C
```
ConceptClass FLT.Concept ProperFiniteSupportLearner ProperFiniteSupportLearner.learn ProperFiniteSupportLearner.sampleBound boundedSubsamples hypothesisEnvelope labeledSampleOfFinset
Uses
- ProperFiniteSupportLearner.output_mem
Used by
- moran_yehudayoff_forward_construction
DeclProperFiniteSupportLearner.output_memDeclaration kindtheorem
```
∀ {X : Type u} {C : ConceptClass X Bool} (self : ProperFiniteSupportLearner X C) {m : ℕ} (S : Fin m → X × Bool),
  self.learn S ∈ C
```
ConceptClass FLT.Concept ProperFiniteSupportLearner ProperFiniteSupportLearner.learn
Used by
- hypothesisEnvelope_sub
Declgood_on_support_gives_row_responseDeclaration kindtheorem
For each C-realizable sample, the proper learner provides a row-response for the minimax game on the hypothesis envelope.
```
∀ {X : Type u} {C : ConceptClass X Bool} (L : ProperFiniteSupportLearner X C),
  ∀ c ∈ C,
    ∀ (Y : Finset X) [Nonempty ↥Y] (HY : Finset (X → Bool)),
      HY = hypothesisEnvelope L c Y →
        ∀ (q : FinitePMF ↥Y), ∃ h, 2 / 3 ≤ ∑ y, q.prob y * if decide (↑h ↑y = c ↑y) = true then 1 else 0
```
ConceptClass FLT.Concept FinitePMF FinitePMF.prob ProperFiniteSupportLearner ProperFiniteSupportLearner.learn ProperFiniteSupportLearner.sampleBound boundedSubsamples hypothesisEnvelope labeledSampleOfFinset supportError
Uses
- ProperFiniteSupportLearner.good_on_support
- supportAgreement_eq_one_sub_supportError
Used by
- moran_yehudayoff_forward_construction
DeclsupportAgreement_eq_one_sub_supportErrorDeclaration kindtheorem
Weighted agreement = 1 - supportError.
```
∀ {X : Type u} (Y : Finset X) (q : FinitePMF ↥Y) (h c : X → Bool),
  (∑ y, q.prob y * if h ↑y = c ↑y then 1 else 0) = 1 - supportError Y q h c
```
FinitePMF FinitePMF.prob supportError
Uses
- FinitePMF.prob_sum_one
Used by
- good_on_support_gives_row_response
DeclProperFiniteSupportLearner.good_on_supportDeclaration kindtheorem
```
∀ {X : Type u} {C : ConceptClass X Bool} (self : ProperFiniteSupportLearner X C),
  ∀ c ∈ C,
    ∀ (Y : Finset X) (q : FinitePMF ↥Y),
      ∃ Z ⊆ Y, Z.card ≤ self.sampleBound ∧ supportError Y q (self.learn (labeledSampleOfFinset c Z)) c ≤ 1 / 3
```
ConceptClass FLT.Concept FinitePMF ProperFiniteSupportLearner ProperFiniteSupportLearner.learn ProperFiniteSupportLearner.sampleBound labeledSampleOfFinset supportError
Used by
- good_on_support_gives_row_response
Declfinite_support_vc_approxDeclaration kindtheorem
Finite-support distributions uniformly approximate any distribution on a VC class. For a class of VC dimension at most d and any ε > 0, there exists T = T(d, ε) such that every finitely supported distribution μ is within ε (uniformly over the class) of some empirical distribution on T points. A density-style reduction that lets the approximate minimax / MWU machinery, which lives in finite support, apply to general distributions.
```
∀ (d : ℕ) (ε : ℝ),
 0 < ε →
 ∃ T,
 ∃ (hT : 0 < T),
 ∀ {H : Type u_1} [inst : Fintype H] [inst_1 : DecidableEq H] (A : Finset (H → Bool)),
 A.boolVCDim ≤ d →
 ∀ (μ : FinitePMF H),
 ∃ hs, ∀ a ∈ A, |boolTestExpectation μ a - boolTestExpectation (empiricalPMF hT hs) a| ≤ ε
```
ConceptClass EmpiricalError FLT.Concept FinitePMF FinitePMF.prob FinitePMF.toPMF Finset.boolVCDim GrowthFunction Shatters TrueErrorReal VCDim boolFamilyToFinsetFamily boolTestExpectation empiricalPMF extendBool liftClass zeroOneLoss
Uses
Used by
- moran_yehudayoff_forward_construction
- vcdim_finite_imp_proper_finite_support_learner

DecltrueErrorReal_extend_falseDeclaration kindtheorem

∀ {H : Type u_1} [inst : Fintype H] [DecidableEq H] [inst_2 : MeasurableSpace H] [MeasurableSingletonClass H]
  (μ : FinitePMF H) (a : H → Bool),
  TrueErrorReal (H ⊕ ℕ) (extendBool✝ a) (fun x => false) (PMF.map Sum.inl (FinitePMF.toPMF✝ μ)).toMeasure =
    boolTestExpectation μ a

FinitePMF FinitePMF.prob FinitePMF.toPMF TrueError TrueErrorReal boolTestExpectation extendBool

Uses

FinitePMF.prob_nonneg
FinitePMF.prob_sum_one

Used by

finite_support_vc_approx

DeclboolTestExpectation_nonnegDeclaration kindtheorem
A convex combination of values in {0, 1} is nonnegative.
```
∀ {H : Type u_1} [inst : Fintype H] (μ : FinitePMF H) (f : H → Bool), 0 ≤ boolTestExpectation μ f
```
FinitePMF FinitePMF.prob boolTestExpectation
Uses
- FinitePMF.prob_nonneg
Used by
- finite_support_vc_approx
DeclboolTestExpectation_le_oneDeclaration kindtheorem
A convex combination of values in {0, 1} is at most 1.
```
∀ {H : Type u_1} [inst : Fintype H] (μ : FinitePMF H) (f : H → Bool), boolTestExpectation μ f ≤ 1
```
FinitePMF FinitePMF.prob boolTestExpectation
Uses
- FinitePMF.prob_nonneg
- FinitePMF.prob_sum_one
Used by
- finite_support_vc_approx
DeclFinitePMF.prob_nonnegDeclaration kindtheorem
```
∀ {H : Type u_1} [inst : Fintype H] (self : FinitePMF H) (h : H), 0 ≤ self.prob h
```
FinitePMF FinitePMF.prob
Used by
DeclFinitePMF.prob_sum_oneDeclaration kindtheorem
```
∀ {H : Type u_1} [inst : Fintype H] (self : FinitePMF H), ∑ h, self.prob h = 1
```
FinitePMF FinitePMF.prob
Used by

DeclfinalizeIncidenceSchemeDeclaration kindtheorem

Final existential wrapper: closes the theorem in the exact form expected.

∀ {X : Type u} {C : ConceptClass X Bool} (T K : ℕ)
  (compressCore : {m : ℕ} → (Fin m → X × Bool) → Finset (X × Bool) × IncidenceInfo T K)
  (blockHyp : Finset (X × Bool) → IncidenceInfo T K → Fin T → X → Bool)
  (rowHyp : {m : ℕ} → (S : Fin m → X × Bool) → (∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) → Fin T → X → Bool),
  0 < T →
    (∀ {m : ℕ} (S : Fin m → X × Bool), (compressCore S).1.card ≤ K) →
      (∀ {m : ℕ} (S : Fin m → X × Bool), ↑(compressCore S).1 ⊆ Set.range S) →
        (∀ {m : ℕ} (S : Fin m → X × Bool) (hreal : ∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) (i : Fin m) (t : Fin T),
            blockHyp (compressCore S).1 (compressCore S).2 t (S i).1 = rowHyp S hreal t (S i).1) →
          (∀ {m : ℕ} (S : Fin m → X × Bool) (hreal : ∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) (i : Fin m),
              (∑ t, if rowHyp S hreal t (S i).1 = (S i).2 then 1 else 0) / ↑T > 1 / 2) →
            ∃ k cs, CompressionSchemeWithInfo.size cs = k

CompressionSchemeWithInfo.size CompressionSchemeWithInfo0 ConceptClass FLT.Concept IncidenceInfo mkIncidenceSchemeOfMajority

Used by

moran_yehudayoff_forward_construction

DeclencodeWitnessInfo.congr_simpDeclaration kindtheorem

∀ {X : Type u} {inst : DecidableEq X} [inst_1 : DecidableEq X] (kernel kernel_1 : Finset (X × Bool)),
  kernel = kernel_1 →
    ∀ (c c_1 : X → Bool),
      c = c_1 →
        ∀ (K : ℕ) (W W_1 : Finset X), W = W_1 → encodeWitnessInfo kernel c K W = encodeWitnessInfo kernel_1 c_1 K W_1

encodeWitnessInfo

Used by

moran_yehudayoff_forward_construction

DeclboolTestExpectation_empirical_eq_avgDeclaration kindtheorem
Bridges the FinitePMF view and the sample-average view: the expectation of a Bool-valued test under the empirical PMF of a sample equals the sample average (1/T) ∑_t f (s_t). This lets the MWU updates and the approximation transfer principle live in the same distributional framework.
```
∀ {H : Type u_1} [inst : Fintype H] [inst_1 : DecidableEq H] {T : ℕ} (hT : 0 < T) (hs : Fin T → H) (f : H → Bool),
 boolTestExpectation (empiricalPMF hT hs) f = (∑ t, if f (hs t) = true then 1 else 0) / ↑T
```
FinitePMF.prob boolTestExpectation empiricalPMF
Used by
DeclboolGamePayoff_eq_boolTestExpectationDeclaration kindtheorem
Identifies the game-theoretic payoff (a row distribution against a fixed column in the Bool game) with the corresponding test expectation. The translation that lets the MWU regret bound be applied directly to the compression problem.
```
∀ {R : Type u_1} [inst : Fintype R] [DecidableEq R] {C : Type u_2} (M : R → C → Bool) (p : FinitePMF R) (c : C),
  boolGamePayoff M p c = boolTestExpectation p fun r => M r c
```
FinitePMF FinitePMF.prob boolGamePayoff boolTestExpectation
Used by
- moran_yehudayoff_forward_construction
DeclagreeTests_boolVCDim_leDeclaration kindtheorem
VC dimension of the agreement-test family is bounded by 2^(d+1) - 1, where d bounds the VC dimension of the concept class C. Uses Assouad's coding argument directly: if a shattered set T in ↥HY has |T| ≥ 2^(d+1), embed bitstrings into T, extract d+1 distinct points from Y via shattering, and show these points are shattered by C (using the XOR trick where b(j) = decide(g(x_j) = c(x_j)) absorbs the agree/disagree flip).
```
∀ {X : Type u} [DecidableEq X] (C : ConceptClass X Bool) (c : X → Bool) (Y : Finset X) (HY : Finset (X → Bool)),
  (∀ h ∈ HY, h ∈ C) → ∀ {d : ℕ}, VCDim X C ≤ ↑d → (agreeTests c Y HY).boolVCDim ≤ 2 ^ (d + 1) - 1
```
ConceptClass FLT.Concept Finset.boolVCDim Shatters VCDim agreeTest agreeTests boolFamilyToFinsetFamily
Used by
- moran_yehudayoff_forward_construction
Declcompression_with_info_imp_vcdim_finiteDeclaration kindtheorem
Compression with side info implies finite VC dimension. Proof by pigeonhole: compress is injective on C-realizable labelings (by correctness), but compressed outputs form a bounded set.
```
∀ (X : Type u) (C : ConceptClass X Bool), (∃ k cs, cs.size = k) → VCDim X C < ⊤
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress CompressionSchemeWithInfo.info_finite CompressionSchemeWithInfo.kernelSize CompressionSchemeWithInfo.size ConceptClass FLT.Concept Shatters VCDim
Uses
Used by
- fundamental_vc_compression_with_info
Declshatters_subset_compressionDeclaration kindtheorem
```
∀ {X : Type u} {C : ConceptClass X Bool} {S T : Finset X}, T ⊆ S → Shatters X C S → Shatters X C T
```
ConceptClass FLT.Concept Shatters
Used by
- compression_with_info_imp_vcdim_finite
Declexp_beats_poly_compressionDeclaration kindtheorem
Exponential beats polynomial for the compression pigeonhole argument.
```
∀ (s : ℕ), (s + 1) ^ 2 * (4 * (s + 1) ^ 2) ^ s < 2 ^ (2 * (s + 1) * (s + 1))
```
Uses
- succ_le_two_pow_compression
Used by
- compression_with_info_imp_vcdim_finite
Declsucc_le_two_pow_compressionDeclaration kindtheorem
```
∀ (k : ℕ), k + 1 ≤ 2 ^ k
```
Used by
- exp_beats_poly_compression
Declcompress_with_info_injective_on_labelingsDeclaration kindtheorem
Pigeonhole core: if two C-realizable samples over the same points with different labelings produce the same (kernel, info) pair, correctness forces the labelings to agree.
```
∀ {X : Type u} {n : ℕ} {C : ConceptClass X Bool} (cs : CompressionSchemeWithInfo X Bool C) (pts : Fin n → X),
  Function.Injective pts →
    ∀ (f g : Fin n → Bool),
      (∃ c ∈ C, ∀ (i : Fin n), c (pts i) = f i) →
        (∃ c ∈ C, ∀ (i : Fin n), c (pts i) = g i) →
          ((cs.compress fun i => (pts i, f i)) = cs.compress fun i => (pts i, g i)) → f = g
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress CompressionSchemeWithInfo.reconstruct ConceptClass FLT.Concept
Uses
- CompressionSchemeWithInfo.correct
Used by
- compression_with_info_imp_vcdim_finite
DeclCompressionSchemeWithInfo.correctDeclaration kindtheorem
Correctness: reconstructed hypothesis agrees with every sample point, when the sample is C-realizable
```
∀ {X : Type u} {Y : Type v} {C : ConceptClass X Y} (self : CompressionSchemeWithInfo X Y C) {m : ℕ} (S : Fin m → X × Y),
  (∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) →
    ∀ (i : Fin m), self.reconstruct (self.compress S).1 (self.compress S).2 (S i).1 = (S i).2
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress CompressionSchemeWithInfo.reconstruct ConceptClass FLT.Concept
Used by
- compress_with_info_injective_on_labelings
DeclCompressionSchemeWithInfo.compress_subDeclaration kindtheorem
Compressed set is a subset of the sample
```
∀ {X : Type u} {Y : Type v} {C : ConceptClass X Y} (self : CompressionSchemeWithInfo X Y C) {m : ℕ} (S : Fin m → X × Y),
  ↑(self.compress S).1 ⊆ Set.range S
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress ConceptClass
Used by
- compression_with_info_imp_vcdim_finite
DeclCompressionSchemeWithInfo.compress_smallDeclaration kindtheorem
Compressed set is small
```
∀ {X : Type u} {Y : Type v} {C : ConceptClass X Y} (self : CompressionSchemeWithInfo X Y C) {m : ℕ} (S : Fin m → X × Y),
  (self.compress S).1.card ≤ self.kernelSize
```
CompressionSchemeWithInfo CompressionSchemeWithInfo.Info CompressionSchemeWithInfo.compress CompressionSchemeWithInfo.kernelSize ConceptClass
Used by
- compression_with_info_imp_vcdim_finite
Declfundamental_rademacherDeclaration kindtheorem
Fundamental theorem: Rademacher complexity characterization. BP₅: two asymmetric directions crossing different paradigm joints. Uses uniform vanishing (∃ m₀ ∀ D), which is the textbook-standard form.
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
 [MeasurableConceptClass X C],
 PACLearnable X C ↔
 ∀ ε > 0,
 ∃ m₀,
 ∀ (D : MeasureTheory.Measure X),
 MeasureTheory.IsProbabilityMeasure D → ∀ m ≥ m₀, RademacherComplexity X C D m < ε
```
ConceptClass FLT.Concept MeasurableConceptClass PACLearnable RademacherComplexity Shatters VCDim WellBehavedVC
Uses
Used by
- fundamental_theorem
Declvcdim_finite_imp_rademacher_vanishingDeclaration kindtheorem
VCDim finite → Rademacher vanishes uniformly. The bound m₀ depends only on d and ε, NOT on D.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
 VCDim X C < ⊤ →
 ∀ ε > 0,
 ∃ m₀,
 ∀ (D : MeasureTheory.Measure X),
 MeasureTheory.IsProbabilityMeasure D → ∀ m ≥ m₀, RademacherComplexity X C D m < ε
```
ConceptClass RademacherComplexity VCDim
Uses
Used by
- fundamental_rademacher

Declvcdim_zero_rademacher_le_inv_sqrtDeclaration kindtheorem

∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) (D : MeasureTheory.Measure X),
  VCDim X C = ↑0 →
    ∀ (m : ℕ),
      0 < m →
        ∀ [MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.pi fun x => D)],
          RademacherComplexity X C D m ≤ 1 / √↑m

ConceptClass EmpiricalRademacherComplexity FLT.Concept RademacherComplexity SignVector VCDim boolToSign rademacherCorrelation

Uses

empRad_nonneg
sum_boolToSign_cancel
vcdim_zero_concepts_agree

Used by

vcdim_finite_imp_rademacher_vanishing

Declvcdim_zero_concepts_agreeDeclaration kindtheorem
When VCDim = 0, Rademacher complexity is bounded by 1/√m.
VCDim = 0 means no singleton is shattered, so the concept class acts as a single effective labeling. EmpRad ≤ 1/√m by Khintchine's inequality / Jensen. This avoids the d > 0 hypothesis of vcdim_bounds_rademacher_quantitative.
```
∀ (X : Type u) (C : ConceptClass X Bool),
  VCDim X C = ↑0 → ∀ (h₁ h₂ : Concept X Bool), h₁ ∈ C → h₂ ∈ C → ∀ (x : X), h₁ x = h₂ x
```
ConceptClass FLT.Concept Shatters VCDim
Used by
- vcdim_zero_rademacher_le_inv_sqrt
Declvcdim_bounds_rademacher_quantitativeDeclaration kindtheorem
VC dimension upper bounds Rademacher complexity: Rad ≤ √(2d·log(em/d)/m).
The proof decomposes into: (1) Pointwise: EmpRad(xs) ≤ B for all xs [Massart + Sauer-Shelah] (2) Integral: Rad = ∫ EmpRad ≤ ∫ B = B [probability measure]
Step (2) is proved. Step (1) for B ≥ 1 follows from EmpRad ≤ 1. Step (1) for B < 1 requires Massart finite lemma + Sauer-Shelah growth bound.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) (D : MeasureTheory.Measure X) (m : ℕ),
 0 < m →
 ∀ (d : ℕ),
 VCDim X C = ↑d →
 0 < d →
 d ≤ m →
 ∀ [MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.pi fun x => D)],
 RademacherComplexity X C D m ≤ √(2 * ↑d * Real.log (Real.exp 1 * ↑m / ↑d) / ↑m)
```
ConceptClass EmpiricalRademacherComplexity FLT.Concept RademacherComplexity Shatters SignVector VCDim boolToSign rademacherCorrelation
Uses
Used by
- vcdim_finite_imp_rademacher_vanishing
Declncard_restrictions_le_sum_choose_setDeclaration kindtheorem
For a Set-based concept class C with VCDim X C = d, the number of distinct restrictions of C to any finite set S is bounded by ∑_{i≤d} C(|S|, i).
This bridges from our Set-based VCDim to Mathlib's Finset.vcDim on the restriction to S, using the fact that ↥S is Fintype for any Finset S.
```
∀ {X : Type u} (C : ConceptClass X Bool) (S : Finset X) (d : ℕ),
  VCDim X C = ↑d → {f | ∃ c ∈ C, ∀ (x : ↥S), c ↑x = f x}.ncard ≤ ∑ i ∈ Finset.range (d + 1), S.card.choose i
```
ConceptClass FLT.Concept Shatters VCDim
Used by
- vcdim_bounds_rademacher_quantitative

Declfinite_massart_lemmaDeclaration kindtheorem

Massart finite lemma: E_σ[max_{j ≤ N} Z_j] ≤ σ√(2 log N).

∀ {m : ℕ},
  0 < m →
    ∀ {N : ℕ} (hN : 0 < N) (Z : Fin N → SignVector m → ℝ) (σ_param : ℝ),
      0 < σ_param →
        (∀ (j : Fin N) (t : ℝ),
            0 ≤ t →
              1 / ↑(Fintype.card (SignVector m)) * ∑ sv, Real.exp (t * Z j sv) ≤ Real.exp (t ^ 2 * σ_param ^ 2 / 2)) →
          (1 / ↑(Fintype.card (SignVector m)) * ∑ sv, Finset.univ.sup' ⋯ fun j => Z j sv) ≤ σ_param * √(2 * Real.log ↑N)

SignVector

Uses

exp_mul_sup'_le_sum

Used by

vcdim_bounds_rademacher_quantitative

Declexp_mul_sup'_le_sumDeclaration kindtheorem

Soft-max bound: exp(t · Finset.sup') ≤ Σ exp(t · f_i).

∀ {ι : Type u_1} [DecidableEq ι] (s : Finset ι) (hs : s.Nonempty) (f : ι → ℝ) (t : ℝ),
  0 ≤ t → Real.exp (t * s.sup' hs f) ≤ ∑ i ∈ s, Real.exp (t * f i)

Used by

finite_massart_lemma

DeclrademacherComplexity_le_oneDeclaration kindtheorem

∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) (D : MeasureTheory.Measure X) (m : ℕ),
  0 < m → ∀ [MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.pi fun x => D)], RademacherComplexity X C D m ≤ 1

ConceptClass EmpiricalRademacherComplexity RademacherComplexity

Uses

empRad_nonneg
empiricalRademacherComplexity_le_one

Used by

vcdim_finite_imp_rademacher_vanishing

Declanalytical_log_sqrt_boundDeclaration kindtheorem
Analytical lemma: for d > 0, m ≥ ⌈32(d+1)/ε⁴⌉+1, ε ∈ (0,1], we have 2d·log(em/d)/m < ε².
Uses Real.log_le_rpow_div with exponent 1/2: log(x) ≤ x^(1/2)/(1/2) = 2√x. Then 2d·log(em/d)/m ≤ 2d·2√(em/d)/(m) ≤ ε².
```
∀ (d m : ℕ) (ε : ℝ),
 0 < ε →
 ε ≤ 1 → 0 < d → d ≤ m → ⌈32 * (↑d + 1) / ε ^ 4⌉₊ + 1 ≤ m → 2 * ↑d * Real.log (Real.exp 1 * ↑m / ↑d) / ↑m < ε ^ 2
```
Used by
- vcdim_finite_imp_rademacher_vanishing
Declvcdim_finite_imp_pac_via_uc'Declaration kindtheorem
VCDim < ⊤ → PACLearnable via UC route.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
 VCDim X C < ⊤ →
 (∀ h ∈ C, Measurable h) → (∀ (c : Concept X Bool), Measurable c) → WellBehavedVC X C → PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept PACLearnable VCDim WellBehavedVC
Uses
- uc_imp_pac
- vcdim_finite_imp_uc'
Used by
- fundamental_rademacher
Declvcdim_finite_imp_uc'Declaration kindtheorem
Finite VCDim implies uniform convergence. Proof: VCDim < ∞ → UC.
- Finite X: direct Hoeffding per-hypothesis + finite union bound.
- Infinite X: Sauer-Shelah → symmetrization + growth function → UC.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
 VCDim X C < ⊤ →
 (∀ h ∈ C, Measurable h) → (∀ (c : Concept X Bool), Measurable c) → WellBehavedVC X C → HasUniformConvergence X C
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction HasUniformConvergence HypothesisSpace TrueErrorReal VCDim WellBehavedVC zeroOneLoss
Uses
Used by
Declvcdim_finite_imp_growth_boundedDeclaration kindtheorem
VCDim < ⊤ → growth function polynomially bounded by partial binomial sum. Forward direction of fundamental_theorem conjunct 5. Uses Sauer-Shelah: GrowthFunction(m) ≤ ∑_{i≤d} C(m,i) where d = VCDim.
```
∀ (X : Type u) (C : ConceptClass X Bool),
 VCDim X C < ⊤ → ∃ d, ∀ (m : ℕ), d ≤ m → GrowthFunction X C m ≤ ∑ i ∈ Finset.range (d + 1), m.choose i
```
ConceptClass FLT.Concept GrowthFunction Shatters VCDim
Used by
- fundamental_theorem
- vcdim_finite_imp_uc'

Decluc_bad_event_le_delta_provedDeclaration kindtheorem

UC bad-event bound: for m ≥ m₀(v,ε,δ), the probability of the bad event (∃ h with |TrueErr-EmpErr| ≥ ε) is at most δ. Composes symmetrization_uc_bound with growth_exp_le_delta.

∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε δ : ℝ),
            0 < ε →
              0 < δ →
                δ < 1 →
                  ∀ (v : ℕ),
                    0 < v →
                      (∀ (n : ℕ), v ≤ n → GrowthFunction X C n ≤ ∑ i ∈ Finset.range (v + 1), n.choose i) →
                        (16 * Real.exp 1 * (↑v + 1) / ε ^ 2) ^ (v + 1) / δ ≤ ↑m →
                          MeasureTheory.NullMeasurableSet
                              {p |
                                ∃ h ∈ C,
                                  EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                                      EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                                    ε / 2}
                              ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
                            (MeasureTheory.Measure.pi fun x => D)
                                {xs |
                                  ∃ h ∈ C,
                                    |TrueErrorReal X h c D -
                                          EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool)| ≥
                                      ε} ≤
                              ENNReal.ofReal δ

ConceptClass EmpiricalError FLT.Concept GrowthFunction TrueErrorReal zeroOneLoss

Uses

growth_exp_le_delta
symmetrization_uc_bound

Used by

vcdim_finite_imp_uc'

Declsymmetrization_uc_boundDeclaration kindtheorem
The symmetrization uniform convergence bound: two-sided version. P[∃h∈C: |TrueErr-EmpErr| ≥ ε] ≤ 4·GF(C,2m)·exp(-mε²/8).
Proof strategy (4 steps):
1. Decompose absolute value: |TrueErr - EmpErr| ≥ ε ↔ (TrueErr - EmpErr ≥ ε) ∨ (EmpErr - TrueErr ≥ ε)
have abs_decomp : ∀ (a b : ℝ), |a - b| ≥ ε ↔ a - b ≥ ε ∨ b - a ≥ ε := by intro a b; constructor · intro h; by_cases h' : a - b ≥ ε · exact Or.inl h' · exact Or.inr (by linarith [abs_sub_comm a b, le_abs_self (a - b)]) · intro h; cases h with | inl h => exact le_trans (le_of_eq (abs_of_nonneg (by linarith))) (by linarith) | inr h => exact le_trans (le_of_eq (abs_of_nonpos (by linarith) ▸ ...)) ...
2. Upper tail: P[∃h∈C: TrueErr-EmpErr ≥ ε] ≤ 2·GF(C,2m)·exp(-mε²/8)
- Direct application of symmetrization_step + double_sample_pattern_bound.
3. Lower tail: P[∃h∈C: EmpErr-TrueErr ≥ ε] ≤ 2·GF(C,2m)·exp(-mε²/8)
- Apply the symmetric argument: swap roles of S and S' in the double sample.
- Equivalently, apply symmetrization_step to the event EmpErr-TrueErr ≥ ε and bound the double-sample event {EmpErr_S - EmpErr_{S'} ≥ ε/2}.
- The bound is symmetric because D^m ⊗ D^m is symmetric under swapping factors. have swap_symmetry : DoubleSampleMeasure D m {p | ∃ h ∈ C, EmpErr(S) - EmpErr(S') ≥ ε/2} = DoubleSampleMeasure D m {p | ∃ h ∈ C, EmpErr(S') - EmpErr(S) ≥ ε/2} := Measure.prod_swap ...
4. Union bound: P[|gap| ≥ ε] ≤ P[gap ≥ ε] + P[gap ≤ -ε] ≤ 2·GF·exp(...) + 2·GF·exp(...) = 4·GF(C,2m)·exp(-mε²/8)
-- Uses: MeasureTheory.measure_union_le for the union of two events -- CAST: 2 * X + 2 * X = 4 * X in ENNReal (need ENNReal.add_mul or similar)
References: SSBD Theorem 6.7, Kakade-Tewari Lecture 19
```
∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
 [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 2 * Real.log 2 ≤ ↑m * ε ^ 2 →
 MeasureTheory.NullMeasurableSet
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 ∃ h ∈ C,
 |TrueErrorReal X h c D -
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool)| ≥
 ε} ≤
 ENNReal.ofReal (4 * ↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction TrueErrorReal zeroOneLoss
Uses
Used by
- finite_support_vc_approx
- uc_bad_event_le_delta_proved

Declsymmetrization_step_lowerDeclaration kindtheorem

Symmetrization step for the lower tail: P[∃h: EmpErr-TrueErr ≥ ε] ≤ 2·P_{double}[∃h: EmpErr_S-EmpErr_{S'} ≥ ε/2].

Mirror of symmetrization_step for the opposite direction. Uses hoeffding_one_sided_upper instead of hoeffding_one_sided.

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε : ℝ),
            0 < ε →
              2 * Real.log 2 ≤ ↑m * ε ^ 2 →
                (MeasureTheory.Measure.pi fun x => D)
                    {xs |
                      ∃ h ∈ C,
                        EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) - TrueErrorReal X h c D ≥
                          ε} ≤
                  2 *
                    ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
                      {p |
                        ∃ h ∈ C,
                          EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) -
                              EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) ≥
                            ε / 2}

ConceptClass EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Uses

hoeffding_one_sided_upper

Used by

symmetrization_uc_bound

Declsymmetrization_stepDeclaration kindtheorem
Symmetrization: the probability of a large gap TrueErr-EmpErr is at most twice the probability of a large gap EmpErr'-EmpErr on the double sample.
Proof strategy (6 steps):
1. Witness selection: For S in the bad event, ∃h* ∈ C with TrueErr(h) - EmpErr_S(h) ≥ ε.
-- In the bad event set, extract h* by classical choice have h_witness : ∀ xs ∈ bad_event, ∃ h* ∈ C, TrueErrorReal X h* c D - EmpiricalError X Bool h* (sample xs) (zeroOneLoss Bool) ≥ ε
2. Ghost sample mean: E_{S'}[EmpErr_{S'}(h)] = TrueErr(h) ≥ EmpErr_S(h*) + ε.
- Uses: MeasureTheory.integral_pi to compute E[EmpErr] over product measure.
- KEY LEMMA: For fixed h, E_{D^m}[EmpiricalError(h,S)] = TrueErrorReal(h,c,D). This is because EmpErr = (1/m)∑ indicator(x_i), and E[indicator(x_i)] = TrueErrorReal. have expected_emp_err : ∀ h* : Concept X Bool, ∫ xs, EmpiricalError X Bool h* (sample xs) (zeroOneLoss Bool) ∂(Measure.pi (fun _ : Fin m => D)) = TrueErrorReal X h* c D := by ...
3. Hoeffding on ghost sample: P_{S'}[EmpErr_{S'}(h) < TrueErr(h) - ε/2] ≤ exp(-mε²/2).
- Apply hoeffding_one_sided with t = ε/2.
- The hm_large hypothesis ensures exp(-mε²/2) < 1/2: 2·ln2 ≤ mε² ⟹ mε²/2 ≥ ln2 ⟹ exp(-mε²/2) ≤ 1/2. have hoeffding_ghost : ∀ h* ∈ C, Measure.pi (fun _ : Fin m => D) {xs' | EmpiricalError X Bool h* (sample xs') (zeroOneLoss Bool) < TrueErrorReal X h* c D - ε/2} ≤ ENNReal.ofReal (Real.exp (-m * (ε/2)^2 * 2)) := by intro h* _; exact hoeffding_one_sided D h* c m hm (ε/2) (by linarith) (by ...) (by ...)
4. Complementary probability: P_{S'}[EmpErr_{S'}(h) - EmpErr_S(h) ≥ ε/2] ≥ 1/2.
- From step 2: TrueErr(h) ≥ EmpErr_S(h) + ε
- From step 3: P[EmpErr_{S'} ≥ TrueErr - ε/2] ≥ 1/2
- Chain: EmpErr_{S'} ≥ TrueErr - ε/2 ≥ EmpErr_S + ε - ε/2 = EmpErr_S + ε/2
5. Conditional to unconditional: The witness h* from step 1 also witnesses the double-sample event ∃h∈C: EmpErr'-EmpErr ≥ ε/2. So: P_{S'}[double event | S bad] ≥ 1/2.
have conditional_bound : ∀ xs ∈ bad_event, Measure.pi (fun _ : Fin m => D) {xs' | ∃ h ∈ C, EmpiricalError ... xs' - EmpiricalError ... xs ≥ ε/2} ≥ ENNReal.ofReal (1/2) := by ...
6. Fubini integration: By Measure.prod_apply and Fubini: P_{S,S'}[double event] = ∫_S P_{S'}[double event | S] ≥ (1/2) · P_S[bad event] ⟹ P_S[bad event] ≤ 2 · P_{S,S'}[double event].
-- Uses: MeasureTheory.Measure.prod_apply or lintegral_prod -- MEASURABILITY: the double-sample event is measurable as a finite union -- of sets of the form {(xs,xs') | EmpErr'(h) - EmpErr(h) ≥ ε/2} for h ∈ C. -- Since C may be infinite, measurability requires care: the sup over h -- must be shown to be measurable. For finite restriction patterns (≤ 2^m -- on Fin m → Bool), this is a finite union.
MEASURABILITY CONCERNS:
- {xs | ∃ h ∈ C, ...} is NOT obviously measurable for infinite C. Strategy: decompose via restriction patterns. On any fixed xs, the set of labelings {(h(xs 0), ..., h(xs(m-1))) | h ∈ C} has at most GF(C,m) ≤ 2^m elements. So the ∃h event is a finite union of measurable sets.
- EmpiricalError is a finite sum of measurable functions, hence measurable.
- The product σ-algebra on (Fin m → X) × (Fin m → X) is generated by cylinder sets, and our events are in this σ-algebra.
References: SSBD Lemma 4.5, Kakade-Tewari Lecture 19 Lemma 1
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 2 * Real.log 2 ≤ ↑m * ε ^ 2 →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 ∃ h ∈ C,
 TrueErrorReal X h c D - EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥
 ε} ≤
 2 *
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
```
ConceptClass EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Uses
- hoeffding_one_sided
Used by
- symmetrization_uc_bound
Decldouble_sample_pattern_boundDeclaration kindtheorem
On the double sample, the probability that any hypothesis has EmpErr' - EmpErr ≥ ε/2 is bounded by GF(C,2m) · exp(-mε²/8).
Proof strategy (Approach A — standard exchangeability, 5 steps):
1. EXCHANGEABILITY: Under D^m ⊗ D^m, the 2m draws z₁,...,z_{2m} are iid from D. The joint distribution is invariant under permutations of {1,...,2m}.
Key lemma: P_{D^m⊗D^m}[event(S,S')] = E_z[P_{split}[event | z]] where z = merged sample and the split is uniformly random among all C(2m,m) ways to partition z into two groups of m.
-- Measure.pi permutation invariance have pi_perm_invariant : ∀ (σ : Equiv.Perm (Fin (2*m))), (Measure.pi (fun _ : Fin (2*m) => D)).map (fun z i => z (σ i)) = Measure.pi (fun _ : Fin (2*m) => D) := by ... -- Consequence: the event probability equals the split-averaged probability have exchangeability : DoubleSampleMeasure D m {p | ∃ h ∈ C, gap(p) ≥ ε/2} = ∫ z, SplitMeasure m {vs | ∃ h ∈ C, gap(split z vs) ≥ ε/2} ∂(Measure.pi (fun _ : Fin (2*m) => D)) := by ...
2. CONDITIONING: For fixed merged sample z of 2m points:
- C restricts to at most GF(C,2m) distinct labeling patterns on z (deterministic).
- For each pattern p, define: diff(p, split) = EmpErr_{S'}(p) - EmpErr_S(p) = (1/m) ∑_{i∈S'} a_i - (1/m) ∑_{i∈S} a_i where a_i = 1[pattern(z_i) ≠ c(z_i)] ∈ {0,1}.
-- Number of distinct patterns have num_patterns : ∀ (z : MergedSample X m), Set.ncard {p : Fin (2*m) → Bool | ∃ h ∈ C, ∀ i, p i = (h (z i) ≠ c (z i))} ≤ GrowthFunction X C (2*m) := by ...
3. PER-PATTERN HOEFFDING ON SPLITS: For fixed z and fixed pattern p: Under uniformly random split (S,S') of z into two groups of m: diff(p, split) = (1/m) ∑_{i∈S'} a_i - (1/m) ∑_{i∈S} a_i
This is a function of the random partition. By Hoeffding's inequality for sampling without replacement (Serfling 1974): P_split[diff ≥ ε/2] ≤ exp(-mε²/8)
Alternative derivation: Hoeffding without replacement from Hoeffding with replacement (iid signs) via coupling. The without-replacement bound is actually TIGHTER (variance reduction), but the with-replacement bound suffices.
-- Per-pattern concentration have per_pattern_bound : ∀ (z : MergedSample X m) (a : Fin (2*m) → ℝ) (ha : ∀ i, a i ∈ Set.Icc 0 1), SplitMeasure m {vs | (1/m) * ∑ i ∈ second_group vs, a i - (1/m) * ∑ i ∈ first_group vs, a i ≥ ε/2} ≤ ENNReal.ofReal (Real.exp (-(m : ℝ) * (ε/2)^2 / 2)) := by ... -- Note: m*(ε/2)^2/2 = mε²/8
4. UNION BOUND: P_split[∃ pattern: diff ≥ ε/2 | z] ≤ (number of patterns) · max_pattern P_split[diff ≥ ε/2] ≤ GF(C,2m) · exp(-mε²/8)
have union_bound : ∀ (z : MergedSample X m), SplitMeasure m {vs | ∃ h ∈ C, gap(split z vs, h) ≥ ε/2} ≤ ENNReal.ofReal (GrowthFunction X C (2*m) * Real.exp (-(m : ℝ) * ε^2 / 8)) := by ...
5. INTEGRATE: P_{D^m⊗D^m}[event] = E_z[P_split[event|z]] (by step 1) ≤ E_z[GF(C,2m) · exp(-mε²/8)] (by step 4, pointwise) = GF(C,2m) · exp(-mε²/8) (bound is independent of z)
-- The bound is a constant, so integrating gives the same constant -- (using IsProbabilityMeasure for the 2m-fold product)
Infrastructure needed:
- Fin.sumFinEquiv : Fin m ⊕ Fin n ≃ Fin (m + n) (available in Mathlib)
- mergeSamples / splitMergedSample (defined above)
- SplitMeasure and ValidSplit (defined above)
- Measure.pi permutation invariance (to be proved or imported)
- Hoeffding for sampling without replacement
- GrowthFunction on 2m points + sauer_shelah_exp_bound from Rademacher.lean
MEASURABILITY CONCERNS:
- The merged sample z ↦ P_split[event|z] must be measurable as a function of z. Since the event is a finite union over patterns, and each pattern's indicator is a measurable function of z (finite evaluation), this follows.
- GrowthFunction X C (2*m) is a natural number (deterministic), no measurability issue.
References: SSBD Theorem 6.7, Hoeffding (1963), Serfling (1974)
```
∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
 [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 MeasureTheory.NullMeasurableSet
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2} ≤
 ENNReal.ofReal (↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction zeroOneLoss
Uses
- exchangeability_chain_bound
Used by
- symmetrization_uc_bound

Declexchangeability_chain_boundDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε : ℝ),
            0 < ε →
              ε ≤ 2 →
                Set.Nonempty C →
                  MeasureTheory.NullMeasurableSet
                      {p |
                        ∃ h ∈ C,
                          EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                              EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                            ε / 2}
                      ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
                    have μ := MeasureTheory.Measure.pi fun x => D;
                    (μ.prod μ)
                        {p |
                          ∃ h ∈ C,
                            EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                                EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                              ε / 2} ≤
                      ENNReal.ofReal (↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))

ConceptClass EmpiricalError FLT.Concept GrowthFunction SignVector boolToSign zeroOneLoss

Uses

finite_exchangeability_bound
rademacher_mgf_bound
restriction_pattern_count
zeroOneLoss.congr_simp

Used by

double_sample_pattern_bound

DeclzeroOneLoss.congr_simpDeclaration kindtheorem

∀ (Y : Type v) {inst : DecidableEq Y} [inst_1 : DecidableEq Y] (a a_1 : Y),
  a = a_1 → ∀ (a_2 a_3 : Y), a_2 = a_3 → zeroOneLoss Y a a_2 = zeroOneLoss Y a_1 a_3

zeroOneLoss

Used by

exchangeability_chain_bound

Declrestriction_pattern_countDeclaration kindtheorem
The number of distinct restriction patterns of C on any n points is at most GF(C,n). For z : Fin n → X, define patterns(z) = {p : Fin n → Bool | ∃ h ∈ C, ∀ i, p i = (h(z i) ≠ c(z i))}. Then patterns(z).ncard ≤ GrowthFunction X C n by definition of GrowthFunction.
```
∀ {X : Type u} [MeasurableSpace X] [Infinite X] (C : ConceptClass X Bool) (c : Concept X Bool) (n : ℕ) (z : Fin n → X),
  {p | ∃ h ∈ C, ∀ (i : Fin n), p i = decide (h (z i) ≠ c (z i))}.ncard ≤ GrowthFunction X C n
```
ConceptClass FLT.Concept GrowthFunction
Used by
- exchangeability_chain_bound

Declrademacher_mgf_boundDeclaration kindtheorem

Rademacher MGF bound.

∀ {m : ℕ},
  0 < m →
    ∀ (a : Fin m → ℝ) (c : ℝ),
      0 ≤ c →
        (∀ (i : Fin m), |a i| ≤ c) →
          ∀ (t : ℝ),
            0 ≤ t →
              1 / ↑(Fintype.card (SignVector m)) * ∑ σ, Real.exp (t * (1 / ↑m * ∑ i, a i * boolToSign (σ i))) ≤
                Real.exp (t ^ 2 * c ^ 2 / (2 * ↑m))

SignVector boolToSign

Uses

cosh_le_exp_sq_half

Used by

exchangeability_chain_bound
vcdim_bounds_rademacher_quantitative

Declcosh_le_exp_sq_halfDeclaration kindtheorem
cosh(x) ≤ exp(x²/2). Standard sub-Gaussian bound.
```
∀ (x : ℝ), Real.cosh x ≤ Real.exp (x ^ 2 / 2)
```
Used by
- rademacher_mgf_bound

Declfinite_exchangeability_boundDeclaration kindtheorem

∀ {Ω : Type u_1} {G : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : Fintype G] [Nonempty G]
  {ν : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure ν] (T : G → Ω → Ω) (S : Set Ω),
  (∀ (g : G), MeasureTheory.MeasurePreserving (T g) ν ν) →
    MeasureTheory.NullMeasurableSet S ν →
      ∀ (B : ENNReal), (∀ (z : Ω), ∑ g, (T g ⁻¹' S).indicator 1 z ≤ B * ↑(Fintype.card G)) → ν S ≤ B

Used by

exchangeability_chain_bound

Declgrowth_exp_le_deltaDeclaration kindtheorem

∀ {X : Type u} [MeasurableSpace X] (C : ConceptClass X Bool) (v : ℕ),
  0 < v →
    ∀ (m : ℕ),
      0 < m →
        ∀ (ε δ : ℝ),
          0 < ε →
            0 < δ →
              δ < 1 →
                (∀ (n : ℕ), v ≤ n → GrowthFunction X C n ≤ ∑ i ∈ Finset.range (v + 1), n.choose i) →
                  (16 * Real.exp 1 * (↑v + 1) / ε ^ 2) ^ (v + 1) / δ ≤ ↑m →
                    4 * ↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)) ≤ δ ∧ 2 * Real.log 2 ≤ ↑m * ε ^ 2

ConceptClass GrowthFunction

Uses

growth_function_le_two_pow
pow_mul_exp_neg_le_factorial_div
sum_choose_le_exp_pow

Used by

finite_support_vc_approx
uc_bad_event_le_delta_proved

Declsum_choose_le_exp_powDeclaration kindtheorem
Pure combinatorial inequality: ∑_{i=0}^d C(m,i) ≤ (em/d)^d for d ≤ m, d ≥ 1.
```
∀ (d m : ℕ), 0 < d → d ≤ m → ∑ i ∈ Finset.range (d + 1), ↑(m.choose i) ≤ (Real.exp 1 * ↑m / ↑d) ^ d
```
Used by
- growth_exp_le_delta
- vcdim_bounds_rademacher_quantitative
Declpow_mul_exp_neg_le_factorial_divDeclaration kindtheorem
Key arithmetic lemma for PAC bound: for t > 0, t^d * exp(-t) ≤ (d+1)!/t. Follows from exp(t) ≥ t^(d+1)/(d+1)! (partial sum of Taylor series).
```
∀ {d : ℕ} {t : ℝ}, 0 < t → t ^ d * Real.exp (-t) ≤ ↑(d + 1).factorial / t
```
Used by
- growth_exp_le_delta
Declgrowth_function_le_two_powDeclaration kindtheorem
Trivial bound: GrowthFunction ≤ 2^n for all concept classes. Each restriction to an n-element set yields a function in S → Bool, and there are at most 2^n such functions.
```
∀ {X : Type u} (C : ConceptClass X Bool) (n : ℕ), GrowthFunction X C n ≤ 2 ^ n
```
ConceptClass FLT.Concept GrowthFunction
Used by
- growth_exp_le_delta

Declhoeffding_one_sided_upperDeclaration kindtheorem

Upper-tail Hoeffding: for iid Bernoulli(p) draws, the empirical average overshoots the mean by ≥ t with probability ≤ exp(-2mt²).

This is the mirror of hoeffding_one_sided (which bounds the lower tail). The proof uses the same sub-Gaussian machinery with Z_i = indicator(x_i) - p (instead of p - indicator(x_i)).

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (h c : Concept X Bool) (m : ℕ),
  0 < m →
    ∀ (t : ℝ),
      0 < t →
        t ≤ 1 →
          MeasurableSet {x | h x ≠ c x} →
            (MeasureTheory.Measure.pi fun x => D)
                {xs |
                  EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥ TrueErrorReal X h c D + t} ≤
              ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))

EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Used by

symmetrization_step_lower
vcdim_finite_imp_uc'

Declhoeffding_one_sidedDeclaration kindtheorem
One-sided Hoeffding: for iid Bernoulli(p) draws, the empirical average undershoots the mean by ≥ t with probability ≤ exp(-2mt²).
Proof strategy (3 steps):
1. MGF bound (Hoeffding's lemma): For X ∈ [0,1] with E[X] = p, E[exp(s(X-p))] ≤ exp(s²/8).
- Adapt from cosh_le_exp_sq_half infrastructure in Rademacher.lean.
- Key: convexity of exp on [0,1] gives E[exp(sX)] ≤ p·exp(s) + (1-p)·exp(0), then the s²/8 bound follows from ln(1 + x) ≤ x and Taylor expansion. have mgf_bound : ∀ (s : ℝ), ∫ x, Real.exp (s * (indicator x - p)) ∂D ≤ Real.exp (s^2 / 8) := by ...
2. Product independence: E[exp(s·∑(X_i-p))] = ∏ E[exp(s(X_i-p))] ≤ exp(ms²/8).
- Uses MeasureTheory.Measure.pi independence structure.
- Needs: Measure.pi integral factorization for product of functions.
- MEASURABILITY: fun xs => Real.exp (s * ∑ i, f (xs i)) is measurable (composition of measurable functions). have product_bound : ∀ (s : ℝ), ∫ xs, Real.exp (s * ∑ i, (indicator (xs i) - p)) ∂Measure.pi (fun _ => D) ≤ Real.exp (m * s^2 / 8) := by ...
3. Exponential Markov + optimize: P[∑(X_i-p) ≤ -mt] = P[exp(-s·∑(X_i-p)) ≥ exp(smt)] ≤ exp(-smt + ms²/8). Optimize over s: set s = 4t to get ≤ exp(-2mt²).
- Uses Markov's inequality in ENNReal form.
- CAST ISSUE: Markov gives ENNReal bound, need to convert exp(-2mt²) between ENNReal.ofReal and the measure value. have markov_step : ∀ (s : ℝ) (hs : 0 < s), Measure.pi (fun _ => D) {xs | ∑ i, (indicator (xs i) - p) ≤ -(m : ℝ) * t} ≤ ENNReal.ofReal (Real.exp (-(s * m * t) + m * s^2 / 8)) := by ... have optimize : Real.exp (-(4*t * m * t) + m * (4*t)^2 / 8) = Real.exp (-2 * m * t^2) := by ring_nf
CAST ISSUES to watch:
- m : ℕ needs cast to ℝ in the exponent: (m : ℝ)
- EmpiricalError returns ℝ, TrueErrorReal returns ℝ, good — no ENNReal gap
- The measure value is ENNReal, the bound exp(-2mt²) is ℝ≥0∞ via ENNReal.ofReal
References: SSBD Lemma B.3, Hoeffding (1963)
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (h c : Concept X Bool) (m : ℕ),
 0 < m →
 ∀ (t : ℝ),
 0 < t →
 t ≤ 1 →
 MeasurableSet {x | h x ≠ c x} →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≤ TrueErrorReal X h c D - t} ≤
 ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))
```
EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Used by
- symmetrization_step
- vcdim_finite_imp_uc'
Decluc_imp_pacDeclaration kindtheorem
Uniform convergence implies PAC learnability via ERM. The ERM learner (which exists by ermLearn) achieves PAC learning when uniform convergence holds. This is the second half of vcdim_finite_imp_pac.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
  Set.Nonempty C → HasUniformConvergence X C → PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass EmpiricalError FLT.Concept HasUniformConvergence HypothesisSpace IsConsistentWith PACLearnable TrueError TrueErrorReal zeroOneLoss
Uses
- BatchLearner.output_in_H
Used by
DeclBatchLearner.output_in_HDeclaration kindtheorem
Output is in the hypothesis space
```
∀ {X : Type u} {Y : Type v} (self : BatchLearner X Y) {m : ℕ} (S : Fin m → X × Y), self.learn S ∈ self.hypotheses
```
BatchLearner BatchLearner.hypotheses BatchLearner.learn FLT.Concept HypothesisSpace
Used by
- uc_imp_pac
Declrademacher_lower_bound_on_shatteredDeclaration kindtheorem
Adversarial Rademacher lower bound on shattered sets. For |T| >= 4m^2 + 1, exists D with Rad_m(C,D) >= 1/2.
Proof: D = uniform on T. Product measure = uniform on T^m. On injective samples from T (shattered): EmpRad = 1 (by empRad_eq_one_of_injective_in_shattered). EmpRad ≥ 0 everywhere (by empRad_nonneg). Birthday bound: P[injective m draws from n ≥ 4m²+1 points] ≥ 1 - m(m-1)/(2n) ≥ 7/8 ≥ 1/2. So ∫ EmpRad ≥ P[injective] · 1 + P[¬injective] · 0 ≥ 1/2.
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool) (T : Finset X),
 Shatters X C T →
 ∀ (m : ℕ),
 0 < m → 4 * m ^ 2 + 1 ≤ T.card → ∃ D, MeasureTheory.IsProbabilityMeasure D ∧ 1 / 2 ≤ RademacherComplexity X C D m
```
ConceptClass EmpiricalRademacherComplexity RademacherComplexity Shatters uniformMeasure
Uses
Used by
- fundamental_rademacher
DeclempiricalRademacherComplexity_le_oneDeclaration kindtheorem
```
∀ (X : Type u) (C : ConceptClass X Bool) {m : ℕ}, 0 < m → ∀ (xs : Fin m → X), EmpiricalRademacherComplexity X C xs ≤ 1
```
ConceptClass EmpiricalRademacherComplexity FLT.Concept SignVector rademacherCorrelation
Uses
- rademacherCorrelation_abs_le_one
Used by
DeclempRad_nonnegDeclaration kindtheorem
```
∀ {X : Type u} (C : ConceptClass X Bool) {m : ℕ}, m ≠ 0 → ∀ (xs : Fin m → X), 0 ≤ EmpiricalRademacherComplexity X C xs
```
ConceptClass EmpiricalRademacherComplexity FLT.Concept SignVector boolToSign rademacherCorrelation
Uses
- rademacherCorrelation_abs_le_one
- sum_boolToSign_cancel
Used by
Declsum_boolToSign_cancelDeclaration kindtheorem
Rademacher cancellation: Σ_σ boolToSign(σ i) * f(σ) = 0 when f doesn't depend on coordinate i. Proof: the bit-flip involution at coordinate i pairs each σ with flipAt i σ, negating boolToSign(σ i) while preserving f.
```
∀ {m : ℕ} (i : Fin m) (f : SignVector m → ℝ),
  (∀ (σ σ' : SignVector m), (∀ (k : Fin m), k ≠ i → σ k = σ' k) → f σ = f σ') → ∑ σ, boolToSign (σ i) * f σ = 0
```
SignVector boolToSign flipAt
Uses
Used by
- empRad_nonneg
- vcdim_zero_rademacher_le_inv_sqrt

DeclflipAt_otherDeclaration kindtheorem

∀ {m : ℕ} (i : Fin m) (σ : SignVector m) (k : Fin m), k ≠ i → flipAt✝ i σ k = σ k

SignVector flipAt

Used by

sum_boolToSign_cancel

DeclflipAt_involutiveDeclaration kindtheorem
```
∀ {m : ℕ} (i : Fin m), Function.Involutive (flipAt✝ i)
```
SignVector flipAt
Used by
- sum_boolToSign_cancel
DeclflipAt_boolToSignDeclaration kindtheorem
```
∀ {m : ℕ} (i : Fin m) (σ : SignVector m), boolToSign (flipAt✝ i σ i) = -boolToSign (σ i)
```
SignVector boolToSign flipAt
Used by
- sum_boolToSign_cancel
DeclempRad_eq_one_of_injective_in_shatteredDeclaration kindtheorem
Key combinatorial lemma: injective samples from a shattered set have EmpRad = 1.
```
∀ {X : Type u} [DecidableEq X] (C : ConceptClass X Bool) {m : ℕ},
 0 < m →
 ∀ (T : Finset X),
 Shatters X C T →
 ∀ (xs : Fin m → X), Function.Injective xs → (∀ (i : Fin m), xs i ∈ T) → EmpiricalRademacherComplexity X C xs = 1
```
ConceptClass EmpiricalRademacherComplexity FLT.Concept Shatters SignVector
Uses
- empRad_eq_one_of_all_labelings
- shatters_subset
Used by
- rademacher_lower_bound_on_shattered
Declshatters_subsetDeclaration kindtheorem
Subset of a shattered set is shattered.
```
∀ {X : Type u} (C : ConceptClass X Bool) (T S : Finset X), S ⊆ T → Shatters X C T → Shatters X C S
```
ConceptClass FLT.Concept Shatters
Used by
- empRad_eq_one_of_injective_in_shattered
DeclempRad_eq_one_of_all_labelingsDeclaration kindtheorem
On samples where every labeling is realizable, EmpRad = 1.
For each sign vector σ, the hypothesis provides h ∈ C with h(xs i) = σ i, giving corr(h,σ,xs) = 1. Since |corr| ≤ 1, the sSup is exactly 1. Averaging over all σ gives EmpRad = (1/2^m)·2^m·1 = 1.
This is the combinatorial core of the NFL Rademacher lower bound: when xs are distinct points from a shattered set, every labeling is realized, so this lemma applies.
```
∀ {X : Type u} (C : ConceptClass X Bool) {m : ℕ},
 0 < m →
 ∀ (xs : Fin m → X),
 (∀ (σ : SignVector m), ∃ h ∈ C, ∀ (i : Fin m), h (xs i) = σ i) → EmpiricalRademacherComplexity X C xs = 1
```
ConceptClass EmpiricalRademacherComplexity FLT.Concept SignVector rademacherCorrelation
Uses
- corr_eq_one_of_agree
- rademacherCorrelation_abs_le_one
Used by
- empRad_eq_one_of_injective_in_shattered
DeclrademacherCorrelation_abs_le_oneDeclaration kindtheorem
```
∀ {X : Type u} {m : ℕ},
 0 < m → ∀ (h : Concept X Bool) (σ : SignVector m) (xs : Fin m → X), |rademacherCorrelation h σ xs| ≤ 1
```
FLT.Concept SignVector boolToSign rademacherCorrelation
Uses
- boolToSign_mul_abs_le_one
Used by
DeclboolToSign_mul_abs_le_oneDeclaration kindtheorem
```
∀ (b₁ b₂ : Bool), |boolToSign b₁ * boolToSign b₂| ≤ 1
```
boolToSign
Uses
- boolToSign_abs_le_one
Used by
- rademacherCorrelation_abs_le_one
DeclboolToSign_abs_le_oneDeclaration kindtheorem
```
∀ (b : Bool), |boolToSign b| ≤ 1
```
boolToSign
Uses
- boolToSign_abs_eq_one
Used by
- boolToSign_mul_abs_le_one
DeclboolToSign_abs_eq_oneDeclaration kindtheorem
```
∀ (b : Bool), |boolToSign b| = 1
```
boolToSign
Used by
- boolToSign_abs_le_one
- vcdim_bounds_rademacher_quantitative
Declcorr_eq_one_of_agreeDeclaration kindtheorem
When h agrees with σ on all sample points, correlation is exactly 1.
```
∀ {X : Type u} {m : ℕ},
 0 < m →
 ∀ (h : Concept X Bool) (σ : SignVector m) (xs : Fin m → X),
 (∀ (i : Fin m), h (xs i) = σ i) → rademacherCorrelation h σ xs = 1
```
FLT.Concept SignVector boolToSign rademacherCorrelation
Used by
- empRad_eq_one_of_all_labelings
Declpac_imp_vcdim_finiteDeclaration kindtheorem
Direction →: PAC learnability implies finite VCDim.
PROOF ROUTE (via double-sample infrastructure in Generalization.lean): Step 1: Contrapositive — assume VCDim = ∞ Step 2: For m = mf(ε,δ), extract S with |S| = 2m shattered by C (uses WithTop.eq_top_iff_forall_ge, same as vcdim_univ_infinite) Step 3: Construct D = uniform on S (Finset.uniformMeasure?) KU₁₉: Mathlib's uniform measure on a finite set — does MeasureTheory.Measure.count / Finset.card give IsProbabilityMeasure? Step 4: Double-sample trick via GhostSample + symmetrization Step 5: Counting argument on restricted labelings
HC at this joint: Step 3 requires constructing a specific probability measure from a combinatorial object (the shattered set). This is a P₁→P₂ crossing. UK₉: The construction of the hard distribution is the only non-constructive step. Can it be made constructive? (Related to derandomization in learning.)
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool),
 PACLearnable X C → VCDim X C < ⊤
```
ConceptClass PACLearnable VCDim
Uses
- vcdim_infinite_not_pac
Used by
- fundamental_rademacher
- vc_characterization
Declvcdim_infinite_not_pacDeclaration kindtheorem
If VCDim = ⊤, then C is not PAC learnable. Proof: for any learner L with sample function mf, pick ε = 1/4, δ = 1/4. Let m = mf(1/4, 1/4). Since VCDim = ⊤, ∃ shattered set S with |S| ≥ 2m. Put D = uniform on S. For random labeling, any m-sample learner has expected error ≥ 1/4 on unseen points. This is the core of pac_imp_vcdim_finite (contrapositive direction).
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool),
  VCDim X C = ⊤ → ¬PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept PACLearnable Shatters VCDim uniformMeasure
Uses
- nfl_counting_core
- uniformMeasure_isProbability
Used by
- pac_imp_vcdim_finite
DecluniformMeasure_isProbabilityDeclaration kindtheorem
The uniform measure is a probability measure when X is nonempty and finite.
```
∀ (X : Type u) [inst : MeasurableSpace X] [inst_1 : Fintype X] [MeasurableSingletonClass X] (hne : Nonempty X),
 0 < Fintype.card X → MeasureTheory.IsProbabilityMeasure (uniformMeasure X hne)
```
uniformMeasure
Used by
Declnfl_counting_coreDeclaration kindtheorem
NFL counting core: for a shattered set T with |T| > 2m, there exists a labeling f₀ : ↥T → Bool and its shattering witness c₀ ∈ C such that the number of samples xs : Fin m → ↥T where the learner achieves low error (≤ |T|/4) is at most half the total number of samples. Proof: double-counting + pigeonhole using per_sample_labeling_bound.
```
∀ {X : Type u} {C : ConceptClass X Bool} {T : Finset X},
 Shatters X C T →
 ∀ {m : ℕ},
 2 * m < T.card →
 ∀ (L : BatchLearner X Bool),
 ∃ f₀,
 ∃ c₀ ∈ C,
 (∀ (t : ↥T), c₀ ↑t = f₀ t) ∧
 2 * {xs | {t | c₀ ↑t ≠ L.learn (fun i => (↑(xs i), c₀ ↑(xs i))) ↑t}.card * 4 ≤ T.card}.card ≤
 Fintype.card (Fin m → ↥T)
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept Shatters
Uses
- per_sample_labeling_bound
Used by
- pac_lower_bound_member
- vcdim_infinite_not_pac
Declper_sample_labeling_boundDeclaration kindtheorem
Per-sample labeling bound: for any fixed xs : Fin m → α on a Fintype α with 2m < |α|, and any function output : (α → Bool) → (α → Bool) that only depends on the restriction of f to {xs i}, at most half the labelings f : α → Bool have error(f, output(f)) * 4 ≤ |α|.
Proof: pair each f with flip_unseen(f). The pair has complementary disagreements on unseen points, and |unseen| > |α|/2, so at most one can have low error.
```
∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (m : ℕ),
 2 * m < Fintype.card α →
 ∀ (xs : Fin m → α) (output : (α → Bool) → α → Bool),
 (∀ (f f' : α → Bool), (∀ (i : Fin m), f (xs i) = f' (xs i)) → output f = output f') →
 2 * {f | {t | f t ≠ output f t}.card * 4 ≤ Fintype.card α}.card ≤ Fintype.card (α → Bool)
```
Used by
- nfl_counting_core
DeclMeasurableConceptClass.hmeas_CDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C],
  ∀ c ∈ C, Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Uses
- MeasurableConceptClass.mem_measurable
Used by
DeclMeasurableConceptClass.mem_measurableDeclaration kindtheorem
Every concept in C is measurable
```
∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : MeasurableConceptClass X C],
  ∀ h ∈ C, Measurable h
```
ConceptClass FLT.Concept MeasurableConceptClass
Used by
- MeasurableConceptClass.hmeas_C
DeclMeasurableConceptClass.hc_measDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C]
  (c : Concept X Bool), Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Uses
- MeasurableConceptClass.all_measurable
Used by
DeclMeasurableConceptClass.all_measurableDeclaration kindtheorem
All concepts X → Bool are measurable (for disagreement sets)
```
∀ {X : Type u} {inst : MeasurableSpace X} (C : ConceptClass X Bool) [self : MeasurableConceptClass X C]
  (c : Concept X Bool), Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Used by
- MeasurableConceptClass.hc_meas
DeclMeasurableConceptClass.hWBDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C], WellBehavedVC X C
```
ConceptClass MeasurableConceptClass WellBehavedVC
Uses
- MeasurableConceptClass.wellBehaved
Used by
DeclMeasurableConceptClass.wellBehavedDeclaration kindtheorem
Uniform convergence bad event is NullMeasurableSet
```
∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : MeasurableConceptClass X C],
  WellBehavedVC X C
```
ConceptClass MeasurableConceptClass WellBehavedVC
Used by
- MeasurableConceptClass.hWB
DefinitionBatchLearnerstructure
A batch learner (PAC paradigm): takes a finite sample, returns a hypothesis.
```
Type u → Type v → Type (max u v)
```

DefinitionBatchLearner.hypothesesdef

The learner's hypothesis space

{X : Type u} → {Y : Type v} → BatchLearner X Y → HypothesisSpace X Y

DefinitionBatchLearner.learndef

The learning algorithm: given a sample, produce a hypothesis

{X : Type u} → {Y : Type v} → BatchLearner X Y → {m : ℕ} → (Fin m → X × Y) → Concept X Y

DefinitionCompressionSchemeWithInfostructure
A labeled compression scheme with finite side information. This is the object proved to exist by Moran-Yehudayoff (2016, arXiv:1503.06960).
The current CompressionScheme is strictly stronger: it requires reconstruction from the compressed Finset alone (no side information). See Open_NoInfoCompressionStrengthening for that conjecture.
```
(X : Type u) → (Y : Type v) → ConceptClass X Y → Type (max (max u (u_1 + 1)) v)
```

DefinitionCompressionSchemeWithInfo.Infodef

The side information type

{X : Type u} → {Y : Type v} → {C : ConceptClass X Y} → CompressionSchemeWithInfo X Y C → Type u_1

DefinitionCompressionSchemeWithInfo.compressdef

Compression: extract ≤ kernelSize labeled examples + side information

{X : Type u} →
  {Y : Type v} →
    {C : ConceptClass X Y} →
      (self : CompressionSchemeWithInfo X Y C) → {m : ℕ} → (Fin m → X × Y) → Finset (X × Y) × self.Info

DefinitionCompressionSchemeWithInfo.info_finitedef

Side information is finite

{X : Type u} → {Y : Type v} → {C : ConceptClass X Y} → (self : CompressionSchemeWithInfo X Y C) → Fintype self.Info

DefinitionCompressionSchemeWithInfo.kernelSizedef

Kernel size bound

{X : Type u} → {Y : Type v} → {C : ConceptClass X Y} → CompressionSchemeWithInfo X Y C → ℕ

DefinitionCompressionSchemeWithInfo.reconstructdef

Reconstruction: produce hypothesis from compressed subset AND side information

{X : Type u} →
  {Y : Type v} → {C : ConceptClass X Y} → (self : CompressionSchemeWithInfo X Y C) → Finset (X × Y) → self.Info → X → Y

DefinitionCompressionSchemeWithInfo.sizedef
Total size of a compression scheme with side information: kernel size + number of side information states. (The paper uses k + log₂(|I|+1); we use the simpler k + |I| which is an upper bound and avoids importing Real.log.)
```
{X : Type u} → {Y : Type v} → {C : ConceptClass X Y} → CompressionSchemeWithInfo X Y C → ℕ
```
DefinitionCompressionSchemeWithInfo0def
Fix the hidden Info universe parameter of CompressionSchemeWithInfo to 0. This resolves the universe elaboration obstruction: Fin T → Finset (Fin K) is Type 0, while CompressionSchemeWithInfo X Bool C with X : Type u infers Info : Type u. Pinning to .{u, 0, 0} allows Type 0 Info directly.
```
(X : Type u) → (Y : Type) → ConceptClass X Y → Type (max (max u 1) 0)
```
DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```

DefinitionEmpiricalErrordef

Empirical error: average loss on a finite sample.

(X : Type u) → (Y : Type v) → Concept X Y → {m : ℕ} → (Fin m → X × Y) → LossFunction Y → ℝ

DefinitionEmpiricalRademacherComplexitydef

(X : Type u) → ConceptClass X Bool → {m : ℕ} → (Fin m → X) → ℝ

DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionFinitePMFstructure
A probability mass function over a finite type. Named FinitePMF to avoid conflict with Mathlib's PMF.
```
(H : Type u_1) → [Fintype H] → Type u_1
```

DefinitionFinitePMF.probdef

{H : Type u_1} → [inst : Fintype H] → FinitePMF H → H → ℝ

DefinitionFinitePMF.toPMFdef

{H : Type u_1} → [inst : Fintype H] → FinitePMF H → PMF H

DefinitionFinset.boolVCDimdef
VC dimension of a finite Bool-valued family, computed via the set-system image boolFamilyToFinsetFamily and Mathlib's Finset.vcDim. Declared noncomputable because the underlying vcDim is.
```
{H : Type u_1} → [Fintype H] → [DecidableEq H] → Finset (H → Bool) → ℕ
```
DefinitionGrowthFunctiondef
Growth function (shattering coefficient): π_C(m) = max_{|S|=m} |{c|_S : c ∈ C}|. For each m-element set S, counts the number of distinct restrictions of C to S, then takes the supremum over all such S.
```
(X : Type u) → ConceptClass X Bool → ℕ → ℕ
```
DefinitionHasUniformConvergencedef
Uniform convergence of empirical error to true error over a hypothesis class. This is the property that makes finite VCDim → PAC learnability work. BP₅ connects here: this is ONE of the five characterizations.
M-DefinitionRepair (Γ₃₅ → Γ₄₁): The m₀ must be INDEPENDENT of D and c. That's what "uniform" means — convergence is uniform over all distributions and all target concepts. The original definition had m₀ depending on D and c, making uc_imp_pac unprovable (PACLearnable's mf must be independent of D, c). Repaired: ∃ m₀ is now BEFORE ∀ D, ∀ c. This STRENGTHENS the definition (A5-valid: adds content, doesn't simplify).
```
(X : Type u) → [MeasurableSpace X] → HypothesisSpace X Bool → Prop
```
DefinitionHypothesisSpacedef
A hypothesis space is a set of candidate concepts that the learner searches over. When H = C (the realizable case), every concept in the target class is available. When H ⊂ C or H ⊃ C, we are in the improper/agnostic regime.
Structurally identical to ConceptClass but semantically distinct: ConceptClass is the ground truth collection; HypothesisSpace is what the learner has access to.
```
Type u → Type v → Type (max v u)
```
DefinitionIncidenceInfodef
Concrete side information for the MY construction: each of the T recovered blocks is represented by the set of kernel positions it uses.
```
ℕ → ℕ → Type
```

DefinitionIsConsistentWithdef

A hypothesis h is consistent with labeled sample S.

(X : Type u) → (Y : Type v) → [DecidableEq Y] → Concept X Y → {m : ℕ} → (Fin m → X × Y) → Prop

DefinitionMWUConfigstructure
MWU config: weight vector with positivity proof.
```
(C : Type u_1) → [Fintype C] → Type u_1
```

DefinitionMWUConfig.potentialdef

Potential = sum of weights.

{C : Type u_1} → [inst : Fintype C] → MWUConfig C → ℝ

DefinitionMWUConfig.toPMFdef

Normalize config to PMF.

{C : Type u_1} → [inst : Fintype C] → [Nonempty C] → MWUConfig C → FinitePMF C

DefinitionMWUConfig.weightsdef

{C : Type u_1} → [inst : Fintype C] → MWUConfig C → C → ℝ

DefinitionMeasurableConceptClassstructure
A concept class with the measure-theoretic regularity needed for PAC theory.
Bundles three conditions: 1. Every concept in C is measurable 2. All concepts are measurable (needed for disagreement set measurability) 3. The UC bad event satisfies NullMeasurableSet (WellBehavedVC)
Condition 3 is the deep one: for uncountable C, the existential {∃ h ∈ C, |TrueErr - EmpErr| ≥ ε} is NOT MeasurableSet in general. WellBehavedVC asserts it is NullMeasurableSet, which suffices for integration (lintegral_indicator_one₀).
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionPACLearnabledef
PAC (Probably Approximately Correct) learning. The central definition of computational learning theory.
Sample space: Fin m → X with i.i.d. product measure D^m. Labels: derived deterministically from target concept c (realizable case). Error: D-probability of disagreement between learner output and c.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionProperFiniteSupportLearnerstructure
A proper finite-support learner for a concept class C. This structure captures the existence of a bounded-support ERM with error at most 1/3 for any C-realizable finite distribution. CORRECTED: good_on_support returns Finset X (not Fin k → X).
```
(X : Type u) → ConceptClass X Bool → Type u
```

DefinitionProperFiniteSupportLearner.learndef

{X : Type u} → {C : ConceptClass X Bool} → ProperFiniteSupportLearner X C → {m : ℕ} → (Fin m → X × Bool) → X → Bool

DefinitionProperFiniteSupportLearner.sampleBounddef

{X : Type u} → {C : ConceptClass X Bool} → ProperFiniteSupportLearner X C → ℕ

DefinitionRademacherComplexitydef

(X : Type u) → [inst : MeasurableSpace X] → ConceptClass X Bool → MeasureTheory.Measure X → ℕ → ℝ

DefinitionSampleComplexitydef
Sample complexity of PAC learning: the minimum number of samples needed to achieve (ε,δ)-PAC learning. m_C(ε,δ) = sInf{m | ∃ L, ∀ D prob, ∀ c ∈ C, D^m{S : error(L(S)) ≤ ε} ≥ 1-δ}.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → ℝ → ℝ → ℕ
```
DefinitionShattersdefYaël Dillies
A set S ⊆ X is shattered by concept class C if every labeling of S is realized by some concept in C.
```
(X : Type u) → ConceptClass X Bool → Finset X → Prop
```
DefinitionSignVectordef
```
ℕ → Type
```
DefinitionTrueErrordef
True error (0-1 loss, realizable case): D-probability of disagreement. This is what PACLearnable's success event measures.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ENNReal
```
DefinitionTrueErrorRealdef
True error in ℝ: for use in bounds involving subtraction/absolute value. COUNTER-1 of TrueError. The toReal bridge loses information when the measure is ⊤.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ℝ
```
DefinitionVCDimdef
VC dimension of a concept class: the size of the largest shattered set. Returns ℕ∞ = WithTop ℕ.
```
(X : Type u) → ConceptClass X Bool → WithTop ℕ
```
DefinitionWellBehavedVCdef
A concept class is well-behaved if the ghost gap event is null-measurable. This is the minimal regularity assumption for the symmetrization proof.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionagreeTestdef
Per-point agreement test: for a fixed point x ∈ Y and concept c, maps hypothesis h to whether h(x) = c(x).
```
{X : Type u} → (X → Bool) → X → (HY : Finset (X → Bool)) → ↥HY → Bool
```

DefinitionagreeTestsdef

The family of agreement tests over all points in Y.

{X : Type u} → (X → Bool) → Finset X → (HY : Finset (X → Bool)) → Finset (↥HY → Bool)

DefinitionboolFamilyToFinsetFamilydef
Maps a finite family of Bool-valued functions to its image as a family of accepting sets. The set-system view is what Mathlib's Finset.Shatters and Finset.vcDim consume, so this is the entry point from the function-class view to the combinatorial VC machinery.
```
{H : Type u_1} → [Fintype H] → [DecidableEq H] → Finset (H → Bool) → Finset (Finset H)
```

DefinitionboolGamePayoffdef

Expected payoff of distribution p against column c in a Boolean game.

{R : Type u_1} → {C : Type u_2} → [inst : Fintype R] → (R → C → Bool) → FinitePMF R → C → ℝ

DefinitionboolTestExpectationdef
Expected value of a Bool-valued test under a finite distribution, via the indicator embedding if f h then 1 else 0. The central quantity of the finite-VC approximation layer: a TV bound on distributions translates to a uniform bound on test expectations via expectation_approx_of_tv.
```
{H : Type u_1} → [inst : Fintype H] → FinitePMF H → (H → Bool) → ℝ
```
DefinitionboolToSigndef
Convert Bool labels to ±1 reals. true ↦ 1, false ↦ -1.
```
Bool → ℝ
```
DefinitionboundedSubsamplesdef
Bounded subsamples: all subsets of Y with cardinality ≤ s.
```
{X : Type u} → Finset X → ℕ → Finset (Finset X)
```
DefinitiondecodeWitnessLabeldef
Decode labels from the kernel. This is exactly the current MY reconstruction convention in your file.
```
{X : Type u} → [DecidableEq X] → Finset (X × Bool) → X → Bool
```
DefinitiondecodeWitnessXCoordsdef
Decode the X-coordinates of a block from kernel positions. This matches the current blockHyp shape.
```
{X : Type u} → Finset (X × Bool) → {K : ℕ} → Finset (Fin K) → Finset X
```
DefinitiondisagreementFamilydef
The disagreement family: for each h ∈ C, the test y ↦ decide(h(y) ≠ c(y)) restricted to Y. Used for the VC approximation step in the proper learner proof.
```
{X : Type u} → ConceptClass X Bool → (X → Bool) → (Y : Finset X) → Finset (↥Y → Bool)
```

DefinitionempiricalPMFdef

Build FinitePMF from empirical frequencies of a finite sequence.

{α : Type u_1} → [inst : Fintype α] → [DecidableEq α] → {T : ℕ} → 0 < T → (Fin T → α) → FinitePMF α

DefinitionencodeWitnessInfodef
Encode a witness set W as the set of kernel positions of the pairs (x, c x). The bound kernel.card ≤ K is fed into the encoding through the if branch, so the result has the same shape as the current compressCore code.
```
{X : Type u} → [DecidableEq X] → Finset (X × Bool) → (X → Bool) → (K : ℕ) → Finset X → Finset (Fin K)
```

DefinitionextendBooldef

{H : Type u_1} → (H → Bool) → H ⊕ ℕ → Bool

DefinitionflipAtdef
Bit-flip at coordinate i: σ ↦ σ' where σ'(i) = !σ(i), σ'(k) = σ(k) for k ≠ i.
```
{m : ℕ} → Fin m → SignVector m → SignVector m
```
DefinitionhypothesisEnvelopedef
The hypothesis envelope: the finite set of all possible learner outputs on bounded subsamples of Y, labeled by concept c.
```
{X : Type u} → {C : ConceptClass X Bool} → ProperFiniteSupportLearner X C → (X → Bool) → Finset X → Finset (X → Bool)
```
DefinitionlabeledSampleOfFinsetdef
Build a labeled sample from a Finset of points and a concept.
```
{X : Type u} → (X → Bool) → (Z : Finset X) → Fin Z.card → X × Bool
```

DefinitionliftClassdef

{H : Type u_1} → Finset (H → Bool) → ConceptClass (H ⊕ ℕ) Bool

DefinitionmkIncidenceSchemeOfMajoritydef

{X : Type u} →
  {C : ConceptClass X Bool} →
    (T K : ℕ) →
      (compressCore : {m : ℕ} → (Fin m → X × Bool) → Finset (X × Bool) × IncidenceInfo T K) →
        (blockHyp : Finset (X × Bool) → IncidenceInfo T K → Fin T → X → Bool) →
          (rowHyp :
              {m : ℕ} → (S : Fin m → X × Bool) → (∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) → Fin T → X → Bool) →
            0 < T →
              (∀ {m : ℕ} (S : Fin m → X × Bool), (compressCore S).1.card ≤ K) →
                (∀ {m : ℕ} (S : Fin m → X × Bool), ↑(compressCore S).1 ⊆ Set.range S) →
                  (∀ {m : ℕ} (S : Fin m → X × Bool) (hreal : ∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) (i : Fin m)
                      (t : Fin T),
                      blockHyp (compressCore S).1 (compressCore S).2 t (S i).1 = rowHyp S hreal t (S i).1) →
                    (∀ {m : ℕ} (S : Fin m → X × Bool) (hreal : ∃ c ∈ C, ∀ (i : Fin m), c (S i).1 = (S i).2) (i : Fin m),
                        (∑ t, if rowHyp S hreal t (S i).1 = (S i).2 then 1 else 0) / ↑T > 1 / 2) →
                      CompressionSchemeWithInfo0 X Bool C

DefinitionmwuConfigdef

The MWU config after T steps.

{R : Type u_1} →
  {C : Type u_2} →
    [Fintype R] →
      [inst : Fintype C] →
        [Nonempty C] →
          (M : R → C → Bool) →
            (η : ℝ) →
              η < 1 →
                (v : ℝ) →
                  (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) → ℕ → MWUConfig C

DefinitionmwuHitCountdef

Count how many rounds hit a fixed column, aligned to the recursion of mwuRun.

{R : Type u_1} →
  {C : Type u_2} →
    [Fintype R] →
      [inst : Fintype C] →
        [Nonempty C] →
          (M : R → C → Bool) →
            (η : ℝ) →
              η < 1 →
                (v : ℝ) → (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) → ℕ → C → ℕ

DefinitionmwuInitdef

Initial config: all weights = 1.

(C : Type u_1) → [inst : Fintype C] → MWUConfig C

DefinitionmwuRowsdef

The MWU row sequence after T steps.

{R : Type u_1} →
  {C : Type u_2} →
    [Fintype R] →
      [inst : Fintype C] →
        [Nonempty C] →
          (M : R → C → Bool) →
            (η : ℝ) →
              η < 1 →
                (v : ℝ) →
                  (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) → (T : ℕ) → Fin T → R

DefinitionmwuRundef

MWU run: iterate T steps, returning final config and row sequence.

{R : Type u_1} →
  {C : Type u_2} →
    [Fintype R] →
      [inst : Fintype C] →
        [Nonempty C] →
          (M : R → C → Bool) →
            (η : ℝ) →
              η < 1 →
                (v : ℝ) →
                  (∀ (q : FinitePMF C), ∃ r, v ≤ ∑ c, q.prob c * if M r c = true then 1 else 0) →
                    (T : ℕ) → MWUConfig C × (Fin T → R)

DefinitionmwuUpdateWeightsdef

One MWU update step on weights.

{C : Type u_1} → [inst : Fintype C] → {R : Type u_2} → (R → C → Bool) → (η : ℝ) → η < 1 → MWUConfig C → R → MWUConfig C

DefinitionpointSupportdef
Extract the domain points from a labeled sample.
```
{X : Type u} → {m : ℕ} → (Fin m → X × Bool) → Finset X
```

DefinitionrademacherCorrelationdef

{X : Type u} → {m : ℕ} → Concept X Bool → SignVector m → (Fin m → X) → ℝ

DefinitionsupportErrordef

Weighted error of hypothesis h vs concept c over a FinitePMF on Y.

{X : Type u} → (Y : Finset X) → FinitePMF ↥Y → (X → Bool) → (X → Bool) → ℝ

DefinitionuniformMeasuredef
Uniform probability measure on a Fintype: (1/|X|) · count. This gives each point probability 1/|X|. Requires |X| > 0 (nonempty).
```
(X : Type u) → [inst : MeasurableSpace X] → [Fintype X] → Nonempty X → MeasureTheory.Measure X
```

DefinitionuniformPMFdef

Uniform PMF over a nonempty Fintype.

(C : Type u_1) → [inst : Fintype C] → [Nonempty C] → FinitePMF C

DefinitionzeroOneLossdef
The 0-1 loss for classification.
```
(Y : Type v) → [DecidableEq Y] → LossFunction Y
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

The fundamental theorem of statistical learning. For a measurable concept class, finite VC dimension, eventually polynomial growth, and PAC learnability are mutually equivalent.

DeclvcDim_fundamental_theorem

∀ {X : Type u} [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
  [MeasurableConceptClass X C],
  (VCDim X C < ⊤ ↔ PACLearnable X C) ∧
    (VCDim X C < ⊤ ↔ ∃ K d, ∀ᶠ (m : ℕ) in Filter.atTop, ↑(GrowthFunction X C m) ≤ K * ↑m ^ d)

ThesisStepDefinition

DeclvcDim_fundamental_theoremDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
  [MeasurableConceptClass X C],
  (VCDim X C < ⊤ ↔ PACLearnable X C) ∧
    (VCDim X C < ⊤ ↔ ∃ K d, ∀ᶠ (m : ℕ) in Filter.atTop, ↑(GrowthFunction X C m) ≤ K * ↑m ^ d)

ConceptClass GrowthFunction MeasurableConceptClass PACLearnable VCDim

Uses

vcDim_lt_top_iff_growth_poly
vcDim_lt_top_iff_pacLearnable

DeclvcDim_lt_top_iff_pacLearnableDeclaration kindtheorem
Finite VC dimension ⟺ PAC learnability. The measure-theoretic half: VCDim X C < ⊤ exactly when C is PAC learnable. This is the kernel's vc_characterization, surfaced for the independent module; it requires the domain's measurability structure.
```
∀ {X : Type u} [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
 [MeasurableConceptClass X C], VCDim X C < ⊤ ↔ PACLearnable X C
```
ConceptClass MeasurableConceptClass PACLearnable VCDim
Uses
- vc_characterization
Used by
- vcDim_fundamental_theorem
Declvc_characterizationDeclaration kindtheorem
VC characterization: C is PAC-learnable iff VCDim(C) < ∞.
PROOF DECOMPOSITION: This theorem factors through the two directions above: ← : vcdim_finite_imp_uc + uc_imp_pac (in Generalization.lean) → : pac_imp_vcdim_finite (contrapositive via double-sample)
HC at this joint: The ← direction crosses from combinatorics (VCDim, GrowthFunction) to measure theory (Measure.pi, TrueError). The → direction crosses from measure theory back to combinatorics. Both crossings have HC > 0.
UK₈: The ↔ hides an ASYMMETRY: the ← proof is constructive (produces ERM), while the → proof is non-constructive (produces hard distribution).
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool)
 [MeasurableConceptClass X C], PACLearnable X C ↔ VCDim X C < ⊤
```
ConceptClass MeasurableConceptClass PACLearnable VCDim
Uses
- pac_imp_vcdim_finite
- vcdim_finite_imp_pac
Used by
- vcDim_lt_top_iff_pacLearnable
Declvcdim_finite_imp_pacDeclaration kindtheorem
Direction ←: finite VCDim implies PAC learnability.
PROOF ROUTE (via new infrastructure in Generalization.lean): Step 1: VCDim < ∞ → HasUniformConvergence (vcdim_finite_imp_uc) Sub-step 1a: Sauer-Shelah gives GrowthFunction bound Sub-step 1b: Symmetrization reduces UC to growth function counting Sub-step 1c: Concentration inequality closes the bound Step 2: HasUniformConvergence → PACLearnable (uc_imp_pac) Sub-step 2a: Construct ERM learner Sub-step 2b: ERM is consistent in realizable case Sub-step 2c: Consistent + UC → low TrueError
KU₁₈: C.Nonempty is needed for ERM but not stated as hypothesis. If C = ∅, then PACLearnable is vacuously true (∀ c ∈ C, ... is vacuous). But ERM needs a fallback hypothesis from C. Is this a genuine gap or does the empty case work out vacuously?
Counterdefinition (COUNTER-4): If the ERM approach fails for computational reasons (ERM is noncomputable, and we need a computable learner for computational learning theory), swap to the compression-based proof: VCDim < ∞ → finite compression scheme (Moran-Yehudayoff 2016) → compression scheme learner is PAC. Swap condition: When proving COMPUTATIONAL PAC learnability (polynomial time).
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool),
 VCDim X C < ⊤ → ∀ [MeasurableConceptClass X C], PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept MeasurableConceptClass PACLearnable VCDim WellBehavedVC
Uses
Used by
- vc_characterization
Declvcdim_finite_imp_uc'Declaration kindtheorem
Finite VCDim implies uniform convergence. Proof: VCDim < ∞ → UC.
- Finite X: direct Hoeffding per-hypothesis + finite union bound.
- Infinite X: Sauer-Shelah → symmetrization + growth function → UC.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
 VCDim X C < ⊤ →
 (∀ h ∈ C, Measurable h) → (∀ (c : Concept X Bool), Measurable c) → WellBehavedVC X C → HasUniformConvergence X C
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction HasUniformConvergence HypothesisSpace TrueErrorReal VCDim WellBehavedVC zeroOneLoss
Uses
Used by
- vcdim_finite_imp_pac

Decluc_bad_event_le_delta_provedDeclaration kindtheorem

UC bad-event bound: for m ≥ m₀(v,ε,δ), the probability of the bad event (∃ h with |TrueErr-EmpErr| ≥ ε) is at most δ. Composes symmetrization_uc_bound with growth_exp_le_delta.

∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε δ : ℝ),
            0 < ε →
              0 < δ →
                δ < 1 →
                  ∀ (v : ℕ),
                    0 < v →
                      (∀ (n : ℕ), v ≤ n → GrowthFunction X C n ≤ ∑ i ∈ Finset.range (v + 1), n.choose i) →
                        (16 * Real.exp 1 * (↑v + 1) / ε ^ 2) ^ (v + 1) / δ ≤ ↑m →
                          MeasureTheory.NullMeasurableSet
                              {p |
                                ∃ h ∈ C,
                                  EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                                      EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                                    ε / 2}
                              ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
                            (MeasureTheory.Measure.pi fun x => D)
                                {xs |
                                  ∃ h ∈ C,
                                    |TrueErrorReal X h c D -
                                          EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool)| ≥
                                      ε} ≤
                              ENNReal.ofReal δ

ConceptClass EmpiricalError FLT.Concept GrowthFunction TrueErrorReal zeroOneLoss

Uses

growth_exp_le_delta
symmetrization_uc_bound

Used by

vcdim_finite_imp_uc'

Declsymmetrization_uc_boundDeclaration kindtheorem
The symmetrization uniform convergence bound: two-sided version. P[∃h∈C: |TrueErr-EmpErr| ≥ ε] ≤ 4·GF(C,2m)·exp(-mε²/8).
Proof strategy (4 steps):
1. Decompose absolute value: |TrueErr - EmpErr| ≥ ε ↔ (TrueErr - EmpErr ≥ ε) ∨ (EmpErr - TrueErr ≥ ε)
have abs_decomp : ∀ (a b : ℝ), |a - b| ≥ ε ↔ a - b ≥ ε ∨ b - a ≥ ε := by intro a b; constructor · intro h; by_cases h' : a - b ≥ ε · exact Or.inl h' · exact Or.inr (by linarith [abs_sub_comm a b, le_abs_self (a - b)]) · intro h; cases h with | inl h => exact le_trans (le_of_eq (abs_of_nonneg (by linarith))) (by linarith) | inr h => exact le_trans (le_of_eq (abs_of_nonpos (by linarith) ▸ ...)) ...
2. Upper tail: P[∃h∈C: TrueErr-EmpErr ≥ ε] ≤ 2·GF(C,2m)·exp(-mε²/8)
- Direct application of symmetrization_step + double_sample_pattern_bound.
3. Lower tail: P[∃h∈C: EmpErr-TrueErr ≥ ε] ≤ 2·GF(C,2m)·exp(-mε²/8)
- Apply the symmetric argument: swap roles of S and S' in the double sample.
- Equivalently, apply symmetrization_step to the event EmpErr-TrueErr ≥ ε and bound the double-sample event {EmpErr_S - EmpErr_{S'} ≥ ε/2}.
- The bound is symmetric because D^m ⊗ D^m is symmetric under swapping factors. have swap_symmetry : DoubleSampleMeasure D m {p | ∃ h ∈ C, EmpErr(S) - EmpErr(S') ≥ ε/2} = DoubleSampleMeasure D m {p | ∃ h ∈ C, EmpErr(S') - EmpErr(S) ≥ ε/2} := Measure.prod_swap ...
4. Union bound: P[|gap| ≥ ε] ≤ P[gap ≥ ε] + P[gap ≤ -ε] ≤ 2·GF·exp(...) + 2·GF·exp(...) = 4·GF(C,2m)·exp(-mε²/8)
-- Uses: MeasureTheory.measure_union_le for the union of two events -- CAST: 2 * X + 2 * X = 4 * X in ENNReal (need ENNReal.add_mul or similar)
References: SSBD Theorem 6.7, Kakade-Tewari Lecture 19
```
∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
 [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 2 * Real.log 2 ≤ ↑m * ε ^ 2 →
 MeasureTheory.NullMeasurableSet
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 ∃ h ∈ C,
 |TrueErrorReal X h c D -
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool)| ≥
 ε} ≤
 ENNReal.ofReal (4 * ↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction TrueErrorReal zeroOneLoss
Uses
Used by
- uc_bad_event_le_delta_proved

Declsymmetrization_step_lowerDeclaration kindtheorem

Symmetrization step for the lower tail: P[∃h: EmpErr-TrueErr ≥ ε] ≤ 2·P_{double}[∃h: EmpErr_S-EmpErr_{S'} ≥ ε/2].

Mirror of symmetrization_step for the opposite direction. Uses hoeffding_one_sided_upper instead of hoeffding_one_sided.

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε : ℝ),
            0 < ε →
              2 * Real.log 2 ≤ ↑m * ε ^ 2 →
                (MeasureTheory.Measure.pi fun x => D)
                    {xs |
                      ∃ h ∈ C,
                        EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) - TrueErrorReal X h c D ≥
                          ε} ≤
                  2 *
                    ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
                      {p |
                        ∃ h ∈ C,
                          EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) -
                              EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) ≥
                            ε / 2}

ConceptClass EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Uses

hoeffding_one_sided_upper

Used by

symmetrization_uc_bound

Declsymmetrization_stepDeclaration kindtheorem
Symmetrization: the probability of a large gap TrueErr-EmpErr is at most twice the probability of a large gap EmpErr'-EmpErr on the double sample.
Proof strategy (6 steps):
1. Witness selection: For S in the bad event, ∃h* ∈ C with TrueErr(h) - EmpErr_S(h) ≥ ε.
-- In the bad event set, extract h* by classical choice have h_witness : ∀ xs ∈ bad_event, ∃ h* ∈ C, TrueErrorReal X h* c D - EmpiricalError X Bool h* (sample xs) (zeroOneLoss Bool) ≥ ε
2. Ghost sample mean: E_{S'}[EmpErr_{S'}(h)] = TrueErr(h) ≥ EmpErr_S(h*) + ε.
- Uses: MeasureTheory.integral_pi to compute E[EmpErr] over product measure.
- KEY LEMMA: For fixed h, E_{D^m}[EmpiricalError(h,S)] = TrueErrorReal(h,c,D). This is because EmpErr = (1/m)∑ indicator(x_i), and E[indicator(x_i)] = TrueErrorReal. have expected_emp_err : ∀ h* : Concept X Bool, ∫ xs, EmpiricalError X Bool h* (sample xs) (zeroOneLoss Bool) ∂(Measure.pi (fun _ : Fin m => D)) = TrueErrorReal X h* c D := by ...
3. Hoeffding on ghost sample: P_{S'}[EmpErr_{S'}(h) < TrueErr(h) - ε/2] ≤ exp(-mε²/2).
- Apply hoeffding_one_sided with t = ε/2.
- The hm_large hypothesis ensures exp(-mε²/2) < 1/2: 2·ln2 ≤ mε² ⟹ mε²/2 ≥ ln2 ⟹ exp(-mε²/2) ≤ 1/2. have hoeffding_ghost : ∀ h* ∈ C, Measure.pi (fun _ : Fin m => D) {xs' | EmpiricalError X Bool h* (sample xs') (zeroOneLoss Bool) < TrueErrorReal X h* c D - ε/2} ≤ ENNReal.ofReal (Real.exp (-m * (ε/2)^2 * 2)) := by intro h* _; exact hoeffding_one_sided D h* c m hm (ε/2) (by linarith) (by ...) (by ...)
4. Complementary probability: P_{S'}[EmpErr_{S'}(h) - EmpErr_S(h) ≥ ε/2] ≥ 1/2.
- From step 2: TrueErr(h) ≥ EmpErr_S(h) + ε
- From step 3: P[EmpErr_{S'} ≥ TrueErr - ε/2] ≥ 1/2
- Chain: EmpErr_{S'} ≥ TrueErr - ε/2 ≥ EmpErr_S + ε - ε/2 = EmpErr_S + ε/2
5. Conditional to unconditional: The witness h* from step 1 also witnesses the double-sample event ∃h∈C: EmpErr'-EmpErr ≥ ε/2. So: P_{S'}[double event | S bad] ≥ 1/2.
have conditional_bound : ∀ xs ∈ bad_event, Measure.pi (fun _ : Fin m => D) {xs' | ∃ h ∈ C, EmpiricalError ... xs' - EmpiricalError ... xs ≥ ε/2} ≥ ENNReal.ofReal (1/2) := by ...
6. Fubini integration: By Measure.prod_apply and Fubini: P_{S,S'}[double event] = ∫_S P_{S'}[double event | S] ≥ (1/2) · P_S[bad event] ⟹ P_S[bad event] ≤ 2 · P_{S,S'}[double event].
-- Uses: MeasureTheory.Measure.prod_apply or lintegral_prod -- MEASURABILITY: the double-sample event is measurable as a finite union -- of sets of the form {(xs,xs') | EmpErr'(h) - EmpErr(h) ≥ ε/2} for h ∈ C. -- Since C may be infinite, measurability requires care: the sup over h -- must be shown to be measurable. For finite restriction patterns (≤ 2^m -- on Fin m → Bool), this is a finite union.
MEASURABILITY CONCERNS:
- {xs | ∃ h ∈ C, ...} is NOT obviously measurable for infinite C. Strategy: decompose via restriction patterns. On any fixed xs, the set of labelings {(h(xs 0), ..., h(xs(m-1))) | h ∈ C} has at most GF(C,m) ≤ 2^m elements. So the ∃h event is a finite union of measurable sets.
- EmpiricalError is a finite sum of measurable functions, hence measurable.
- The product σ-algebra on (Fin m → X) × (Fin m → X) is generated by cylinder sets, and our events are in this σ-algebra.
References: SSBD Lemma 4.5, Kakade-Tewari Lecture 19 Lemma 1
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 2 * Real.log 2 ≤ ↑m * ε ^ 2 →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 ∃ h ∈ C,
 TrueErrorReal X h c D - EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥
 ε} ≤
 2 *
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
```
ConceptClass EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Uses
- hoeffding_one_sided
Used by
- symmetrization_uc_bound
Decldouble_sample_pattern_boundDeclaration kindtheorem
On the double sample, the probability that any hypothesis has EmpErr' - EmpErr ≥ ε/2 is bounded by GF(C,2m) · exp(-mε²/8).
Proof strategy (Approach A — standard exchangeability, 5 steps):
1. EXCHANGEABILITY: Under D^m ⊗ D^m, the 2m draws z₁,...,z_{2m} are iid from D. The joint distribution is invariant under permutations of {1,...,2m}.
Key lemma: P_{D^m⊗D^m}[event(S,S')] = E_z[P_{split}[event | z]] where z = merged sample and the split is uniformly random among all C(2m,m) ways to partition z into two groups of m.
-- Measure.pi permutation invariance have pi_perm_invariant : ∀ (σ : Equiv.Perm (Fin (2*m))), (Measure.pi (fun _ : Fin (2*m) => D)).map (fun z i => z (σ i)) = Measure.pi (fun _ : Fin (2*m) => D) := by ... -- Consequence: the event probability equals the split-averaged probability have exchangeability : DoubleSampleMeasure D m {p | ∃ h ∈ C, gap(p) ≥ ε/2} = ∫ z, SplitMeasure m {vs | ∃ h ∈ C, gap(split z vs) ≥ ε/2} ∂(Measure.pi (fun _ : Fin (2*m) => D)) := by ...
2. CONDITIONING: For fixed merged sample z of 2m points:
- C restricts to at most GF(C,2m) distinct labeling patterns on z (deterministic).
- For each pattern p, define: diff(p, split) = EmpErr_{S'}(p) - EmpErr_S(p) = (1/m) ∑_{i∈S'} a_i - (1/m) ∑_{i∈S} a_i where a_i = 1[pattern(z_i) ≠ c(z_i)] ∈ {0,1}.
-- Number of distinct patterns have num_patterns : ∀ (z : MergedSample X m), Set.ncard {p : Fin (2*m) → Bool | ∃ h ∈ C, ∀ i, p i = (h (z i) ≠ c (z i))} ≤ GrowthFunction X C (2*m) := by ...
3. PER-PATTERN HOEFFDING ON SPLITS: For fixed z and fixed pattern p: Under uniformly random split (S,S') of z into two groups of m: diff(p, split) = (1/m) ∑_{i∈S'} a_i - (1/m) ∑_{i∈S} a_i
This is a function of the random partition. By Hoeffding's inequality for sampling without replacement (Serfling 1974): P_split[diff ≥ ε/2] ≤ exp(-mε²/8)
Alternative derivation: Hoeffding without replacement from Hoeffding with replacement (iid signs) via coupling. The without-replacement bound is actually TIGHTER (variance reduction), but the with-replacement bound suffices.
-- Per-pattern concentration have per_pattern_bound : ∀ (z : MergedSample X m) (a : Fin (2*m) → ℝ) (ha : ∀ i, a i ∈ Set.Icc 0 1), SplitMeasure m {vs | (1/m) * ∑ i ∈ second_group vs, a i - (1/m) * ∑ i ∈ first_group vs, a i ≥ ε/2} ≤ ENNReal.ofReal (Real.exp (-(m : ℝ) * (ε/2)^2 / 2)) := by ... -- Note: m*(ε/2)^2/2 = mε²/8
4. UNION BOUND: P_split[∃ pattern: diff ≥ ε/2 | z] ≤ (number of patterns) · max_pattern P_split[diff ≥ ε/2] ≤ GF(C,2m) · exp(-mε²/8)
have union_bound : ∀ (z : MergedSample X m), SplitMeasure m {vs | ∃ h ∈ C, gap(split z vs, h) ≥ ε/2} ≤ ENNReal.ofReal (GrowthFunction X C (2*m) * Real.exp (-(m : ℝ) * ε^2 / 8)) := by ...
5. INTEGRATE: P_{D^m⊗D^m}[event] = E_z[P_split[event|z]] (by step 1) ≤ E_z[GF(C,2m) · exp(-mε²/8)] (by step 4, pointwise) = GF(C,2m) · exp(-mε²/8) (bound is independent of z)
-- The bound is a constant, so integrating gives the same constant -- (using IsProbabilityMeasure for the 2m-fold product)
Infrastructure needed:
- Fin.sumFinEquiv : Fin m ⊕ Fin n ≃ Fin (m + n) (available in Mathlib)
- mergeSamples / splitMergedSample (defined above)
- SplitMeasure and ValidSplit (defined above)
- Measure.pi permutation invariance (to be proved or imported)
- Hoeffding for sampling without replacement
- GrowthFunction on 2m points + sauer_shelah_exp_bound from Rademacher.lean
MEASURABILITY CONCERNS:
- The merged sample z ↦ P_split[event|z] must be measurable as a function of z. Since the event is a finite union over patterns, and each pattern's indicator is a measurable function of z (finite evaluation), this follows.
- GrowthFunction X C (2*m) is a natural number (deterministic), no measurability issue.
References: SSBD Theorem 6.7, Hoeffding (1963), Serfling (1974)
```
∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
 [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 MeasureTheory.NullMeasurableSet
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2} ≤
 ENNReal.ofReal (↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction zeroOneLoss
Uses
- exchangeability_chain_bound
Used by
- symmetrization_uc_bound

Declexchangeability_chain_boundDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε : ℝ),
            0 < ε →
              ε ≤ 2 →
                Set.Nonempty C →
                  MeasureTheory.NullMeasurableSet
                      {p |
                        ∃ h ∈ C,
                          EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                              EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                            ε / 2}
                      ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
                    have μ := MeasureTheory.Measure.pi fun x => D;
                    (μ.prod μ)
                        {p |
                          ∃ h ∈ C,
                            EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                                EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                              ε / 2} ≤
                      ENNReal.ofReal (↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))

ConceptClass EmpiricalError FLT.Concept GrowthFunction SignVector boolToSign zeroOneLoss

Uses

finite_exchangeability_bound
rademacher_mgf_bound
restriction_pattern_count
zeroOneLoss.congr_simp

Used by

double_sample_pattern_bound

DeclzeroOneLoss.congr_simpDeclaration kindtheorem

∀ (Y : Type v) {inst : DecidableEq Y} [inst_1 : DecidableEq Y] (a a_1 : Y),
  a = a_1 → ∀ (a_2 a_3 : Y), a_2 = a_3 → zeroOneLoss Y a a_2 = zeroOneLoss Y a_1 a_3

zeroOneLoss

Used by

exchangeability_chain_bound

Declrestriction_pattern_countDeclaration kindtheorem
The number of distinct restriction patterns of C on any n points is at most GF(C,n). For z : Fin n → X, define patterns(z) = {p : Fin n → Bool | ∃ h ∈ C, ∀ i, p i = (h(z i) ≠ c(z i))}. Then patterns(z).ncard ≤ GrowthFunction X C n by definition of GrowthFunction.
```
∀ {X : Type u} [MeasurableSpace X] [Infinite X] (C : ConceptClass X Bool) (c : Concept X Bool) (n : ℕ) (z : Fin n → X),
  {p | ∃ h ∈ C, ∀ (i : Fin n), p i = decide (h (z i) ≠ c (z i))}.ncard ≤ GrowthFunction X C n
```
ConceptClass FLT.Concept GrowthFunction
Used by
- exchangeability_chain_bound

Declrademacher_mgf_boundDeclaration kindtheorem

Rademacher MGF bound.

∀ {m : ℕ},
  0 < m →
    ∀ (a : Fin m → ℝ) (c : ℝ),
      0 ≤ c →
        (∀ (i : Fin m), |a i| ≤ c) →
          ∀ (t : ℝ),
            0 ≤ t →
              1 / ↑(Fintype.card (SignVector m)) * ∑ σ, Real.exp (t * (1 / ↑m * ∑ i, a i * boolToSign (σ i))) ≤
                Real.exp (t ^ 2 * c ^ 2 / (2 * ↑m))

SignVector boolToSign

Uses

cosh_le_exp_sq_half

Used by

exchangeability_chain_bound

Declcosh_le_exp_sq_halfDeclaration kindtheorem
cosh(x) ≤ exp(x²/2). Standard sub-Gaussian bound.
```
∀ (x : ℝ), Real.cosh x ≤ Real.exp (x ^ 2 / 2)
```
Used by
- rademacher_mgf_bound

Declfinite_exchangeability_boundDeclaration kindtheorem

∀ {Ω : Type u_1} {G : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : Fintype G] [Nonempty G]
  {ν : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure ν] (T : G → Ω → Ω) (S : Set Ω),
  (∀ (g : G), MeasureTheory.MeasurePreserving (T g) ν ν) →
    MeasureTheory.NullMeasurableSet S ν →
      ∀ (B : ENNReal), (∀ (z : Ω), ∑ g, (T g ⁻¹' S).indicator 1 z ≤ B * ↑(Fintype.card G)) → ν S ≤ B

Used by

exchangeability_chain_bound

Declgrowth_exp_le_deltaDeclaration kindtheorem

∀ {X : Type u} [MeasurableSpace X] (C : ConceptClass X Bool) (v : ℕ),
  0 < v →
    ∀ (m : ℕ),
      0 < m →
        ∀ (ε δ : ℝ),
          0 < ε →
            0 < δ →
              δ < 1 →
                (∀ (n : ℕ), v ≤ n → GrowthFunction X C n ≤ ∑ i ∈ Finset.range (v + 1), n.choose i) →
                  (16 * Real.exp 1 * (↑v + 1) / ε ^ 2) ^ (v + 1) / δ ≤ ↑m →
                    4 * ↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)) ≤ δ ∧ 2 * Real.log 2 ≤ ↑m * ε ^ 2

ConceptClass GrowthFunction

Uses

growth_function_le_two_pow
pow_mul_exp_neg_le_factorial_div
sum_choose_le_exp_pow

Used by

uc_bad_event_le_delta_proved

Declsum_choose_le_exp_powDeclaration kindtheorem
Pure combinatorial inequality: ∑_{i=0}^d C(m,i) ≤ (em/d)^d for d ≤ m, d ≥ 1.
```
∀ (d m : ℕ), 0 < d → d ≤ m → ∑ i ∈ Finset.range (d + 1), ↑(m.choose i) ≤ (Real.exp 1 * ↑m / ↑d) ^ d
```
Used by
- growth_exp_le_delta
Declpow_mul_exp_neg_le_factorial_divDeclaration kindtheorem
Key arithmetic lemma for PAC bound: for t > 0, t^d * exp(-t) ≤ (d+1)!/t. Follows from exp(t) ≥ t^(d+1)/(d+1)! (partial sum of Taylor series).
```
∀ {d : ℕ} {t : ℝ}, 0 < t → t ^ d * Real.exp (-t) ≤ ↑(d + 1).factorial / t
```
Used by
- growth_exp_le_delta
Declgrowth_function_le_two_powDeclaration kindtheorem
Trivial bound: GrowthFunction ≤ 2^n for all concept classes. Each restriction to an n-element set yields a function in S → Bool, and there are at most 2^n such functions.
```
∀ {X : Type u} (C : ConceptClass X Bool) (n : ℕ), GrowthFunction X C n ≤ 2 ^ n
```
ConceptClass FLT.Concept GrowthFunction
Used by
- growth_exp_le_delta

Declhoeffding_one_sided_upperDeclaration kindtheorem

Upper-tail Hoeffding: for iid Bernoulli(p) draws, the empirical average overshoots the mean by ≥ t with probability ≤ exp(-2mt²).

This is the mirror of hoeffding_one_sided (which bounds the lower tail). The proof uses the same sub-Gaussian machinery with Z_i = indicator(x_i) - p (instead of p - indicator(x_i)).

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (h c : Concept X Bool) (m : ℕ),
  0 < m →
    ∀ (t : ℝ),
      0 < t →
        t ≤ 1 →
          MeasurableSet {x | h x ≠ c x} →
            (MeasureTheory.Measure.pi fun x => D)
                {xs |
                  EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥ TrueErrorReal X h c D + t} ≤
              ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))

EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Used by

symmetrization_step_lower
vcdim_finite_imp_uc'

Declhoeffding_one_sidedDeclaration kindtheorem
One-sided Hoeffding: for iid Bernoulli(p) draws, the empirical average undershoots the mean by ≥ t with probability ≤ exp(-2mt²).
Proof strategy (3 steps):
1. MGF bound (Hoeffding's lemma): For X ∈ [0,1] with E[X] = p, E[exp(s(X-p))] ≤ exp(s²/8).
- Adapt from cosh_le_exp_sq_half infrastructure in Rademacher.lean.
- Key: convexity of exp on [0,1] gives E[exp(sX)] ≤ p·exp(s) + (1-p)·exp(0), then the s²/8 bound follows from ln(1 + x) ≤ x and Taylor expansion. have mgf_bound : ∀ (s : ℝ), ∫ x, Real.exp (s * (indicator x - p)) ∂D ≤ Real.exp (s^2 / 8) := by ...
2. Product independence: E[exp(s·∑(X_i-p))] = ∏ E[exp(s(X_i-p))] ≤ exp(ms²/8).
- Uses MeasureTheory.Measure.pi independence structure.
- Needs: Measure.pi integral factorization for product of functions.
- MEASURABILITY: fun xs => Real.exp (s * ∑ i, f (xs i)) is measurable (composition of measurable functions). have product_bound : ∀ (s : ℝ), ∫ xs, Real.exp (s * ∑ i, (indicator (xs i) - p)) ∂Measure.pi (fun _ => D) ≤ Real.exp (m * s^2 / 8) := by ...
3. Exponential Markov + optimize: P[∑(X_i-p) ≤ -mt] = P[exp(-s·∑(X_i-p)) ≥ exp(smt)] ≤ exp(-smt + ms²/8). Optimize over s: set s = 4t to get ≤ exp(-2mt²).
- Uses Markov's inequality in ENNReal form.
- CAST ISSUE: Markov gives ENNReal bound, need to convert exp(-2mt²) between ENNReal.ofReal and the measure value. have markov_step : ∀ (s : ℝ) (hs : 0 < s), Measure.pi (fun _ => D) {xs | ∑ i, (indicator (xs i) - p) ≤ -(m : ℝ) * t} ≤ ENNReal.ofReal (Real.exp (-(s * m * t) + m * s^2 / 8)) := by ... have optimize : Real.exp (-(4*t * m * t) + m * (4*t)^2 / 8) = Real.exp (-2 * m * t^2) := by ring_nf
CAST ISSUES to watch:
- m : ℕ needs cast to ℝ in the exponent: (m : ℝ)
- EmpiricalError returns ℝ, TrueErrorReal returns ℝ, good — no ENNReal gap
- The measure value is ENNReal, the bound exp(-2mt²) is ℝ≥0∞ via ENNReal.ofReal
References: SSBD Lemma B.3, Hoeffding (1963)
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (h c : Concept X Bool) (m : ℕ),
 0 < m →
 ∀ (t : ℝ),
 0 < t →
 t ≤ 1 →
 MeasurableSet {x | h x ≠ c x} →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≤ TrueErrorReal X h c D - t} ≤
 ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))
```
EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Used by
- symmetrization_step
- vcdim_finite_imp_uc'
Decluc_imp_pacDeclaration kindtheorem
Uniform convergence implies PAC learnability via ERM. The ERM learner (which exists by ermLearn) achieves PAC learning when uniform convergence holds. This is the second half of vcdim_finite_imp_pac.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
  Set.Nonempty C → HasUniformConvergence X C → PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass EmpiricalError FLT.Concept HasUniformConvergence HypothesisSpace IsConsistentWith PACLearnable TrueError TrueErrorReal zeroOneLoss
Uses
- BatchLearner.output_in_H
Used by
- vcdim_finite_imp_pac
DeclBatchLearner.output_in_HDeclaration kindtheorem
Output is in the hypothesis space
```
∀ {X : Type u} {Y : Type v} (self : BatchLearner X Y) {m : ℕ} (S : Fin m → X × Y), self.learn S ∈ self.hypotheses
```
BatchLearner BatchLearner.hypotheses BatchLearner.learn FLT.Concept HypothesisSpace
Used by
- uc_imp_pac
DeclMeasurableConceptClass.hmeas_CDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C],
  ∀ c ∈ C, Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Uses
- MeasurableConceptClass.mem_measurable
Used by
- vcdim_finite_imp_pac
DeclMeasurableConceptClass.mem_measurableDeclaration kindtheorem
Every concept in C is measurable
```
∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : MeasurableConceptClass X C],
  ∀ h ∈ C, Measurable h
```
ConceptClass FLT.Concept MeasurableConceptClass
Used by
- MeasurableConceptClass.hmeas_C
DeclMeasurableConceptClass.hc_measDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C]
  (c : Concept X Bool), Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Uses
- MeasurableConceptClass.all_measurable
Used by
- vcdim_finite_imp_pac
DeclMeasurableConceptClass.all_measurableDeclaration kindtheorem
All concepts X → Bool are measurable (for disagreement sets)
```
∀ {X : Type u} {inst : MeasurableSpace X} (C : ConceptClass X Bool) [self : MeasurableConceptClass X C]
  (c : Concept X Bool), Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Used by
- MeasurableConceptClass.hc_meas
DeclMeasurableConceptClass.hWBDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C], WellBehavedVC X C
```
ConceptClass MeasurableConceptClass WellBehavedVC
Uses
- MeasurableConceptClass.wellBehaved
Used by
- vcdim_finite_imp_pac
DeclMeasurableConceptClass.wellBehavedDeclaration kindtheorem
Uniform convergence bad event is NullMeasurableSet
```
∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : MeasurableConceptClass X C],
  WellBehavedVC X C
```
ConceptClass MeasurableConceptClass WellBehavedVC
Used by
- MeasurableConceptClass.hWB
Declpac_imp_vcdim_finiteDeclaration kindtheorem
Direction →: PAC learnability implies finite VCDim.
PROOF ROUTE (via double-sample infrastructure in Generalization.lean): Step 1: Contrapositive — assume VCDim = ∞ Step 2: For m = mf(ε,δ), extract S with |S| = 2m shattered by C (uses WithTop.eq_top_iff_forall_ge, same as vcdim_univ_infinite) Step 3: Construct D = uniform on S (Finset.uniformMeasure?) KU₁₉: Mathlib's uniform measure on a finite set — does MeasureTheory.Measure.count / Finset.card give IsProbabilityMeasure? Step 4: Double-sample trick via GhostSample + symmetrization Step 5: Counting argument on restricted labelings
HC at this joint: Step 3 requires constructing a specific probability measure from a combinatorial object (the shattered set). This is a P₁→P₂ crossing. UK₉: The construction of the hard distribution is the only non-constructive step. Can it be made constructive? (Related to derandomization in learning.)
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool),
 PACLearnable X C → VCDim X C < ⊤
```
ConceptClass PACLearnable VCDim
Uses
- vcdim_infinite_not_pac
Used by
- vc_characterization
Declvcdim_infinite_not_pacDeclaration kindtheorem
If VCDim = ⊤, then C is not PAC learnable. Proof: for any learner L with sample function mf, pick ε = 1/4, δ = 1/4. Let m = mf(1/4, 1/4). Since VCDim = ⊤, ∃ shattered set S with |S| ≥ 2m. Put D = uniform on S. For random labeling, any m-sample learner has expected error ≥ 1/4 on unseen points. This is the core of pac_imp_vcdim_finite (contrapositive direction).
```
∀ (X : Type u) [inst : MeasurableSpace X] [MeasurableSingletonClass X] (C : ConceptClass X Bool),
  VCDim X C = ⊤ → ¬PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept PACLearnable Shatters VCDim uniformMeasure
Uses
- nfl_counting_core
- uniformMeasure_isProbability
Used by
- pac_imp_vcdim_finite

DecluniformMeasure_isProbabilityDeclaration kindtheorem

The uniform measure is a probability measure when X is nonempty and finite.

∀ (X : Type u) [inst : MeasurableSpace X] [inst_1 : Fintype X] [MeasurableSingletonClass X] (hne : Nonempty X),
  0 < Fintype.card X → MeasureTheory.IsProbabilityMeasure (uniformMeasure X hne)

uniformMeasure

Used by

vcdim_infinite_not_pac

Declnfl_counting_coreDeclaration kindtheorem
NFL counting core: for a shattered set T with |T| > 2m, there exists a labeling f₀ : ↥T → Bool and its shattering witness c₀ ∈ C such that the number of samples xs : Fin m → ↥T where the learner achieves low error (≤ |T|/4) is at most half the total number of samples. Proof: double-counting + pigeonhole using per_sample_labeling_bound.
```
∀ {X : Type u} {C : ConceptClass X Bool} {T : Finset X},
 Shatters X C T →
 ∀ {m : ℕ},
 2 * m < T.card →
 ∀ (L : BatchLearner X Bool),
 ∃ f₀,
 ∃ c₀ ∈ C,
 (∀ (t : ↥T), c₀ ↑t = f₀ t) ∧
 2 * {xs | {t | c₀ ↑t ≠ L.learn (fun i => (↑(xs i), c₀ ↑(xs i))) ↑t}.card * 4 ≤ T.card}.card ≤
 Fintype.card (Fin m → ↥T)
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept Shatters
Uses
- per_sample_labeling_bound
Used by
- vcdim_infinite_not_pac
Declper_sample_labeling_boundDeclaration kindtheorem
Per-sample labeling bound: for any fixed xs : Fin m → α on a Fintype α with 2m < |α|, and any function output : (α → Bool) → (α → Bool) that only depends on the restriction of f to {xs i}, at most half the labelings f : α → Bool have error(f, output(f)) * 4 ≤ |α|.
Proof: pair each f with flip_unseen(f). The pair has complementary disagreements on unseen points, and |unseen| > |α|/2, so at most one can have low error.
```
∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (m : ℕ),
 2 * m < Fintype.card α →
 ∀ (xs : Fin m → α) (output : (α → Bool) → α → Bool),
 (∀ (f f' : α → Bool), (∀ (i : Fin m), f (xs i) = f' (xs i)) → output f = output f') →
 2 * {f | {t | f t ≠ output f t}.card * 4 ≤ Fintype.card α}.card ≤ Fintype.card (α → Bool)
```
Used by
- nfl_counting_core
DeclvcDim_lt_top_iff_growth_polyDeclaration kindtheorem
Finite VC dimension ⟺ eventually polynomial growth. The purely combinatorial half of the fundamental theorem: VCDim X C < ⊤ exactly when the growth function is eventually bounded by a polynomial.
```
∀ {X : Type u} {C : ConceptClass X Bool},
 VCDim X C < ⊤ ↔ ∃ K d, ∀ᶠ (m : ℕ) in Filter.atTop, ↑(GrowthFunction X C m) ≤ K * ↑m ^ d
```
ConceptClass GrowthFunction VCDim
Uses
- vcDim_finite_imp_growth_poly
- vcDim_lt_top_of_growth_poly
Used by
- vcDim_fundamental_theorem
DeclvcDim_lt_top_of_growth_polyDeclaration kindtheorem
Polynomial growth implies finite VC dimension. If GrowthFunction X C m ≤ K · m ^ d for all large m, then VCDim X C < ⊤: an infinite VC dimension produces shattered sets of every size, forcing 2 ^ m ≤ K · m ^ d for arbitrarily large m, which is impossible. The hypothesis is the eventually filter (the ∀ m form is unsatisfiable at m = 0); Sauer-Shelah supplies it for m ≥ d.
```
∀ {X : Type u} {C : ConceptClass X Bool} (K : ℝ) (d : ℕ),
 (∀ᶠ (m : ℕ) in Filter.atTop, ↑(GrowthFunction X C m) ≤ K * ↑m ^ d) → VCDim X C < ⊤
```
ConceptClass GrowthFunction VCDim
Uses
- no_eventually_two_pow_le_poly
- two_pow_le_growthFunction_of_top
Used by
- vcDim_lt_top_iff_growth_poly
Decltwo_pow_le_growthFunction_of_topDeclaration kindtheorem
An infinite VC dimension forces the growth function to be at least 2 ^ m at every size: it shatters sets of every size, by iSup₂_eq_top and downward closure.
```
∀ {X : Type u} {C : ConceptClass X Bool}, VCDim X C = ⊤ → ∀ (m : ℕ), 2 ^ m ≤ GrowthFunction X C m
```
ConceptClass GrowthFunction Shatters VCDim
Uses
- growthFunction_ge_two_pow_of_shatters
- shatters_of_subset
Used by
- vcDim_lt_top_of_growth_poly
Declshatters_of_subsetDeclaration kindtheorem
Shattering is closed under restriction of the sample: if C shatters S and T ⊆ S, then C shatters T. Any labelling of T extends to a labelling of S, which is realized.
```
∀ {X : Type u} {C : ConceptClass X Bool} {S T : Finset X}, Shatters X C S → T ⊆ S → Shatters X C T
```
ConceptClass FLT.Concept Shatters
Used by
- two_pow_le_growthFunction_of_top
DeclgrowthFunction_ge_two_pow_of_shattersDeclaration kindtheorem
A shattered sample of size m forces the growth function at m to be at least 2 ^ m.
```
∀ {X : Type u} {C : ConceptClass X Bool} {S : Finset X}, Shatters X C S → 2 ^ S.card ≤ GrowthFunction X C S.card
```
ConceptClass GrowthFunction Shatters restrictionSet
Uses
- restrictionSet_eq_univ_of_shatters
- restrictionSet_ncard_le_growthFunction
Used by
- two_pow_le_growthFunction_of_top
DeclrestrictionSet_ncard_le_growthFunctionDeclaration kindtheorem
Each restriction count is at most the growth function at the matching sample size.
```
∀ {X : Type u} (C : ConceptClass X Bool) {S : Finset X} {m : ℕ},
  S.card = m → (restrictionSet C S).ncard ≤ GrowthFunction X C m
```
ConceptClass GrowthFunction restrictionSet
Uses
- growthFunction_eq
- restrictionSet_ncard_le_two_pow
Used by
- growthFunction_ge_two_pow_of_shatters
DeclrestrictionSet_ncard_le_two_powDeclaration kindtheorem
```
∀ {X : Type u} (C : ConceptClass X Bool) (S : Finset X), (restrictionSet C S).ncard ≤ 2 ^ S.card
```
ConceptClass restrictionSet
Used by
- restrictionSet_ncard_le_growthFunction

DeclgrowthFunction_eqDeclaration kindtheorem

∀ {X : Type u} (C : ConceptClass X Bool) (m : ℕ),
  GrowthFunction X C m = sSup (Set.range fun S => (restrictionSet C ↑S).ncard)

ConceptClass GrowthFunction restrictionSet

Used by

restrictionSet_ncard_le_growthFunction

DeclrestrictionSet_eq_univ_of_shattersDeclaration kindtheorem
A shattered sample realizes every labelling, so its restriction-pattern set is everything.
```
∀ {X : Type u} {C : ConceptClass X Bool} {S : Finset X}, Shatters X C S → restrictionSet C S = Set.univ
```
ConceptClass Shatters restrictionSet
Used by
- growthFunction_ge_two_pow_of_shatters
Declno_eventually_two_pow_le_polyDeclaration kindtheorem
The exponential-beats-polynomial crux. 2 ^ m ≤ K · m ^ d cannot hold for arbitrarily large m, since m ^ d = o(2 ^ m). Stated with the eventually filter so it is applicable (the ∀ m form is unsatisfiable at m = 0 for d ≥ 1).
```
∀ (K : ℝ) (d : ℕ), (∀ᶠ (m : ℕ) in Filter.atTop, 2 ^ m ≤ K * ↑m ^ d) → False
```
Used by
- vcDim_lt_top_of_growth_poly
DeclvcDim_finite_imp_growth_polyDeclaration kindtheorem
Finite VC dimension implies eventual polynomial growth. If VCDim X C < ⊤ then the growth function is eventually bounded by a polynomial K · m ^ d.
```
∀ {X : Type u} {C : ConceptClass X Bool},
 VCDim X C < ⊤ → ∃ K d, ∀ᶠ (m : ℕ) in Filter.atTop, ↑(GrowthFunction X C m) ≤ K * ↑m ^ d
```
ConceptClass GrowthFunction VCDim
Uses
- vcdim_finite_imp_growth_bounded
Used by
- vcDim_lt_top_iff_growth_poly
Declvcdim_finite_imp_growth_boundedDeclaration kindtheorem
VCDim < ⊤ → growth function polynomially bounded by partial binomial sum. Forward direction of fundamental_theorem conjunct 5. Uses Sauer-Shelah: GrowthFunction(m) ≤ ∑_{i≤d} C(m,i) where d = VCDim.
```
∀ (X : Type u) (C : ConceptClass X Bool),
 VCDim X C < ⊤ → ∃ d, ∀ (m : ℕ), d ≤ m → GrowthFunction X C m ≤ ∑ i ∈ Finset.range (d + 1), m.choose i
```
ConceptClass FLT.Concept GrowthFunction Shatters VCDim
Used by
- vcDim_finite_imp_growth_poly
- vcdim_finite_imp_uc'
DefinitionBatchLearnerstructure
A batch learner (PAC paradigm): takes a finite sample, returns a hypothesis.
```
Type u → Type v → Type (max u v)
```

DefinitionBatchLearner.hypothesesdef

The learner's hypothesis space

{X : Type u} → {Y : Type v} → BatchLearner X Y → HypothesisSpace X Y

DefinitionBatchLearner.learndef

The learning algorithm: given a sample, produce a hypothesis

{X : Type u} → {Y : Type v} → BatchLearner X Y → {m : ℕ} → (Fin m → X × Y) → Concept X Y

DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```

DefinitionEmpiricalErrordef

Empirical error: average loss on a finite sample.

(X : Type u) → (Y : Type v) → Concept X Y → {m : ℕ} → (Fin m → X × Y) → LossFunction Y → ℝ

DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionGrowthFunctiondef
Growth function (shattering coefficient): π_C(m) = max_{|S|=m} |{c|_S : c ∈ C}|. For each m-element set S, counts the number of distinct restrictions of C to S, then takes the supremum over all such S.
```
(X : Type u) → ConceptClass X Bool → ℕ → ℕ
```
DefinitionHasUniformConvergencedef
Uniform convergence of empirical error to true error over a hypothesis class. This is the property that makes finite VCDim → PAC learnability work. BP₅ connects here: this is ONE of the five characterizations.
M-DefinitionRepair (Γ₃₅ → Γ₄₁): The m₀ must be INDEPENDENT of D and c. That's what "uniform" means — convergence is uniform over all distributions and all target concepts. The original definition had m₀ depending on D and c, making uc_imp_pac unprovable (PACLearnable's mf must be independent of D, c). Repaired: ∃ m₀ is now BEFORE ∀ D, ∀ c. This STRENGTHENS the definition (A5-valid: adds content, doesn't simplify).
```
(X : Type u) → [MeasurableSpace X] → HypothesisSpace X Bool → Prop
```
DefinitionHypothesisSpacedef
A hypothesis space is a set of candidate concepts that the learner searches over. When H = C (the realizable case), every concept in the target class is available. When H ⊂ C or H ⊃ C, we are in the improper/agnostic regime.
Structurally identical to ConceptClass but semantically distinct: ConceptClass is the ground truth collection; HypothesisSpace is what the learner has access to.
```
Type u → Type v → Type (max v u)
```

DefinitionIsConsistentWithdef

A hypothesis h is consistent with labeled sample S.

(X : Type u) → (Y : Type v) → [DecidableEq Y] → Concept X Y → {m : ℕ} → (Fin m → X × Y) → Prop

DefinitionMeasurableConceptClassstructure
A concept class with the measure-theoretic regularity needed for PAC theory.
Bundles three conditions: 1. Every concept in C is measurable 2. All concepts are measurable (needed for disagreement set measurability) 3. The UC bad event satisfies NullMeasurableSet (WellBehavedVC)
Condition 3 is the deep one: for uncountable C, the existential {∃ h ∈ C, |TrueErr - EmpErr| ≥ ε} is NOT MeasurableSet in general. WellBehavedVC asserts it is NullMeasurableSet, which suffices for integration (lintegral_indicator_one₀).
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionPACLearnabledef
PAC (Probably Approximately Correct) learning. The central definition of computational learning theory.
Sample space: Fin m → X with i.i.d. product measure D^m. Labels: derived deterministically from target concept c (realizable case). Error: D-probability of disagreement between learner output and c.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionShattersdefYaël Dillies
A set S ⊆ X is shattered by concept class C if every labeling of S is realized by some concept in C.
```
(X : Type u) → ConceptClass X Bool → Finset X → Prop
```
DefinitionSignVectordef
```
ℕ → Type
```
DefinitionTrueErrordef
True error (0-1 loss, realizable case): D-probability of disagreement. This is what PACLearnable's success event measures.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ENNReal
```
DefinitionTrueErrorRealdef
True error in ℝ: for use in bounds involving subtraction/absolute value. COUNTER-1 of TrueError. The toReal bridge loses information when the measure is ⊤.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ℝ
```
DefinitionVCDimdef
VC dimension of a concept class: the size of the largest shattered set. Returns ℕ∞ = WithTop ℕ.
```
(X : Type u) → ConceptClass X Bool → WithTop ℕ
```
DefinitionWellBehavedVCdef
A concept class is well-behaved if the ghost gap event is null-measurable. This is the minimal regularity assumption for the symmetrization proof.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionboolToSigndef
Convert Bool labels to ±1 reals. true ↦ 1, false ↦ -1.
```
Bool → ℝ
```
DefinitionrestrictionSetdef
The set of labelling patterns that C realizes on a finite sample S.
```
{X : Type u} → ConceptClass X Bool → (S : Finset X) → Set (↥S → Bool)
```
DefinitionuniformMeasuredef
Uniform probability measure on a Fintype: (1/|X|) · count. This gives each point probability 1/|X|. Requires |X| > 0 (nonempty).
```
(X : Type u) → [inst : MeasurableSpace X] → [Fintype X] → Nonempty X → MeasureTheory.Measure X
```
DefinitionzeroOneLossdef
The 0-1 loss for classification.
```
(Y : Type v) → [DecidableEq Y] → LossFunction Y
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

Online learning is strictly stronger than PAC learning.

Declonline_strictly_stronger_pac

(∀ (X : Type) [inst : MeasurableSpace X] (C : ConceptClass X Bool) [MeasurableConceptClass X C],
    OnlineLearnable X Bool C → PACLearnable X C) ∧
  ∃ X x C, PACLearnable X C ∧ ¬OnlineLearnable X Bool C

ThesisStepDefinition

Declonline_strictly_stronger_pacDeclaration kindtheorem

(∀ (X : Type) [inst : MeasurableSpace X] (C : ConceptClass X Bool) [MeasurableConceptClass X C],
    OnlineLearnable X Bool C → PACLearnable X C) ∧
  ∃ X x C, PACLearnable X C ∧ ¬OnlineLearnable X Bool C

ConceptClass MeasurableConceptClass OnlineLearnable PACLearnable

Uses

online_imp_pac
pac_not_implies_online

Declpac_not_implies_onlineDeclaration kindtheorem
```
∃ X x C, PACLearnable X C ∧ ¬OnlineLearnable X Bool C
```
ConceptClass EmpiricalError FLT.Concept LittlestoneDim OnlineLearnable PACLearnable WellBehavedVC thresholdClass zeroOneLoss
Uses
Used by
- online_strictly_stronger_pac
Declvcdim_threshold_finiteDeclaration kindtheorem
VCDim of threshold class on ℕ is finite (≤ 1).
```
VCDim ℕ thresholdClass✝ < ⊤
```
Shatters VCDim thresholdClass
Uses
- threshold_not_shatter_pair
Used by
- pac_not_implies_online
Declthreshold_not_shatter_pairDeclaration kindtheorem
No 2-element subset of ℕ is shattered by the threshold class. Key: the labeling (smaller → false, larger → true) is impossible by monotonicity.
```
∀ {S : Finset ℕ}, 2 ≤ S.card → ¬Shatters ℕ thresholdClass✝ S
```
ConceptClass FLT.Concept Shatters thresholdClass
Used by
- vcdim_threshold_finite
Declldim_threshold_topDeclaration kindtheorem
LittlestoneDim of threshold class = ⊤.
```
LittlestoneDim ℕ thresholdClass✝ = ⊤
```
FLT.Concept LTree LTree.isShattered LittlestoneDim thresholdClass
Uses
- threshold_shattered_all_depths
Used by
- pac_not_implies_online
Declthreshold_shattered_all_depthsDeclaration kindtheorem
```
∀ (d : ℕ), ∃ T, LTree.isShattered thresholdClass✝ T
```
FLT.Concept LTree LTree.isShattered thresholdClass thresholdTree
Uses
- thresholdTree_shattered
Used by
- ldim_threshold_top
DeclthresholdTree_shatteredDeclaration kindtheorem
The threshold tree is shattered by any concept class containing all thresholds with indices in [lo, lo + 2^d - 1].
```
∀ (lo d : ℕ) (C : ConceptClass ℕ Bool),
 (∀ (n : ℕ), lo ≤ n → n < lo + 2 ^ d → (fun x => decide (x ≤ n)) ∈ C) → LTree.isShattered C (thresholdTree✝ lo d)
```
ConceptClass FLT.Concept LTree LTree.isShattered thresholdTree
Used by
- threshold_shattered_all_depths
Declforward_directionDeclaration kindtheorem
Forward direction: OnlineLearnable → LittlestoneDim < ⊤
```
∀ (X : Type) (C : ConceptClass X Bool), OnlineLearnable X Bool C → LittlestoneDim X C < ⊤
```
ConceptClass FLT.Concept LTree LTree.isShattered LittlestoneDim MistakeBounded OnlineLearnable OnlineLearner OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakesFrom
Uses
Used by
- pac_not_implies_online
DeclmistakesFrom_init_eqDeclaration kindtheorem
Relate mistakesFrom to the original mistakes function.
```
∀ {X : Type} (L : OnlineLearner X Bool) (c : X → Bool) (seq : List X), L.mistakesFrom L.init c seq = L.mistakes c seq
```
OnlineLearner OnlineLearner.State OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakes.go OnlineLearner.mistakesFrom OnlineLearner.predict OnlineLearner.update
Used by
- forward_direction
Decladversary_coreDeclaration kindtheorem
Core adversary lemma.
```
∀ {X : Type} (L : OnlineLearner X Bool) (s : L.State) {C : ConceptClass X Bool} {n : ℕ} (T : LTree X n),
  LTree.isShattered C T → Set.Nonempty C → ∃ seq, ∃ c ∈ C, L.mistakesFrom s c seq = n
```
ConceptClass FLT.Concept LTree LTree.isShattered OnlineLearner OnlineLearner.State OnlineLearner.mistakesFrom OnlineLearner.predict OnlineLearner.update
Used by
- forward_direction
DeclLTree.nonempty_of_isShatteredDeclaration kindtheorem
Helper: shattering implies the concept class is nonempty.
```
∀ {X : Type} {C : ConceptClass X Bool} {n : ℕ} (T : LTree X n), LTree.isShattered C T → Set.Nonempty C
```
ConceptClass FLT.Concept LTree LTree.isShattered
Used by
- forward_direction
Declonline_imp_pacDeclaration kindtheorem
Online learnable → PAC learnable. Γ₄₈: requires LittlestoneDim → VCDim bridge or online-to-batch conversion.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
  OnlineLearnable X Bool C → ∀ [MeasurableConceptClass X C], PACLearnable X C
```
ConceptClass FLT.Concept MeasurableConceptClass MistakeBounded OnlineLearnable PACLearnable VCDim WellBehavedVC
Uses
Used by
- online_strictly_stronger_pac
Declvcdim_le_of_mistake_boundedDeclaration kindtheorem
Mistake-bounded learner → VCDim ≤ M (universe-polymorphic).
```
∀ {X : Type u} {C : ConceptClass X Bool} {M : ℕ}, MistakeBounded X Bool C M → VCDim X C ≤ ↑M
```
ConceptClass FLT.Concept MistakeBounded OnlineLearner OnlineLearner.init OnlineLearner.mistakes Shatters VCDim mistakesFromU
Uses
- adversary_from_shatters
- mistakesFromU_init_eq
Used by
- online_imp_pac
DeclmistakesFromU_init_eqDeclaration kindtheorem
Relate mistakesFromU to the original mistakes function.
```
∀ {X : Type u} (L : OnlineLearner X Bool) (c : X → Bool) (seq : List X),
  mistakesFromU✝ L L.init c seq = L.mistakes c seq
```
OnlineLearner OnlineLearner.State OnlineLearner.init OnlineLearner.mistakes OnlineLearner.mistakes.go OnlineLearner.predict OnlineLearner.update mistakesFromU
Used by
- vcdim_le_of_mistake_bounded
Decladversary_from_shattersDeclaration kindtheorem
Adversary argument directly from shattering (universe-polymorphic). Given a shattered set S and any online learner L starting from state s, there exists a sequence and target concept where L makes |S| mistakes.
```
∀ {X : Type u} (L : OnlineLearner X Bool) (s : L.State) {C : ConceptClass X Bool} {S : Finset X},
  Shatters X C S → ∃ seq, ∃ c ∈ C, mistakesFromU✝ L s c seq = S.card
```
ConceptClass FLT.Concept OnlineLearner OnlineLearner.State OnlineLearner.predict OnlineLearner.update Shatters mistakesFromU
Uses
- shatters_restrict
Used by
- vcdim_le_of_mistake_bounded
Declshatters_restrictDeclaration kindtheorem
Restricted shattering: if C shatters S and we restrict to {c ∈ C | c x = b}, then S \ {x} is shattered by the restricted class (when x ∈ S).
```
∀ {X : Type u} {C : ConceptClass X Bool} {S : Finset X},
  Shatters X C S → ∀ {x : X}, x ∈ S → ∀ (b : Bool), Shatters X {c | c ∈ C ∧ c x = b} (S.erase x)
```
ConceptClass FLT.Concept Shatters
Used by
- adversary_from_shatters
Declvcdim_finite_imp_pac_via_uc'Declaration kindtheorem
VCDim < ⊤ → PACLearnable via UC route.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
 VCDim X C < ⊤ →
 (∀ h ∈ C, Measurable h) → (∀ (c : Concept X Bool), Measurable c) → WellBehavedVC X C → PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass FLT.Concept PACLearnable VCDim WellBehavedVC
Uses
- uc_imp_pac
- vcdim_finite_imp_uc'
Used by
- online_imp_pac
- pac_not_implies_online
Declvcdim_finite_imp_uc'Declaration kindtheorem
Finite VCDim implies uniform convergence. Proof: VCDim < ∞ → UC.
- Finite X: direct Hoeffding per-hypothesis + finite union bound.
- Infinite X: Sauer-Shelah → symmetrization + growth function → UC.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
 VCDim X C < ⊤ →
 (∀ h ∈ C, Measurable h) → (∀ (c : Concept X Bool), Measurable c) → WellBehavedVC X C → HasUniformConvergence X C
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction HasUniformConvergence HypothesisSpace TrueErrorReal VCDim WellBehavedVC zeroOneLoss
Uses
Used by
- vcdim_finite_imp_pac_via_uc'
Declvcdim_finite_imp_growth_boundedDeclaration kindtheorem
VCDim < ⊤ → growth function polynomially bounded by partial binomial sum. Forward direction of fundamental_theorem conjunct 5. Uses Sauer-Shelah: GrowthFunction(m) ≤ ∑_{i≤d} C(m,i) where d = VCDim.
```
∀ (X : Type u) (C : ConceptClass X Bool),
 VCDim X C < ⊤ → ∃ d, ∀ (m : ℕ), d ≤ m → GrowthFunction X C m ≤ ∑ i ∈ Finset.range (d + 1), m.choose i
```
ConceptClass FLT.Concept GrowthFunction Shatters VCDim
Used by
- vcdim_finite_imp_uc'

Decluc_bad_event_le_delta_provedDeclaration kindtheorem

UC bad-event bound: for m ≥ m₀(v,ε,δ), the probability of the bad event (∃ h with |TrueErr-EmpErr| ≥ ε) is at most δ. Composes symmetrization_uc_bound with growth_exp_le_delta.

∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε δ : ℝ),
            0 < ε →
              0 < δ →
                δ < 1 →
                  ∀ (v : ℕ),
                    0 < v →
                      (∀ (n : ℕ), v ≤ n → GrowthFunction X C n ≤ ∑ i ∈ Finset.range (v + 1), n.choose i) →
                        (16 * Real.exp 1 * (↑v + 1) / ε ^ 2) ^ (v + 1) / δ ≤ ↑m →
                          MeasureTheory.NullMeasurableSet
                              {p |
                                ∃ h ∈ C,
                                  EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                                      EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                                    ε / 2}
                              ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
                            (MeasureTheory.Measure.pi fun x => D)
                                {xs |
                                  ∃ h ∈ C,
                                    |TrueErrorReal X h c D -
                                          EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool)| ≥
                                      ε} ≤
                              ENNReal.ofReal δ

ConceptClass EmpiricalError FLT.Concept GrowthFunction TrueErrorReal zeroOneLoss

Uses

growth_exp_le_delta
symmetrization_uc_bound

Used by

vcdim_finite_imp_uc'

Declsymmetrization_uc_boundDeclaration kindtheorem
The symmetrization uniform convergence bound: two-sided version. P[∃h∈C: |TrueErr-EmpErr| ≥ ε] ≤ 4·GF(C,2m)·exp(-mε²/8).
Proof strategy (4 steps):
1. Decompose absolute value: |TrueErr - EmpErr| ≥ ε ↔ (TrueErr - EmpErr ≥ ε) ∨ (EmpErr - TrueErr ≥ ε)
have abs_decomp : ∀ (a b : ℝ), |a - b| ≥ ε ↔ a - b ≥ ε ∨ b - a ≥ ε := by intro a b; constructor · intro h; by_cases h' : a - b ≥ ε · exact Or.inl h' · exact Or.inr (by linarith [abs_sub_comm a b, le_abs_self (a - b)]) · intro h; cases h with | inl h => exact le_trans (le_of_eq (abs_of_nonneg (by linarith))) (by linarith) | inr h => exact le_trans (le_of_eq (abs_of_nonpos (by linarith) ▸ ...)) ...
2. Upper tail: P[∃h∈C: TrueErr-EmpErr ≥ ε] ≤ 2·GF(C,2m)·exp(-mε²/8)
- Direct application of symmetrization_step + double_sample_pattern_bound.
3. Lower tail: P[∃h∈C: EmpErr-TrueErr ≥ ε] ≤ 2·GF(C,2m)·exp(-mε²/8)
- Apply the symmetric argument: swap roles of S and S' in the double sample.
- Equivalently, apply symmetrization_step to the event EmpErr-TrueErr ≥ ε and bound the double-sample event {EmpErr_S - EmpErr_{S'} ≥ ε/2}.
- The bound is symmetric because D^m ⊗ D^m is symmetric under swapping factors. have swap_symmetry : DoubleSampleMeasure D m {p | ∃ h ∈ C, EmpErr(S) - EmpErr(S') ≥ ε/2} = DoubleSampleMeasure D m {p | ∃ h ∈ C, EmpErr(S') - EmpErr(S) ≥ ε/2} := Measure.prod_swap ...
4. Union bound: P[|gap| ≥ ε] ≤ P[gap ≥ ε] + P[gap ≤ -ε] ≤ 2·GF·exp(...) + 2·GF·exp(...) = 4·GF(C,2m)·exp(-mε²/8)
-- Uses: MeasureTheory.measure_union_le for the union of two events -- CAST: 2 * X + 2 * X = 4 * X in ENNReal (need ENNReal.add_mul or similar)
References: SSBD Theorem 6.7, Kakade-Tewari Lecture 19
```
∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
 [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 2 * Real.log 2 ≤ ↑m * ε ^ 2 →
 MeasureTheory.NullMeasurableSet
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 ∃ h ∈ C,
 |TrueErrorReal X h c D -
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool)| ≥
 ε} ≤
 ENNReal.ofReal (4 * ↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction TrueErrorReal zeroOneLoss
Uses
Used by
- uc_bad_event_le_delta_proved

Declsymmetrization_step_lowerDeclaration kindtheorem

Symmetrization step for the lower tail: P[∃h: EmpErr-TrueErr ≥ ε] ≤ 2·P_{double}[∃h: EmpErr_S-EmpErr_{S'} ≥ ε/2].

Mirror of symmetrization_step for the opposite direction. Uses hoeffding_one_sided_upper instead of hoeffding_one_sided.

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε : ℝ),
            0 < ε →
              2 * Real.log 2 ≤ ↑m * ε ^ 2 →
                (MeasureTheory.Measure.pi fun x => D)
                    {xs |
                      ∃ h ∈ C,
                        EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) - TrueErrorReal X h c D ≥
                          ε} ≤
                  2 *
                    ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
                      {p |
                        ∃ h ∈ C,
                          EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) -
                              EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) ≥
                            ε / 2}

ConceptClass EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Uses

hoeffding_one_sided_upper

Used by

symmetrization_uc_bound

Declsymmetrization_stepDeclaration kindtheorem
Symmetrization: the probability of a large gap TrueErr-EmpErr is at most twice the probability of a large gap EmpErr'-EmpErr on the double sample.
Proof strategy (6 steps):
1. Witness selection: For S in the bad event, ∃h* ∈ C with TrueErr(h) - EmpErr_S(h) ≥ ε.
-- In the bad event set, extract h* by classical choice have h_witness : ∀ xs ∈ bad_event, ∃ h* ∈ C, TrueErrorReal X h* c D - EmpiricalError X Bool h* (sample xs) (zeroOneLoss Bool) ≥ ε
2. Ghost sample mean: E_{S'}[EmpErr_{S'}(h)] = TrueErr(h) ≥ EmpErr_S(h*) + ε.
- Uses: MeasureTheory.integral_pi to compute E[EmpErr] over product measure.
- KEY LEMMA: For fixed h, E_{D^m}[EmpiricalError(h,S)] = TrueErrorReal(h,c,D). This is because EmpErr = (1/m)∑ indicator(x_i), and E[indicator(x_i)] = TrueErrorReal. have expected_emp_err : ∀ h* : Concept X Bool, ∫ xs, EmpiricalError X Bool h* (sample xs) (zeroOneLoss Bool) ∂(Measure.pi (fun _ : Fin m => D)) = TrueErrorReal X h* c D := by ...
3. Hoeffding on ghost sample: P_{S'}[EmpErr_{S'}(h) < TrueErr(h) - ε/2] ≤ exp(-mε²/2).
- Apply hoeffding_one_sided with t = ε/2.
- The hm_large hypothesis ensures exp(-mε²/2) < 1/2: 2·ln2 ≤ mε² ⟹ mε²/2 ≥ ln2 ⟹ exp(-mε²/2) ≤ 1/2. have hoeffding_ghost : ∀ h* ∈ C, Measure.pi (fun _ : Fin m => D) {xs' | EmpiricalError X Bool h* (sample xs') (zeroOneLoss Bool) < TrueErrorReal X h* c D - ε/2} ≤ ENNReal.ofReal (Real.exp (-m * (ε/2)^2 * 2)) := by intro h* _; exact hoeffding_one_sided D h* c m hm (ε/2) (by linarith) (by ...) (by ...)
4. Complementary probability: P_{S'}[EmpErr_{S'}(h) - EmpErr_S(h) ≥ ε/2] ≥ 1/2.
- From step 2: TrueErr(h) ≥ EmpErr_S(h) + ε
- From step 3: P[EmpErr_{S'} ≥ TrueErr - ε/2] ≥ 1/2
- Chain: EmpErr_{S'} ≥ TrueErr - ε/2 ≥ EmpErr_S + ε - ε/2 = EmpErr_S + ε/2
5. Conditional to unconditional: The witness h* from step 1 also witnesses the double-sample event ∃h∈C: EmpErr'-EmpErr ≥ ε/2. So: P_{S'}[double event | S bad] ≥ 1/2.
have conditional_bound : ∀ xs ∈ bad_event, Measure.pi (fun _ : Fin m => D) {xs' | ∃ h ∈ C, EmpiricalError ... xs' - EmpiricalError ... xs ≥ ε/2} ≥ ENNReal.ofReal (1/2) := by ...
6. Fubini integration: By Measure.prod_apply and Fubini: P_{S,S'}[double event] = ∫_S P_{S'}[double event | S] ≥ (1/2) · P_S[bad event] ⟹ P_S[bad event] ≤ 2 · P_{S,S'}[double event].
-- Uses: MeasureTheory.Measure.prod_apply or lintegral_prod -- MEASURABILITY: the double-sample event is measurable as a finite union -- of sets of the form {(xs,xs') | EmpErr'(h) - EmpErr(h) ≥ ε/2} for h ∈ C. -- Since C may be infinite, measurability requires care: the sup over h -- must be shown to be measurable. For finite restriction patterns (≤ 2^m -- on Fin m → Bool), this is a finite union.
MEASURABILITY CONCERNS:
- {xs | ∃ h ∈ C, ...} is NOT obviously measurable for infinite C. Strategy: decompose via restriction patterns. On any fixed xs, the set of labelings {(h(xs 0), ..., h(xs(m-1))) | h ∈ C} has at most GF(C,m) ≤ 2^m elements. So the ∃h event is a finite union of measurable sets.
- EmpiricalError is a finite sum of measurable functions, hence measurable.
- The product σ-algebra on (Fin m → X) × (Fin m → X) is generated by cylinder sets, and our events are in this σ-algebra.
References: SSBD Lemma 4.5, Kakade-Tewari Lecture 19 Lemma 1
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 2 * Real.log 2 ≤ ↑m * ε ^ 2 →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 ∃ h ∈ C,
 TrueErrorReal X h c D - EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥
 ε} ≤
 2 *
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
```
ConceptClass EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Uses
- hoeffding_one_sided
Used by
- symmetrization_uc_bound
Decldouble_sample_pattern_boundDeclaration kindtheorem
On the double sample, the probability that any hypothesis has EmpErr' - EmpErr ≥ ε/2 is bounded by GF(C,2m) · exp(-mε²/8).
Proof strategy (Approach A — standard exchangeability, 5 steps):
1. EXCHANGEABILITY: Under D^m ⊗ D^m, the 2m draws z₁,...,z_{2m} are iid from D. The joint distribution is invariant under permutations of {1,...,2m}.
Key lemma: P_{D^m⊗D^m}[event(S,S')] = E_z[P_{split}[event | z]] where z = merged sample and the split is uniformly random among all C(2m,m) ways to partition z into two groups of m.
-- Measure.pi permutation invariance have pi_perm_invariant : ∀ (σ : Equiv.Perm (Fin (2*m))), (Measure.pi (fun _ : Fin (2*m) => D)).map (fun z i => z (σ i)) = Measure.pi (fun _ : Fin (2*m) => D) := by ... -- Consequence: the event probability equals the split-averaged probability have exchangeability : DoubleSampleMeasure D m {p | ∃ h ∈ C, gap(p) ≥ ε/2} = ∫ z, SplitMeasure m {vs | ∃ h ∈ C, gap(split z vs) ≥ ε/2} ∂(Measure.pi (fun _ : Fin (2*m) => D)) := by ...
2. CONDITIONING: For fixed merged sample z of 2m points:
- C restricts to at most GF(C,2m) distinct labeling patterns on z (deterministic).
- For each pattern p, define: diff(p, split) = EmpErr_{S'}(p) - EmpErr_S(p) = (1/m) ∑_{i∈S'} a_i - (1/m) ∑_{i∈S} a_i where a_i = 1[pattern(z_i) ≠ c(z_i)] ∈ {0,1}.
-- Number of distinct patterns have num_patterns : ∀ (z : MergedSample X m), Set.ncard {p : Fin (2*m) → Bool | ∃ h ∈ C, ∀ i, p i = (h (z i) ≠ c (z i))} ≤ GrowthFunction X C (2*m) := by ...
3. PER-PATTERN HOEFFDING ON SPLITS: For fixed z and fixed pattern p: Under uniformly random split (S,S') of z into two groups of m: diff(p, split) = (1/m) ∑_{i∈S'} a_i - (1/m) ∑_{i∈S} a_i
This is a function of the random partition. By Hoeffding's inequality for sampling without replacement (Serfling 1974): P_split[diff ≥ ε/2] ≤ exp(-mε²/8)
Alternative derivation: Hoeffding without replacement from Hoeffding with replacement (iid signs) via coupling. The without-replacement bound is actually TIGHTER (variance reduction), but the with-replacement bound suffices.
-- Per-pattern concentration have per_pattern_bound : ∀ (z : MergedSample X m) (a : Fin (2*m) → ℝ) (ha : ∀ i, a i ∈ Set.Icc 0 1), SplitMeasure m {vs | (1/m) * ∑ i ∈ second_group vs, a i - (1/m) * ∑ i ∈ first_group vs, a i ≥ ε/2} ≤ ENNReal.ofReal (Real.exp (-(m : ℝ) * (ε/2)^2 / 2)) := by ... -- Note: m*(ε/2)^2/2 = mε²/8
4. UNION BOUND: P_split[∃ pattern: diff ≥ ε/2 | z] ≤ (number of patterns) · max_pattern P_split[diff ≥ ε/2] ≤ GF(C,2m) · exp(-mε²/8)
have union_bound : ∀ (z : MergedSample X m), SplitMeasure m {vs | ∃ h ∈ C, gap(split z vs, h) ≥ ε/2} ≤ ENNReal.ofReal (GrowthFunction X C (2*m) * Real.exp (-(m : ℝ) * ε^2 / 8)) := by ...
5. INTEGRATE: P_{D^m⊗D^m}[event] = E_z[P_split[event|z]] (by step 1) ≤ E_z[GF(C,2m) · exp(-mε²/8)] (by step 4, pointwise) = GF(C,2m) · exp(-mε²/8) (bound is independent of z)
-- The bound is a constant, so integrating gives the same constant -- (using IsProbabilityMeasure for the 2m-fold product)
Infrastructure needed:
- Fin.sumFinEquiv : Fin m ⊕ Fin n ≃ Fin (m + n) (available in Mathlib)
- mergeSamples / splitMergedSample (defined above)
- SplitMeasure and ValidSplit (defined above)
- Measure.pi permutation invariance (to be proved or imported)
- Hoeffding for sampling without replacement
- GrowthFunction on 2m points + sauer_shelah_exp_bound from Rademacher.lean
MEASURABILITY CONCERNS:
- The merged sample z ↦ P_split[event|z] must be measurable as a function of z. Since the event is a finite union over patterns, and each pattern's indicator is a measurable function of z (finite evaluation), this follows.
- GrowthFunction X C (2*m) is a natural number (deterministic), no measurability issue.
References: SSBD Theorem 6.7, Hoeffding (1963), Serfling (1974)
```
∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
 [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
 (∀ h ∈ C, Measurable h) →
 Measurable c →
 ∀ (m : ℕ),
 0 < m →
 ∀ (ε : ℝ),
 0 < ε →
 MeasureTheory.NullMeasurableSet
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2}
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
 ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D))
 {p |
 ∃ h ∈ C,
 EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
 EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
 ε / 2} ≤
 ENNReal.ofReal (↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))
```
ConceptClass EmpiricalError FLT.Concept GrowthFunction zeroOneLoss
Uses
- exchangeability_chain_bound
Used by
- symmetrization_uc_bound

Declexchangeability_chain_boundDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] [Infinite X] (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D] (C : ConceptClass X Bool) (c : Concept X Bool),
  (∀ h ∈ C, Measurable h) →
    Measurable c →
      ∀ (m : ℕ),
        0 < m →
          ∀ (ε : ℝ),
            0 < ε →
              ε ≤ 2 →
                Set.Nonempty C →
                  MeasureTheory.NullMeasurableSet
                      {p |
                        ∃ h ∈ C,
                          EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                              EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                            ε / 2}
                      ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) →
                    have μ := MeasureTheory.Measure.pi fun x => D;
                    (μ.prod μ)
                        {p |
                          ∃ h ∈ C,
                            EmpiricalError X Bool h (fun i => (p.2 i, c (p.2 i))) (zeroOneLoss Bool) -
                                EmpiricalError X Bool h (fun i => (p.1 i, c (p.1 i))) (zeroOneLoss Bool) ≥
                              ε / 2} ≤
                      ENNReal.ofReal (↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)))

ConceptClass EmpiricalError FLT.Concept GrowthFunction SignVector boolToSign zeroOneLoss

Uses

finite_exchangeability_bound
rademacher_mgf_bound
restriction_pattern_count
zeroOneLoss.congr_simp

Used by

double_sample_pattern_bound

DeclzeroOneLoss.congr_simpDeclaration kindtheorem

∀ (Y : Type v) {inst : DecidableEq Y} [inst_1 : DecidableEq Y] (a a_1 : Y),
  a = a_1 → ∀ (a_2 a_3 : Y), a_2 = a_3 → zeroOneLoss Y a a_2 = zeroOneLoss Y a_1 a_3

zeroOneLoss

Used by

exchangeability_chain_bound

Declrestriction_pattern_countDeclaration kindtheorem
The number of distinct restriction patterns of C on any n points is at most GF(C,n). For z : Fin n → X, define patterns(z) = {p : Fin n → Bool | ∃ h ∈ C, ∀ i, p i = (h(z i) ≠ c(z i))}. Then patterns(z).ncard ≤ GrowthFunction X C n by definition of GrowthFunction.
```
∀ {X : Type u} [MeasurableSpace X] [Infinite X] (C : ConceptClass X Bool) (c : Concept X Bool) (n : ℕ) (z : Fin n → X),
  {p | ∃ h ∈ C, ∀ (i : Fin n), p i = decide (h (z i) ≠ c (z i))}.ncard ≤ GrowthFunction X C n
```
ConceptClass FLT.Concept GrowthFunction
Used by
- exchangeability_chain_bound

Declrademacher_mgf_boundDeclaration kindtheorem

Rademacher MGF bound.

∀ {m : ℕ},
  0 < m →
    ∀ (a : Fin m → ℝ) (c : ℝ),
      0 ≤ c →
        (∀ (i : Fin m), |a i| ≤ c) →
          ∀ (t : ℝ),
            0 ≤ t →
              1 / ↑(Fintype.card (SignVector m)) * ∑ σ, Real.exp (t * (1 / ↑m * ∑ i, a i * boolToSign (σ i))) ≤
                Real.exp (t ^ 2 * c ^ 2 / (2 * ↑m))

SignVector boolToSign

Uses

cosh_le_exp_sq_half

Used by

exchangeability_chain_bound

Declcosh_le_exp_sq_halfDeclaration kindtheorem
cosh(x) ≤ exp(x²/2). Standard sub-Gaussian bound.
```
∀ (x : ℝ), Real.cosh x ≤ Real.exp (x ^ 2 / 2)
```
Used by
- rademacher_mgf_bound

Declfinite_exchangeability_boundDeclaration kindtheorem

∀ {Ω : Type u_1} {G : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : Fintype G] [Nonempty G]
  {ν : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure ν] (T : G → Ω → Ω) (S : Set Ω),
  (∀ (g : G), MeasureTheory.MeasurePreserving (T g) ν ν) →
    MeasureTheory.NullMeasurableSet S ν →
      ∀ (B : ENNReal), (∀ (z : Ω), ∑ g, (T g ⁻¹' S).indicator 1 z ≤ B * ↑(Fintype.card G)) → ν S ≤ B

Used by

exchangeability_chain_bound

Declgrowth_exp_le_deltaDeclaration kindtheorem

∀ {X : Type u} [MeasurableSpace X] (C : ConceptClass X Bool) (v : ℕ),
  0 < v →
    ∀ (m : ℕ),
      0 < m →
        ∀ (ε δ : ℝ),
          0 < ε →
            0 < δ →
              δ < 1 →
                (∀ (n : ℕ), v ≤ n → GrowthFunction X C n ≤ ∑ i ∈ Finset.range (v + 1), n.choose i) →
                  (16 * Real.exp 1 * (↑v + 1) / ε ^ 2) ^ (v + 1) / δ ≤ ↑m →
                    4 * ↑(GrowthFunction X C (2 * m)) * Real.exp (-(↑m * ε ^ 2 / 8)) ≤ δ ∧ 2 * Real.log 2 ≤ ↑m * ε ^ 2

ConceptClass GrowthFunction

Uses

growth_function_le_two_pow
pow_mul_exp_neg_le_factorial_div
sum_choose_le_exp_pow

Used by

uc_bad_event_le_delta_proved

Declsum_choose_le_exp_powDeclaration kindtheorem
Pure combinatorial inequality: ∑_{i=0}^d C(m,i) ≤ (em/d)^d for d ≤ m, d ≥ 1.
```
∀ (d m : ℕ), 0 < d → d ≤ m → ∑ i ∈ Finset.range (d + 1), ↑(m.choose i) ≤ (Real.exp 1 * ↑m / ↑d) ^ d
```
Used by
- growth_exp_le_delta
Declpow_mul_exp_neg_le_factorial_divDeclaration kindtheorem
Key arithmetic lemma for PAC bound: for t > 0, t^d * exp(-t) ≤ (d+1)!/t. Follows from exp(t) ≥ t^(d+1)/(d+1)! (partial sum of Taylor series).
```
∀ {d : ℕ} {t : ℝ}, 0 < t → t ^ d * Real.exp (-t) ≤ ↑(d + 1).factorial / t
```
Used by
- growth_exp_le_delta
Declgrowth_function_le_two_powDeclaration kindtheorem
Trivial bound: GrowthFunction ≤ 2^n for all concept classes. Each restriction to an n-element set yields a function in S → Bool, and there are at most 2^n such functions.
```
∀ {X : Type u} (C : ConceptClass X Bool) (n : ℕ), GrowthFunction X C n ≤ 2 ^ n
```
ConceptClass FLT.Concept GrowthFunction
Used by
- growth_exp_le_delta

Declhoeffding_one_sided_upperDeclaration kindtheorem

Upper-tail Hoeffding: for iid Bernoulli(p) draws, the empirical average overshoots the mean by ≥ t with probability ≤ exp(-2mt²).

This is the mirror of hoeffding_one_sided (which bounds the lower tail). The proof uses the same sub-Gaussian machinery with Z_i = indicator(x_i) - p (instead of p - indicator(x_i)).

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (h c : Concept X Bool) (m : ℕ),
  0 < m →
    ∀ (t : ℝ),
      0 < t →
        t ≤ 1 →
          MeasurableSet {x | h x ≠ c x} →
            (MeasureTheory.Measure.pi fun x => D)
                {xs |
                  EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥ TrueErrorReal X h c D + t} ≤
              ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))

EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Used by

symmetrization_step_lower
vcdim_finite_imp_uc'

Declhoeffding_one_sidedDeclaration kindtheorem
One-sided Hoeffding: for iid Bernoulli(p) draws, the empirical average undershoots the mean by ≥ t with probability ≤ exp(-2mt²).
Proof strategy (3 steps):
1. MGF bound (Hoeffding's lemma): For X ∈ [0,1] with E[X] = p, E[exp(s(X-p))] ≤ exp(s²/8).
- Adapt from cosh_le_exp_sq_half infrastructure in Rademacher.lean.
- Key: convexity of exp on [0,1] gives E[exp(sX)] ≤ p·exp(s) + (1-p)·exp(0), then the s²/8 bound follows from ln(1 + x) ≤ x and Taylor expansion. have mgf_bound : ∀ (s : ℝ), ∫ x, Real.exp (s * (indicator x - p)) ∂D ≤ Real.exp (s^2 / 8) := by ...
2. Product independence: E[exp(s·∑(X_i-p))] = ∏ E[exp(s(X_i-p))] ≤ exp(ms²/8).
- Uses MeasureTheory.Measure.pi independence structure.
- Needs: Measure.pi integral factorization for product of functions.
- MEASURABILITY: fun xs => Real.exp (s * ∑ i, f (xs i)) is measurable (composition of measurable functions). have product_bound : ∀ (s : ℝ), ∫ xs, Real.exp (s * ∑ i, (indicator (xs i) - p)) ∂Measure.pi (fun _ => D) ≤ Real.exp (m * s^2 / 8) := by ...
3. Exponential Markov + optimize: P[∑(X_i-p) ≤ -mt] = P[exp(-s·∑(X_i-p)) ≥ exp(smt)] ≤ exp(-smt + ms²/8). Optimize over s: set s = 4t to get ≤ exp(-2mt²).
- Uses Markov's inequality in ENNReal form.
- CAST ISSUE: Markov gives ENNReal bound, need to convert exp(-2mt²) between ENNReal.ofReal and the measure value. have markov_step : ∀ (s : ℝ) (hs : 0 < s), Measure.pi (fun _ => D) {xs | ∑ i, (indicator (xs i) - p) ≤ -(m : ℝ) * t} ≤ ENNReal.ofReal (Real.exp (-(s * m * t) + m * s^2 / 8)) := by ... have optimize : Real.exp (-(4*t * m * t) + m * (4*t)^2 / 8) = Real.exp (-2 * m * t^2) := by ring_nf
CAST ISSUES to watch:
- m : ℕ needs cast to ℝ in the exponent: (m : ℝ)
- EmpiricalError returns ℝ, TrueErrorReal returns ℝ, good — no ENNReal gap
- The measure value is ENNReal, the bound exp(-2mt²) is ℝ≥0∞ via ENNReal.ofReal
References: SSBD Lemma B.3, Hoeffding (1963)
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (h c : Concept X Bool) (m : ℕ),
 0 < m →
 ∀ (t : ℝ),
 0 < t →
 t ≤ 1 →
 MeasurableSet {x | h x ≠ c x} →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≤ TrueErrorReal X h c D - t} ≤
 ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))
```
EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Used by
- symmetrization_step
- vcdim_finite_imp_uc'
Decluc_imp_pacDeclaration kindtheorem
Uniform convergence implies PAC learnability via ERM. The ERM learner (which exists by ermLearn) achieves PAC learning when uniform convergence holds. This is the second half of vcdim_finite_imp_pac.
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool),
  Set.Nonempty C → HasUniformConvergence X C → PACLearnable X C
```
BatchLearner BatchLearner.learn ConceptClass EmpiricalError FLT.Concept HasUniformConvergence HypothesisSpace IsConsistentWith PACLearnable TrueError TrueErrorReal zeroOneLoss
Uses
- BatchLearner.output_in_H
Used by
- vcdim_finite_imp_pac_via_uc'
DeclBatchLearner.output_in_HDeclaration kindtheorem
Output is in the hypothesis space
```
∀ {X : Type u} {Y : Type v} (self : BatchLearner X Y) {m : ℕ} (S : Fin m → X × Y), self.learn S ∈ self.hypotheses
```
BatchLearner BatchLearner.hypotheses BatchLearner.learn FLT.Concept HypothesisSpace
Used by
- uc_imp_pac
DeclMeasurableConceptClass.hmeas_CDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C],
  ∀ c ∈ C, Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Uses
- MeasurableConceptClass.mem_measurable
Used by
- online_imp_pac
DeclMeasurableConceptClass.mem_measurableDeclaration kindtheorem
Every concept in C is measurable
```
∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : MeasurableConceptClass X C],
  ∀ h ∈ C, Measurable h
```
ConceptClass FLT.Concept MeasurableConceptClass
Used by
- MeasurableConceptClass.hmeas_C
DeclMeasurableConceptClass.hc_measDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C]
  (c : Concept X Bool), Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Uses
- MeasurableConceptClass.all_measurable
Used by
- online_imp_pac
DeclMeasurableConceptClass.all_measurableDeclaration kindtheorem
All concepts X → Bool are measurable (for disagreement sets)
```
∀ {X : Type u} {inst : MeasurableSpace X} (C : ConceptClass X Bool) [self : MeasurableConceptClass X C]
  (c : Concept X Bool), Measurable c
```
ConceptClass FLT.Concept MeasurableConceptClass
Used by
- MeasurableConceptClass.hc_meas
DeclMeasurableConceptClass.hWBDeclaration kindtheorem
```
∀ {X : Type u} [inst : MeasurableSpace X] (C : ConceptClass X Bool) [h : MeasurableConceptClass X C], WellBehavedVC X C
```
ConceptClass MeasurableConceptClass WellBehavedVC
Uses
- MeasurableConceptClass.wellBehaved
Used by
- online_imp_pac
DeclMeasurableConceptClass.wellBehavedDeclaration kindtheorem
Uniform convergence bad event is NullMeasurableSet
```
∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : MeasurableConceptClass X C],
  WellBehavedVC X C
```
ConceptClass MeasurableConceptClass WellBehavedVC
Used by
- MeasurableConceptClass.hWB
DefinitionBatchLearnerstructure
A batch learner (PAC paradigm): takes a finite sample, returns a hypothesis.
```
Type u → Type v → Type (max u v)
```

DefinitionBatchLearner.hypothesesdef

The learner's hypothesis space

{X : Type u} → {Y : Type v} → BatchLearner X Y → HypothesisSpace X Y

DefinitionBatchLearner.learndef

The learning algorithm: given a sample, produce a hypothesis

{X : Type u} → {Y : Type v} → BatchLearner X Y → {m : ℕ} → (Fin m → X × Y) → Concept X Y

DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```

DefinitionEmpiricalErrordef

Empirical error: average loss on a finite sample.

(X : Type u) → (Y : Type v) → Concept X Y → {m : ℕ} → (Fin m → X × Y) → LossFunction Y → ℝ

DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionGrowthFunctiondef
Growth function (shattering coefficient): π_C(m) = max_{|S|=m} |{c|_S : c ∈ C}|. For each m-element set S, counts the number of distinct restrictions of C to S, then takes the supremum over all such S.
```
(X : Type u) → ConceptClass X Bool → ℕ → ℕ
```
DefinitionHasUniformConvergencedef
Uniform convergence of empirical error to true error over a hypothesis class. This is the property that makes finite VCDim → PAC learnability work. BP₅ connects here: this is ONE of the five characterizations.
M-DefinitionRepair (Γ₃₅ → Γ₄₁): The m₀ must be INDEPENDENT of D and c. That's what "uniform" means — convergence is uniform over all distributions and all target concepts. The original definition had m₀ depending on D and c, making uc_imp_pac unprovable (PACLearnable's mf must be independent of D, c). Repaired: ∃ m₀ is now BEFORE ∀ D, ∀ c. This STRENGTHENS the definition (A5-valid: adds content, doesn't simplify).
```
(X : Type u) → [MeasurableSpace X] → HypothesisSpace X Bool → Prop
```
DefinitionHypothesisSpacedef
A hypothesis space is a set of candidate concepts that the learner searches over. When H = C (the realizable case), every concept in the target class is available. When H ⊂ C or H ⊃ C, we are in the improper/agnostic regime.
Structurally identical to ConceptClass but semantically distinct: ConceptClass is the ground truth collection; HypothesisSpace is what the learner has access to.
```
Type u → Type v → Type (max v u)
```

DefinitionIsConsistentWithdef

A hypothesis h is consistent with labeled sample S.

(X : Type u) → (Y : Type v) → [DecidableEq Y] → Concept X Y → {m : ℕ} → (Fin m → X × Y) → Prop

DefinitionLTreeinductive
A complete binary Littlestone tree of depth n.
```
Type → ℕ → Type
```
DefinitionLTree.isShattereddef
Path-wise shattering for complete trees. Path B: leaf case requires C.Nonempty (NA₁₀).
```
{X : Type} → {n : ℕ} → ConceptClass X Bool → LTree X n → Prop
```
DefinitionLittlestoneDimdef
Littlestone dimension: the maximum depth of a complete shattered tree. Path B: returns WithBot (WithTop ℕ) so Ldim(∅) = ⊥ (NA₁₀).
```
(X : Type) → ConceptClass X Bool → WithBot (WithTop ℕ)
```
DefinitionMeasurableConceptClassstructure
A concept class with the measure-theoretic regularity needed for PAC theory.
Bundles three conditions: 1. Every concept in C is measurable 2. All concepts are measurable (needed for disagreement set measurability) 3. The UC bad event satisfies NullMeasurableSet (WellBehavedVC)
Condition 3 is the deep one: for uncountable C, the existential {∃ h ∈ C, |TrueErr - EmpErr| ≥ ε} is NOT MeasurableSet in general. WellBehavedVC asserts it is NullMeasurableSet, which suffices for integration (lintegral_indicator_one₀).
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionMistakeBoundeddef
Mistake-bounded learning: the learner makes at most M mistakes on ANY sequence. No distribution assumption. Characterized by Littlestone dimension.
```
(X : Type u) → (Y : Type v) → [DecidableEq Y] → ConceptClass X Y → ℕ → Prop
```
DefinitionOnlineLearnabledef
Online learnable: there exists a finite mistake bound.
```
(X : Type u) → (Y : Type v) → [DecidableEq Y] → ConceptClass X Y → Prop
```
DefinitionOnlineLearnerstructure
An online learner: receives instances one at a time, makes predictions sequentially.
```
Type u → Type v → Type (max (max 1 u) v)
```

DefinitionOnlineLearner.Statedef

Internal state type

{X : Type u} → {Y : Type v} → OnlineLearner X Y → Type

DefinitionOnlineLearner.initdef

Initial state

{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State

DefinitionOnlineLearner.mistakesdef

Helper: run an online learner on a sequence, counting mistakes.

{X : Type u} → {Y : Type v} → [DecidableEq Y] → OnlineLearner X Y → Concept X Y → List X → ℕ

DefinitionOnlineLearner.mistakes.godef

{X : Type u} → {Y : Type v} → [DecidableEq Y] → (L : OnlineLearner X Y) → Concept X Y → L.State → List X → ℕ → ℕ

DefinitionOnlineLearner.mistakesFromdef

Count mistakes starting from state s.

{X : Type} → (L : OnlineLearner X Bool) → L.State → (X → Bool) → List X → ℕ

DefinitionOnlineLearner.predictdef
Predict: given current state and new instance, output a prediction
```
{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State → X → Y
```
DefinitionOnlineLearner.updatedef
Update: given current state, instance, and revealed true label, update state
```
{X : Type u} → {Y : Type v} → (self : OnlineLearner X Y) → self.State → X → Y → self.State
```
DefinitionPACLearnabledef
PAC (Probably Approximately Correct) learning. The central definition of computational learning theory.
Sample space: Fin m → X with i.i.d. product measure D^m. Labels: derived deterministically from target concept c (realizable case). Error: D-probability of disagreement between learner output and c.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionShattersdefYaël Dillies
A set S ⊆ X is shattered by concept class C if every labeling of S is realized by some concept in C.
```
(X : Type u) → ConceptClass X Bool → Finset X → Prop
```
DefinitionSignVectordef
```
ℕ → Type
```
DefinitionTrueErrordef
True error (0-1 loss, realizable case): D-probability of disagreement. This is what PACLearnable's success event measures.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ENNReal
```
DefinitionTrueErrorRealdef
True error in ℝ: for use in bounds involving subtraction/absolute value. COUNTER-1 of TrueError. The toReal bridge loses information when the measure is ⊤.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ℝ
```
DefinitionVCDimdef
VC dimension of a concept class: the size of the largest shattered set. Returns ℕ∞ = WithTop ℕ.
```
(X : Type u) → ConceptClass X Bool → WithTop ℕ
```
DefinitionWellBehavedVCdef
A concept class is well-behaved if the ghost gap event is null-measurable. This is the minimal regularity assumption for the symmetrization proof.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionboolToSigndef
Convert Bool labels to ±1 reals. true ↦ 1, false ↦ -1.
```
Bool → ℝ
```
DefinitionmistakesFromUdef
Count mistakes starting from state s (universe-polymorphic version).
```
{X : Type u} → (L : OnlineLearner X Bool) → L.State → (X → Bool) → List X → ℕ
```
DefinitionthresholdClassdef
Threshold concept class on ℕ: { (· ≤ n) | n : ℕ }. VCDim = 1 (PAC-learnable), LittlestoneDim = ∞ (not online-learnable).
```
ConceptClass ℕ Bool
```
DefinitionthresholdTreedef
Build a shattered Littlestone tree of depth d for the threshold class restricted to thresholds in interval [lo, lo + 2^d - 1]. The concept class parameter C should contain all thresholds (· ≤ n) for lo ≤ n ≤ lo + 2^d - 1. We show the tree is shattered by C when C ⊇ these thresholds.
```
ℕ → (d : ℕ) → LTree ℕ d
```
DefinitionzeroOneLossdef
The 0-1 loss for classification.
```
(Y : Type v) → [DecidableEq Y] → LossFunction Y
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

Advice elimination (Ben-David & Dichterman 1998): If C is PAC-learnable with concept-dependent advice from a FINITE set A (with measurability regularity), then C is PAC-learnable without advice.

Proof strategy: run the advice-augmented learner with each a ∈ A on a training portion of the sample, producing |A| candidate hypotheses. Use a validation portion to select the candidate with lowest empirical error. Union bound over |A| advice values + Hoeffding on validation controls total failure probability. Sample complexity: O(m_orig(ε/2, δ/(2|A|)) + log(|A|/δ)/ε²).

The [Fintype A] constraint is essential: for infinite A, the theorem is false (no finite union bound). [Nonempty A] ensures the advice space is inhabited.

Decladvice_elimination

∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) [MeasurableHypotheses X C] (A : Type u_1)
  [inst_2 : Fintype A] [inst_3 : Nonempty A], PACLearnableWithAdviceRegular X C A → PACLearnable X C

ThesisStepHypothesisDefinition

Decladvice_eliminationDeclaration kindtheorem
```
∀ (X : Type u) [inst : MeasurableSpace X] (C : ConceptClass X Bool) [MeasurableHypotheses X C] (A : Type u_1)
  [inst_2 : Fintype A] [inst_3 : Nonempty A], PACLearnableWithAdviceRegular X C A → PACLearnable X C
```
AdviceEvalMeasurable BatchLearner BatchLearner.learn ConceptClass EmpiricalError FLT.Concept LearnerWithAdvice LearnerWithAdvice.learnWithAdvice MeasurableHypotheses PACLearnable PACLearnableWithAdviceRegular TrueError TrueErrorReal bestAdvice splitUsedEquiv usedPrefix zeroOneLoss
Uses

Declused_sample_split_measureDeclaration kindtheorem

Split D^{m₁+m₂} into D^{m₁} × D^{m₂} via splitUsedEquiv.

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (m₁ m₂ : ℕ) (Success : Set ((Fin m₁ → X) × (Fin m₂ → X))),
  MeasurableSet Success →
    (MeasureTheory.Measure.pi fun x => D) (⇑(splitUsedEquiv✝ m₁ m₂) ⁻¹' Success) =
      ((MeasureTheory.Measure.pi fun x => D).prod (MeasureTheory.Measure.pi fun x => D)) Success

splitUsedEquiv

Used by

advice_elimination

DecltrueErrorReal_le_of_bestAdviceDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] {A : Type u_1} [inst_1 : Fintype A] [inst_2 : Nonempty A]
  (cand : A → Concept X Bool) (c : Concept X Bool) (D : MeasureTheory.Measure X) {m : ℕ} (Sval : Fin m → X × Bool)
  (η τ : ℝ),
  0 ≤ η →
    (∀ (a : A), |TrueErrorReal X (cand a) c D - EmpiricalError X Bool (cand a) Sval (zeroOneLoss Bool)| ≤ η) →
      ∀ (aStar : A),
        TrueErrorReal X (cand aStar) c D ≤ τ → TrueErrorReal X (cand (bestAdvice cand Sval)) c D ≤ τ + 2 * η

EmpiricalError FLT.Concept TrueErrorReal bestAdvice zeroOneLoss

Used by

advice_elimination

Declprob_ge_one_sub_complDeclaration kindtheorem

For a probability measure, μ(S) ≥ 1 - μ(Sᶜ), and hence μ(S) ≥ 1 - δ if μ(Sᶜ) ≤ δ.

∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ]
  (S : Set Ω) (δ : ENNReal), μ Sᶜ ≤ δ → μ S ≥ 1 - δ

Used by

advice_elimination

Declnat_pair_sample_marginalDeclaration kindtheorem

Sampling Nat.pair m₁ m₂ coordinates and taking the first m₁+m₂ gives the same measure as sampling m₁+m₂ coordinates directly. The extra junk coordinates integrate out via pi_cylinder_set_eq.

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  [MeasureTheory.SigmaFinite D] (m₁ m₂ : ℕ) (Success : Set (Fin (m₁ + m₂) → X)),
  MeasurableSet Success →
    (MeasureTheory.Measure.pi fun x => D) (usedPrefix✝ m₁ m₂ ⁻¹' Success) =
      (MeasureTheory.Measure.pi fun x => D) Success

usedPrefix

Uses

pi_cylinder_set_eq

Used by

advice_elimination

Declpi_cylinder_set_eqDeclaration kindtheorem

Cylinder set measure on product: if an event depends only on the first coordinates (those satisfying predicate p), then its measure under D^ι equals D^{p}(event). Uses piEquivPiSubtypeProd: D^ι ≃ D^{p} × D^{¬p}, and (D^{p} × D^{¬p})(A × univ) = D^{p}(A) · D^{¬p}(univ) = D^{p}(A).

∀ {ι : Type u_1} [inst : Fintype ι] [DecidableEq ι] {X : Type u} [inst_2 : MeasurableSpace X]
  (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D] [MeasureTheory.SigmaFinite D] (p : ι → Prop)
  [inst_5 : DecidablePred p] (S : Set ({ i // p i } → X)),
  MeasurableSet S →
    (MeasureTheory.Measure.pi fun x => D) {xs | (fun i => xs ↑i) ∈ S} = (MeasureTheory.Measure.pi fun x => D) S

Used by

nat_pair_sample_marginal

DecllearnWithAdvice_measurable_fixedDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] {A : Type u_1} (LA : LearnerWithAdvice X Bool A),
  AdviceEvalMeasurable LA → ∀ (a : A) {m : ℕ} (S : Fin m → X × Bool), Measurable (LA.learnWithAdvice a S)

AdviceEvalMeasurable LearnerWithAdvice LearnerWithAdvice.learnWithAdvice

Used by

advice_elimination

Declfinite_validation_family_boundDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] {A : Type u_1} [inst_1 : Fintype A] (D : MeasureTheory.Measure X)
  [MeasureTheory.IsProbabilityMeasure D] (c : Concept X Bool),
  Measurable c →
    ∀ (cand : A → Concept X Bool),
      (∀ (a : A), Measurable (cand a)) →
        ∀ (m : ℕ),
          0 < m →
            ∀ (η : ℝ),
              0 < η →
                η ≤ 1 →
                  (MeasureTheory.Measure.pi fun x => D)
                      {xs |
                        ∃ a,
                          |TrueErrorReal X (cand a) c D -
                                EmpiricalError X Bool (cand a) (fun i => (xs i, c (xs i))) (zeroOneLoss Bool)| ≥
                            η} ≤
                    ENNReal.ofReal (↑(Fintype.card A) * 2 * Real.exp (-2 * ↑m * η ^ 2))

EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Uses

hoeffding_one_sided
hoeffding_one_sided_upper

Used by

advice_elimination

Declhoeffding_one_sided_upperDeclaration kindtheorem

Upper-tail Hoeffding: for iid Bernoulli(p) draws, the empirical average overshoots the mean by ≥ t with probability ≤ exp(-2mt²).

This is the mirror of hoeffding_one_sided (which bounds the lower tail). The proof uses the same sub-Gaussian machinery with Z_i = indicator(x_i) - p (instead of p - indicator(x_i)).

∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
  (h c : Concept X Bool) (m : ℕ),
  0 < m →
    ∀ (t : ℝ),
      0 < t →
        t ≤ 1 →
          MeasurableSet {x | h x ≠ c x} →
            (MeasureTheory.Measure.pi fun x => D)
                {xs |
                  EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≥ TrueErrorReal X h c D + t} ≤
              ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))

EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss

Used by

finite_validation_family_bound

Declhoeffding_one_sidedDeclaration kindtheorem
One-sided Hoeffding: for iid Bernoulli(p) draws, the empirical average undershoots the mean by ≥ t with probability ≤ exp(-2mt²).
Proof strategy (3 steps):
1. MGF bound (Hoeffding's lemma): For X ∈ [0,1] with E[X] = p, E[exp(s(X-p))] ≤ exp(s²/8).
- Adapt from cosh_le_exp_sq_half infrastructure in Rademacher.lean.
- Key: convexity of exp on [0,1] gives E[exp(sX)] ≤ p·exp(s) + (1-p)·exp(0), then the s²/8 bound follows from ln(1 + x) ≤ x and Taylor expansion. have mgf_bound : ∀ (s : ℝ), ∫ x, Real.exp (s * (indicator x - p)) ∂D ≤ Real.exp (s^2 / 8) := by ...
2. Product independence: E[exp(s·∑(X_i-p))] = ∏ E[exp(s(X_i-p))] ≤ exp(ms²/8).
- Uses MeasureTheory.Measure.pi independence structure.
- Needs: Measure.pi integral factorization for product of functions.
- MEASURABILITY: fun xs => Real.exp (s * ∑ i, f (xs i)) is measurable (composition of measurable functions). have product_bound : ∀ (s : ℝ), ∫ xs, Real.exp (s * ∑ i, (indicator (xs i) - p)) ∂Measure.pi (fun _ => D) ≤ Real.exp (m * s^2 / 8) := by ...
3. Exponential Markov + optimize: P[∑(X_i-p) ≤ -mt] = P[exp(-s·∑(X_i-p)) ≥ exp(smt)] ≤ exp(-smt + ms²/8). Optimize over s: set s = 4t to get ≤ exp(-2mt²).
- Uses Markov's inequality in ENNReal form.
- CAST ISSUE: Markov gives ENNReal bound, need to convert exp(-2mt²) between ENNReal.ofReal and the measure value. have markov_step : ∀ (s : ℝ) (hs : 0 < s), Measure.pi (fun _ => D) {xs | ∑ i, (indicator (xs i) - p) ≤ -(m : ℝ) * t} ≤ ENNReal.ofReal (Real.exp (-(s * m * t) + m * s^2 / 8)) := by ... have optimize : Real.exp (-(4*t * m * t) + m * (4*t)^2 / 8) = Real.exp (-2 * m * t^2) := by ring_nf
CAST ISSUES to watch:
- m : ℕ needs cast to ℝ in the exponent: (m : ℝ)
- EmpiricalError returns ℝ, TrueErrorReal returns ℝ, good — no ENNReal gap
- The measure value is ENNReal, the bound exp(-2mt²) is ℝ≥0∞ via ENNReal.ofReal
References: SSBD Lemma B.3, Hoeffding (1963)
```
∀ {X : Type u} [inst : MeasurableSpace X] (D : MeasureTheory.Measure X) [MeasureTheory.IsProbabilityMeasure D]
 (h c : Concept X Bool) (m : ℕ),
 0 < m →
 ∀ (t : ℝ),
 0 < t →
 t ≤ 1 →
 MeasurableSet {x | h x ≠ c x} →
 (MeasureTheory.Measure.pi fun x => D)
 {xs |
 EmpiricalError X Bool h (fun i => (xs i, c (xs i))) (zeroOneLoss Bool) ≤ TrueErrorReal X h c D - t} ≤
 ENNReal.ofReal (Real.exp (-2 * ↑m * t ^ 2))
```
EmpiricalError FLT.Concept TrueErrorReal zeroOneLoss
Used by
- finite_validation_family_bound

DeclbestAdvice.congr_simpDeclaration kindtheorem

∀ {X : Type u} [inst : MeasurableSpace X] {A : Type u_1} [inst_1 : Fintype A] [inst_2 : Nonempty A]
  (cand cand_1 : A → Concept X Bool),
  cand = cand_1 →
    ∀ {m : ℕ} (Sval Sval_1 : Fin m → X × Bool), Sval = Sval_1 → bestAdvice cand Sval = bestAdvice cand_1 Sval_1

FLT.Concept bestAdvice

Used by

advice_elimination

DeclMeasurableHypotheses.mem_measurableDeclaration kindtheorem

∀ {X : Type u} {inst : MeasurableSpace X} {C : ConceptClass X Bool} [self : MeasurableHypotheses X C],
  ∀ h ∈ C, Measurable h

ConceptClass FLT.Concept MeasurableHypotheses

Used by

advice_elimination

Hypothesisa
```
PACLearnableWithAdviceRegular X C A
```
DefinitionAdviceEvalMeasurabledef
Joint measurability of a sample-dependent advice learner's evaluation map.
```
{X : Type u} → [MeasurableSpace X] → {A : Type u_1} → LearnerWithAdvice X Bool A → Prop
```
DefinitionBatchLearnerstructure
A batch learner (PAC paradigm): takes a finite sample, returns a hypothesis.
```
Type u → Type v → Type (max u v)
```

DefinitionBatchLearner.learndef

The learning algorithm: given a sample, produce a hypothesis

{X : Type u} → {Y : Type v} → BatchLearner X Y → {m : ℕ} → (Fin m → X × Y) → Concept X Y

DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```

DefinitionEmpiricalErrordef

Empirical error: average loss on a finite sample.

(X : Type u) → (Y : Type v) → Concept X Y → {m : ℕ} → (Fin m → X × Y) → LossFunction Y → ℝ

DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionLearnerWithAdvicestructure
A learner augmented with advice.
```
Type u → Type v → Type u_1 → Type (max (max u u_1) v)
```

DefinitionLearnerWithAdvice.learnWithAdvicedef

Advice-augmented learning: advice → sample → hypothesis

{X : Type u} → {Y : Type v} → {A : Type u_1} → LearnerWithAdvice X Y A → A → {m : ℕ} → (Fin m → X × Y) → Concept X Y

DefinitionMeasurableHypothesesstructure
Every concept in C is a measurable function. Krapp-Wirth precondition: Γ(h) ∈ Σ_Z for all h ∈ H.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```
DefinitionPACLearnabledef
PAC (Probably Approximately Correct) learning. The central definition of computational learning theory.
Sample space: Fin m → X with i.i.d. product measure D^m. Labels: derived deterministically from target concept c (realizable case). Error: D-probability of disagreement between learner output and c.
```
(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → Prop
```

DefinitionPACLearnableWithAdviceRegulardef

PAC learnability with finite advice, plus measurability for holdout validation.

(X : Type u) → [MeasurableSpace X] → ConceptClass X Bool → (A : Type u_1) → [Fintype A] → [Nonempty A] → Prop

DefinitionTrueErrordef
True error (0-1 loss, realizable case): D-probability of disagreement. This is what PACLearnable's success event measures.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ENNReal
```
DefinitionTrueErrorRealdef
True error in ℝ: for use in bounds involving subtraction/absolute value. COUNTER-1 of TrueError. The toReal bridge loses information when the measure is ⊤.
```
(X : Type u) → [inst : MeasurableSpace X] → Concept X Bool → Concept X Bool → MeasureTheory.Measure X → ℝ
```

DefinitionbestAdvicedef

Choose the advice value with minimum validation empirical error.

{X : Type u} →
  [MeasurableSpace X] →
    {A : Type u_1} → [Fintype A] → [Nonempty A] → (A → Concept X Bool) → {m : ℕ} → (Fin m → X × Bool) → A

DefinitionsplitUsedEquivdef

Split Fin (m₁ + m₂) → X into (Fin m₁ → X) × (Fin m₂ → X) measurably.

{X : Type u} → [inst : MeasurableSpace X] → (m₁ m₂ : ℕ) → (Fin (m₁ + m₂) → X) ≃ᵐ (Fin m₁ → X) × (Fin m₂ → X)

DefinitionusedPrefixdef

Extract the first m₁ + m₂ coordinates from a sample of size Nat.pair m₁ m₂.

{X : Type u} → [MeasurableSpace X] → (m₁ m₂ : ℕ) → (Fin (Nat.pair m₁ m₂) → X) → Fin (m₁ + m₂) → X

DefinitionzeroOneLossdef
The 0-1 loss for classification.
```
(Y : Type v) → [DecidableEq Y] → LossFunction Y
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

VC dimension of homogeneous linear halfspaces is exactly n (Cover 1965; Vapnik–Chervonenkis). The class signClass (coordSpace n) of homogeneous linear halfspaces of ℝⁿ has VC dimension equal to the ambient dimension n: the Dudley bound gives ≤ n, and the n standard basis points are shattered, giving ≥ n.

DeclFLT.Halfspace.vcDim_halfspace_eq

∀ (n : ℕ), VCDim (Fin n → ℝ) (signClass (FLT.Halfspace.coordSpace n)) = ↑n

ThesisStepDefinition

DeclFLT.Halfspace.vcDim_halfspace_eqDeclaration kindtheorem
```
∀ (n : ℕ), VCDim (Fin n → ℝ) (signClass (FLT.Halfspace.coordSpace n)) = ↑n
```
FLT.Halfspace.coordSpace VCDim signClass
Uses
- FLT.Halfspace.vcDim_halfspace_ge
- FLT.Halfspace.vcDim_halfspace_le
DeclFLT.Halfspace.vcDim_halfspace_leDeclaration kindtheorem
VC dimension of homogeneous linear halfspaces: the Dudley upper bound.
The class of homogeneous linear halfspaces x ↦ (0 < ⟨w, x⟩) in ℝⁿ has VC dimension at most n. This is the canonical instance of Dudley's bound (vcDim_signClass_le): the underlying function space is coordSpace n, of dimension n. (Cover 1965; Vapnik–Chervonenkis.)
```
∀ (n : ℕ), VCDim (Fin n → ℝ) (signClass (FLT.Halfspace.coordSpace n)) ≤ ↑n
```
FLT.Halfspace.coordSpace VCDim signClass
Uses
Used by
- FLT.Halfspace.vcDim_halfspace_eq
DeclvcDim_signClass_leDeclaration kindtheorem
Dudley's bound. The VC dimension of the linear sign class of a finite-dimensional subspace V ≤ (X → ℝ) is at most dim V.
```
∀ {X : Type u} (V : Submodule ℝ (X → ℝ)) [FiniteDimensional ℝ ↥V], VCDim X (signClass V) ≤ ↑(Module.finrank ℝ ↥V)
```
ConceptClass FLT.Concept Shatters VCDim evalAt signClass
Used by
- FLT.Halfspace.vcDim_halfspace_le
DeclFLT.Halfspace.finrank_coordSpaceDeclaration kindtheorem
The dimension of the coordinate space is n. The coordinate functionals form the dual basis of ℝⁿ, so their span has dimension n.
```
∀ (n : ℕ), Module.finrank ℝ ↥(FLT.Halfspace.coordSpace n) = n
```
FLT.Halfspace.coord FLT.Halfspace.coordSpace
Uses
- FLT.Halfspace.linearIndependent_coord
Used by
- FLT.Halfspace.vcDim_halfspace_le
DeclFLT.Halfspace.linearIndependent_coordDeclaration kindtheorem
The coordinate functionals are linearly independent. They are the dual basis of the standard basis; concretely, evaluating a vanishing combination at each standard basis point Pi.single j 1 isolates the j-th coefficient.
```
∀ (n : ℕ), LinearIndependent ℝ (FLT.Halfspace.coord n)
```
FLT.Halfspace.coord
Uses
- FLT.Halfspace.coord_single
Used by
- FLT.Halfspace.finrank_coordSpace
DeclFLT.Halfspace.coord_singleDeclaration kindtheorem
Evaluating the i-th coordinate functional at the j-th standard basis point gives the identity matrix: coord n i (Pi.single j 1) = if i = j then 1 else 0.
```
∀ (n : ℕ) (i j : Fin n), FLT.Halfspace.coord n i (Pi.single j 1) = if i = j then 1 else 0
```
FLT.Halfspace.coord
Used by
- FLT.Halfspace.linearIndependent_coord
DeclFLT.Halfspace.finiteDimensional_coordSpaceDeclaration kindtheorem
The coordinate space is finite-dimensional (it is the span of a finite family).
```
∀ (n : ℕ), FiniteDimensional ℝ ↥(FLT.Halfspace.coordSpace n)
```
FLT.Halfspace.coord FLT.Halfspace.coordSpace
Used by
- FLT.Halfspace.vcDim_halfspace_le
DeclFLT.Halfspace.vcDim_halfspace_geDeclaration kindtheorem
VC dimension of homogeneous linear halfspaces: the lower bound. The n standard basis points are shattered, so the VC dimension is at least n.
```
∀ (n : ℕ), ↑n ≤ VCDim (Fin n → ℝ) (signClass (FLT.Halfspace.coordSpace n))
```
FLT.Halfspace.basisPoints FLT.Halfspace.coordSpace Shatters VCDim signClass
Uses
- FLT.Halfspace.card_basisPoints
- FLT.Halfspace.shatters_basisPoints
Used by
- FLT.Halfspace.vcDim_halfspace_eq
DeclFLT.Halfspace.shatters_basisPointsDeclaration kindtheorem
The standard basis points are shattered by homogeneous halfspaces. Given any labelling, the ±1-weighted functional g x = ∑ i, w i * x i with w i = ±1 selected by the label realises it: g (Pi.single j 1) = w j, and 0 < w j iff the label is true.
```
∀ (n : ℕ), Shatters (Fin n → ℝ) (signClass (FLT.Halfspace.coordSpace n)) (FLT.Halfspace.basisPoints n)
```
ConceptClass FLT.Concept FLT.Halfspace.basisPoints FLT.Halfspace.coordSpace Shatters signClass
Uses
Used by
- FLT.Halfspace.vcDim_halfspace_ge
DeclFLT.Halfspace.weighted_singleDeclaration kindtheorem
A weighted functional evaluated at a standard basis point returns that point's weight: (∑ i, w i * (Pi.single j 1) i) = w j.
```
∀ (n : ℕ) (w : Fin n → ℝ) (j : Fin n), ∑ i, w i * Pi.single j 1 i = w j
```
Used by
- FLT.Halfspace.shatters_basisPoints
DeclFLT.Halfspace.weighted_mem_coordSpaceDeclaration kindtheorem
A ±1-weighted coordinate functional belongs to the coordinate space. Concretely, for any weights w : Fin n → ℝ, the functional x ↦ ∑ i, w i * x i is a member of coordSpace n.
```
∀ (n : ℕ) (w : Fin n → ℝ), (fun x => ∑ i, w i * x i) ∈ FLT.Halfspace.coordSpace n
```
FLT.Halfspace.coord FLT.Halfspace.coordSpace
Used by
- FLT.Halfspace.shatters_basisPoints
DeclFLT.Halfspace.single_mem_basisPointsDeclaration kindtheorem
Each standard basis point lies in basisPoints n.
```
∀ (n : ℕ) (i : Fin n), Pi.single i 1 ∈ FLT.Halfspace.basisPoints n
```
FLT.Halfspace.basisPoints
Used by
- FLT.Halfspace.shatters_basisPoints
DeclFLT.Halfspace.card_basisPointsDeclaration kindtheorem
There are exactly n standard basis points.
```
∀ (n : ℕ), (FLT.Halfspace.basisPoints n).card = n
```
FLT.Halfspace.basisPoints
Uses
- FLT.Halfspace.single_injective
Used by
- FLT.Halfspace.vcDim_halfspace_ge
DeclFLT.Halfspace.single_injectiveDeclaration kindtheorem
The map i ↦ Pi.single i 1 is injective (the basis points are distinct).
```
∀ (n : ℕ), Function.Injective fun i => Pi.single i 1
```
Used by
- FLT.Halfspace.card_basisPoints
DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```
DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionFLT.Halfspace.basisPointsdef
The n standard basis points {Pi.single i 1 | i : Fin n} of ℝⁿ. These are the witnesses for the VC-dimension lower bound.
```
(n : ℕ) → Finset (Fin n → ℝ)
```
DefinitionFLT.Halfspace.coorddef
The i-th coordinate functional x ↦ x i on Fin n → ℝ, viewed as an element of the function space (Fin n → ℝ) → ℝ.
```
(n : ℕ) → Fin n → (Fin n → ℝ) → ℝ
```
DefinitionFLT.Halfspace.coordSpacedef
The coordinate space: the span of the n coordinate functionals (fun x => x i) inside (Fin n → ℝ) → ℝ. This is the (dual) space of homogeneous linear functionals on ℝⁿ; its sign class is exactly the family of homogeneous linear halfspaces.
```
(n : ℕ) → Submodule ℝ ((Fin n → ℝ) → ℝ)
```
DefinitionShattersdefYaël Dillies
A set S ⊆ X is shattered by concept class C if every labeling of S is realized by some concept in C.
```
(X : Type u) → ConceptClass X Bool → Finset X → Prop
```
DefinitionVCDimdef
VC dimension of a concept class: the size of the largest shattered set. Returns ℕ∞ = WithTop ℕ.
```
(X : Type u) → ConceptClass X Bool → WithTop ℕ
```
DefinitionevalAtdef
Evaluation at a point x : X as a linear functional on V: g ↦ (g : X → ℝ) x.
```
{X : Type u} → (V : Submodule ℝ (X → ℝ)) → X → ↥V →ₗ[ℝ] ℝ
```
DefinitionsignClassdef
The sign-pattern concept class of a subspace V ≤ (X → ℝ): all concepts of the form x ↦ decide (0 < g x) for some g ∈ V.
```
{X : Type u} → Submodule ℝ (X → ℝ) → ConceptClass X Bool
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

Assouad's dual VC bound. If VCDim X C ≤ d, then VCDim(dualClass C) ≤ 2^(d+1) − 1.

DeclvcDim_dualClass_le

∀ {X : Type u} {C : ConceptClass X Bool} {d : ℕ}, VCDim X C ≤ ↑d → VCDim (↑C) (dualClass C) ≤ ↑(2 ^ (d + 1) - 1)

ThesisStepHypothesisDefinition

DeclvcDim_dualClass_leDeclaration kindtheorem

∀ {X : Type u} {C : ConceptClass X Bool} {d : ℕ}, VCDim X C ≤ ↑d → VCDim (↑C) (dualClass C) ≤ ↑(2 ^ (d + 1) - 1)

ConceptClass FLT.Concept Shatters VCDim dualClass

Uses

dualClass_shatters_imp_shatters

DecldualClass_shatters_imp_shattersDeclaration kindtheorem
Assouad's coding lemma. If the dual class shatters a set S of concepts with 2^(d+1) ≤ S.card, then C shatters some set of d + 1 points.
Index 2^(d+1) of the shattered concepts by bitstrings; for each coordinate k, dual shattering realizes the labelling "is this codeword in the k-th bit slice", which supplies a point x k reading off exactly that bit. These d + 1 points are then shattered by C.
```
∀ {X : Type u} {C : ConceptClass X Bool} {d : ℕ} (S : Finset ↑C),
  Shatters (↑C) (dualClass C) S → 2 ^ (d + 1) ≤ S.card → ∃ T, T.card = d + 1 ∧ Shatters X C T
```
ConceptClass FLT.Concept Shatters cubeBitSlice cubeEmbedding dualClass
Uses
- mem_cubeBitSlice_iff
Used by
- vcDim_dualClass_le

Declmem_cubeBitSlice_iffDeclaration kindtheorem

Codeword (cube b).val is in cubeBitSlice cube k iff b k = true.

∀ {X : Type u} {C : ConceptClass X Bool} {n : ℕ} {S : Finset ↑C} (cube : (Fin n → Bool) ↪ ↥S) (b : Fin n → Bool)
  (k : Fin n), ↑(cube b) ∈ cubeBitSlice✝ cube k ↔ b k = true

ConceptClass FLT.Concept cubeBitSlice

Used by

dualClass_shatters_imp_shatters

Hypothesishd
```
VCDim X C ≤ ↑d
```
DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```
DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionShattersdefYaël Dillies
A set S ⊆ X is shattered by concept class C if every labeling of S is realized by some concept in C.
```
(X : Type u) → ConceptClass X Bool → Finset X → Prop
```
DefinitionVCDimdef
VC dimension of a concept class: the size of the largest shattered set. Returns ℕ∞ = WithTop ℕ.
```
(X : Type u) → ConceptClass X Bool → WithTop ℕ
```

DefinitioncubeBitSlicedef

The image of {b : Fin n → Bool | b k = true} under a cube embedding: the codewords whose k-th bit is set.

{X : Type u} → {C : ConceptClass X Bool} → {n : ℕ} → {S : Finset ↑C} → ((Fin n → Bool) ↪ ↥S) → Fin n → Finset ↑C

DefinitioncubeEmbeddingdef
Embedding (Fin n → Bool) ↪ ↥S when 2 ^ n ≤ S.card, via (Fin n → Bool) ≃ Fin (2 ^ n) ↪ Fin S.card ≃ ↥S.
```
{X : Type u} → {C : ConceptClass X Bool} → {n : ℕ} → (S : Finset ↑C) → 2 ^ n ≤ S.card → (Fin n → Bool) ↪ ↥S
```
DefinitiondualClassdef
The dual concept class: each point x : X gives the evaluation concept c ↦ c x on the new domain ↥C. The dual class collects these over all points.
```
{X : Type u} → (C : ConceptClass X Bool) → ConceptClass (↑C) Bool
```

Dhruv GuptaZetetic-Dhruvperson2026-09-24T00:00:00Z

CitesYaël Dillies

Assouad's lower bound. For a finite-VC class, ⌊log₂ VCDim⌋ ≤ VCDim(dualClass): the exponential blow-up under dualization is necessary, not merely permitted. Together with the proven upper bound vcDim_dualClass_le (VCDim(dual) ≤ 2^(VCDim+1) − 1) this sandwiches the dual VC dimension between ⌊log₂ d⌋ and 2^(d+1) − 1.

Stated with d := VCDim C extracted as a natural number (finite by hypothesis). The proof picks a shattered set T with 2^(log₂ d) ≤ |T| (which exists because 2^(log₂ d) ≤ d ≤ |T| for the supremal shattered set) and applies pow_le_vcDim_imp_le_vcDim_dualClass.

Decllog₂_vcDim_le_vcDim_dualClass

∀ {X : Type u} {C : ConceptClass X Bool} {d : ℕ}, VCDim X C = ↑d → 0 < d → ↑(Nat.log 2 d) ≤ VCDim (↑C) (dualClass C)

ThesisStepHypothesisDefinition

Decllog₂_vcDim_le_vcDim_dualClassDeclaration kindtheorem
```
∀ {X : Type u} {C : ConceptClass X Bool} {d : ℕ}, VCDim X C = ↑d → 0 < d → ↑(Nat.log 2 d) ≤ VCDim (↑C) (dualClass C)
```
ConceptClass FLT.Concept Shatters VCDim dualClass
Uses
- pow_le_vcDim_imp_le_vcDim_dualClass
Declpow_le_vcDim_imp_le_vcDim_dualClassDeclaration kindtheorem
Assouad's lower construction. If C shatters a set T of at least 2^k points, then dualClass C shatters a set of k evaluation concepts, so k ≤ VCDim(dualClass C).
Bitstrings index a 2^k-subset of T; coordinate j is realized by a concept c_j ∈ C reading off the j-th bit, and the dual class shatters {c_j} because the evaluation point indexed by a bitstring σ realizes exactly the labelling σ of the c_j.
```
∀ {X : Type u} {C : ConceptClass X Bool} {k : ℕ} (T : Finset X),
  Shatters X C T → 2 ^ k ≤ T.card → ↑k ≤ VCDim (↑C) (dualClass C)
```
ConceptClass FLT.Concept Shatters VCDim dualClass evalConcept
Uses
- evalConcept_mem
Used by
- log₂_vcDim_le_vcDim_dualClass
DeclevalConcept_memDeclaration kindtheorem
Each evaluation concept belongs to the dual class.
```
∀ {X : Type u} (C : ConceptClass X Bool) (x : X), evalConcept C x ∈ dualClass C
```
ConceptClass FLT.Concept dualClass evalConcept
Used by
- pow_le_vcDim_imp_le_vcDim_dualClass
Hypothesishd
```
VCDim X C = ↑d
```
Hypothesishd0
```
0 < d
```
DefinitionConceptClassdef
A concept class is a set of concepts. Used by every paradigm, complexity measure, and criterion.
Primary definition: Set of functions. Used for PAC/agnostic PAC where concept classes are sets over which VC dimension, Rademacher complexity, covering numbers, etc. are measured. Alternative definitions below for contexts requiring decidability, enumerability, or measurability.
```
Type u → Type v → Type (max v u)
```
DefinitionFLT.Conceptdef
A concept is a function from domain to label. This is the atomic unit that concept classes collect and learners try to approximate.
```
Type u → Type v → Type (max u v)
```
DefinitionShattersdefYaël Dillies
A set S ⊆ X is shattered by concept class C if every labeling of S is realized by some concept in C.
```
(X : Type u) → ConceptClass X Bool → Finset X → Prop
```
DefinitionVCDimdef
VC dimension of a concept class: the size of the largest shattered set. Returns ℕ∞ = WithTop ℕ.
```
(X : Type u) → ConceptClass X Bool → WithTop ℕ
```
DefinitiondualClassdef
The dual concept class: each point x : X gives the evaluation concept c ↦ c x on the new domain ↥C. The dual class collects these over all points.
```
{X : Type u} → (C : ConceptClass X Bool) → ConceptClass (↑C) Bool
```
DefinitionevalConceptdef
The evaluation concept at a point x: the map c ↦ c x on ↥C.
```
{X : Type u} → (C : ConceptClass X Bool) → X → ↑C → Bool
```