Walsh–Fourier analysis on the uniform cube and the KKL reduction
Definition\(\pm 1\) value of a bit#✓fully proved
The ±1 value of a bit: false ↦ 1, true ↦ -1.
def khc_sign (b : Bool) : ℝ := if b then -1 else 1
Used by 6
DefinitionWalsh character on the Boolean cube#✓fully proved
The Walsh character χ_S(x) = ∏_{i ∈ S} (-1)^{x i} on {0, 1}^ι.
This legacy sign convention is retained for KKL consumers; its proofs use
BooleanCube.cubeChi through khc_walshChar_eq_cubeChi.
noncomputable def khc_walshChar (S : Finset ι) (x : ι → Bool) : ℝ :=
∏ i ∈ S, khc_sign (x i)
def khc_sign (b : Bool) : ℝ := if b then -1 else 1
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:72
Uses 1 · Used by 12
DefinitionFourier–Walsh coefficient under the uniform measure#✓fully proved
The Fourier–Walsh coefficient f̂(S) = 𝔼[f χ_S] under the uniform measure.
This retains the legacy signs; khc_fourierCoeff_eq_boolFourierCoeff transports
the canonical Fourier identities used below.
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
noncomputable def bnt_uexp (f : (ι → Bool) → ℝ) : ℝ :=
(∑ ω : ι → Bool, f ω) / (2 ^ (Fintype.card ι))
MathlibExt/Probability/Hypercontractivity/BonamiTensorize.lean:66
noncomputable def khc_walshChar (S : Finset ι) (x : ι → Bool) : ℝ :=
∏ i ∈ S, khc_sign (x i)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:84
Uses 2 · Used by 33
DefinitionReindexing a cube function along an index bijection#✓fully proved
The function f on {0, 1}^ι transported to {0, 1}^κ along the bijection e : κ ≃ ι.
noncomputable def khc_reindex {κ : Type*} (e : κ ≃ ι) (f : (ι → Bool) → ℝ) :
(κ → Bool) → ℝ :=
fun y => f (fun i => y (e.symm i))
Used by 14
DefinitionCube bijection induced by an index bijection#✓fully proved
The bijection {0, 1}^ι ≃ {0, 1}^κ induced by e : κ ≃ ι.
def khc_cubeEquiv {κ : Type*} (e : κ ≃ ι) : (ι → Bool) ≃ (κ → Bool) :=
Equiv.arrowCongr e.symm (Equiv.refl Bool)
Used by 11
TheoremWalsh character agrees with the canonical cube character up to sign#✓fully proved
On Fin n, the Walsh character is BooleanCube.cubeChi up to the sign (-1)^{|S|}:
BooleanCube.cubeVal sends true to 1, while khc_sign sends it to -1.
theorem khc_walshChar_eq_cubeChi {n : ℕ} (S : Finset (Fin n)) (x : Fin n → Bool) :
khc_walshChar S x = (-1) ^ S.card * BooleanCube.cubeChi n S x
noncomputable def khc_walshChar (S : Finset ι) (x : ι → Bool) : ℝ :=
∏ i ∈ S, khc_sign (x i)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:84
def cubeChi (n : ℕ) (S : Finset (Fin n)) (x : BoolCube n) : ℝ :=
∏ i ∈ S, cubeVal (x i)
MathlibExt/Analysis/Fourier/BooleanCube.lean:58
Uses 4 · Used by 4
TheoremWalsh coefficient is the canonical Fourier coefficient up to sign#✓fully proved
On Fin n, the Fourier coefficient is BooleanCube.boolFourierCoeff up to the sign
(-1)^{|S|}.
theorem khc_fourierCoeff_eq_boolFourierCoeff {n : ℕ} (f : (Fin n → Bool) → ℝ)
(S : Finset (Fin n)) :
khc_fourierCoeff f S = (-1) ^ S.card * BooleanCube.boolFourierCoeff n f S
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
noncomputable def boolFourierCoeff (n : ℕ) (f : BoolCube n → ℝ)
(S : Finset (Fin n)) : ℝ :=
(∑ x : BoolCube n, f x * cubeChi n S x) / (Fintype.card (BoolCube n) : ℝ)
MathlibExt/Analysis/Fourier/BooleanCube.lean:62
Uses 8 · Used by 7
TheoremReindexing a Walsh character reindexes its coordinate set#✓fully proved
Reindexing a Walsh character reindexes its finite set of coordinates.
theorem khc_walshChar_reindex {κ : Type*} (e : ι ≃ κ) (S : Finset ι) :
khc_reindex e.symm (khc_walshChar S) = khc_walshChar (e.finsetCongr S)
noncomputable def khc_reindex {κ : Type*} (e : κ ≃ ι) (f : (ι → Bool) → ℝ) :
(κ → Bool) → ℝ :=
fun y => f (fun i => y (e.symm i))
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:120
noncomputable def khc_walshChar (S : Finset ι) (x : ι → Bool) : ℝ :=
∏ i ∈ S, khc_sign (x i)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:84
Uses 3 · Used by 4
TheoremReindexing preserves values at corresponding cube points#✓fully proved
Reindexing back at the corresponding cube point recovers the original value.
theorem khc_reindex_cubeEquiv {κ : Type*} (e : κ ≃ ι) (f : (ι → Bool) → ℝ)
(x : ι → Bool) : khc_reindex e f (khc_cubeEquiv e x) = f x
noncomputable def khc_reindex {κ : Type*} (e : κ ≃ ι) (f : (ι → Bool) → ℝ) :
(κ → Bool) → ℝ :=
fun y => f (fun i => y (e.symm i))
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:120
def khc_cubeEquiv {κ : Type*} (e : κ ≃ ι) : (ι → Bool) ≃ (κ → Bool) :=
Equiv.arrowCongr e.symm (Equiv.refl Bool)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:125
TheoremFourier coefficients are invariant under reindexing#✓fully proved
Fourier coefficients are unchanged when both the function and its index are reindexed.
theorem khc_fourierCoeff_reindex {κ : Type*} [Fintype κ] [DecidableEq κ]
(e : ι ≃ κ) (f : (ι → Bool) → ℝ) (S : Finset ι) :
khc_fourierCoeff (khc_reindex e.symm f) (e.finsetCongr S) = khc_fourierCoeff f S
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
noncomputable def khc_reindex {κ : Type*} (e : κ ≃ ι) (f : (ι → Bool) → ℝ) :
(κ → Bool) → ℝ :=
fun y => f (fun i => y (e.symm i))
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:120
Uses 6 · Used by 7
TheoremFourier inversion on the Boolean cube#✓fully proved
Fourier inversion: f = ∑_S f̂(S) χ_S.
theorem khc_fourier_expansion (f : (ι → Bool) → ℝ) (x : ι → Bool) :
(∑ S : Finset ι, khc_fourierCoeff f S * khc_walshChar S x) = f x
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
noncomputable def khc_walshChar (S : Finset ι) (x : ι → Bool) : ℝ :=
∏ i ∈ S, khc_sign (x i)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:84
Uses 12 · Used by 1
TheoremParseval's identity on the Boolean cube#✓fully proved
Parseval's identity: 𝔼[f g] = ∑_S f̂(S) ĝ(S).
Transported from BooleanCube.expect_mul_eq_sum_boolFourierCoeff_mul.
theorem khc_parseval (f g : (ι → Bool) → ℝ) :
bnt_uexp (fun x => f x * g x)
= ∑ S : Finset ι, khc_fourierCoeff f S * khc_fourierCoeff g S
noncomputable def bnt_uexp (f : (ι → Bool) → ℝ) : ℝ :=
(∑ ω : ι → Bool, f ω) / (2 ^ (Fintype.card ι))
MathlibExt/Probability/Hypercontractivity/BonamiTensorize.lean:66
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
Uses 10 · Used by 1
TheoremNoise operator is diagonal in the Walsh basis#✓fully proved
The noise operator acts diagonally on the Walsh basis: T_ρ f = ∑_S ρ^{|S|} f̂(S) χ_S.
Transported from BooleanCube.boolNoiseOp_eq_sum, for every real ρ.
theorem khc_noiseOp_fourier (ρ : ℝ) (f : (ι → Bool) → ℝ) :
bnt_noiseOp ρ f
= fun x => ∑ S : Finset ι, (ρ ^ S.card * khc_fourierCoeff f S) * khc_walshChar S x
noncomputable def bnt_noiseOp (ρ : ℝ) (f : (ι → Bool) → ℝ) : (ι → Bool) → ℝ :=
fun x => ∑ y : ι → Bool, bnt_noiseKernel ρ x y * f y
MathlibExt/Probability/Hypercontractivity/BonamiTensorize.lean:93
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
noncomputable def khc_walshChar (S : Finset ι) (x : ι → Bool) : ℝ :=
∏ i ∈ S, khc_sign (x i)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:84
Uses 16
TheoremBonami–Beckner hypercontractive inequality#✓fully proved
Bonami–Beckner hypercontractive inequality (A. Bonami, Étude des coefficients de Fourier
des fonctions de Lᵖ(G), Ann. Inst. Fourier 1970; W. Beckner, Inequalities in Fourier
analysis, Ann. of Math. 1975): ‖T_ρ g‖₂ ≤ ‖g‖_{1+ρ²} on {0, 1}^ι for 0 ≤ ρ ≤ 1.
theorem khc_hypercontractivity_general {ρ : ℝ} (h0 : 0 ≤ ρ) (h1 : ρ ≤ 1)
(g : (ι → Bool) → ℝ) :
bnt_qnorm 2 (bnt_noiseOp ρ g) ≤ bnt_qnorm (1 + ρ ^ 2) g
noncomputable def bnt_qnorm (q : ℝ) (f : (ι → Bool) → ℝ) : ℝ :=
(bnt_qnormPow q f) ^ (1 / q)
MathlibExt/Probability/Hypercontractivity/BonamiTensorize.lean:74
noncomputable def bnt_noiseOp (ρ : ℝ) (f : (ι → Bool) → ℝ) : (ι → Bool) → ℝ :=
fun x => ∑ y : ι → Bool, bnt_noiseKernel ρ x y * f y
MathlibExt/Probability/Hypercontractivity/BonamiTensorize.lean:93
Uses 9 · Used by 2
TheoremHypercontractivity in Fourier form#✓fully proved
Hypercontractivity in Fourier form: ∑_S ρ^{2|S|} f̂(S)² ≤ ‖f‖²_{1+ρ²}.
theorem khc_lowDegreeWeight_le {ρ : ℝ} (h0 : 0 ≤ ρ) (h1 : ρ ≤ 1)
(f : (ι → Bool) → ℝ) :
(∑ S : Finset ι, (ρ ^ S.card) ^ 2 * (khc_fourierCoeff f S) ^ 2)
≤ (bnt_qnorm (1 + ρ ^ 2) f) ^ 2
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
noncomputable def bnt_qnorm (q : ℝ) (f : (ι → Bool) → ℝ) : ℝ :=
(bnt_qnormPow q f) ^ (1 / q)
MathlibExt/Probability/Hypercontractivity/BonamiTensorize.lean:74
Uses 18 · Used by 2
TheoremVariance as Fourier weight off the empty set#✓fully proved
Variance under the uniform measure is the Fourier weight off the empty set.
theorem khc_var_eq_fourierWeight (g : ConfigSpace ι → ℝ) :
OSSS.var (OSSS.bernoulliWeight (1 / 2 : ℝ)) g
= ∑ S ∈ (univ.erase (∅ : Finset ι)), (khc_fourierCoeff g S) ^ 2
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
noncomputable def var (ν : E → Bool → ℝ) (g : ConfigSpace E → ℝ) : ℝ := cov ν g g
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:161
noncomputable def bernoulliWeight (p : ℝ) : E → Bool → ℝ :=
fun _ b => if b then p else 1 - p
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:915
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
Uses 18 · Used by 1
TheoremEvent influence is four times the canonical influence#✓fully proved
Event influence is four times canonical quarter-square influence after reindexing.
theorem khc_infl_eq_four_boolInfluence {n : ℕ} (e : ι ≃ Fin n)
(φ : ConfigSpace ι → Bool) (i : ι) :
OSSS.infl (OSSS.bernoulliWeight (1 / 2 : ℝ))
(fun x => if φ x then (1 : ℝ) else 0) i =
4 * BooleanCube.boolInfluence
(khc_reindex e.symm (fun x => if φ x then (1 : ℝ) else 0)) (e i)
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
noncomputable def infl (ν : E → Bool → ℝ) (g : ConfigSpace E → ℝ) (e : E) : ℝ :=
expect ν (fun ω => |g (setOpen e ω) - g (setClosed e ω)|)
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:168
noncomputable def bernoulliWeight (p : ℝ) : E → Bool → ℝ :=
fun _ b => if b then p else 1 - p
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:915
noncomputable def boolInfluence (f : BoolCube n → ℝ) (i : Fin n) : ℝ :=
𝔼 x, ((f x - f (flipCoord x i)) / 2) ^ 2
MathlibExt/Analysis/Fourier/BooleanCubeInfluence.lean:302
noncomputable def khc_reindex {κ : Type*} (e : κ ≃ ι) (f : (ι → Bool) → ℝ) :
(κ → Bool) → ℝ :=
fun y => f (fun i => y (e.symm i))
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:120
Uses 14 · Used by 2
TheoremInfluence of a coordinate as Fourier weight#✓fully proved
The influence of e on a Boolean function is ∑_{S ∋ e} 4 f̂(S)².
theorem khc_infl_eq_fourierWeight (φ : ConfigSpace ι → Bool) (e : ι) :
OSSS.infl (OSSS.bernoulliWeight (1 / 2 : ℝ)) (fun ω => if φ ω then (1 : ℝ) else 0) e
= ∑ S ∈ univ.filter (fun S : Finset ι => e ∈ S),
4 * (khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
noncomputable def infl (ν : E → Bool → ℝ) (g : ConfigSpace E → ℝ) (e : E) : ℝ :=
expect ν (fun ω => |g (setOpen e ω) - g (setClosed e ω)|)
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:168
noncomputable def bernoulliWeight (p : ℝ) : E → Bool → ℝ :=
fun _ b => if b then p else 1 - p
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:915
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
Uses 11
TheoremTotal influence as Fourier weight#✓fully proved
The total influence of a Boolean function is ∑_S 4 |S| f̂(S)².
theorem khc_totalInfl_eq_fourierWeight (φ : ConfigSpace ι → Bool) :
totalInfl (OSSS.bernoulliWeight (1 / 2 : ℝ)) (fun ω => if φ ω then (1 : ℝ) else 0)
= ∑ S : Finset ι, 4 * (S.card : ℝ)
* (khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
noncomputable def totalInfl (ν : E → Bool → ℝ) (g : ConfigSpace E → ℝ) : ℝ :=
∑ e, OSSS.infl ν g e
CSLibExt/Complexity/BooleanFunctions/KKL/KKLInequality.lean:62
noncomputable def bernoulliWeight (p : ℝ) : E → Bool → ℝ :=
fun _ b => if b then p else 1 - p
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:915
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
Uses 14 · Used by 4
DefinitionFourier-form KKL inequality given the hypercontractive bound#✓fully proved
The KKL inequality at p = 1/2 in Fourier form, with the hypercontractive bound as a
hypothesis: for every Boolean φ, if ∑_S ρ^{2|S|} f̂(S)² ≤ ‖f‖²_{1+ρ²} for all ρ ∈ [0, 1],
then c · ∑_{S ≠ ∅} f̂(S)² · log (1 / maxₑ Infₑ(f)) ≤ ∑_S 4 |S| f̂(S)², where f = 1_φ. The
hypothesis always holds (khc_lowDegreeWeight_le).
def khc_LogSobolevStep (c : ℝ) : Prop :=
∀ {E : Type} [Fintype E] [DecidableEq E] [Nonempty E] (φ : ConfigSpace E → Bool),
(∀ ρ : ℝ, 0 ≤ ρ → ρ ≤ 1 →
(∑ S : Finset E, (ρ ^ S.card) ^ 2
* (khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2)
≤ (bnt_qnorm (1 + ρ ^ 2) (fun ω => if φ ω then (1 : ℝ) else 0)) ^ 2) →
c * (∑ S ∈ (univ.erase (∅ : Finset E)),
(khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2)
* Real.log (1 / maxInfl (OSSS.bernoulliWeight (1 / 2 : ℝ))
(fun ω => if φ ω then (1 : ℝ) else 0))
≤ ∑ S : Finset E, 4 * (S.card : ℝ)
* (khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
noncomputable def khc_fourierCoeff (f : (ι → Bool) → ℝ) (S : Finset ι) : ℝ :=
bnt_uexp (fun x => f x * khc_walshChar S x)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:116
noncomputable def bnt_qnorm (q : ℝ) (f : (ι → Bool) → ℝ) : ℝ :=
(bnt_qnormPow q f) ^ (1 / q)
MathlibExt/Probability/Hypercontractivity/BonamiTensorize.lean:74
noncomputable def maxInfl [Nonempty E] (ν : E → Bool → ℝ) (g : ConfigSpace E → ℝ) : ℝ :=
Finset.univ.sup' Finset.univ_nonempty (OSSS.infl ν g)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLInequality.lean:70
noncomputable def bernoulliWeight (p : ℝ) : E → Bool → ℝ :=
fun _ b => if b then p else 1 - p
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:915
TheoremHypercontractive form of KKL with constant 0 holds trivially#✓fully proved
khc_LogSobolevStep 0 holds trivially.
theorem khc_logSobolevStep_zero : khc_LogSobolevStep 0
def khc_LogSobolevStep (c : ℝ) : Prop :=
∀ {E : Type} [Fintype E] [DecidableEq E] [Nonempty E] (φ : ConfigSpace E → Bool),
(∀ ρ : ℝ, 0 ≤ ρ → ρ ≤ 1 →
(∑ S : Finset E, (ρ ^ S.card) ^ 2
* (khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2)
≤ (bnt_qnorm (1 + ρ ^ 2) (fun ω => if φ ω then (1 : ℝ) else 0)) ^ 2) →
c * (∑ S ∈ (univ.erase (∅ : Finset E)),
(khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2)
* Real.log (1 / maxInfl (OSSS.bernoulliWeight (1 / 2 : ℝ))
(fun ω => if φ ω then (1 : ℝ) else 0))
≤ ∑ S : Finset E, 4 * (S.card : ℝ)
* (khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:641
Uses 14
TheoremHypercontractive form of KKL implies the KKL inequality at \(p = 1/2\)#✓fully proved
The Fourier form khc_LogSobolevStep c implies the KKL inequality KKLHypercontractive (1/2)
c.
theorem khc_KKL {c : ℝ} (H : khc_LogSobolevStep c) :
KKLHypercontractive (1 / 2 : ℝ) c
def khc_LogSobolevStep (c : ℝ) : Prop :=
∀ {E : Type} [Fintype E] [DecidableEq E] [Nonempty E] (φ : ConfigSpace E → Bool),
(∀ ρ : ℝ, 0 ≤ ρ → ρ ≤ 1 →
(∑ S : Finset E, (ρ ^ S.card) ^ 2
* (khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2)
≤ (bnt_qnorm (1 + ρ ^ 2) (fun ω => if φ ω then (1 : ℝ) else 0)) ^ 2) →
c * (∑ S ∈ (univ.erase (∅ : Finset E)),
(khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2)
* Real.log (1 / maxInfl (OSSS.bernoulliWeight (1 / 2 : ℝ))
(fun ω => if φ ω then (1 : ℝ) else 0))
≤ ∑ S : Finset E, 4 * (S.card : ℝ)
* (khc_fourierCoeff (fun ω => if φ ω then (1 : ℝ) else 0) S) ^ 2
CSLibExt/Complexity/BooleanFunctions/KKL/KKLfromHC.lean:641
def KKLHypercontractive (p c : ℝ) : Prop :=
∀ {E : Type} [Fintype E] [DecidableEq E] [Nonempty E] (φ : ConfigSpace E → Bool),
c * OSSS.var (bernoulliWeight p) (fun ω => if φ ω then (1 : ℝ) else 0)
* Real.log (1 / maxInfl (bernoulliWeight p) (fun ω => if φ ω then (1 : ℝ) else 0))
≤ totalInfl (bernoulliWeight p) (fun ω => if φ ω then (1 : ℝ) else 0)
CSLibExt/Complexity/BooleanFunctions/KKL/KKLInequality.lean:159
Uses 11 · Used by 1
TheoremUniform variance agrees with the canonical Boolean variance#✓fully proved
On Fin n, the variance under the uniform product weight is BooleanCube.boolVariance.
theorem khc_var_half_eq_boolVariance {n : ℕ} (f : (Fin n → Bool) → ℝ) :
OSSS.var (OSSS.bernoulliWeight (1 / 2 : ℝ)) f = BooleanCube.boolVariance f
noncomputable def var (ν : E → Bool → ℝ) (g : ConfigSpace E → ℝ) : ℝ := cov ν g g
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:161
noncomputable def bernoulliWeight (p : ℝ) : E → Bool → ℝ :=
fun _ b => if b then p else 1 - p
CSLibExt/Complexity/BooleanFunctions/OSSS.lean:915
noncomputable def boolVariance (f : BoolCube n → ℝ) : ℝ :=
𝔼 x, (f x - 𝔼 y, f y) ^ 2
MathlibExt/Analysis/Fourier/BooleanCubeInfluence.lean:310
Uses 11
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.