[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
⊢ Finset.card (increment hP G ε).parts = stepBound (Finset.card P.parts)
[PROOFSTEP]
have hPα' : stepBound P.parts.card ≤ card α := (mul_le_mul_left' (pow_le_pow_of_le_left' (by norm_num) _) _).trans hPα
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
⊢ 4 ≤ 16
[PROOFSTEP]
norm_num
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
⊢ Finset.card (increment hP G ε).parts = stepBound (Finset.card P.parts)
[PROOFSTEP]
have hPpos : 0 < stepBound P.parts.card := stepBound_pos (nonempty_of_not_uniform hPG).card_pos
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ Finset.card (increment hP G ε).parts = stepBound (Finset.card P.parts)
[PROOFSTEP]
rw [increment, card_bind]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ∑ A in attach P.parts, Finset.card (chunk hP G ε (_ : ↑A ∈ P.parts)).parts = stepBound (Finset.card P.parts)
[PROOFSTEP]
simp_rw [chunk, apply_dite Finpartition.parts, apply_dite card, sum_dite]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ∑ x in
        attach
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)),
        Finset.card
          (equitabilise
              (_ :
                (4 ^ Finset.card P.parts -
                        (Fintype.card α / Finset.card P.parts -
                          Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts)) *
                      (Fintype.card α / stepBound (Finset.card P.parts)) +
                    (Fintype.card α / Finset.card P.parts -
                        Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts) *
                      (Fintype.card α / stepBound (Finset.card P.parts) + 1) =
                  Finset.card ↑↑x)).parts +
      ∑ x in
        attach
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)),
        Finset.card
          (equitabilise
              (_ :
                (4 ^ Finset.card P.parts -
                        (Fintype.card α / Finset.card P.parts -
                            Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                          1)) *
                      (Fintype.card α / stepBound (Finset.card P.parts)) +
                    (Fintype.card α / Finset.card P.parts -
                          Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                        1) *
                      (Fintype.card α / stepBound (Finset.card P.parts) + 1) =
                  Finset.card ↑↑x)).parts =
    stepBound (Finset.card P.parts)
[PROOFSTEP]
rw [sum_const_nat, sum_const_nat, card_attach, card_attach]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ Finset.card
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) *
        ?m.158358 +
      Finset.card
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) *
        ?m.158415 =
    stepBound (Finset.card P.parts)
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ∀
    (x :
      { x //
        x ∈
          filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts) }),
    x ∈
        attach
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) →
      Finset.card
          (equitabilise
              (_ :
                (4 ^ Finset.card P.parts -
                        (Fintype.card α / Finset.card P.parts -
                            Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                          1)) *
                      (Fintype.card α / stepBound (Finset.card P.parts)) +
                    (Fintype.card α / Finset.card P.parts -
                          Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                        1) *
                      (Fintype.card α / stepBound (Finset.card P.parts) + 1) =
                  Finset.card ↑↑x)).parts =
        ?m.158415
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ∀
    (x :
      { x //
        x ∈
          filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts) }),
    x ∈
        attach
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) →
      Finset.card
          (equitabilise
              (_ :
                (4 ^ Finset.card P.parts -
                        (Fintype.card α / Finset.card P.parts -
                          Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts)) *
                      (Fintype.card α / stepBound (Finset.card P.parts)) +
                    (Fintype.card α / Finset.card P.parts -
                        Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts) *
                      (Fintype.card α / stepBound (Finset.card P.parts) + 1) =
                  Finset.card ↑↑x)).parts =
        ?m.158358
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
[PROOFSTEP]
rotate_left
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ∀
    (x :
      { x //
        x ∈
          filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts) }),
    x ∈
        attach
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) →
      Finset.card
          (equitabilise
              (_ :
                (4 ^ Finset.card P.parts -
                        (Fintype.card α / Finset.card P.parts -
                            Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                          1)) *
                      (Fintype.card α / stepBound (Finset.card P.parts)) +
                    (Fintype.card α / Finset.card P.parts -
                          Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                        1) *
                      (Fintype.card α / stepBound (Finset.card P.parts) + 1) =
                  Finset.card ↑↑x)).parts =
        ?m.158415
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ∀
    (x :
      { x //
        x ∈
          filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts) }),
    x ∈
        attach
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) →
      Finset.card
          (equitabilise
              (_ :
                (4 ^ Finset.card P.parts -
                        (Fintype.card α / Finset.card P.parts -
                          Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts)) *
                      (Fintype.card α / stepBound (Finset.card P.parts)) +
                    (Fintype.card α / Finset.card P.parts -
                        Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts) *
                      (Fintype.card α / stepBound (Finset.card P.parts) + 1) =
                  Finset.card ↑↑x)).parts =
        ?m.158358
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ Finset.card
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) *
        ?m.158358 +
      Finset.card
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) *
        ?m.158415 =
    stepBound (Finset.card P.parts)
[PROOFSTEP]
any_goals exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
[PROOFSTEP]
exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
[PROOFSTEP]
exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
[PROOFSTEP]
exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
[PROOFSTEP]
exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ∀
    (x :
      { x //
        x ∈
          filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts) }),
    x ∈
        attach
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) →
      Finset.card
          (equitabilise
              (_ :
                (4 ^ Finset.card P.parts -
                        (Fintype.card α / Finset.card P.parts -
                            Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                          1)) *
                      (Fintype.card α / stepBound (Finset.card P.parts)) +
                    (Fintype.card α / Finset.card P.parts -
                          Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                        1) *
                      (Fintype.card α / stepBound (Finset.card P.parts) + 1) =
                  Finset.card ↑↑x)).parts =
        ?m.158415
[PROOFSTEP]
exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ℕ
[PROOFSTEP]
exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ ∀
    (x :
      { x //
        x ∈
          filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts) }),
    x ∈
        attach
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) →
      Finset.card
          (equitabilise
              (_ :
                (4 ^ Finset.card P.parts -
                        (Fintype.card α / Finset.card P.parts -
                          Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts)) *
                      (Fintype.card α / stepBound (Finset.card P.parts)) +
                    (Fintype.card α / Finset.card P.parts -
                        Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts) *
                      (Fintype.card α / stepBound (Finset.card P.parts) + 1) =
                  Finset.card ↑↑x)).parts =
        ?m.158358
[PROOFSTEP]
exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ Finset.card
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) *
        (4 ^ Finset.card P.parts -
            (Fintype.card α / Finset.card P.parts -
              Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts) +
          (Fintype.card α / Finset.card P.parts -
            Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts)) +
      Finset.card
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) *
        (4 ^ Finset.card P.parts -
            (Fintype.card α / Finset.card P.parts -
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
              1) +
          (Fintype.card α / Finset.card P.parts -
              Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
            1)) =
    stepBound (Finset.card P.parts)
[PROOFSTEP]
exact fun x hx => card_parts_equitabilise _ _ (Nat.div_pos hPα' hPpos).ne'
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ Finset.card
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) *
        (4 ^ Finset.card P.parts -
            (Fintype.card α / Finset.card P.parts -
              Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts) +
          (Fintype.card α / Finset.card P.parts -
            Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts)) +
      Finset.card
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) *
        (4 ^ Finset.card P.parts -
            (Fintype.card α / Finset.card P.parts -
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
              1) +
          (Fintype.card α / Finset.card P.parts -
              Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
            1)) =
    stepBound (Finset.card P.parts)
[PROOFSTEP]
rw [Nat.sub_add_cancel a_add_one_le_four_pow_parts_card,
  Nat.sub_add_cancel ((Nat.le_succ _).trans a_add_one_le_four_pow_parts_card), ← add_mul]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ (Finset.card
          (filter
            (fun x =>
              Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts)) +
        Finset.card
          (filter
            (fun x =>
              ¬Finset.card ↑x =
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                    (Fintype.card α / Finset.card P.parts -
                      Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
            (attach P.parts))) *
      4 ^ Finset.card P.parts =
    stepBound (Finset.card P.parts)
[PROOFSTEP]
congr
[GOAL]
case e_a
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hPα' : stepBound (Finset.card P.parts) ≤ Fintype.card α
hPpos : 0 < stepBound (Finset.card P.parts)
⊢ Finset.card
        (filter
          (fun x =>
            Finset.card ↑x =
              Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                (Fintype.card α / Finset.card P.parts -
                  Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
          (attach P.parts)) +
      Finset.card
        (filter
          (fun x =>
            ¬Finset.card ↑x =
                Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts +
                  (Fintype.card α / Finset.card P.parts -
                    Fintype.card α / stepBound (Finset.card P.parts) * 4 ^ Finset.card P.parts))
          (attach P.parts)) =
    Finset.card P.parts
[PROOFSTEP]
rw [filter_card_add_filter_neg_card_eq_card, card_attach]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G✝ : SimpleGraph α
ε✝ : ℝ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ IsEquipartition (increment hP G ε)
[PROOFSTEP]
simp_rw [IsEquipartition, Set.equitableOn_iff_exists_eq_eq_add_one]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G✝ : SimpleGraph α
ε✝ : ℝ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ ∃ b, ∀ (a : Finset α), a ∈ ↑(increment hP G ε).parts → Finset.card a = b ∨ Finset.card a = b + 1
[PROOFSTEP]
refine' ⟨m, fun A hA => _⟩
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G✝ : SimpleGraph α
ε✝ : ℝ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
A : Finset α
hA : A ∈ ↑(increment hP G ε).parts
⊢ Finset.card A = Fintype.card α / stepBound (Finset.card P.parts) ∨
    Finset.card A = Fintype.card α / stepBound (Finset.card P.parts) + 1
[PROOFSTEP]
rw [mem_coe, increment, mem_bind] at hA
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G✝ : SimpleGraph α
ε✝ : ℝ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
A : Finset α
hA : ∃ A_1 hA, A ∈ (chunk hP G ε hA).parts
⊢ Finset.card A = Fintype.card α / stepBound (Finset.card P.parts) ∨
    Finset.card A = Fintype.card α / stepBound (Finset.card P.parts) + 1
[PROOFSTEP]
obtain ⟨U, hU, hA⟩ := hA
[GOAL]
case intro.intro
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G✝ : SimpleGraph α
ε✝ : ℝ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
A U : Finset α
hU : U ∈ P.parts
hA : A ∈ (chunk hP G ε hU).parts
⊢ Finset.card A = Fintype.card α / stepBound (Finset.card P.parts) ∨
    Finset.card A = Fintype.card α / stepBound (Finset.card P.parts) + 1
[PROOFSTEP]
exact card_eq_of_mem_parts_chunk hA
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ (Finset.biUnion (attach (offDiag P.parts)) fun UV =>
      (chunk hP G ε (_ : (↑UV).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑UV).snd ∈ P.parts)).parts) ⊆
    offDiag (increment hP G ε).parts
[PROOFSTEP]
rintro ⟨Ui, Vj⟩
[GOAL]
case mk
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
Ui Vj : Finset α
⊢ ((Ui, Vj) ∈
      Finset.biUnion (attach (offDiag P.parts)) fun UV =>
        (chunk hP G ε (_ : (↑UV).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑UV).snd ∈ P.parts)).parts) →
    (Ui, Vj) ∈ offDiag (increment hP G ε).parts
[PROOFSTEP]
simp only [increment, mem_offDiag, bind_parts, mem_biUnion, Prod.exists, exists_and_left, exists_prop, mem_product,
  mem_attach, true_and_iff, Subtype.exists, and_imp, mem_offDiag, forall_exists_index, bex_imp, Ne.def]
[GOAL]
case mk
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
Ui Vj : Finset α
⊢ ∀ (x x_1 : Finset α) (x_2 : x ∈ P.parts ∧ x_1 ∈ P.parts ∧ ¬x = x_1),
    Ui ∈ (chunk hP G ε (_ : (↑{ val := (x, x_1), property := (_ : (x, x_1) ∈ offDiag P.parts) }).fst ∈ P.parts)).parts →
      Vj ∈
          (chunk hP G ε
              (_ : (↑{ val := (x, x_1), property := (_ : (x, x_1) ∈ offDiag P.parts) }).snd ∈ P.parts)).parts →
        (∃ a h, Ui ∈ (chunk hP G ε (_ : ↑{ val := a, property := (_ : a ∈ P.parts) } ∈ P.parts)).parts) ∧
          (∃ a h, Vj ∈ (chunk hP G ε (_ : ↑{ val := a, property := (_ : a ∈ P.parts) } ∈ P.parts)).parts) ∧ ¬Ui = Vj
[PROOFSTEP]
refine' fun U V hUV hUi hVj => ⟨⟨_, hUV.1, hUi⟩, ⟨_, hUV.2.1, hVj⟩, _⟩
[GOAL]
case mk
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
Ui Vj U V : Finset α
hUV : U ∈ P.parts ∧ V ∈ P.parts ∧ ¬U = V
hUi : Ui ∈ (chunk hP G ε (_ : (↑{ val := (U, V), property := (_ : (U, V) ∈ offDiag P.parts) }).fst ∈ P.parts)).parts
hVj : Vj ∈ (chunk hP G ε (_ : (↑{ val := (U, V), property := (_ : (U, V) ∈ offDiag P.parts) }).snd ∈ P.parts)).parts
⊢ ¬Ui = Vj
[PROOFSTEP]
rintro rfl
[GOAL]
case mk
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
Ui U V : Finset α
hUV : U ∈ P.parts ∧ V ∈ P.parts ∧ ¬U = V
hUi : Ui ∈ (chunk hP G ε (_ : (↑{ val := (U, V), property := (_ : (U, V) ∈ offDiag P.parts) }).fst ∈ P.parts)).parts
hVj : Ui ∈ (chunk hP G ε (_ : (↑{ val := (U, V), property := (_ : (U, V) ∈ offDiag P.parts) }).snd ∈ P.parts)).parts
⊢ False
[PROOFSTEP]
obtain ⟨i, hi⟩ := nonempty_of_mem_parts _ hUi
[GOAL]
case mk.intro
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
Ui U V : Finset α
hUV : U ∈ P.parts ∧ V ∈ P.parts ∧ ¬U = V
hUi : Ui ∈ (chunk hP G ε (_ : (↑{ val := (U, V), property := (_ : (U, V) ∈ offDiag P.parts) }).fst ∈ P.parts)).parts
hVj : Ui ∈ (chunk hP G ε (_ : (↑{ val := (U, V), property := (_ : (U, V) ∈ offDiag P.parts) }).snd ∈ P.parts)).parts
i : α
hi : i ∈ Ui
⊢ False
[PROOFSTEP]
exact hUV.2.2 (P.disjoint.elim_finset hUV.1 hUV.2.1 i (Finpartition.le _ hUi hi) <| Finpartition.le _ hVj hi)
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ ∑ x in attach (offDiag P.parts),
      SzemerediRegularity.pairContrib G ε hP x / ↑(Finset.card (increment hP G ε).parts) ^ 2 ≤
    energy (increment hP G ε) G
[PROOFSTEP]
simp_rw [pairContrib, ← sum_div]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ (∑ x in attach (offDiag P.parts),
        ∑ i in (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts,
          edgeDensity G i.fst i.snd ^ 2) /
      ↑(Finset.card (increment hP G ε).parts) ^ 2 ≤
    energy (increment hP G ε) G
[PROOFSTEP]
refine' div_le_div_of_le_of_nonneg (α := ℚ) _ (sq_nonneg _)
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ ∑ x in attach (offDiag P.parts),
      ∑ i in (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts,
        edgeDensity G i.fst i.snd ^ 2 ≤
    ∑ uv in offDiag (increment hP G ε).parts, edgeDensity G uv.fst uv.snd ^ 2
[PROOFSTEP]
rw [← sum_biUnion]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ ∑ x in
      Finset.biUnion (attach (offDiag P.parts)) fun x =>
        (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts,
      edgeDensity G x.fst x.snd ^ 2 ≤
    ∑ uv in offDiag (increment hP G ε).parts, edgeDensity G uv.fst uv.snd ^ 2
[PROOFSTEP]
exact sum_le_sum_of_subset_of_nonneg distinct_pairs_increment fun i _ _ => sq_nonneg _
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ Set.PairwiseDisjoint ↑(attach (offDiag P.parts)) fun x =>
    (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts
[PROOFSTEP]
simp only [Set.PairwiseDisjoint, Function.onFun, disjoint_left, inf_eq_inter, mem_inter, mem_product]
[GOAL]
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
⊢ Set.Pairwise ↑(attach (offDiag P.parts)) fun x y =>
    ∀ ⦃a : Finset α × Finset α⦄,
      a.fst ∈ (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ∧ a.snd ∈ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts →
        ¬(a.fst ∈ (chunk hP G ε (_ : (↑y).fst ∈ P.parts)).parts ∧ a.snd ∈ (chunk hP G ε (_ : (↑y).snd ∈ P.parts)).parts)
[PROOFSTEP]
rintro ⟨⟨s₁, s₂⟩, hs⟩ _ ⟨⟨t₁, t₂⟩, ht⟩ _ hst ⟨u, v⟩ huv₁ huv₂
[GOAL]
case mk.mk.mk.mk.mk
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
s₁ s₂ : Finset α
hs : (s₁, s₂) ∈ offDiag P.parts
a✝¹ : { val := (s₁, s₂), property := hs } ∈ ↑(attach (offDiag P.parts))
t₁ t₂ : Finset α
ht : (t₁, t₂) ∈ offDiag P.parts
a✝ : { val := (t₁, t₂), property := ht } ∈ ↑(attach (offDiag P.parts))
hst : { val := (s₁, s₂), property := hs } ≠ { val := (t₁, t₂), property := ht }
u v : Finset α
huv₁ :
  (u, v).fst ∈ (chunk hP G ε (_ : (↑{ val := (s₁, s₂), property := hs }).fst ∈ P.parts)).parts ∧
    (u, v).snd ∈ (chunk hP G ε (_ : (↑{ val := (s₁, s₂), property := hs }).snd ∈ P.parts)).parts
huv₂ :
  (u, v).fst ∈ (chunk hP G ε (_ : (↑{ val := (t₁, t₂), property := ht }).fst ∈ P.parts)).parts ∧
    (u, v).snd ∈ (chunk hP G ε (_ : (↑{ val := (t₁, t₂), property := ht }).snd ∈ P.parts)).parts
⊢ False
[PROOFSTEP]
rw [mem_offDiag] at hs ht
[GOAL]
case mk.mk.mk.mk.mk
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
s₁ s₂ : Finset α
hs✝ : (s₁, s₂) ∈ offDiag P.parts
hs : (s₁, s₂).fst ∈ P.parts ∧ (s₁, s₂).snd ∈ P.parts ∧ (s₁, s₂).fst ≠ (s₁, s₂).snd
a✝¹ : { val := (s₁, s₂), property := hs✝ } ∈ ↑(attach (offDiag P.parts))
t₁ t₂ : Finset α
ht✝ : (t₁, t₂) ∈ offDiag P.parts
ht : (t₁, t₂).fst ∈ P.parts ∧ (t₁, t₂).snd ∈ P.parts ∧ (t₁, t₂).fst ≠ (t₁, t₂).snd
a✝ : { val := (t₁, t₂), property := ht✝ } ∈ ↑(attach (offDiag P.parts))
hst : { val := (s₁, s₂), property := hs✝ } ≠ { val := (t₁, t₂), property := ht✝ }
u v : Finset α
huv₁ :
  (u, v).fst ∈ (chunk hP G ε (_ : (↑{ val := (s₁, s₂), property := hs✝ }).fst ∈ P.parts)).parts ∧
    (u, v).snd ∈ (chunk hP G ε (_ : (↑{ val := (s₁, s₂), property := hs✝ }).snd ∈ P.parts)).parts
huv₂ :
  (u, v).fst ∈ (chunk hP G ε (_ : (↑{ val := (t₁, t₂), property := ht✝ }).fst ∈ P.parts)).parts ∧
    (u, v).snd ∈ (chunk hP G ε (_ : (↑{ val := (t₁, t₂), property := ht✝ }).snd ∈ P.parts)).parts
⊢ False
[PROOFSTEP]
obtain ⟨a, ha⟩ := Finpartition.nonempty_of_mem_parts _ huv₁.1
[GOAL]
case mk.mk.mk.mk.mk.intro
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
s₁ s₂ : Finset α
hs✝ : (s₁, s₂) ∈ offDiag P.parts
hs : (s₁, s₂).fst ∈ P.parts ∧ (s₁, s₂).snd ∈ P.parts ∧ (s₁, s₂).fst ≠ (s₁, s₂).snd
a✝¹ : { val := (s₁, s₂), property := hs✝ } ∈ ↑(attach (offDiag P.parts))
t₁ t₂ : Finset α
ht✝ : (t₁, t₂) ∈ offDiag P.parts
ht : (t₁, t₂).fst ∈ P.parts ∧ (t₁, t₂).snd ∈ P.parts ∧ (t₁, t₂).fst ≠ (t₁, t₂).snd
a✝ : { val := (t₁, t₂), property := ht✝ } ∈ ↑(attach (offDiag P.parts))
hst : { val := (s₁, s₂), property := hs✝ } ≠ { val := (t₁, t₂), property := ht✝ }
u v : Finset α
huv₁ :
  (u, v).fst ∈ (chunk hP G ε (_ : (↑{ val := (s₁, s₂), property := hs✝ }).fst ∈ P.parts)).parts ∧
    (u, v).snd ∈ (chunk hP G ε (_ : (↑{ val := (s₁, s₂), property := hs✝ }).snd ∈ P.parts)).parts
huv₂ :
  (u, v).fst ∈ (chunk hP G ε (_ : (↑{ val := (t₁, t₂), property := ht✝ }).fst ∈ P.parts)).parts ∧
    (u, v).snd ∈ (chunk hP G ε (_ : (↑{ val := (t₁, t₂), property := ht✝ }).snd ∈ P.parts)).parts
a : α
ha : a ∈ (u, v).fst
⊢ False
[PROOFSTEP]
obtain ⟨b, hb⟩ := Finpartition.nonempty_of_mem_parts _ huv₁.2
[GOAL]
case mk.mk.mk.mk.mk.intro.intro
α : Type u_1
inst✝ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
s₁ s₂ : Finset α
hs✝ : (s₁, s₂) ∈ offDiag P.parts
hs : (s₁, s₂).fst ∈ P.parts ∧ (s₁, s₂).snd ∈ P.parts ∧ (s₁, s₂).fst ≠ (s₁, s₂).snd
a✝¹ : { val := (s₁, s₂), property := hs✝ } ∈ ↑(attach (offDiag P.parts))
t₁ t₂ : Finset α
ht✝ : (t₁, t₂) ∈ offDiag P.parts
ht : (t₁, t₂).fst ∈ P.parts ∧ (t₁, t₂).snd ∈ P.parts ∧ (t₁, t₂).fst ≠ (t₁, t₂).snd
a✝ : { val := (t₁, t₂), property := ht✝ } ∈ ↑(attach (offDiag P.parts))
hst : { val := (s₁, s₂), property := hs✝ } ≠ { val := (t₁, t₂), property := ht✝ }
u v : Finset α
huv₁ :
  (u, v).fst ∈ (chunk hP G ε (_ : (↑{ val := (s₁, s₂), property := hs✝ }).fst ∈ P.parts)).parts ∧
    (u, v).snd ∈ (chunk hP G ε (_ : (↑{ val := (s₁, s₂), property := hs✝ }).snd ∈ P.parts)).parts
huv₂ :
  (u, v).fst ∈ (chunk hP G ε (_ : (↑{ val := (t₁, t₂), property := ht✝ }).fst ∈ P.parts)).parts ∧
    (u, v).snd ∈ (chunk hP G ε (_ : (↑{ val := (t₁, t₂), property := ht✝ }).snd ∈ P.parts)).parts
a : α
ha : a ∈ (u, v).fst
b : α
hb : b ∈ (u, v).snd
⊢ False
[PROOFSTEP]
exact
  hst
    (Subtype.ext_val <|
      Prod.ext (P.disjoint.elim_finset hs.1 ht.1 a (Finpartition.le _ huv₁.1 ha) <| Finpartition.le _ huv₂.1 ha) <|
        P.disjoint.elim_finset hs.2.1 ht.2.1 b (Finpartition.le _ huv₁.2 hb) <| Finpartition.le _ huv₂.2 hb)
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
x : { i // i ∈ offDiag P.parts }
hε₁ : ε ≤ 1
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
⊢ (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
      if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) ≤
    ↑(SzemerediRegularity.pairContrib G ε hP x) / 16 ^ Finset.card P.parts
[PROOFSTEP]
rw [pairContrib]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
x : { i // i ∈ offDiag P.parts }
hε₁ : ε ≤ 1
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
⊢ (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
      if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) ≤
    ↑(∑ i in (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts,
          edgeDensity G i.fst i.snd ^ 2) /
      16 ^ Finset.card P.parts
[PROOFSTEP]
push_cast
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
x : { i // i ∈ offDiag P.parts }
hε₁ : ε ≤ 1
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
⊢ (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
      if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) ≤
    (∑ x in (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts,
        ↑(edgeDensity G x.fst x.snd) ^ 2) /
      16 ^ Finset.card P.parts
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
x : { i // i ∈ offDiag P.parts }
hε₁ : ε ≤ 1
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
h : SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd
⊢ ↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 + 0 ≤
    (∑ x in (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts,
        ↑(edgeDensity G x.fst x.snd) ^ 2) /
      16 ^ Finset.card P.parts
[PROOFSTEP]
rw [add_zero]
[GOAL]
case pos
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
x : { i // i ∈ offDiag P.parts }
hε₁ : ε ≤ 1
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
h : SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd
⊢ ↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 ≤
    (∑ x in (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts,
        ↑(edgeDensity G x.fst x.snd) ^ 2) /
      16 ^ Finset.card P.parts
[PROOFSTEP]
exact edgeDensity_chunk_uniform hPα hPε _ _
[GOAL]
case neg
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
x : { i // i ∈ offDiag P.parts }
hε₁ : ε ≤ 1
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
h : ¬SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd
⊢ ↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 + ε ^ 4 / 3 ≤
    (∑ x in (chunk hP G ε (_ : (↑x).fst ∈ P.parts)).parts ×ˢ (chunk hP G ε (_ : (↑x).snd ∈ P.parts)).parts,
        ↑(edgeDensity G x.fst x.snd) ^ 2) /
      16 ^ Finset.card P.parts
[PROOFSTEP]
exact edgeDensity_chunk_not_uniform hPα hPε hε₁ (mem_offDiag.1 x.2).2.2 h
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ (∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4)) /
      ↑(Finset.card P.parts) ^ 2 ≤
    ∑ x in attach (offDiag P.parts),
      ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
[PROOFSTEP]
conv_rhs =>
  rw [← sum_div, card_increment hPα hPG, stepBound, ← Nat.cast_pow, mul_pow, pow_right_comm, Nat.cast_mul, mul_comm, ←
    div_div, show 4 ^ 2 = 16 by norm_num, sum_div]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
| ∑ x in attach (offDiag P.parts),
    ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
[PROOFSTEP]
rw [← sum_div, card_increment hPα hPG, stepBound, ← Nat.cast_pow, mul_pow, pow_right_comm, Nat.cast_mul, mul_comm, ←
    div_div, show 4 ^ 2 = 16 by norm_num, sum_div]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
| ∑ x in attach (offDiag P.parts),
    ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
[PROOFSTEP]
rw [← sum_div, card_increment hPα hPG, stepBound, ← Nat.cast_pow, mul_pow, pow_right_comm, Nat.cast_mul, mul_comm, ←
    div_div, show 4 ^ 2 = 16 by norm_num, sum_div]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
| ∑ x in attach (offDiag P.parts),
    ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
[PROOFSTEP]
rw [← sum_div, card_increment hPα hPG, stepBound, ← Nat.cast_pow, mul_pow, pow_right_comm, Nat.cast_mul, mul_comm, ←
  div_div, show 4 ^ 2 = 16 by norm_num, sum_div]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ 4 ^ 2 = 16
[PROOFSTEP]
norm_num
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ (∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4)) /
      ↑(Finset.card P.parts) ^ 2 ≤
    (∑ x in attach (offDiag P.parts), ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(16 ^ Finset.card P.parts)) /
      ↑(Finset.card P.parts ^ 2)
[PROOFSTEP]
rw [← Nat.cast_pow, Nat.cast_pow 16]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ (∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts ^ 2) * (ε ^ 5 / 4)) /
      ↑(Finset.card P.parts ^ 2) ≤
    (∑ x in attach (offDiag P.parts), ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑16 ^ Finset.card P.parts) /
      ↑(Finset.card P.parts ^ 2)
[PROOFSTEP]
refine' div_le_div_of_le_of_nonneg _ (Nat.cast_nonneg _)
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts ^ 2) * (ε ^ 5 / 4) ≤
    ∑ x in attach (offDiag P.parts), ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑16 ^ Finset.card P.parts
[PROOFSTEP]
norm_num
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) ≤
    ∑ x in attach (offDiag P.parts), ↑(SzemerediRegularity.pairContrib G ε hP x) / 16 ^ Finset.card P.parts
[PROOFSTEP]
trans
  ∑ x in P.parts.offDiag.attach,
    ((G.edgeDensity x.1.1 x.1.2 : ℝ) ^ 2 - ε ^ 5 / ↑25 + if G.IsUniform ε x.1.1 x.1.2 then (0 : ℝ) else ε ^ 4 / 3 : ℝ)
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) ≤
    ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3)
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) ≤
    ∑ x in attach (offDiag P.parts), ↑(SzemerediRegularity.pairContrib G ε hP x) / 16 ^ Finset.card P.parts
[PROOFSTEP]
swap
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) ≤
    ∑ x in attach (offDiag P.parts), ↑(SzemerediRegularity.pairContrib G ε hP x) / 16 ^ Finset.card P.parts
[PROOFSTEP]
exact sum_le_sum fun i _ => pairContrib_lower_bound i hε₁ hPα hPε
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) ≤
    ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3)
[PROOFSTEP]
have :
  ∑ x in P.parts.offDiag.attach,
      ((G.edgeDensity x.1.1 x.1.2 : ℝ) ^ 2 - ε ^ 5 / ↑25 + if G.IsUniform ε x.1.1 x.1.2 then (0 : ℝ) else ε ^ 4 / 3 :
        ℝ) =
    ∑ x in P.parts.offDiag,
      ((G.edgeDensity x.1 x.2 : ℝ) ^ 2 - ε ^ 5 / ↑25 + if G.IsUniform ε x.1 x.2 then (0 : ℝ) else ε ^ 4 / 3) :=
  by convert sum_attach (β := ℝ); rfl
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
⊢ ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
[PROOFSTEP]
convert sum_attach (β := ℝ)
[GOAL]
case h.e'_2.a
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
x✝ : { x // x ∈ offDiag P.parts }
a✝ : x✝ ∈ attach (offDiag P.parts)
⊢ (↑(edgeDensity G (↑x✝).fst (↑x✝).snd) ^ 2 - ε ^ 5 / 25 +
      if SimpleGraph.IsUniform G ε (↑x✝).fst (↑x✝).snd then 0 else ε ^ 4 / 3) =
    ↑(edgeDensity G (↑x✝).fst (↑x✝).snd) ^ 2 - ε ^ 5 / 25 +
      if SimpleGraph.IsUniform G ε (↑x✝).fst (↑x✝).snd then 0 else ε ^ 4 / 3
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) ≤
    ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3)
[PROOFSTEP]
rw [this, sum_add_distrib, sum_sub_distrib, sum_const, nsmul_eq_mul, sum_ite, sum_const_zero, zero_add, sum_const,
  nsmul_eq_mul, ← Finpartition.nonUniforms]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ¬Finpartition.IsUniform P G ε
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) ≤
    ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 - ↑(Finset.card (offDiag P.parts)) * (ε ^ 5 / 25) +
      ↑(Finset.card (nonUniforms P G ε)) * (ε ^ 4 / 3)
[PROOFSTEP]
rw [Finpartition.IsUniform, not_le] at hPG
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) ≤
    ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 - ↑(Finset.card (offDiag P.parts)) * (ε ^ 5 / 25) +
      ↑(Finset.card (nonUniforms P G ε)) * (ε ^ 4 / 3)
[PROOFSTEP]
refine' le_trans _ (add_le_add_left (mul_le_mul_of_nonneg_right hPG.le <| by positivity) _)
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ 0 ≤ ε ^ 4 / 3
[PROOFSTEP]
positivity
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) ≤
    ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 - ↑(Finset.card (offDiag P.parts)) * (ε ^ 5 / 25) +
      ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε * (ε ^ 4 / 3)
[PROOFSTEP]
conv_rhs =>
  enter [1, 2]
  rw [offDiag_card]
  conv => enter [1, 1, 2]; rw [← mul_one P.parts.card]
  rw [← Nat.mul_sub_left_distrib]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 - ↑(Finset.card (offDiag P.parts)) * (ε ^ 5 / 25) +
    ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε * (ε ^ 4 / 3)
[PROOFSTEP]
  enter [1, 2]
  rw [offDiag_card]
  conv => enter [1, 1, 2]; rw [← mul_one P.parts.card]
  rw [← Nat.mul_sub_left_distrib]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 - ↑(Finset.card (offDiag P.parts)) * (ε ^ 5 / 25) +
    ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε * (ε ^ 4 / 3)
[PROOFSTEP]
  enter [1, 2]
  rw [offDiag_card]
  conv => enter [1, 1, 2]; rw [← mul_one P.parts.card]
  rw [← Nat.mul_sub_left_distrib]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 - ↑(Finset.card (offDiag P.parts)) * (ε ^ 5 / 25) +
    ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε * (ε ^ 4 / 3)
[PROOFSTEP]
enter [1, 2]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| ↑(Finset.card (offDiag P.parts)) * (ε ^ 5 / 25)
[PROOFSTEP]
rw [offDiag_card]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| ↑(Finset.card P.parts * Finset.card P.parts - Finset.card P.parts) * (ε ^ 5 / 25)
[PROOFSTEP]
conv => enter [1, 1, 2]; rw [← mul_one P.parts.card]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| ↑(Finset.card P.parts * Finset.card P.parts - Finset.card P.parts) * (ε ^ 5 / 25)
[PROOFSTEP]
enter [1, 1, 2]; rw [← mul_one P.parts.card]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| ↑(Finset.card P.parts * Finset.card P.parts - Finset.card P.parts) * (ε ^ 5 / 25)
[PROOFSTEP]
enter [1, 1, 2]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| Finset.card P.parts
[PROOFSTEP]
rw [← mul_one P.parts.card]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
| ↑(Finset.card P.parts * Finset.card P.parts - Finset.card P.parts * 1) * (ε ^ 5 / 25)
[PROOFSTEP]
rw [← Nat.mul_sub_left_distrib]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) ≤
    ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 -
        ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * (ε ^ 5 / 25) +
      ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε * (ε ^ 4 / 3)
[PROOFSTEP]
simp_rw [mul_assoc, sub_add_eq_add_sub, add_sub_assoc, ← mul_sub_left_distrib, mul_div_assoc' ε, ← pow_succ,
  show 4 + 1 = 5 by rfl, div_eq_mul_one_div (ε ^ 5), ← mul_sub_left_distrib, mul_left_comm _ (ε ^ 5), sq, Nat.cast_mul,
  mul_assoc, ← mul_assoc (ε ^ 5)]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ 4 + 1 = 5
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) * ↑(edgeDensity G x.fst x.snd) +
      ε ^ 5 * ↑(Finset.card P.parts) * (↑(Finset.card P.parts) * (1 / 4)) ≤
    ∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) * ↑(edgeDensity G x.fst x.snd) +
      ε ^ 5 * ↑(Finset.card P.parts) * (↑(Finset.card P.parts - 1) * (1 / 3 - 1 / 25))
[PROOFSTEP]
refine' add_le_add_left (mul_le_mul_of_nonneg_left _ <| by sz_positivity) _
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ 0 ≤ ε ^ 5 * ↑(Finset.card P.parts)
[PROOFSTEP]
sz_positivity
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ ↑(Finset.card P.parts) * (1 / 4) ≤ ↑(Finset.card P.parts - 1) * (1 / 3 - 1 / 25)
[PROOFSTEP]
rw [Nat.cast_sub (P.parts_nonempty <| univ_nonempty.ne_empty).card_pos, mul_sub_right_distrib, Nat.cast_one, one_mul,
  le_sub_comm, ← mul_sub_left_distrib, ← div_le_iff (show (0 : ℝ) < 1 / 3 - 1 / 25 - 1 / 4 by norm_num)]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ 0 < 1 / 3 - 1 / 25 - 1 / 4
[PROOFSTEP]
norm_num
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ (1 / 3 - 1 / 25) / (1 / 3 - 1 / 25 - 1 / 4) ≤ ↑(Finset.card P.parts)
[PROOFSTEP]
exact le_trans (show _ ≤ (7 : ℝ) by norm_num) (by exact_mod_cast hP₇)
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ (1 / 3 - 1 / 25) / (1 / 3 - 1 / 25 - 1 / 4) ≤ 7
[PROOFSTEP]
norm_num
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hε₁ : ε ≤ 1
hP₇ : 7 ≤ Finset.card P.parts
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ Finset.card P.parts * ε ^ 5
hPG : ↑(Finset.card P.parts * (Finset.card P.parts - 1)) * ε < ↑(Finset.card (nonUniforms P G ε))
this :
  ∑ x in attach (offDiag P.parts),
      (↑(edgeDensity G (↑x).fst (↑x).snd) ^ 2 - ε ^ 5 / 25 +
        if SimpleGraph.IsUniform G ε (↑x).fst (↑x).snd then 0 else ε ^ 4 / 3) =
    ∑ x in offDiag P.parts,
      (↑(edgeDensity G x.fst x.snd) ^ 2 - ε ^ 5 / 25 + if SimpleGraph.IsUniform G ε x.fst x.snd then 0 else ε ^ 4 / 3)
⊢ 7 ≤ ↑(Finset.card P.parts)
[PROOFSTEP]
exact_mod_cast hP₇
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hP : IsEquipartition P
hP₇ : 7 ≤ Finset.card P.parts
hε : 100 < 4 ^ Finset.card P.parts * ε ^ 5
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hε₁ : ε ≤ 1
⊢ ↑(energy P G) + ε ^ 5 / 4 ≤ ↑(energy (increment hP G ε) G)
[PROOFSTEP]
rw [coe_energy]
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hP : IsEquipartition P
hP₇ : 7 ≤ Finset.card P.parts
hε : 100 < 4 ^ Finset.card P.parts * ε ^ 5
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hε₁ : ε ≤ 1
⊢ (∑ uv in offDiag P.parts, ↑(edgeDensity G uv.fst uv.snd) ^ 2) / ↑(Finset.card P.parts) ^ 2 + ε ^ 5 / 4 ≤
    ↑(energy (increment hP G ε) G)
[PROOFSTEP]
have h := uniform_add_nonuniform_eq_offDiag_pairs (hP := hP) hε₁ hP₇ hPα hε.le hPG
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hP : IsEquipartition P
hP₇ : 7 ≤ Finset.card P.parts
hε : 100 < 4 ^ Finset.card P.parts * ε ^ 5
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hε₁ : ε ≤ 1
h :
  (∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2 + ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4)) /
      ↑(Finset.card P.parts) ^ 2 ≤
    ∑ x in attach (offDiag P.parts),
      ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
⊢ (∑ uv in offDiag P.parts, ↑(edgeDensity G uv.fst uv.snd) ^ 2) / ↑(Finset.card P.parts) ^ 2 + ε ^ 5 / 4 ≤
    ↑(energy (increment hP G ε) G)
[PROOFSTEP]
rw [add_div, mul_div_cancel_left] at h
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hP : IsEquipartition P
hP₇ : 7 ≤ Finset.card P.parts
hε : 100 < 4 ^ Finset.card P.parts * ε ^ 5
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hε₁ : ε ≤ 1
h :
  (∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2) / ↑(Finset.card P.parts) ^ 2 + ε ^ 5 / 4 ≤
    ∑ x in attach (offDiag P.parts),
      ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
⊢ (∑ uv in offDiag P.parts, ↑(edgeDensity G uv.fst uv.snd) ^ 2) / ↑(Finset.card P.parts) ^ 2 + ε ^ 5 / 4 ≤
    ↑(energy (increment hP G ε) G)
case ha
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hP : IsEquipartition P
hP₇ : 7 ≤ Finset.card P.parts
hε : 100 < 4 ^ Finset.card P.parts * ε ^ 5
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hε₁ : ε ≤ 1
h :
  (∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2) / ↑(Finset.card P.parts) ^ 2 +
      ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) / ↑(Finset.card P.parts) ^ 2 ≤
    ∑ x in attach (offDiag P.parts),
      ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
⊢ ↑(Finset.card P.parts) ^ 2 ≠ 0
[PROOFSTEP]
exact h.trans (by exact_mod_cast offDiag_pairs_le_increment_energy)
[GOAL]
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hP : IsEquipartition P
hP₇ : 7 ≤ Finset.card P.parts
hε : 100 < 4 ^ Finset.card P.parts * ε ^ 5
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hε₁ : ε ≤ 1
h :
  (∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2) / ↑(Finset.card P.parts) ^ 2 + ε ^ 5 / 4 ≤
    ∑ x in attach (offDiag P.parts),
      ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
⊢ ∑ x in attach (offDiag P.parts),
      ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2 ≤
    ↑(energy (increment hP G ε) G)
[PROOFSTEP]
exact_mod_cast offDiag_pairs_le_increment_energy
[GOAL]
case ha
α : Type u_1
inst✝¹ : Fintype α
P : Finpartition univ
hP✝ : IsEquipartition P
G : SimpleGraph α
ε : ℝ
inst✝ : Nonempty α
hP : IsEquipartition P
hP₇ : 7 ≤ Finset.card P.parts
hε : 100 < 4 ^ Finset.card P.parts * ε ^ 5
hPα : Finset.card P.parts * 16 ^ Finset.card P.parts ≤ Fintype.card α
hPG : ¬Finpartition.IsUniform P G ε
hε₁ : ε ≤ 1
h :
  (∑ x in offDiag P.parts, ↑(edgeDensity G x.fst x.snd) ^ 2) / ↑(Finset.card P.parts) ^ 2 +
      ↑(Finset.card P.parts) ^ 2 * (ε ^ 5 / 4) / ↑(Finset.card P.parts) ^ 2 ≤
    ∑ x in attach (offDiag P.parts),
      ↑(SzemerediRegularity.pairContrib G ε hP x) / ↑(Finset.card (increment hP G ε).parts) ^ 2
⊢ ↑(Finset.card P.parts) ^ 2 ≠ 0
[PROOFSTEP]
positivity


[GOAL]
α : Type u_1
inst✝ : CommSemigroup α
s t : Set α
a : α
x : α × α
⊢ Prod.swap x ∈ mulAntidiagonal s t a ↔ x ∈ mulAntidiagonal t s a
[PROOFSTEP]
simp [mul_comm, and_left_comm]
[GOAL]
α : Type u_1
inst✝ : CommSemigroup α
s t : Set α
a : α
x : α × α
⊢ x.snd ∈ s ∧ x.fst ∈ t ∧ x.snd * x.fst = a ↔ x ∈ mulAntidiagonal t s a
[PROOFSTEP]
simp [mul_comm, and_left_comm]
[GOAL]
α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(mulAntidiagonal s t a)
h : (↑x).fst = (↑y).fst
⊢ a = (↑y).fst * (↑x).snd
[PROOFSTEP]
rw [← h]
[GOAL]
α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(mulAntidiagonal s t a)
h : (↑x).fst = (↑y).fst
⊢ a = (↑x).fst * (↑x).snd
[PROOFSTEP]
exact x.2.2.2.symm
[GOAL]
α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(mulAntidiagonal s t a)
h : (↑x).snd = (↑y).snd
⊢ a = (↑x).fst * (↑y).snd
[PROOFSTEP]
rw [← h]
[GOAL]
α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(mulAntidiagonal s t a)
h : (↑x).snd = (↑y).snd
⊢ a = (↑x).fst * (↑x).snd
[PROOFSTEP]
exact x.2.2.2.symm
[GOAL]
α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
a✝ : α
x y : ↑(mulAntidiagonal s t a✝)
hs : IsPwo s
ht : IsPwo t
a : α
⊢ Set.Finite (mulAntidiagonal s t a)
[PROOFSTEP]
refine' not_infinite.1 fun h => _
[GOAL]
α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
a✝ : α
x y : ↑(mulAntidiagonal s t a✝)
hs : IsPwo s
ht : IsPwo t
a : α
h : Set.Infinite (mulAntidiagonal s t a)
⊢ False
[PROOFSTEP]
have h1 : (mulAntidiagonal s t a).PartiallyWellOrderedOn (Prod.fst ⁻¹'o (· ≤ ·)) := fun f hf =>
  hs (Prod.fst ∘ f) fun n => (mem_mulAntidiagonal.1 (hf n)).1
[GOAL]
α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
a✝ : α
x y : ↑(mulAntidiagonal s t a✝)
hs : IsPwo s
ht : IsPwo t
a : α
h : Set.Infinite (mulAntidiagonal s t a)
h1 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.fst ⁻¹'o fun x x_1 => x ≤ x_1)
⊢ False
[PROOFSTEP]
have h2 : (mulAntidiagonal s t a).PartiallyWellOrderedOn (Prod.snd ⁻¹'o (· ≤ ·)) := fun f hf =>
  ht (Prod.snd ∘ f) fun n => (mem_mulAntidiagonal.1 (hf n)).2.1
[GOAL]
α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
a✝ : α
x y : ↑(mulAntidiagonal s t a✝)
hs : IsPwo s
ht : IsPwo t
a : α
h : Set.Infinite (mulAntidiagonal s t a)
h1 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.fst ⁻¹'o fun x x_1 => x ≤ x_1)
h2 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.snd ⁻¹'o fun x x_1 => x ≤ x_1)
⊢ False
[PROOFSTEP]
obtain ⟨g, hg⟩ := h1.exists_monotone_subseq (fun n => h.natEmbedding _ n) fun n => (h.natEmbedding _ n).2
[GOAL]
case intro
α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
a✝ : α
x y : ↑(mulAntidiagonal s t a✝)
hs : IsPwo s
ht : IsPwo t
a : α
h : Set.Infinite (mulAntidiagonal s t a)
h1 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.fst ⁻¹'o fun x x_1 => x ≤ x_1)
h2 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.snd ⁻¹'o fun x x_1 => x ≤ x_1)
g : ℕ ↪o ℕ
hg :
  ∀ (m n : ℕ),
    m ≤ n →
      (Prod.fst ⁻¹'o fun x x_1 => x ≤ x_1) ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g m))
        ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g n))
⊢ False
[PROOFSTEP]
obtain ⟨m, n, mn, h2'⟩ := h2 (fun x => (h.natEmbedding _) (g x)) fun n => (h.natEmbedding _ _).2
[GOAL]
case intro.intro.intro.intro
α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
a✝ : α
x y : ↑(mulAntidiagonal s t a✝)
hs : IsPwo s
ht : IsPwo t
a : α
h : Set.Infinite (mulAntidiagonal s t a)
h1 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.fst ⁻¹'o fun x x_1 => x ≤ x_1)
h2 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.snd ⁻¹'o fun x x_1 => x ≤ x_1)
g : ℕ ↪o ℕ
hg :
  ∀ (m n : ℕ),
    m ≤ n →
      (Prod.fst ⁻¹'o fun x x_1 => x ≤ x_1) ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g m))
        ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g n))
m n : ℕ
mn : m < n
h2' :
  (Prod.snd ⁻¹'o fun x x_1 => x ≤ x_1) ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g m))
    ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g n))
⊢ False
[PROOFSTEP]
refine' mn.ne (g.injective <| (h.natEmbedding _).injective _)
[GOAL]
case intro.intro.intro.intro
α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
a✝ : α
x y : ↑(mulAntidiagonal s t a✝)
hs : IsPwo s
ht : IsPwo t
a : α
h : Set.Infinite (mulAntidiagonal s t a)
h1 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.fst ⁻¹'o fun x x_1 => x ≤ x_1)
h2 : PartiallyWellOrderedOn (mulAntidiagonal s t a) (Prod.snd ⁻¹'o fun x x_1 => x ≤ x_1)
g : ℕ ↪o ℕ
hg :
  ∀ (m n : ℕ),
    m ≤ n →
      (Prod.fst ⁻¹'o fun x x_1 => x ≤ x_1) ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g m))
        ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g n))
m n : ℕ
mn : m < n
h2' :
  (Prod.snd ⁻¹'o fun x x_1 => x ≤ x_1) ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g m))
    ↑(↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g n))
⊢ ↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g m) = ↑(Infinite.natEmbedding (mulAntidiagonal s t a) h) (↑g n)
[PROOFSTEP]
exact eq_of_fst_le_fst_of_snd_le_snd _ _ _ (hg _ _ mn.le) h2'


[GOAL]
α : Type u
l : Thunk (List α)
t : List α
⊢ (fun xs => Thunk.get l ++ xs) t = (fun xs => Thunk.get l ++ xs) [] ++ t
[PROOFSTEP]
simp
[GOAL]
α : Type u
l : List α
⊢ toList (ofList l) = l
[PROOFSTEP]
cases l
[GOAL]
case nil
α : Type u
⊢ toList (ofList []) = []
case cons α : Type u head✝ : α tail✝ : List α ⊢ toList (ofList (head✝ :: tail✝)) = head✝ :: tail✝
[PROOFSTEP]
rfl
[GOAL]
case cons
α : Type u
head✝ : α
tail✝ : List α
⊢ toList (ofList (head✝ :: tail✝)) = head✝ :: tail✝
[PROOFSTEP]
simp only [DList.toList, DList.ofList, List.cons_append, List.append_nil]
[GOAL]
α : Type u
l : DList α
⊢ ofList (toList l) = l
[PROOFSTEP]
cases' l with app inv
[GOAL]
case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ ofList (toList { apply := app, invariant := inv }) = { apply := app, invariant := inv }
[PROOFSTEP]
simp only [ofList, toList, mk.injEq]
[GOAL]
case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ (fun x => app [] ++ x) = app
[PROOFSTEP]
funext x
[GOAL]
case mk.h
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
x : List α
⊢ app [] ++ x = app x
[PROOFSTEP]
rw [(inv x)]
[GOAL]
α : Type u
⊢ toList empty = []
[PROOFSTEP]
simp
[GOAL]
α : Type u
x : α
⊢ toList (singleton x) = [x]
[PROOFSTEP]
simp
[GOAL]
α : Type u
l₁ l₂ : DList α
⊢ toList (append l₁ l₂) = toList l₁ ++ toList l₂
[PROOFSTEP]
cases' l₁ with _ l₁_invariant
[GOAL]
case mk
α : Type u
l₂ : DList α
apply✝ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ toList (append { apply := apply✝, invariant := l₁_invariant } l₂) =
    toList { apply := apply✝, invariant := l₁_invariant } ++ toList l₂
[PROOFSTEP]
cases' l₂
[GOAL]
case mk.mk
α : Type u
apply✝¹ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝¹ l = apply✝¹ [] ++ l
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ toList (append { apply := apply✝¹, invariant := l₁_invariant } { apply := apply✝, invariant := invariant✝ }) =
    toList { apply := apply✝¹, invariant := l₁_invariant } ++ toList { apply := apply✝, invariant := invariant✝ }
[PROOFSTEP]
simp
[GOAL]
case mk.mk
α : Type u
apply✝¹ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝¹ l = apply✝¹ [] ++ l
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ apply✝¹ (apply✝ []) = apply✝¹ [] ++ apply✝ []
[PROOFSTEP]
rw [l₁_invariant]
[GOAL]
α : Type u
x : α
l : DList α
⊢ toList (cons x l) = x :: toList l
[PROOFSTEP]
cases l
[GOAL]
case mk
α : Type u
x : α
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ toList (cons x { apply := apply✝, invariant := invariant✝ }) =
    x :: toList { apply := apply✝, invariant := invariant✝ }
[PROOFSTEP]
simp
[GOAL]
α : Type u
x : α
l : DList α
⊢ toList (push l x) = toList l ++ [x]
[PROOFSTEP]
cases' l with _ l_invariant
[GOAL]
case mk
α : Type u
x : α
apply✝ : List α → List α
l_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ toList (push { apply := apply✝, invariant := l_invariant } x) =
    toList { apply := apply✝, invariant := l_invariant } ++ [x]
[PROOFSTEP]
simp
[GOAL]
case mk
α : Type u
x : α
apply✝ : List α → List α
l_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ apply✝ [x] = apply✝ [] ++ [x]
[PROOFSTEP]
rw [l_invariant]