Datasets:

roseking
/

openAI-math-dataset

import Mathlib

namespace OAI

section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
namespace VertexCover.FiniteAntiConcentration
open scoped BigOperators
noncomputable section

variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def subsetSum (w : ι → ℝ) (s : Finset ι) : ℝ := ∑ i ∈ s, w i

def intervalFamily (w : ι → ℝ) (L U : ℝ) : Finset (Finset ι) :=
  Finset.univ.filter (fun s => L ≤ subsetSum w s ∧ subsetSum w s ≤ U)

omit [Fintype ι] in
theorem subsetSum_increase (w : ι → ℝ) {δ : ℝ} (hδ : 0 ≤ δ)
    (hw : ∀ i, δ ≤ w i) {s t : Finset ι} (hst : s ⊂ t) :
    subsetSum w s + δ ≤ subsetSum w t := by
  obtain ⟨i, hit, his⟩ := Finset.exists_of_ssubset hst
  have hd := Finset.single_le_sum (s := t \ s) (f := w)
    (fun j _ => hδ.trans (hw j)) (Finset.mem_sdiff.mpr ⟨hit, his⟩)
  have he := Finset.sum_sdiff (f := w) (Finset.Subset.refl s |>.trans hst.le)
  unfold subsetSum
  linarith [hw i]

theorem interval_card_le (w : ι → ℝ) (L U δ : ℝ) (N : ℕ)
    (hδ : 0 < δ) (hw : ∀ i, δ ≤ w i) (hwide : U - L < N * δ) :
    (intervalFamily w L U).card ≤ N * (Fintype.card ι).choose (Fintype.card ι / 2) := by
  classical
  let bucket : Finset ι → ℕ := fun s => ⌊(subsetSum w s - L) / δ⌋₊
  have hb : ∀ s ∈ intervalFamily w L U, bucket s < N := by
    intro s hs
    have hs' := (Finset.mem_filter.mp hs).2
    apply (Nat.floor_lt (div_nonneg (sub_nonneg.mpr hs'.1) hδ.le)).mpr
    apply (div_lt_iff₀ hδ).mpr
    linarith [hs'.2]
  have hc : ∀ k, ((intervalFamily w L U).filter (fun s => bucket s = k)).card ≤
      (Fintype.card ι).choose (Fintype.card ι / 2) := by
    intro k
    apply IsAntichain.sperner
    intro s hs t ht hne hst
    have hs' := Finset.mem_filter.mp hs
    have ht' := Finset.mem_filter.mp ht
    have hsL := (Finset.mem_filter.mp hs'.1).2.1
    have hi := subsetSum_increase w hδ.le hw
      (Finset.ssubset_iff_subset_ne.mpr ⟨hst, hne⟩)
    have hlo := Nat.floor_le (div_nonneg (sub_nonneg.mpr hsL) hδ.le)
    have hhi := Nat.lt_floor_add_one ((subsetSum w t - L) / δ)
    change (bucket s : ℝ) ≤ (subsetSum w s - L) / δ at hlo
    change (subsetSum w t - L) / δ < (bucket t : ℝ) + 1 at hhi
    rw [hs'.2] at hlo
    rw [ht'.2] at hhi
    have hlo' := (le_div_iff₀ hδ).mp hlo
    have hhi' := (div_lt_iff₀ hδ).mp hhi
    nlinarith
  have ht : Set.MapsTo bucket (intervalFamily w L U) (Finset.range N) := by
    intro s hs
    exact Finset.mem_range.mpr (hb s hs)
  rw [Finset.card_eq_sum_card_fiberwise ht]
  calc
    _ ≤ ∑ _k ∈ Finset.range N, (Fintype.card ι).choose (Fintype.card ι / 2) :=
      Finset.sum_le_sum (fun k _ => hc k)
    _ = _ := by simp

def choices (lo hi : ι → ℝ) (s : Finset ι) : ℝ :=
  ∑ i, if i ∈ s then hi i else lo i

theorem choices_eq (lo hi : ι → ℝ) (s : Finset ι) :
    choices lo hi s = (∑ i, lo i) + subsetSum (fun i => hi i - lo i) s := by
  classical
  unfold choices subsetSum
  have hs : (∑ i ∈ s, (hi i - lo i)) = ∑ i, if i ∈ s then hi i - lo i else 0 := by
    symm
    simp
  rw [hs, ← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro i hi'
  by_cases h : i ∈ s <;> simp [h]

theorem choice_card_le (lo hi : ι → ℝ) (L U δ : ℝ) (N : ℕ)
    (hδ : 0 < δ) (hdiff : ∀ i, lo i + δ ≤ hi i) (hwide : U - L < N * δ) :
    (Finset.univ.filter (fun s : Finset ι => L ≤ choices lo hi s ∧ choices lo hi s ≤ U)).card ≤
      N * (Fintype.card ι).choose (Fintype.card ι / 2) := by
  classical
  have he : (Finset.univ.filter (fun s : Finset ι => L ≤ choices lo hi s ∧ choices lo hi s ≤ U)) =
      intervalFamily (fun i => hi i - lo i) (L - ∑ i, lo i) (U - ∑ i, lo i) := by
    ext s
    simp only [Finset.mem_filter, Finset.mem_univ, true_and, intervalFamily, choices_eq]
    constructor <;> intro h <;> constructor <;> linarith [h.1, h.2]
  rw [he]
  apply interval_card_le _ _ _ δ N hδ (fun i => by linarith [hdiff i])
  linarith

def toggleEquiv (mask : Finset ι) : Finset ι ≃ Finset ι where
  toFun s := symmDiff s mask
  invFun s := symmDiff s mask
  left_inv s := by
    ext i
    simp only [Finset.mem_symmDiff]
    tauto
  right_inv s := by
    ext i
    simp only [Finset.mem_symmDiff]
    tauto

variable {α : Type*} [Fintype α]

def orderedChoice (g : α → ℝ) (τ : α ≃ α) (x : ι → α) (s : Finset ι) : ℝ :=
  choices (fun i => min (g (x i)) (g (τ (x i))))
    (fun i => max (g (x i)) (g (τ (x i)))) s

def rawChoice (g : α → ℝ) (τ : α ≃ α) (x : ι → α) (s : Finset ι) : ℝ :=
  ∑ i, if i ∈ s then g (τ (x i)) else g (x i)

omit [Fintype α] in
theorem orderedChoice_eq (g : α → ℝ) (τ : α ≃ α) (x : ι → α) (s : Finset ι) :
    orderedChoice g τ x s = rawChoice g τ x
      (toggleEquiv (Finset.univ.filter (fun i => g (τ (x i)) < g (x i))) s) := by
  classical
  unfold orderedChoice rawChoice choices toggleEquiv
  apply Finset.sum_congr rfl
  intro i hi
  by_cases hm : i ∈ s <;> by_cases ho : g (τ (x i)) < g (x i)
  · simp [Finset.mem_symmDiff, hm, ho, max_eq_left ho.le]
  · simp [Finset.mem_symmDiff, hm, ho, max_eq_right (le_of_not_gt ho)]
  · simp [Finset.mem_symmDiff, hm, ho, min_eq_right ho.le]
  · simp [Finset.mem_symmDiff, hm, ho, min_eq_left (le_of_not_gt ho)]

def coordinateShift (τ : α ≃ α) (s : Finset ι) : (ι → α) ≃ (ι → α) :=
  Equiv.piCongrRight (fun i => if i ∈ s then τ else Equiv.refl α)

omit [Fintype α] in
theorem rawChoice_eq (g : α → ℝ) (τ : α ≃ α) (x : ι → α) (s : Finset ι) :
    rawChoice g τ x s = ∑ i, g (coordinateShift τ s x i) := by
  apply Finset.sum_congr rfl
  intro i hi
  by_cases hm : i ∈ s <;> simp [coordinateShift, hm]

theorem sum_orderedChoices (g : α → ℝ) (τ : α ≃ α) (f : ℝ → ℝ) :
    (∑ x : ι → α, ∑ s : Finset ι, f (orderedChoice g τ x s)) =
      (2 : ℝ) ^ Fintype.card ι * ∑ x : ι → α, f (∑ i, g (x i)) := by
  classical
  calc
    _ = ∑ x : ι → α, ∑ s : Finset ι, f (rawChoice g τ x s) := by
      apply Finset.sum_congr rfl
      intro x hx
      simp only [orderedChoice_eq]
      exact (toggleEquiv (Finset.univ.filter (fun i => g (τ (x i)) < g (x i)))).sum_comp (fun s => f (rawChoice g τ x s))
    _ = ∑ s : Finset ι, ∑ x : ι → α, f (rawChoice g τ x s) := Finset.sum_comm
    _ = ∑ _s : Finset ι, ∑ x : ι → α, f (∑ i, g (x i)) := by
      apply Finset.sum_congr rfl
      intro s hs
      simp only [rawChoice_eq]
      exact (coordinateShift τ s).sum_comp (fun x => f (∑ i, g (x i)))
    _ = _ := by simp [Fintype.card_finset]

def grid (d : ℕ) (u : Fin (2*d+1)) : ℝ :=
  2 * ((u.val : ℝ) - d) / (2*d+1)

def gridShift (d : ℕ) : Fin (2*d+1) ≃ Fin (2*d+1) :=
  Equiv.addRight ⟨d, by omega⟩

theorem grid_gap (d : ℕ) (u : Fin (2*d+1)) :
    (2*d : ℝ)/(2*d+1) ≤ |grid d (gridShift d u) - grid d u| := by
  have hp : (0 : ℝ) < 2*d+1 := by positivity
  have hv : (gridShift d u).val =
      if 2*d+1 ≤ u.val+d then u.val+d-(2*d+1) else u.val+d := by
    exact Fin.val_add_eq_ite u ⟨d, by omega⟩
  unfold grid
  rw [hv]
  split_ifs with h
  · have hs : ((u.val+d-(2*d+1) : ℕ) : ℝ) = (u.val : ℝ)+d-(2*d+1) := by
      rw [Nat.cast_sub h]
      push_cast
      rfl
    rw [hs]
    have he : 2*((u.val:ℝ)+d-(2*d+1)-d)/(2*d+1) -
        2*((u.val:ℝ)-d)/(2*d+1) = -(2*(d+1)/(2*d+1)) := by ring
    rw [he, abs_neg, abs_of_nonneg (by positivity)]
    exact div_le_div_of_nonneg_right (by linarith) hp.le
  · push_cast
    have he : 2*((u.val:ℝ)+d-d)/(2*d+1) -
        2*((u.val:ℝ)-d)/(2*d+1) = 2*d/(2*d+1) := by ring
    rw [he, abs_of_nonneg (by positivity)]

theorem grid_ordered_gap (d : ℕ) (u : Fin (2*d+1)) :
    min (grid d u) (grid d (gridShift d u)) + (2*d : ℝ)/(2*d+1) ≤
      max (grid d u) (grid d (gridShift d u)) := by
  have h := grid_gap d u
  rw [← max_sub_min_eq_abs] at h
  linarith

theorem grid_neg (d : ℕ) (u : Fin (2*d+1)) : grid d (Fin.rev u) = - grid d u := by
  unfold grid
  rw [Fin.val_rev, Nat.cast_sub (by omega)]
  push_cast
  ring

theorem grid_interval_card (d n N : ℕ) (hd : 0 < d) (L U : ℝ)
    (hwide : U-L < N * ((2*d : ℝ)/(2*d+1))) :
    (2 : ℝ)^n *
      ((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
        L ≤ ∑ i, grid d (x i) ∧ (∑ i, grid d (x i)) ≤ U)).card : ℝ) ≤
    ((2*d+1 : ℕ)^n : ℝ) * N * (n.choose (n/2)) := by
  classical
  let f : ℝ → ℝ := fun y => if L ≤ y ∧ y ≤ U then 1 else 0
  have hlaw := sum_orderedChoices (ι := Fin n) (grid d) (gridShift d) f
  have hc (x : Fin n → Fin (2*d+1)) :
      ∑ s : Finset (Fin n), f (orderedChoice (grid d) (gridShift d) x s) ≤
        (N * n.choose (n/2) : ℕ) := by
    have h := choice_card_le
      (fun i => min (grid d (x i)) (grid d (gridShift d (x i))))
      (fun i => max (grid d (x i)) (grid d (gridShift d (x i))))
      L U ((2*d : ℝ)/(2*d+1)) N
      (by positivity) (fun i => grid_ordered_gap d (x i)) hwide
    have hs : (∑ s : Finset (Fin n), f (orderedChoice (grid d) (gridShift d) x s)) =
        ((Finset.univ.filter (fun s : Finset (Fin n) =>
          L ≤ orderedChoice (grid d) (gridShift d) x s ∧
          orderedChoice (grid d) (gridShift d) x s ≤ U)).card : ℝ) := by
      exact Finset.sum_boole _ _
    rw [hs]
    simp only [Fintype.card_fin] at h
    exact_mod_cast h
  have hs := Finset.sum_le_sum (s := Finset.univ) (fun x _ => hc x)
  rw [hlaw] at hs
  have hcount : (∑ x : Fin n → Fin (2*d+1), f (∑ i, grid d (x i))) =
      ((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
        L ≤ ∑ i, grid d (x i) ∧ (∑ i, grid d (x i)) ≤ U)).card : ℝ) := by
    exact Finset.sum_boole _ _
  rw [hcount] at hs
  simpa [Fintype.card_fun, mul_assoc] using hs

theorem symmetric_tail_count {Ω : Type*} [Fintype Ω] (f : Ω → ℝ)
    (rev : Ω ≃ Ω) (hrev : ∀ x, f (rev x) = -f x) (t : ℝ) (ht : 0 ≤ t) :
    2 * ((Finset.univ.filter (fun x => t < f x)).card : ℝ) +
      ((Finset.univ.filter (fun x => -t ≤ f x ∧ f x ≤ t)).card : ℝ) = Fintype.card Ω := by
  classical
  let pos : Ω → ℝ := fun x => if t < f x then 1 else 0
  let neg : Ω → ℝ := fun x => if f x < -t then 1 else 0
  let mid : Ω → ℝ := fun x => if -t ≤ f x ∧ f x ≤ t then 1 else 0
  have he (x : Ω) : pos x + neg x + mid x = 1 := by
    dsimp [pos, neg, mid]
    split_ifs <;> simp_all <;> linarith
  have hn : (∑ x, neg x) = ∑ x, pos x := by
    have h : (∑ x, pos (rev x)) = ∑ x, neg x := by
      apply Finset.sum_congr rfl
      intro x hx
      simp [pos, neg, hrev, lt_neg]
    rw [← h]
    exact rev.sum_comp pos
  have hs : (∑ x, pos x) + (∑ x, neg x) + (∑ x, mid x) = Fintype.card Ω := by
    rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
    simp only [he]
    simp
  rw [hn] at hs
  have hpcount : (∑ x, pos x) = ((Finset.univ.filter (fun x => t < f x)).card : ℝ) :=
    Finset.sum_boole _ _
  have hmcount : (∑ x, mid x) =
      ((Finset.univ.filter (fun x => -t ≤ f x ∧ f x ≤ t)).card : ℝ) :=
    Finset.sum_boole _ _
  rw [hpcount, hmcount] at hs
  linarith

theorem grid_tail_count (d n t : ℕ) :
    2 * ((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
      (t : ℝ) < ∑ i, grid d (x i))).card : ℝ) +
    ((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
      -(t : ℝ) ≤ ∑ i, grid d (x i) ∧ (∑ i, grid d (x i)) ≤ t)).card : ℝ) =
      ((2*d+1 : ℕ)^n : ℝ) := by
  classical
  have hr (x : Fin n → Fin (2*d+1)) :
      (∑ i, grid d ((Equiv.piCongrRight (fun _ : Fin n => Fin.revPerm)) x i)) =
      -(∑ i, grid d (x i)) := by
    change (∑ i, grid d (Fin.rev (x i))) = -(∑ i, grid d (x i))
    simp only [grid_neg, Finset.sum_neg_distrib]
  simpa [Fintype.card_fun] using symmetric_tail_count
    (fun x : Fin n → Fin (2*d+1) => ∑ i, grid d (x i))
    (Equiv.piCongrRight (fun _ : Fin n => Fin.revPerm)) hr (t : ℝ) (by positivity)

theorem grid_central_card (d n t : ℕ) (ht : t < d) :
    (2 : ℝ)^n *
      ((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
        -(t : ℝ) ≤ ∑ i, grid d (x i) ∧ (∑ i, grid d (x i)) ≤ t)).card : ℝ) ≤
    ((2*d+1 : ℕ)^n : ℝ) * (2*t+1) * (n.choose (n/2) : ℝ) := by
  have htr : (t:ℝ) < d := Nat.cast_lt.mpr ht
  have hwide : (t:ℝ)-(-t) < (2*t+1 : ℕ)*((2*d : ℝ)/(2*d+1)) := by
    push_cast
    rw [mul_div, lt_div_iff₀ (by positivity : (0:ℝ) < 2*d+1)]
    nlinarith
  simpa using grid_interval_card d n (2*t+1) (by omega) (-(t:ℝ)) (t:ℝ) hwide

end
end VertexCover.FiniteAntiConcentration


end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end

end OAI

	import Mathlib

	namespace OAI

	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	namespace VertexCover.FiniteAntiConcentration
	open scoped BigOperators
	noncomputable section

	variable {ι : Type*} [Fintype ι] [DecidableEq ι]

	def subsetSum (w : ι → ℝ) (s : Finset ι) : ℝ := ∑ i ∈ s, w i

	def intervalFamily (w : ι → ℝ) (L U : ℝ) : Finset (Finset ι) :=
	Finset.univ.filter (fun s => L ≤ subsetSum w s ∧ subsetSum w s ≤ U)

	omit [Fintype ι] in
	theorem subsetSum_increase (w : ι → ℝ) {δ : ℝ} (hδ : 0 ≤ δ)
	(hw : ∀ i, δ ≤ w i) {s t : Finset ι} (hst : s ⊂ t) :
	subsetSum w s + δ ≤ subsetSum w t := by
	obtain ⟨i, hit, his⟩ := Finset.exists_of_ssubset hst
	have hd := Finset.single_le_sum (s := t \ s) (f := w)
	(fun j _ => hδ.trans (hw j)) (Finset.mem_sdiff.mpr ⟨hit, his⟩)
	have he := Finset.sum_sdiff (f := w) (Finset.Subset.refl s \|>.trans hst.le)
	unfold subsetSum
	linarith [hw i]

	theorem interval_card_le (w : ι → ℝ) (L U δ : ℝ) (N : ℕ)
	(hδ : 0 < δ) (hw : ∀ i, δ ≤ w i) (hwide : U - L < N * δ) :
	(intervalFamily w L U).card ≤ N * (Fintype.card ι).choose (Fintype.card ι / 2) := by
	classical
	let bucket : Finset ι → ℕ := fun s => ⌊(subsetSum w s - L) / δ⌋₊
	have hb : ∀ s ∈ intervalFamily w L U, bucket s < N := by
	intro s hs
	have hs' := (Finset.mem_filter.mp hs).2
	apply (Nat.floor_lt (div_nonneg (sub_nonneg.mpr hs'.1) hδ.le)).mpr
	apply (div_lt_iff₀ hδ).mpr
	linarith [hs'.2]
	have hc : ∀ k, ((intervalFamily w L U).filter (fun s => bucket s = k)).card ≤
	(Fintype.card ι).choose (Fintype.card ι / 2) := by
	intro k
	apply IsAntichain.sperner
	intro s hs t ht hne hst
	have hs' := Finset.mem_filter.mp hs
	have ht' := Finset.mem_filter.mp ht
	have hsL := (Finset.mem_filter.mp hs'.1).2.1
	have hi := subsetSum_increase w hδ.le hw
	(Finset.ssubset_iff_subset_ne.mpr ⟨hst, hne⟩)
	have hlo := Nat.floor_le (div_nonneg (sub_nonneg.mpr hsL) hδ.le)
	have hhi := Nat.lt_floor_add_one ((subsetSum w t - L) / δ)
	change (bucket s : ℝ) ≤ (subsetSum w s - L) / δ at hlo
	change (subsetSum w t - L) / δ < (bucket t : ℝ) + 1 at hhi
	rw [hs'.2] at hlo
	rw [ht'.2] at hhi
	have hlo' := (le_div_iff₀ hδ).mp hlo
	have hhi' := (div_lt_iff₀ hδ).mp hhi
	nlinarith
	have ht : Set.MapsTo bucket (intervalFamily w L U) (Finset.range N) := by
	intro s hs
	exact Finset.mem_range.mpr (hb s hs)
	rw [Finset.card_eq_sum_card_fiberwise ht]
	calc
	_ ≤ ∑ _k ∈ Finset.range N, (Fintype.card ι).choose (Fintype.card ι / 2) :=
	Finset.sum_le_sum (fun k _ => hc k)
	_ = _ := by simp

	def choices (lo hi : ι → ℝ) (s : Finset ι) : ℝ :=
	∑ i, if i ∈ s then hi i else lo i

	theorem choices_eq (lo hi : ι → ℝ) (s : Finset ι) :
	choices lo hi s = (∑ i, lo i) + subsetSum (fun i => hi i - lo i) s := by
	classical
	unfold choices subsetSum
	have hs : (∑ i ∈ s, (hi i - lo i)) = ∑ i, if i ∈ s then hi i - lo i else 0 := by
	symm
	simp
	rw [hs, ← Finset.sum_add_distrib]
	apply Finset.sum_congr rfl
	intro i hi'
	by_cases h : i ∈ s <;> simp [h]

	theorem choice_card_le (lo hi : ι → ℝ) (L U δ : ℝ) (N : ℕ)
	(hδ : 0 < δ) (hdiff : ∀ i, lo i + δ ≤ hi i) (hwide : U - L < N * δ) :
	(Finset.univ.filter (fun s : Finset ι => L ≤ choices lo hi s ∧ choices lo hi s ≤ U)).card ≤
	N * (Fintype.card ι).choose (Fintype.card ι / 2) := by
	classical
	have he : (Finset.univ.filter (fun s : Finset ι => L ≤ choices lo hi s ∧ choices lo hi s ≤ U)) =
	intervalFamily (fun i => hi i - lo i) (L - ∑ i, lo i) (U - ∑ i, lo i) := by
	ext s
	simp only [Finset.mem_filter, Finset.mem_univ, true_and, intervalFamily, choices_eq]
	constructor <;> intro h <;> constructor <;> linarith [h.1, h.2]
	rw [he]
	apply interval_card_le _ _ _ δ N hδ (fun i => by linarith [hdiff i])
	linarith

	def toggleEquiv (mask : Finset ι) : Finset ι ≃ Finset ι where
	toFun s := symmDiff s mask
	invFun s := symmDiff s mask
	left_inv s := by
	ext i
	simp only [Finset.mem_symmDiff]
	tauto
	right_inv s := by
	ext i
	simp only [Finset.mem_symmDiff]
	tauto

	variable {α : Type*} [Fintype α]

	def orderedChoice (g : α → ℝ) (τ : α ≃ α) (x : ι → α) (s : Finset ι) : ℝ :=
	choices (fun i => min (g (x i)) (g (τ (x i))))
	(fun i => max (g (x i)) (g (τ (x i)))) s

	def rawChoice (g : α → ℝ) (τ : α ≃ α) (x : ι → α) (s : Finset ι) : ℝ :=
	∑ i, if i ∈ s then g (τ (x i)) else g (x i)

	omit [Fintype α] in
	theorem orderedChoice_eq (g : α → ℝ) (τ : α ≃ α) (x : ι → α) (s : Finset ι) :
	orderedChoice g τ x s = rawChoice g τ x
	(toggleEquiv (Finset.univ.filter (fun i => g (τ (x i)) < g (x i))) s) := by
	classical
	unfold orderedChoice rawChoice choices toggleEquiv
	apply Finset.sum_congr rfl
	intro i hi
	by_cases hm : i ∈ s <;> by_cases ho : g (τ (x i)) < g (x i)
	· simp [Finset.mem_symmDiff, hm, ho, max_eq_left ho.le]
	· simp [Finset.mem_symmDiff, hm, ho, max_eq_right (le_of_not_gt ho)]
	· simp [Finset.mem_symmDiff, hm, ho, min_eq_right ho.le]
	· simp [Finset.mem_symmDiff, hm, ho, min_eq_left (le_of_not_gt ho)]

	def coordinateShift (τ : α ≃ α) (s : Finset ι) : (ι → α) ≃ (ι → α) :=
	Equiv.piCongrRight (fun i => if i ∈ s then τ else Equiv.refl α)

	omit [Fintype α] in
	theorem rawChoice_eq (g : α → ℝ) (τ : α ≃ α) (x : ι → α) (s : Finset ι) :
	rawChoice g τ x s = ∑ i, g (coordinateShift τ s x i) := by
	apply Finset.sum_congr rfl
	intro i hi
	by_cases hm : i ∈ s <;> simp [coordinateShift, hm]

	theorem sum_orderedChoices (g : α → ℝ) (τ : α ≃ α) (f : ℝ → ℝ) :
	(∑ x : ι → α, ∑ s : Finset ι, f (orderedChoice g τ x s)) =
	(2 : ℝ) ^ Fintype.card ι * ∑ x : ι → α, f (∑ i, g (x i)) := by
	classical
	calc
	_ = ∑ x : ι → α, ∑ s : Finset ι, f (rawChoice g τ x s) := by
	apply Finset.sum_congr rfl
	intro x hx
	simp only [orderedChoice_eq]
	exact (toggleEquiv (Finset.univ.filter (fun i => g (τ (x i)) < g (x i)))).sum_comp (fun s => f (rawChoice g τ x s))
	_ = ∑ s : Finset ι, ∑ x : ι → α, f (rawChoice g τ x s) := Finset.sum_comm
	_ = ∑ _s : Finset ι, ∑ x : ι → α, f (∑ i, g (x i)) := by
	apply Finset.sum_congr rfl
	intro s hs
	simp only [rawChoice_eq]
	exact (coordinateShift τ s).sum_comp (fun x => f (∑ i, g (x i)))
	_ = _ := by simp [Fintype.card_finset]

	def grid (d : ℕ) (u : Fin (2*d+1)) : ℝ :=
	2 * ((u.val : ℝ) - d) / (2*d+1)

	def gridShift (d : ℕ) : Fin (2d+1) ≃ Fin (2d+1) :=
	Equiv.addRight ⟨d, by omega⟩

	theorem grid_gap (d : ℕ) (u : Fin (2*d+1)) :
	(2d : ℝ)/(2d+1) ≤ \|grid d (gridShift d u) - grid d u\| := by
	have hp : (0 : ℝ) < 2*d+1 := by positivity
	have hv : (gridShift d u).val =
	if 2d+1 ≤ u.val+d then u.val+d-(2d+1) else u.val+d := by
	exact Fin.val_add_eq_ite u ⟨d, by omega⟩
	unfold grid
	rw [hv]
	split_ifs with h
	· have hs : ((u.val+d-(2d+1) : ℕ) : ℝ) = (u.val : ℝ)+d-(2d+1) := by
	rw [Nat.cast_sub h]
	push_cast
	rfl
	rw [hs]
	have he : 2((u.val:ℝ)+d-(2d+1)-d)/(2*d+1) -
	2((u.val:ℝ)-d)/(2d+1) = -(2(d+1)/(2d+1)) := by ring
	rw [he, abs_neg, abs_of_nonneg (by positivity)]
	exact div_le_div_of_nonneg_right (by linarith) hp.le
	· push_cast
	have he : 2((u.val:ℝ)+d-d)/(2d+1) -
	2((u.val:ℝ)-d)/(2d+1) = 2d/(2d+1) := by ring
	rw [he, abs_of_nonneg (by positivity)]

	theorem grid_ordered_gap (d : ℕ) (u : Fin (2*d+1)) :
	min (grid d u) (grid d (gridShift d u)) + (2d : ℝ)/(2d+1) ≤
	max (grid d u) (grid d (gridShift d u)) := by
	have h := grid_gap d u
	rw [← max_sub_min_eq_abs] at h
	linarith

	theorem grid_neg (d : ℕ) (u : Fin (2*d+1)) : grid d (Fin.rev u) = - grid d u := by
	unfold grid
	rw [Fin.val_rev, Nat.cast_sub (by omega)]
	push_cast
	ring

	theorem grid_interval_card (d n N : ℕ) (hd : 0 < d) (L U : ℝ)
	(hwide : U-L < N * ((2d : ℝ)/(2d+1))) :
	(2 : ℝ)^n *
	((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
	L ≤ ∑ i, grid d (x i) ∧ (∑ i, grid d (x i)) ≤ U)).card : ℝ) ≤
	((2d+1 : ℕ)^n : ℝ) N * (n.choose (n/2)) := by
	classical
	let f : ℝ → ℝ := fun y => if L ≤ y ∧ y ≤ U then 1 else 0
	have hlaw := sum_orderedChoices (ι := Fin n) (grid d) (gridShift d) f
	have hc (x : Fin n → Fin (2*d+1)) :
	∑ s : Finset (Fin n), f (orderedChoice (grid d) (gridShift d) x s) ≤
	(N * n.choose (n/2) : ℕ) := by
	have h := choice_card_le
	(fun i => min (grid d (x i)) (grid d (gridShift d (x i))))
	(fun i => max (grid d (x i)) (grid d (gridShift d (x i))))
	L U ((2d : ℝ)/(2d+1)) N
	(by positivity) (fun i => grid_ordered_gap d (x i)) hwide
	have hs : (∑ s : Finset (Fin n), f (orderedChoice (grid d) (gridShift d) x s)) =
	((Finset.univ.filter (fun s : Finset (Fin n) =>
	L ≤ orderedChoice (grid d) (gridShift d) x s ∧
	orderedChoice (grid d) (gridShift d) x s ≤ U)).card : ℝ) := by
	exact Finset.sum_boole _ _
	rw [hs]
	simp only [Fintype.card_fin] at h
	exact_mod_cast h
	have hs := Finset.sum_le_sum (s := Finset.univ) (fun x _ => hc x)
	rw [hlaw] at hs
	have hcount : (∑ x : Fin n → Fin (2*d+1), f (∑ i, grid d (x i))) =
	((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
	L ≤ ∑ i, grid d (x i) ∧ (∑ i, grid d (x i)) ≤ U)).card : ℝ) := by
	exact Finset.sum_boole _ _
	rw [hcount] at hs
	simpa [Fintype.card_fun, mul_assoc] using hs

	theorem symmetric_tail_count {Ω : Type*} [Fintype Ω] (f : Ω → ℝ)
	(rev : Ω ≃ Ω) (hrev : ∀ x, f (rev x) = -f x) (t : ℝ) (ht : 0 ≤ t) :
	2 * ((Finset.univ.filter (fun x => t < f x)).card : ℝ) +
	((Finset.univ.filter (fun x => -t ≤ f x ∧ f x ≤ t)).card : ℝ) = Fintype.card Ω := by
	classical
	let pos : Ω → ℝ := fun x => if t < f x then 1 else 0
	let neg : Ω → ℝ := fun x => if f x < -t then 1 else 0
	let mid : Ω → ℝ := fun x => if -t ≤ f x ∧ f x ≤ t then 1 else 0
	have he (x : Ω) : pos x + neg x + mid x = 1 := by
	dsimp [pos, neg, mid]
	split_ifs <;> simp_all <;> linarith
	have hn : (∑ x, neg x) = ∑ x, pos x := by
	have h : (∑ x, pos (rev x)) = ∑ x, neg x := by
	apply Finset.sum_congr rfl
	intro x hx
	simp [pos, neg, hrev, lt_neg]
	rw [← h]
	exact rev.sum_comp pos
	have hs : (∑ x, pos x) + (∑ x, neg x) + (∑ x, mid x) = Fintype.card Ω := by
	rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
	simp only [he]
	simp
	rw [hn] at hs
	have hpcount : (∑ x, pos x) = ((Finset.univ.filter (fun x => t < f x)).card : ℝ) :=
	Finset.sum_boole _ _
	have hmcount : (∑ x, mid x) =
	((Finset.univ.filter (fun x => -t ≤ f x ∧ f x ≤ t)).card : ℝ) :=
	Finset.sum_boole _ _
	rw [hpcount, hmcount] at hs
	linarith

	theorem grid_tail_count (d n t : ℕ) :
	2 * ((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
	(t : ℝ) < ∑ i, grid d (x i))).card : ℝ) +
	((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
	-(t : ℝ) ≤ ∑ i, grid d (x i) ∧ (∑ i, grid d (x i)) ≤ t)).card : ℝ) =
	((2*d+1 : ℕ)^n : ℝ) := by
	classical
	have hr (x : Fin n → Fin (2*d+1)) :
	(∑ i, grid d ((Equiv.piCongrRight (fun _ : Fin n => Fin.revPerm)) x i)) =
	-(∑ i, grid d (x i)) := by
	change (∑ i, grid d (Fin.rev (x i))) = -(∑ i, grid d (x i))
	simp only [grid_neg, Finset.sum_neg_distrib]
	simpa [Fintype.card_fun] using symmetric_tail_count
	(fun x : Fin n → Fin (2*d+1) => ∑ i, grid d (x i))
	(Equiv.piCongrRight (fun _ : Fin n => Fin.revPerm)) hr (t : ℝ) (by positivity)

	theorem grid_central_card (d n t : ℕ) (ht : t < d) :
	(2 : ℝ)^n *
	((Finset.univ.filter (fun x : Fin n → Fin (2*d+1) =>
	-(t : ℝ) ≤ ∑ i, grid d (x i) ∧ (∑ i, grid d (x i)) ≤ t)).card : ℝ) ≤
	((2d+1 : ℕ)^n : ℝ) (2t+1) (n.choose (n/2) : ℝ) := by
	have htr : (t:ℝ) < d := Nat.cast_lt.mpr ht
	have hwide : (t:ℝ)-(-t) < (2t+1 : ℕ)((2d : ℝ)/(2d+1)) := by
	push_cast
	rw [mul_div, lt_div_iff₀ (by positivity : (0:ℝ) < 2*d+1)]
	nlinarith
	simpa using grid_interval_card d n (2*t+1) (by omega) (-(t:ℝ)) (t:ℝ) hwide

	end
	end VertexCover.FiniteAntiConcentration


	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end

	end OAI