import OAI.Computability.WitnessedChoice.Counting

namespace OAI


namespace WitnessedSeparation.Grid

noncomputable section

open Classical Finset

variable {n : ℕ} {b : Vertex n → Scalar}

variable {J : Type*} [Fintype J]

theorem occurrences_card (a : J → Atom b) : Fintype.card (Occurrences a) ≤ 6*Fintype.card J := by
  rw [Fintype.card_sigma]
  calc
    _ = ∑ j : J, (touch (a j)).card := by congr 1; ext j; exact Fintype.card_coe _
    _ ≤ ∑ _ : J, 6 := sum_le_sum (fun j _ => touch_card (a j))
    _ = _ := by simp [Nat.mul_comm]

theorem augment_card (a : J → Atom b) : Fintype.card (J ⊕ Occurrences a) ≤ 7*Fintype.card J := by
  rw [Fintype.card_sum]
  have := occurrences_card a
  omega

def namesBelow {P : Type*} [Fintype P] {M : ℕ} (h : Fintype.card P < M) : P ↪ Fin M :=
  (Fintype.equivFin P).toEmbedding.trans (Fin.castLEEmb h.le)

theorem namesBelow_spare {P : Type*} [Fintype P] {M : ℕ} (h : Fintype.card P < M) :
    (⟨Fintype.card P,h⟩ : Fin M) ∉ Counting.tupleNames (namesBelow h) := by
  intro hh
  obtain ⟨j,hj⟩ := (Counting.mem_tupleNames _ _).mp hh
  have hv := congrArg Fin.val hj
  change (Fintype.equivFin P j).val = Fintype.card P at hv
  exact (Fintype.equivFin P j).isLt.ne hv

theorem tuple_partial_shift {M : ℕ} [Nonempty (Atom b)] (names : J ↪ Fin M)
    (a a' : J → Atom b) (hw : 7*Fintype.card J < M)
    (ht : Counting.tupleType (analysisStructure b) names a =
      Counting.tupleType (analysisStructure b) names a') :
    ∃ t : Edge n → Scalar, ∀ j, AtomShift t (a j) (a' j) := by
  have hcard : Fintype.card (J ⊕ Occurrences a) < M := lt_of_le_of_lt (augment_card a) hw
  obtain ⟨y,hy⟩ := Counting.tupleType_append (analysisStructure b) (analysisStructure b)
    names (namesBelow hcard) a a' (occurrenceAtom a) ht
  exact augmented_diagram_shift a a' y
    (sameDiagram_of_type _ _ _ hy ⟨_,hcard⟩ (namesBelow_spare hcard))

theorem AtomShift.stateAt_flow {t : Edge n → Scalar} {x y : Atom b}
    (h : AtomShift t x y) (e : Edge n) (he : e ∈ touch x) :
    (stateAt y e (by rw [←touch_shift h]; exact he)).flow =
      t e + (stateAt x e he).flow := by
  cases h with
  | edge f s =>
    have hef : e = f := by simpa [touch,atomBlock,blockEdges] using he
    subst e
    simp only [stateAt_edge (b := b),shiftLocal_flow]
  | config v s h =>
    have hi : incident v e := by simpa [touch,atomBlock,blockEdges] using he
    change ((s.shift t h).state ⟨e,hi⟩).flow = t e + (s.state ⟨e,hi⟩).flow
    simp

theorem AtomShift.unique_on_touch {t u : Edge n → Scalar} {x y : Atom b}
    (ht : AtomShift t x y) (hu : AtomShift u x y) (e : Edge n) (he : e ∈ touch x) :
    t e = u e := by
  have hh := (ht.stateAt_flow e he).symm.trans (hu.stateAt_flow e he)
  exact add_right_cancel hh

end

end WitnessedSeparation.Grid



namespace WitnessedSeparation.Projection

open Finset

variable {X Y Z : Type*} [Fintype X] [Fintype Y] [Fintype Z]

variable [DecidableEq X] [DecidableEq Y] [DecidableEq Z]

private def ind {α : Type*} [DecidableEq α] (S : Finset α) (a : α) : ℕ :=
  if a ∈ S then 1 else 0

private theorem ind_sq {α : Type*} [DecidableEq α] (S : Finset α) (a : α) :
    ind S a ^ 2 = ind S a := by simp [ind]

private theorem sum_ind {α : Type*} [DecidableEq α] [Fintype α] (S : Finset α) :
    ∑ a, ind S a = S.card := by simp [ind]

theorem card_sq_le_projections (R : Finset (X × Y × Z)) :
    R.card^2 ≤ (R.image (fun v => (v.1,v.2.1))).card *
      (R.image (fun v => (v.1,v.2.2))).card * (R.image (fun v => (v.2.1,v.2.2))).card := by
  let A := R.image (fun v => (v.1,v.2.1))
  let B := R.image (fun v => (v.1,v.2.2))
  let D := R.image (fun v => (v.2.1,v.2.2))
  let a (p : X × Y) := ind A p
  let b (p : X × Z) := ind B p
  let d (p : Y × Z) := ind D p
  let c (p : X × Y) := ∑ k, b (p.1,k) * d (p.2,k)
  have hr : R.card ≤ ∑ p, a p * c p := by
    rw [←sum_ind R]
    simp only [Fintype.sum_prod_type]
    dsimp [c]
    simp only [Finset.mul_sum]
    apply Finset.sum_le_sum
    intro i _
    apply Finset.sum_le_sum
    intro j _
    apply Finset.sum_le_sum
    intro k _
    dsimp [a,b,d]
    by_cases h : (i,j,k) ∈ R
    · have ha : (i,j) ∈ A := mem_image.mpr ⟨(i,j,k),h,rfl⟩
      have hb : (i,k) ∈ B := mem_image.mpr ⟨(i,j,k),h,rfl⟩
      have hd : (j,k) ∈ D := mem_image.mpr ⟨(i,j,k),h,rfl⟩
      simp [ind,h,ha,hb,hd]
    · simp [ind,h]
  have hcs := Finset.sum_mul_sq_le_sq_mul_sq (s := (univ : Finset (X × Y))) a c
  have ha : ∑ p : X × Y, a p^2 = A.card := by simp only [a,ind_sq,sum_ind]
  have hc : ∑ p : X × Y, c p^2 ≤ B.card * D.card := by
    calc
      _ ≤ ∑ p : X × Y, (∑ k, b (p.1,k)^2) * (∑ k, d (p.2,k)^2) := by
        apply Finset.sum_le_sum
        intro p _
        exact Finset.sum_mul_sq_le_sq_mul_sq univ (fun k => b (p.1,k)) (fun k => d (p.2,k))
      _ = B.card * D.card := by
        simp only [b,d,ind_sq,Fintype.sum_prod_type]
        rw [←Finset.sum_mul_sum]
        rw [←Fintype.sum_prod_type,←Fintype.sum_prod_type,sum_ind,sum_ind]
  calc
    R.card^2 ≤ (∑ p, a p*c p)^2 := Nat.pow_le_pow_left hr 2
    _ ≤ (∑ p, a p^2) * ∑ p, c p^2 := hcs
    _ ≤ A.card * (B.card*D.card) := by rw [ha]; exact Nat.mul_le_mul_left _ hc
    _ = _ := by dsimp [A,B,D]; simp only [mul_assoc]

end WitnessedSeparation.Projection



namespace WitnessedSeparation.BoxLines

open Finset

variable {J : Type*} [Fintype J] [DecidableEq J] {n : ℕ}

def projection (R : Finset (Fin (n+1) × J)) : Finset J := R.image Prod.snd

def fullLines (R : Finset (Fin (n+1) × J)) : Finset J :=
  univ.filter fun j => ∀ i, (i,j) ∈ R

def edgeBoundary (R : Finset (Fin (n+1) × J)) : Finset (Fin n × J) :=
  univ.filter fun p => ¬ ((p.1.castSucc,p.2) ∈ R ↔ (p.1.succ,p.2) ∈ R)

private theorem fin_constant {P : Fin (n+1) → Prop}
    (h : ∀ i : Fin n, P i.castSucc ↔ P i.succ) (i : Fin (n+1)) : P i ↔ P 0 := by
  induction i using Fin.induction with
  | zero => rfl
  | succ i ih => exact (h i).symm.trans ih

theorem partial_line_boundary (R : Finset (Fin (n+1) × J)) {j : J}
    (hj : j ∈ projection R \ fullLines R) :
    ∃ i : Fin n, (i,j) ∈ edgeBoundary R := by
  classical
  by_contra hn
  have h : ∀ i : Fin n, (i.castSucc,j) ∈ R ↔ (i.succ,j) ∈ R := by
    intro i
    by_contra hh
    exact hn ⟨i,by simp [edgeBoundary,hh]⟩
  obtain ⟨hj,hf⟩ := mem_sdiff.mp hj
  obtain ⟨⟨i,j'⟩,hi,he⟩ := mem_image.mp hj
  dsimp at he
  subst j'
  have hzero := (fin_constant (P := fun i => (i,j) ∈ R) h i).mp hi
  apply hf
  simp only [fullLines,mem_filter,mem_univ,true_and]
  intro i
  exact (fin_constant (P := fun i => (i,j) ∈ R) h i).mpr hzero

theorem line_count (R : Finset (Fin (n+1) × J)) :
    (n+1) * (projection R).card ≤ (n+1) * (edgeBoundary R).card + R.card := by
  classical
  have hF : fullLines R ⊆ projection R := by
    intro j hj
    have h := (mem_filter.mp hj).2
    exact mem_image.mpr ⟨(0,j),h 0,rfl⟩
  have hfull : (n+1) * (fullLines R).card ≤ R.card := by
    have hh : (univ : Finset (Fin (n+1))) ×ˢ fullLines R ⊆ R := by
      rintro ⟨i,j⟩ hp
      exact (mem_filter.mp (mem_product.mp hp).2).2 i
    simpa only [card_product,card_univ,Fintype.card_fin] using card_le_card hh
  have hpartial : (projection R \ fullLines R).card ≤ (edgeBoundary R).card := by
    have hh : projection R \ fullLines R ⊆ (edgeBoundary R).image Prod.snd := by
      intro j hj
      obtain ⟨i,hi⟩ := partial_line_boundary R hj
      exact mem_image.mpr ⟨(i,j),hi,rfl⟩
    exact (card_le_card hh).trans card_image_le
  have hc := card_sdiff_add_card_eq_card hF
  calc
    (n+1) * (projection R).card =
        (n+1) * (projection R \ fullLines R).card + (n+1) * (fullLines R).card := by
      rw [←hc,Nat.mul_add]
    _ ≤ (n+1) * (edgeBoundary R).card + R.card :=
      Nat.add_le_add (Nat.mul_le_mul_left _ hpartial) hfull

end WitnessedSeparation.BoxLines



namespace WitnessedSeparation.Grid

open Finset

variable {n : ℕ}

def edgeBoundary (R : Finset (Vertex n)) : Finset (Edge n) :=
  univ.filter fun e => ¬(tail e ∈ R ↔ head e ∈ R)

def swapXY (v : Vertex n) : Vertex n := (v.2.1,v.1,v.2.2)

def moveZ (v : Vertex n) : Vertex n := (v.2.2,v.1,v.2.1)

theorem swapXY_injective : Function.Injective (@swapXY n) := by
  rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h
  simp only [swapXY,Prod.mk.injEq] at h ⊢
  tauto

theorem moveZ_injective : Function.Injective (@moveZ n) := by
  rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h
  simp only [moveZ,Prod.mk.injEq] at h ⊢
  tauto

private theorem boundary_x_le (R : Finset (Vertex n)) :
    (BoxLines.edgeBoundary R).card ≤ (edgeBoundary R).card := by
  apply card_le_card_of_injOn (fun p => ex p.1 p.2.1 p.2.2)
  · rintro ⟨i,j,k⟩ hp
    have hp' := (Finset.mem_filter.mp (show (i,j,k) ∈ BoxLines.edgeBoundary R from hp)).2
    apply Finset.mem_filter.mpr
    exact ⟨mem_univ _,hp'⟩
  · intro p _ q _ h
    exact Sum.inl.inj h

private theorem boundary_y_le (R : Finset (Vertex n)) :
    (BoxLines.edgeBoundary (R.image swapXY)).card ≤ (edgeBoundary R).card := by
  apply card_le_card_of_injOn (fun p => ey p.2.1 p.1 p.2.2)
  · rintro ⟨j,i,k⟩ hp
    have he (v : Vertex n) : swapXY v ∈ R.image swapXY ↔ v ∈ R :=
      by
        constructor
        · intro h
          obtain ⟨w,hw,he⟩ := mem_image.mp h
          simpa only [swapXY_injective he] using hw
        · intro h; exact mem_image.mpr ⟨v,h,rfl⟩
    have h1 := he (i,j.castSucc,k)
    have h2 := he (i,j.succ,k)
    have hp' := (Finset.mem_filter.mp (show (j,i,k) ∈ BoxLines.edgeBoundary (R.image swapXY) from hp)).2
    apply Finset.mem_filter.mpr
    refine ⟨mem_univ _,?_⟩
    change ¬ ((i,j.castSucc,k) ∈ R ↔ (i,j.succ,k) ∈ R)
    change ¬(swapXY (i,j.castSucc,k) ∈ R.image swapXY ↔ swapXY (i,j.succ,k) ∈ R.image swapXY) at hp'
    simpa only [he] using hp'
  · rintro ⟨j,i,k⟩ _ ⟨j',i',k'⟩ _ h
    simp only [ey,Sum.inr.injEq,Sum.inl.injEq,Prod.mk.injEq] at h ⊢
    tauto

private theorem boundary_z_le (R : Finset (Vertex n)) :
    (BoxLines.edgeBoundary (R.image moveZ)).card ≤ (edgeBoundary R).card := by
  apply card_le_card_of_injOn (fun p => ez p.2.1 p.2.2 p.1)
  · rintro ⟨k,i,j⟩ hp
    have he (v : Vertex n) : moveZ v ∈ R.image moveZ ↔ v ∈ R :=
      by
        constructor
        · intro h
          obtain ⟨w,hw,he⟩ := mem_image.mp h
          simpa only [moveZ_injective he] using hw
        · intro h; exact mem_image.mpr ⟨v,h,rfl⟩
    have h1 := he (i,j,k.castSucc)
    have h2 := he (i,j,k.succ)
    have hp' := (Finset.mem_filter.mp (show (k,i,j) ∈ BoxLines.edgeBoundary (R.image moveZ) from hp)).2
    apply Finset.mem_filter.mpr
    refine ⟨mem_univ _,?_⟩
    change ¬ ((i,j,k.castSucc) ∈ R ↔ (i,j,k.succ) ∈ R)
    change ¬(moveZ (i,j,k.castSucc) ∈ R.image moveZ ↔ moveZ (i,j,k.succ) ∈ R.image moveZ) at hp'
    simpa only [he] using hp'
  · rintro ⟨k,i,j⟩ _ ⟨k',i',j'⟩ _ h
    simp only [ez,Sum.inr.injEq,Prod.mk.injEq] at h ⊢
    tauto

theorem projection_line_bounds (R : Finset (Vertex n)) :
    let A := (R.image fun v => (v.1,v.2.1)).card
    let B := (R.image fun v => (v.1,v.2.2)).card
    let D := (R.image fun v => (v.2.1,v.2.2)).card
    (n+1)*A ≤ (n+1)*(edgeBoundary R).card + R.card ∧
    (n+1)*B ≤ (n+1)*(edgeBoundary R).card + R.card ∧
    (n+1)*D ≤ (n+1)*(edgeBoundary R).card + R.card := by
  have hx := (BoxLines.line_count R).trans
    (Nat.add_le_add_right (Nat.mul_le_mul_left (n+1) (boundary_x_le R)) _)
  have hy := (BoxLines.line_count (R.image swapXY)).trans
    (Nat.add_le_add_right (Nat.mul_le_mul_left (n+1) (boundary_y_le R)) _)
  have hz := (BoxLines.line_count (R.image moveZ)).trans
    (Nat.add_le_add_right (Nat.mul_le_mul_left (n+1) (boundary_z_le R)) _)
  simp only [card_image_of_injective _ swapXY_injective,BoxLines.projection,
    image_image,Function.comp_def,swapXY] at hy
  simp only [card_image_of_injective _ moveZ_injective,BoxLines.projection,
    image_image,Function.comp_def,moveZ] at hz
  exact ⟨hz,hy,hx⟩

end WitnessedSeparation.Grid



namespace WitnessedSeparation.Grid

noncomputable def boxConstant : ℝ := 1 - (2:ℝ)^(-(1:ℝ)/3)

theorem boxConstant_pos : 0 < boxConstant := by
  unfold boxConstant
  have h := Real.rpow_lt_rpow_of_exponent_lt (by norm_num : (1:ℝ) < 2)
    (by norm_num : -(1:ℝ)/3 < 0)
  simpa using h

private theorem boundary_algebra {L r d p : ℝ} (hL : 0 < L) (hr : 0 < r)
    (_hd : 0 ≤ d) (hp : 0 ≤ p) (hhalf : 2*r ≤ L^3)
    (hproj : r^2 ≤ p^3) (hline : L*p ≤ L*d+r) :
    boxConstant * r^((2:ℝ)/3) ≤ d := by
  have hr0 := le_of_lt hr
  have h23 : (r^((2:ℝ)/3))^3 = r^2 := by
    rw [←Real.rpow_natCast,←Real.rpow_mul hr0]
    norm_num
  have h13 : (r^((1:ℝ)/3))^3 = r := by
    rw [←Real.rpow_natCast,←Real.rpow_mul hr0]
    norm_num
  have hc3 : ((2:ℝ)^(-(1:ℝ)/3))^3 = (1:ℝ)/2 := by
    rw [←Real.rpow_natCast,←Real.rpow_mul (by norm_num : (0:ℝ) ≤ 2)]
    norm_num
  have hc : 0 ≤ (2:ℝ)^(-(1:ℝ)/3) := Real.rpow_nonneg (by norm_num) _
  have hp' : r^((2:ℝ)/3) ≤ p := by
    apply (pow_le_pow_iff_left₀ (Real.rpow_nonneg hr0 _) hp (by norm_num : (3:ℕ) ≠ 0)).mp
    simpa only [h23] using hproj
  have hl' : r^((1:ℝ)/3) ≤ (2:ℝ)^(-(1:ℝ)/3)*L := by
    apply (pow_le_pow_iff_left₀ (Real.rpow_nonneg hr0 _)
      (mul_nonneg hc hL.le) (by norm_num : (3:ℕ) ≠ 0)).mp
    rw [h13,mul_pow,hc3]
    linarith
  have hprod : r^((1:ℝ)/3)*r^((2:ℝ)/3) = r := by
    rw [←Real.rpow_add hr]
    norm_num
  have hsmall := mul_le_mul_of_nonneg_right hl' (Real.rpow_nonneg hr0 ((2:ℝ)/3))
  rw [hprod] at hsmall
  have hproj' := mul_le_mul_of_nonneg_left hp' hL.le
  unfold boxConstant
  nlinarith

theorem box_boundary {n : ℕ} (R : Finset (Vertex n)) (hne : R.Nonempty)
    (hhalf : 2*R.card ≤ (n+1)^3) :
    boxConstant * (R.card:ℝ)^((2:ℝ)/3) ≤ (edgeBoundary R).card := by
  let A := (R.image fun v => (v.1,v.2.1)).card
  let B := (R.image fun v => (v.1,v.2.2)).card
  let D := (R.image fun v => (v.2.1,v.2.2)).card
  let p := max A (max B D)
  have ha : A ≤ p := le_max_left _ _
  have hb : B ≤ p := (le_max_left B D).trans (le_max_right _ _)
  have hd : D ≤ p := (le_max_right B D).trans (le_max_right _ _)
  have hp : R.card^2 ≤ p^3 := by
    calc
      _ ≤ A*B*D := Projection.card_sq_le_projections R
      _ ≤ p*p*p := Nat.mul_le_mul (Nat.mul_le_mul ha hb) hd
      _ = p^3 := by ring
  obtain ⟨hA,hB,hD⟩ := projection_line_bounds R
  have hline : (n+1)*p ≤ (n+1)*(edgeBoundary R).card + R.card := by
    dsimp [p]
    rw [mul_max_of_nonneg _ _ (Nat.zero_le _),mul_max_of_nonneg _ _ (Nat.zero_le _)]
    exact max_le hA (max_le hB hD)
  apply boundary_algebra (L := (n+1:ℕ)) (p := p)
  · positivity
  · exact_mod_cast Finset.card_pos.mpr hne
  · positivity
  · positivity
  · exact_mod_cast hhalf
  · exact_mod_cast hp
  · exact_mod_cast hline

end WitnessedSeparation.Grid



namespace WitnessedSeparation.Flows

noncomputable section

open Classical

abbrev Scalar := ZMod 3

variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]

def incidence (tail head : E → V) : (E → Scalar) →ₗ[Scalar] (V → Scalar) where
  toFun t := ∑ e, t e • (Pi.single (head e) 1 - Pi.single (tail e) 1)
  map_add' := by intros; simp [add_smul,Finset.sum_add_distrib]
  map_smul' := by intros; simp [smul_smul,Finset.smul_sum]

omit [Fintype V] in
@[simp] theorem incidence_single (tail head : E → V) (e : E) (z : Scalar) :
    incidence tail head (Pi.single e z) = Pi.single (head e) z - Pi.single (tail e) z := by
  change (∑ x, (Pi.single e z : E → Scalar) x •
    (Pi.single (head x) 1 - Pi.single (tail x) 1)) = _
  rw [Finset.sum_eq_single e]
  · simp [smul_sub,←Pi.single_smul]
  · intro b _ hb; simp [Pi.single_eq_of_ne hb]
  · simp

def edgeRelation (tail head : E → V) (T : Finset E) (x y : V) : Prop :=
  ∃ e, e ∉ T ∧ tail e = x ∧ head e = y

def connected (tail head : E → V) (T : Finset E) : Setoid V :=
  Relation.EqvGen.setoid (edgeRelation tail head T)

abbrev Component (tail head : E → V) (T : Finset E) := Quotient (connected tail head T)

def component (tail head : E → V) (T : Finset E) (v : V) : Finset V :=
  Finset.univ.filter fun w => (connected tail head T).r v w

variable (tail head : E → V) (T : Finset E)

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
@[simp] theorem mem_component (v w : V) : w ∈ component tail head T v ↔
    (connected tail head T).r v w := by simp [component]

omit [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem edge_connected (e : E) (he : e ∉ T) :
    (connected tail head T).r (tail e) (head e) :=
  Relation.EqvGen.rel _ _ ⟨e,he,rfl,rfl⟩

omit [Fintype V] in
theorem path_flow {v w : V} (h : (connected tail head T).r v w) :
    ∃ t : E → Scalar, (∀ e ∈ T, t e = 0) ∧
      incidence tail head t = Pi.single w 1 - Pi.single v 1 := by
  induction h with
  | rel v w h =>
    obtain ⟨e,he,rfl,rfl⟩ := h
    refine ⟨Pi.single e 1,?_,incidence_single tail head e 1⟩
    intro f hf
    exact Pi.single_eq_of_ne (by intro h; subst f; exact he hf) _
  | refl v => exact ⟨0,by simp,by simp⟩
  | symm v w h ih =>
    obtain ⟨t,ht,hd⟩ := ih
    refine ⟨-t,by simpa using ht,?_⟩
    rw [map_neg,hd]; abel
  | trans u v w _ _ ih ih' =>
    obtain ⟨t,ht,hd⟩ := ih
    obtain ⟨t',ht',hd'⟩ := ih'
    refine ⟨t+t',fun e he => by simp [ht e he,ht' e he],?_⟩
    rw [map_add,hd,hd']; abel

omit [Fintype V] in
private theorem sum_single (U : Finset V) (v : V) (z : Scalar) :
    ∑ x ∈ U, (Pi.single v z : V → Scalar) x = if v ∈ U then z else 0 := by
  simp [Pi.single_apply]

omit [DecidableEq E] in
theorem sum_incidence (t : E → Scalar) : ∑ v, incidence tail head t v = 0 := by
  change (∑ v, (∑ e, t e • (Pi.single (head e) 1 - Pi.single (tail e) 1) : V → Scalar) v) = _
  simp only [Finset.sum_apply,Pi.smul_apply,smul_eq_mul,Pi.sub_apply,mul_sub]
  rw [Finset.sum_comm]
  have h (e : E) : ∑ v, (t e * (Pi.single (head e) (1:Scalar) : V → Scalar) v -
      t e * (Pi.single (tail e) (1:Scalar) : V → Scalar) v) = 0 := by
    rw [Finset.sum_sub_distrib,←Finset.mul_sum,←Finset.mul_sum]
    simp [Pi.single_apply]
  simp only [h,Finset.sum_const_zero]

theorem sum_incidence_component (t : E → Scalar) (ht : ∀ e ∈ T, t e = 0) (v : V) :
    ∑ w ∈ component tail head T v, incidence tail head t w = 0 := by
  change (∑ w ∈ component tail head T v,
    (∑ e, t e • (Pi.single (head e) 1 - Pi.single (tail e) 1) : V → Scalar) w) = _
  simp only [Finset.sum_apply,Pi.smul_apply,smul_eq_mul,Pi.sub_apply,mul_sub]
  rw [Finset.sum_comm]
  apply Finset.sum_eq_zero
  intro e _
  rw [Finset.sum_sub_distrib,←Finset.mul_sum,←Finset.mul_sum,sum_single,sum_single]
  by_cases he : e ∈ T
  · simp [ht e he]
  have hc : head e ∈ component tail head T v ↔ tail e ∈ component tail head T v := by
    simp only [mem_component]
    exact ⟨fun h => (connected tail head T).trans h ((connected tail head T).symm (edge_connected tail head T e he)),
      fun h => (connected tail head T).trans h (edge_connected tail head T e he)⟩
  simp only [hc,sub_self]

theorem solvable_iff (b : V → Scalar) :
    (∃ t : E → Scalar, (∀ e ∈ T, t e = 0) ∧ incidence tail head t = b) ↔
      ∀ v, ∑ w ∈ component tail head T v, b w = 0 := by
  constructor
  · rintro ⟨t,ht,rfl⟩
    exact sum_incidence_component tail head T t ht
  · intro hb
    let q : V → Component tail head T := Quotient.mk (connected tail head T)
    let : Fintype (Component tail head T) := Fintype.ofFinite _
    have hp (v : V) : ∃ t : E → Scalar, (∀ e ∈ T, t e = 0) ∧
        incidence tail head t = Pi.single v 1 - Pi.single ((q v).out) 1 := by
      apply path_flow tail head T
      exact Quotient.exact (Quotient.out_eq (q v))
    choose t ht hd using hp
    refine ⟨∑ v, b v • t v,?_,?_⟩
    · intro e he
      simp [Finset.sum_apply,ht _ e he]
    · rw [map_sum]
      simp only [map_smul,hd,smul_sub,Finset.sum_sub_distrib]
      have hfirst : (∑ v, b v • (Pi.single v (1:Scalar) : V → Scalar)) = b := by
        funext j; simp [Finset.sum_apply,Pi.smul_apply,Pi.single_apply]
      have hsecond : (∑ v, b v • (Pi.single (q v).out (1:Scalar) : V → Scalar)) = 0 := by
        rw [←Fintype.sum_fiberwise q]
        apply Finset.sum_eq_zero
        intro c _
        have hf : (∑ v : {v : V // q v = c}, b v) = 0 := by
          have he (v : V) : q v = c ↔ v ∈ component tail head T c.out := by
            rw [mem_component]
            constructor
            · intro h
              exact Quotient.exact ((Quotient.out_eq c).trans h.symm)
            · intro h
              exact (Quotient.sound h).symm.trans (Quotient.out_eq c)
          let ee := Equiv.subtypeEquivRight he
          have hs := Fintype.sum_equiv ee (fun v : {v : V // q v = c} => b v)
            (fun v : component tail head T c.out => b v) (fun _ => rfl)
          rw [hs]
          exact (Finset.sum_coe_sort (component tail head T c.out) b).trans (hb c.out)
        have hx : (∑ v : {v : V // q v = c}, b v •
            (Pi.single (q v).out (1:Scalar) : V → Scalar)) =
            (∑ v : {v : V // q v = c}, b v) • Pi.single c.out 1 := by
          rw [Finset.sum_smul]
          apply Finset.sum_congr rfl
          intro v _; rw [v.2]
        rw [hx,hf,zero_smul]
      rw [hfirst,hsecond,sub_zero]

theorem partial_flow_iff (σ : E → Scalar) :
    (∃ k : E → Scalar, incidence tail head k = 0 ∧ ∀ e ∈ T, k e = σ e) ↔
      ∀ v, ∑ w ∈ component tail head T v,
        incidence tail head (fun e => if e ∈ T then σ e else 0) w = 0 := by
  let z : E → Scalar := fun e => if e ∈ T then σ e else 0
  constructor
  · rintro ⟨k,hk,he⟩ v
    have ht : ∀ e ∈ T, (k-z) e = 0 := by intro e h; simp [z,h,he e h]
    have h := sum_incidence_component tail head T (k-z) ht v
    simpa [map_sub,hk,Finset.sum_neg_distrib] using h
  · intro h
    have hb : ∀ v, ∑ w ∈ component tail head T v, (-incidence tail head z) w = 0 := by
      intro v; simpa [Finset.sum_neg_distrib] using congrArg Neg.neg (h v)
    obtain ⟨t,ht,hd⟩ := (solvable_iff tail head T (-incidence tail head z)).mpr hb
    refine ⟨z+t,by simp [hd],?_⟩
    intro e he; simp [z,he,ht e he]

end





noncomputable section

open Classical Finset

variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]

variable (tail head : E → V) (T : Finset E)

instance : Fintype (Component tail head T) := Fintype.ofFinite _

def cell (c : Component tail head T) : Finset V := component tail head T c.out

def quotientMap (v : V) : Component tail head T := Quotient.mk (connected tail head T) v

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
@[simp] theorem mem_cell (c : Component tail head T) (v : V) :
    v ∈ cell tail head T c ↔ quotientMap tail head T v = c := by
  rw [cell,mem_component]
  constructor
  · intro h
    exact (Quotient.sound h).symm.trans (Quotient.out_eq c)
  · intro h
    exact Quotient.exact ((Quotient.out_eq c).trans h.symm)

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem cell_nonempty (c : Component tail head T) : (cell tail head T c).Nonempty :=
  ⟨c.out,(mem_cell tail head T c c.out).mpr (Quotient.out_eq c)⟩

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem cells_disjoint {c d : Component tail head T} (h : c ≠ d) :
    Disjoint (cell tail head T c) (cell tail head T d) := by
  apply disjoint_left.mpr
  intro v hc hd
  exact h ((mem_cell tail head T c v).mp hc |>.symm.trans ((mem_cell tail head T d v).mp hd))

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem sum_cells {M : Type*} [AddCommMonoid M] (f : V → M) :
    ∑ c : Component tail head T, ∑ v ∈ cell tail head T c, f v = ∑ v, f v := by
  have he (c : Component tail head T) :
      (∑ v ∈ cell tail head T c, f v) = ∑ v, if quotientMap tail head T v = c then f v else 0 := by
    rw [←sum_filter]
    congr 1
    ext v; simp
  simp only [he]
  rw [sum_comm]
  simp

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem sum_card_cells : ∑ c : Component tail head T, (cell tail head T c).card = Fintype.card V := by
  simpa using sum_cells tail head T (fun _ => (1:ℕ))

def edgeBoundary (U : Finset V) : Finset E := univ.filter fun e => ¬(tail e ∈ U ↔ head e ∈ U)

theorem boundary_cell_subset (c : Component tail head T) :
    edgeBoundary tail head (cell tail head T c) ⊆ T := by
  intro e he
  by_contra hn
  have hc := edge_connected tail head T e hn
  have hq : quotientMap tail head T (tail e) = quotientMap tail head T (head e) := Quotient.sound hc
  have hh := (mem_filter.mp he).2
  exact hh (by simp only [mem_cell,hq])

theorem sum_boundary_cells :
    ∑ c : Component tail head T, (edgeBoundary tail head (cell tail head T c)).card ≤ 2*T.card := by
  have he (c : Component tail head T) :
      (edgeBoundary tail head (cell tail head T c)).card =
      ∑ e ∈ T, if e ∈ edgeBoundary tail head (cell tail head T c) then 1 else 0 := by
    rw [←card_filter]
    congr 1
    ext e
    simp only [mem_filter]
    exact ⟨fun h => ⟨boundary_cell_subset tail head T c h,h⟩,fun h => h.2⟩
  simp only [he]
  rw [sum_comm]
  calc
    _ ≤ ∑ _ ∈ T, 2 := by
      apply sum_le_sum
      intro e _
      calc
        _ ≤ ∑ c : Component tail head T,
            ((if quotientMap tail head T (tail e) = c then 1 else 0) +
             (if quotientMap tail head T (head e) = c then 1 else 0)) := by
          apply sum_le_sum
          intro c _
          simp only [edgeBoundary,mem_filter,mem_univ,true_and,mem_cell]
          by_cases h1 : quotientMap tail head T (tail e) = c <;>
            by_cases h2 : quotientMap tail head T (head e) = c <;> simp [h1,h2]
        _ = 2 := by rw [sum_add_distrib]; simp
    _ = 2*T.card := by simp [mul_comm]

omit [Fintype E] [DecidableEq E] in


theorem small_failing_component (b : V → Scalar) (hb : ∑ v, b v = 0)
    (hfail : ∃ c : Component tail head T, (∑ v ∈ cell tail head T c, b v) ≠ 0) :
    ∃ c : Component tail head T, (∑ v ∈ cell tail head T c, b v) ≠ 0 ∧
      2*(cell tail head T c).card ≤ Fintype.card V := by
  obtain ⟨c,hc⟩ := hfail
  by_cases hsmall : 2*(cell tail head T c).card ≤ Fintype.card V
  · exact ⟨c,hc,hsmall⟩
  have he : ∃ d : Component tail head T, d ≠ c ∧ (∑ v ∈ cell tail head T d, b v) ≠ 0 := by
    by_contra hh
    push Not at hh
    have hsum : (∑ d : Component tail head T, ∑ v ∈ cell tail head T d, b v) =
        ∑ v ∈ cell tail head T c, b v := by
      apply sum_eq_single c
      · intro d _ hd; exact hh d hd
      · simp
    rw [sum_cells,hb] at hsum
    exact hc hsum.symm
  obtain ⟨d,hd,hfd⟩ := he
  refine ⟨d,hfd,?_⟩
  have hdis := cells_disjoint tail head T hd.symm
  have hcard := card_le_card (subset_univ (cell tail head T c ∪ cell tail head T d))
  rw [card_union_of_disjoint hdis,card_univ] at hcard
  omega

end

end WitnessedSeparation.Flows



namespace WitnessedSeparation.Grid

noncomputable section

open Classical Finset

variable {n : ℕ}

private theorem bound_of_boundary {r b : ℝ} (hr : 0 ≤ r) (_hb : 0 ≤ b)
    (h : boxConstant * r^((2:ℝ)/3) ≤ b) : r ≤ (b/boxConstant)^((3:ℝ)/2) := by
  have hu : r^((2:ℝ)/3) ≤ b/boxConstant := by
    apply (le_div_iff₀ boxConstant_pos).mpr
    simpa only [mul_comm] using h
  have hv := Real.rpow_le_rpow (Real.rpow_nonneg hr _) hu (by norm_num : (0:ℝ) ≤ 3/2)
  rw [←Real.rpow_mul hr] at hv
  norm_num at hv
  exact hv

theorem small_cell_bound (T : Finset (Edge n)) (c : Flows.Component tail head T)
    (hsmall : 2*(Flows.cell tail head T c).card ≤ (n+1)^3) :
    ((Flows.cell tail head T c).card:ℝ) ≤
      ((Flows.edgeBoundary tail head (Flows.cell tail head T c)).card / boxConstant)^((3:ℝ)/2) :=
  bound_of_boundary (by positivity) (by positivity)
    (box_boundary _ (Flows.cell_nonempty tail head T c) hsmall)

theorem partial_flow_small_obstruction (T : Finset (Edge n)) (σ : Edge n → Scalar)
    (hfail : ¬ ∃ k : Edge n → Scalar, Flows.incidence tail head k = 0 ∧
      ∀ e ∈ T, k e = σ e) :
    ∃ c : Flows.Component tail head T,
      (∑ v ∈ Flows.cell tail head T c,
        Flows.incidence tail head (fun e => if e ∈ T then σ e else 0) v) ≠ 0 ∧
      2*(Flows.cell tail head T c).card ≤ (n+1)^3 ∧
      ((Flows.cell tail head T c).card:ℝ) ≤
        (T.card/boxConstant)^((3:ℝ)/2) := by
  let z : Edge n → Scalar := fun e => if e ∈ T then σ e else 0
  have hf : ∃ v, (∑ w ∈ Flows.component tail head T v, Flows.incidence tail head z w) ≠ 0 := by
    by_contra hh
    push Not at hh
    exact hfail ((Flows.partial_flow_iff tail head T σ).mpr hh)
  obtain ⟨v,hv⟩ := hf
  have hcell : Flows.cell tail head T (Flows.quotientMap tail head T v) =
      Flows.component tail head T v := by
    ext w
    rw [Flows.mem_cell,Flows.mem_component]
    exact ⟨fun h => Quotient.exact h.symm,fun h => (Quotient.sound h).symm⟩
  obtain ⟨c,hc,hs⟩ := Flows.small_failing_component tail head T (Flows.incidence tail head z)
    (Flows.sum_incidence tail head z) ⟨Flows.quotientMap tail head T v,by simpa only [hcell] using hv⟩
  have hcard : Fintype.card (Vertex n) = (n+1)^3 := by simp only [Vertex,Fintype.card_prod,Fintype.card_fin]; ring
  rw [hcard] at hs
  refine ⟨c,hc,hs,(small_cell_bound T c hs).trans ?_⟩
  apply Real.rpow_le_rpow (div_nonneg (Nat.cast_nonneg _) boxConstant_pos.le) _ (by norm_num)
  apply div_le_div_of_nonneg_right _ boxConstant_pos.le
  exact_mod_cast card_le_card (Flows.boundary_cell_subset tail head T c)

private theorem sum_rpow_le {ι : Type*} (s : Finset ι) (f : ι → ℝ)
    (hf : ∀ i ∈ s, 0 ≤ f i) :
    ∑ i ∈ s, (f i)^((3:ℝ)/2) ≤ (∑ i ∈ s, f i)^((3:ℝ)/2) := by
  classical
  induction s using Finset.induction_on with
  | empty => simp
  | @insert a s ha ih =>
    rw [sum_insert ha,sum_insert ha]
    have hs : ∀ i ∈ s, 0 ≤ f i := fun i hi => hf i (mem_insert_of_mem hi)
    calc
      f a ^ ((3:ℝ)/2) + ∑ i ∈ s, f i ^ ((3:ℝ)/2) ≤
          f a ^ ((3:ℝ)/2) + (∑ i ∈ s, f i) ^ ((3:ℝ)/2) := add_le_add (le_refl _) (ih hs)
      _ ≤ (f a + ∑ i ∈ s, f i) ^ ((3:ℝ)/2) :=
        Real.add_rpow_le_rpow_add (hf a (mem_insert_self _ _)) (sum_nonneg hs) (by norm_num)

theorem small_components_bound (T : Finset (Edge n)) (S : Finset (Flows.Component tail head T))
    (hs : ∀ c ∈ S, 2*(Flows.cell tail head T c).card ≤ (n+1)^3) :
    (∑ c ∈ S, ((Flows.cell tail head T c).card:ℝ)) ≤
      ((2*T.card:ℝ)/boxConstant)^((3:ℝ)/2) := by
  let b (c : Flows.Component tail head T) : ℝ :=
    (Flows.edgeBoundary tail head (Flows.cell tail head T c)).card / boxConstant
  have hn (c) : 0 ≤ b c := div_nonneg (Nat.cast_nonneg _) boxConstant_pos.le
  calc
    _ ≤ ∑ c ∈ S, (b c)^((3:ℝ)/2) := sum_le_sum (fun c hc => small_cell_bound T c (hs c hc))
    _ ≤ (∑ c ∈ S, b c)^((3:ℝ)/2) := sum_rpow_le S b (fun c _ => hn c)
    _ ≤ ((2*T.card:ℝ)/boxConstant)^((3:ℝ)/2) := by
      apply Real.rpow_le_rpow (sum_nonneg (fun c _ => hn c)) _ (by norm_num)
      dsimp [b]
      rw [←sum_div]
      apply div_le_div_of_nonneg_right _ boxConstant_pos.le
      calc
        _ ≤ ∑ c : Flows.Component tail head T,
            ((Flows.edgeBoundary tail head (Flows.cell tail head T c)).card:ℝ) :=
          sum_le_sum_of_subset_of_nonneg (subset_univ _) (fun _ _ _ => by positivity)
        _ ≤ 2*T.card := by exact_mod_cast Flows.sum_boundary_cells tail head T

theorem exists_giant (T : Finset (Edge n))
    (hnum : ((2*T.card:ℝ)/boxConstant)^((3:ℝ)/2) < ((n+1)^3:ℕ)) :
    ∃ c : Flows.Component tail head T, (n+1)^3 < 2*(Flows.cell tail head T c).card := by
  by_contra hh
  push Not at hh
  have h := small_components_bound T univ (fun c _ => hh c)
  rw [←Nat.cast_sum,Flows.sum_card_cells] at h
  have hc : Fintype.card (Vertex n) = (n+1)^3 := by simp only [Vertex,Fintype.card_prod,Fintype.card_fin]; ring
  rw [hc] at h
  exact (not_lt_of_ge h) hnum

end

end WitnessedSeparation.Grid



namespace WitnessedSeparation.Flows

noncomputable section

open Classical Finset

variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]

variable (tail head : E → V)

omit [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem connected_mono {T U : Finset E} (hT : T ⊆ U) {v w : V}
    (h : (connected tail head U).r v w) : (connected tail head T).r v w := by
  induction h with
  | rel v w h =>
    obtain ⟨e,he,rfl,rfl⟩ := h
    exact edge_connected tail head T e (fun hh => he (hT hh))
  | refl v => exact .refl v
  | symm v w h ih => exact .symm _ _ ih
  | trans v w z h h' ih ih' => exact .trans _ _ _ ih ih'

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem component_mono {T U : Finset E} (hT : T ⊆ U) (v : V) :
    component tail head U v ⊆ component tail head T v := by
  intro w hw
  exact (mem_component _ _ _ _ _).mpr (connected_mono tail head hT ((mem_component _ _ _ _ _).mp hw))

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem component_eq {T : Finset E} {v w : V} (h : (connected tail head T).r v w) :
    component tail head T v = component tail head T w := by
  ext x; simp only [mem_component]
  exact ⟨fun hv => (connected tail head T).trans ((connected tail head T).symm h) hv,
    fun hw => (connected tail head T).trans h hw⟩

def IsGiant (T : Finset E) (v : V) : Prop :=
  Fintype.card V < 2*(component tail head T v).card

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem giant_mono {T U : Finset E} (hT : T ⊆ U) {v : V} (h : IsGiant tail head U v) :
    IsGiant tail head T v := lt_of_lt_of_le h (Nat.mul_le_mul_left 2 (card_le_card (component_mono tail head hT v)))

omit [Fintype E] [DecidableEq E] in
theorem giants_connected {T : Finset E} {v w : V}
    (hv : IsGiant tail head T v) (hw : IsGiant tail head T w) : (connected tail head T).r v w := by
  by_contra hh
  have hd : Disjoint (component tail head T v) (component tail head T w) := by
    apply disjoint_left.mpr
    intro x hx hx'
    exact hh ((connected tail head T).trans ((mem_component _ _ _ _ _).mp hx)
      ((connected tail head T).symm ((mem_component _ _ _ _ _).mp hx')))
  have hk : (component tail head T v).card + (component tail head T w).card ≤ Fintype.card V := by
    rw [←card_union_of_disjoint hd]
    exact card_le_univ _
  dsimp [IsGiant] at hv hw
  omega

omit [Fintype E] [DecidableEq V] [DecidableEq E] in

theorem component_isolated {T : Finset E} (v : V)
    (h : ∀ e, tail e = v ∨ head e = v → e ∈ T) : component tail head T v = {v} := by
  have hh {x y : V} (hc : (connected tail head T).r x y) : x = v ↔ y = v := by
    induction hc with
    | rel x y hr =>
      obtain ⟨e,he,rfl,rfl⟩ := hr
      exact ⟨fun hv => False.elim (he (h e (Or.inl hv))),fun hv => False.elim (he (h e (Or.inr hv)))⟩
    | refl x => rfl
    | symm x y hc ih => exact ih.symm
    | trans x y z hc hc' ih ih' => exact ih.trans ih'
  ext w
  simp only [mem_component,mem_singleton]
  exact ⟨fun hw => (hh hw).mp rfl,fun hw => by subst w; exact (connected tail head T).refl _⟩

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
theorem giant_ne_isolated {T : Finset E} {w v : V} (hV : 2 ≤ Fintype.card V)
    (hw : IsGiant tail head T w) (h : ∀ e, tail e = v ∨ head e = v → e ∈ T) : w ≠ v := by
  intro he; subst w
  have hh := component_isolated tail head v h
  dsimp [IsGiant] at hw
  rw [hh,card_singleton] at hw
  omega

end

end WitnessedSeparation.Flows



namespace WitnessedSeparation.Grid

noncomputable section

open Classical Finset

variable {n : ℕ}

theorem grid_connected (v w : Vertex n) : (Flows.connected tail head ∅).r v w := by
  have hx (i j k : Fin (n+1)) : (Flows.connected tail head ∅).r (0,j,k) (i,j,k) := by
    induction i using Fin.induction with
    | zero => exact (Flows.connected tail head ∅).refl _
    | succ i ih =>
      exact (Flows.connected tail head ∅).trans ih (Flows.edge_connected tail head ∅ (ex i j k) (by simp))
  have hy (i j k : Fin (n+1)) : (Flows.connected tail head ∅).r (i,0,k) (i,j,k) := by
    induction j using Fin.induction with
    | zero => exact (Flows.connected tail head ∅).refl _
    | succ j ih =>
      exact (Flows.connected tail head ∅).trans ih (Flows.edge_connected tail head ∅ (ey i j k) (by simp))
  have hz (i j k : Fin (n+1)) : (Flows.connected tail head ∅).r (i,j,0) (i,j,k) := by
    induction k using Fin.induction with
    | zero => exact (Flows.connected tail head ∅).refl _
    | succ k ih =>
      exact (Flows.connected tail head ∅).trans ih (Flows.edge_connected tail head ∅ (ez i j k) (by simp))
  have h (v : Vertex n) : (Flows.connected tail head ∅).r (0,0,0) v :=
    (Flows.connected tail head ∅).trans (hx v.1 0 0)
      ((Flows.connected tail head ∅).trans (hy v.1 v.2.1 0) (hz v.1 v.2.1 v.2.2))
  exact (Flows.connected tail head ∅).trans ((Flows.connected tail head ∅).symm (h v)) (h w)

theorem grid_empty_component (v : Vertex n) : Flows.component tail head ∅ v = univ := by
  ext w; simp only [Flows.mem_component,mem_univ,iff_true]; exact grid_connected v w

theorem grid_empty_giant (v : Vertex n) : Flows.IsGiant tail head ∅ v := by
  dsimp [Flows.IsGiant]
  rw [grid_empty_component,card_univ]
  have hpos : 0 < Fintype.card (Vertex n) := Fintype.card_pos_iff.mpr ⟨(0,0,0)⟩
  omega

end





noncomputable section

open Classical Finset

variable {n M : ℕ} {b : Vertex n → Scalar}

theorem AtomShift.config_boundary {t : Edge n → Scalar} {v : Vertex n}
    {s : Configuration b v} {y : Atom b} (h : AtomShift t (.inr ⟨v,s⟩) y) :
    boundary t v = 0 := by
  cases h with
  | config v s h => simpa only [sub_self] using h

theorem quantitative_homogeneity_shift (hn : 1 ≤ n) {J : Type*} [Fintype J] [Nonempty (Atom b)]
    (names : J ↪ Fin M) (a a' : J → Atom b)
    (hw : (7*Fintype.card J:ℝ) + 7*((6*Fintype.card J:ℝ)/boxConstant)^((3:ℝ)/2)+1 ≤ M)
    (ht : Counting.tupleType (analysisStructure b) names a =
      Counting.tupleType (analysisStructure b) names a') :
    ∃ k : Edge n → Scalar, boundary k = 0 ∧ ∀ j, AtomShift k (a j) (a' j) := by
  let : Nonempty (Atom b) := ⟨.inr ⟨(0,0,0),someConfiguration hn b (0,0,0)⟩⟩
  have hp : 0 ≤ ((6*Fintype.card J:ℝ)/boxConstant)^((3:ℝ)/2) := Real.rpow_nonneg (div_nonneg (by positivity) boxConstant_pos.le) _
  have hw' : 7*Fintype.card J < M := by
    have hh : (7*Fintype.card J:ℝ)+1 ≤ M := by linarith
    have hh' : 7*Fintype.card J+1 ≤ M := by exact_mod_cast hh
    omega
  obtain ⟨σ,hσ⟩ := tuple_partial_shift names a a' hw' ht
  let T : Finset (Edge n) := touches univ a
  have hT : T.card ≤ 6*Fintype.card J := by simpa [T] using touches_card univ a
  suffices hs : ∃ k : Edge n → Scalar, Flows.incidence tail head k = 0 ∧ ∀ e ∈ T, k e = σ e by
    obtain ⟨k,hk,he⟩ := hs
    refine ⟨k,hk,fun j => (hσ j).congr ?_⟩
    intro e hej
    exact (he e (touch_subset_touches univ a (mem_univ j) hej)).symm
  by_contra hs
  obtain ⟨C,hbad,hsmall,hcard⟩ := partial_flow_small_obstruction T σ hs
  let U := Flows.cell tail head T C
  have hU : (U.card:ℝ) ≤ ((6*Fintype.card J:ℝ)/boxConstant)^((3:ℝ)/2) := by
    apply hcard.trans
    apply Real.rpow_le_rpow (div_nonneg (Nat.cast_nonneg _) boxConstant_pos.le) _ (by norm_num)
    apply div_le_div_of_nonneg_right _ boxConstant_pos.le
    exact_mod_cast hT
  let conf (v : U) : Atom b := .inr ⟨v.val,someConfiguration hn b v.val⟩
  have hwU : 7*Fintype.card (J ⊕ U) < M := by
    have hh : (7*(Fintype.card J+U.card):ℝ)+1 ≤ M := by linarith
    have hh' : 7*(Fintype.card J+U.card)+1 ≤ M := by exact_mod_cast hh
    simpa only [Fintype.card_sum,Fintype.card_coe] using (show 7*(Fintype.card J+U.card)<M by omega)
  have hcardU : Fintype.card (J ⊕ U) < M := by omega
  obtain ⟨conf',htU⟩ := Counting.tupleType_append (analysisStructure b) (analysisStructure b)
    names (namesBelow hcardU) a a' conf ht
  obtain ⟨d,hd⟩ := tuple_partial_shift (namesBelow hcardU) (Sum.elim a conf) (Sum.elim a' conf') hwU htU
  have hdT : ∀ e ∈ T, d e = σ e := by
    intro e he
    obtain ⟨j,hj,he⟩ := mem_biUnion.mp he
    exact (hd (.inl j)).unique_on_touch (hσ j) e he
  have hdU : ∀ v ∈ U, Flows.incidence tail head d v = 0 := by
    intro v hv
    exact (hd (.inr ⟨v,hv⟩)).config_boundary
  let z : Edge n → Scalar := fun e => if e ∈ T then σ e else 0
  have hd0 : ∀ e ∈ T, (d-z) e = 0 := by intro e he; simp [z,he,hdT e he]
  have hbal := Flows.sum_incidence_component tail head T (d-z) hd0 C.out
  have hsum : (∑ v ∈ U, Flows.incidence tail head d v) = 0 := sum_eq_zero hdU
  change (∑ v ∈ U, Flows.incidence tail head (d-z) v) = 0 at hbal
  simp only [map_sub,Pi.sub_apply,sum_sub_distrib,hsum,zero_sub,neg_eq_zero] at hbal
  exact hbad hbal

end





noncomputable section

open Classical

variable {n M : ℕ} {b : Vertex n → Scalar}

theorem central_atomShift (k : CentralGroup n) (x : Atom b) :
    AtomShift k.toAdd.val x (k • x) := by
  have hk (e : Edge n) : restrictGroup e (Support.H.central flowCycle k.toAdd) =
      Support.H.central (localCycle e) (k.toAdd.val e) := by
    apply Support.H.ext <;> rfl
  cases x with
  | inl x =>
    rcases x with ⟨e,s⟩
    change AtomShift k.toAdd.val (.inl ⟨e,s⟩)
      (.inl ⟨e,restrictGroup e (Support.H.central flowCycle k.toAdd)*s⟩)
    rw [hk]
    exact .edge e s
  | inr x =>
    rcases x with ⟨v,s⟩
    have hb : boundary k.toAdd.val v = b v-b v := by
      simp only [sub_self]
      exact congrFun k.toAdd.property v
    have hs : Support.H.central flowCycle k.toAdd • s = s.shift k.toAdd.val hb := by
      apply Configuration.ext
      intro e
      change restrictGroup e.val (Support.H.central flowCycle k.toAdd)*s.state e = _
      rw [hk]
      rfl
    change AtomShift k.toAdd.val (.inr ⟨v,s⟩) (.inr ⟨v,Support.H.central flowCycle k.toAdd • s⟩)
    rw [hs]
    exact .config v s hb

theorem quantitative_homogeneity (hn : 1 ≤ n) {J : Type*} [Fintype J] [Nonempty (Atom b)]
    (names : J ↪ Fin M) (a a' : J → Atom b)
    (hw : (7*Fintype.card J:ℝ) + 7*((6*Fintype.card J:ℝ)/boxConstant)^((3:ℝ)/2)+1 ≤ M)
    (ht : Counting.tupleType (analysisStructure b) names a =
      Counting.tupleType (analysisStructure b) names a') :
    ∃ k : CentralGroup n, ∀ j, k • a j = a' j := by
  obtain ⟨k,hk,ha⟩ := quantitative_homogeneity_shift hn names a a' hw ht
  let g : CentralGroup n := Multiplicative.ofAdd ⟨k,hk⟩
  exact ⟨g,fun j => (central_atomShift g (a j)).functional (ha j)⟩

theorem empty_homogeneity {J : Type*} [IsEmpty J] (a a' : J → Atom b) :
    ∃ k : CentralGroup n, ∀ j, k • a j = a' j := ⟨1,fun j => isEmptyElim j⟩

end

end WitnessedSeparation.Grid



namespace WitnessedSeparation.Counting.Formula

noncomputable section

open Classical Finset

variable {R I A B : Type*} [DecidableEq I]

theorem eval_of_partialBijectionSystem (S : Structure R A) (T : Structure R B)
    (E : Finset I → (I → A) → (I → B) → Prop)
    (heq : ∀ names v w, E names v w → ∀ i ∈ names, ∀ j ∈ names, (v i = v j ↔ w i = w j))
    (hrel : ∀ names v w, E names v w → ∀ r i, i ∈ names → ∀ j, j ∈ names →
      (S.rel r (v i) (v j) ↔ T.rel r (w i) (w j)))
    (hext : ∀ names v w, E names v w → ∀ i, ∃ e : A ≃ B,
      ∀ a, E (insert i (names.erase i)) (Function.update v i a) (Function.update w i (e a)))
    (φ : Formula R I) : ∀ names v w, E names v w → φ.free ⊆ names →
      (φ.eval S v ↔ φ.eval T w) := by
  induction φ with
  | falsum => intros; rfl
  | equal i j =>
    intro names v w h hf
    exact heq names v w h i (hf (by simp [free])) j (hf (by simp [free]))
  | relation r i j =>
    intro names v w h hf
    exact hrel names v w h r i (hf (by simp [free])) j (hf (by simp [free]))
  | neg φ ih => intro names v w h hf; exact not_congr (ih names v w h hf)
  | and φ ψ ih ih' =>
    intro names v w h hf
    exact and_congr (ih names v w h (subset_union_left.trans hf))
      (ih' names v w h (subset_union_right.trans hf))
  | ex i φ ih =>
    intro names v w h hf
    obtain ⟨e,he⟩ := hext names v w h i
    have hfree : φ.free ⊆ insert i (names.erase i) := by
      intro j hj
      by_cases hji : j = i
      · simp [hji]
      · exact mem_insert_of_mem (mem_erase.mpr ⟨hji,hf (mem_erase.mpr ⟨hji,hj⟩)⟩)
    change (∃ a, φ.eval S (Function.update v i a)) ↔ _
    constructor
    · rintro ⟨a,ha⟩; exact ⟨e a,(ih _ _ _ (he a) hfree).mp ha⟩
    · rintro ⟨b,hb⟩; obtain ⟨a,rfl⟩ := e.surjective b
      exact ⟨a,(ih _ _ _ (he a) hfree).mpr hb⟩
  | exact i n φ ih =>
    intro names v w h hf
    obtain ⟨e,he⟩ := hext names v w h i
    have hfree : φ.free ⊆ insert i (names.erase i) := by
      intro j hj
      by_cases hji : j = i
      · simp [hji]
      · exact mem_insert_of_mem (mem_erase.mpr ⟨hji,hf (mem_erase.mpr ⟨hji,hj⟩)⟩)
    let f : {a : A // φ.eval S (Function.update v i a)} ≃
        {b : B // φ.eval T (Function.update w i b)} :=
      e.subtypeEquiv (fun a => ih _ _ _ (he a) hfree)
    exact ⟨fun ⟨g⟩ => ⟨f.symm.trans g⟩,fun ⟨g⟩ => ⟨f.trans g⟩⟩

end

end WitnessedSeparation.Counting.Formula

end OAI