Theorem: roth_3ap_theorem
File: Mathlib/Combinatorics/Additive/Corner/Roth.lean

tactic: rintro hA
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
⊢ ¬ThreeAPFree ↑A
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
⊢ False

tactic: classical
let B : Finset (G × G) := univ.filter fun (x, y) ↦ y - x ∈ A
have : ε * card G ^ 2 ≤ B.card := by
  calc
    _ = card G * (ε * card G) := by ring
    _ ≤ card G * A.card := by gcongr
    _ = B.card := ?_
  norm_cast
  rw [← card_univ, ← card_product]
  exact card_equiv ((Equiv.refl _).prodShear fun a ↦ Equiv.addLeft a) (by simp [B])
obtain ⟨x₁, y₁, x₂, y₂, hx₁y₁, hx₁y₂, hx₂y₁, hxy, hx₁x₂⟩ :
    ∃ x₁ y₁ x₂ y₂, y₁ - x₁ ∈ A ∧ y₂ - x₁ ∈ A ∧ y₁ - x₂ ∈ A ∧ x₁ + y₂ = x₂ + y₁ ∧ x₁ ≠ x₂ := by
  simpa [IsCornerFree, isCorner_iff, B, -exists_and_left, -exists_and_right]
    using corners_theorem ε hε hG B this
have := hA hx₂y₁ hx₁y₁ hx₁y₂ $ by rw [sub_add_sub_comm, add_comm, add_sub_add_comm, add_right_cancel_iff,
    sub_eq_sub_iff_add_eq_add, add_comm, hxy, add_comm]
exact hx₁x₂ $ by simpa using this.symm
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
⊢ False
state_after: no goals

tactic: let B : Finset (G × G) := univ.filter fun (x, y) ↦ y - x ∈ A
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
⊢ False
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ False

tactic: have : ε * card G ^ 2 ≤ B.card := by
  calc
    _ = card G * (ε * card G) := by ring
    _ ≤ card G * A.card := by gcongr
    _ = B.card := ?_
  norm_cast
  rw [← card_univ, ← card_product]
  exact card_equiv ((Equiv.refl _).prodShear fun a ↦ Equiv.addLeft a) (by simp [B])
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ False
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
⊢ False

tactic: obtain ⟨x₁, y₁, x₂, y₂, hx₁y₁, hx₁y₂, hx₂y₁, hxy, hx₁x₂⟩ :
    ∃ x₁ y₁ x₂ y₂, y₁ - x₁ ∈ A ∧ y₂ - x₁ ∈ A ∧ y₁ - x₂ ∈ A ∧ x₁ + y₂ = x₂ + y₁ ∧ x₁ ≠ x₂ := by
  simpa [IsCornerFree, isCorner_iff, B, -exists_and_left, -exists_and_right]
    using corners_theorem ε hε hG B this
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
⊢ False
state_after: case intro.intro.intro.intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
x₁ y₁ x₂ y₂ : G
hx₁y₁ : y₁ - x₁ ∈ A
hx₁y₂ : y₂ - x₁ ∈ A
hx₂y₁ : y₁ - x₂ ∈ A
hxy : x₁ + y₂ = x₂ + y₁
hx₁x₂ : x₁ ≠ x₂
⊢ False

tactic: have := hA hx₂y₁ hx₁y₁ hx₁y₂ $ by rw [sub_add_sub_comm, add_comm, add_sub_add_comm, add_right_cancel_iff,
    sub_eq_sub_iff_add_eq_add, add_comm, hxy, add_comm]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
x₁ y₁ x₂ y₂ : G
hx₁y₁ : y₁ - x₁ ∈ A
hx₁y₂ : y₂ - x₁ ∈ A
hx₂y₁ : y₁ - x₂ ∈ A
hxy : x₁ + y₂ = x₂ + y₁
hx₁x₂ : x₁ ≠ x₂
⊢ False
state_after: case intro.intro.intro.intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this✝ : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
x₁ y₁ x₂ y₂ : G
hx₁y₁ : y₁ - x₁ ∈ A
hx₁y₂ : y₂ - x₁ ∈ A
hx₂y₁ : y₁ - x₂ ∈ A
hxy : x₁ + y₂ = x₂ + y₁
hx₁x₂ : x₁ ≠ x₂
this : y₁ - x₂ = y₁ - x₁
⊢ False

tactic: exact hx₁x₂ $ by simpa using this.symm
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this✝ : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
x₁ y₁ x₂ y₂ : G
hx₁y₁ : y₁ - x₁ ∈ A
hx₁y₂ : y₂ - x₁ ∈ A
hx₂y₁ : y₁ - x₂ ∈ A
hxy : x₁ + y₂ = x₂ + y₁
hx₁x₂ : x₁ ≠ x₂
this : y₁ - x₂ = y₁ - x₁
⊢ False
state_after: no goals

tactic: calc
  _ = card G * (ε * card G) := by ring
  _ ≤ card G * A.card := by gcongr
  _ = B.card := ?_
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ ↑(Fintype.card G) * ↑A.card = ↑B.card

tactic: norm_cast
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ ↑(Fintype.card G) * ↑A.card = ↑B.card
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ Fintype.card G * A.card = B.card

tactic: rw [← card_univ, ← card_product]
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ Fintype.card G * A.card = B.card
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ (univ ×ˢ A).card = B.card

tactic: exact card_equiv ((Equiv.refl _).prodShear fun a ↦ Equiv.addLeft a) (by simp [B])
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ (univ ×ˢ A).card = B.card
state_after: no goals

tactic: ring
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ ε * ↑(Fintype.card G) ^ 2 = ↑(Fintype.card G) * (ε * ↑(Fintype.card G))
state_after: no goals

tactic: gcongr
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ ↑(Fintype.card G) * (ε * ↑(Fintype.card G)) ≤ ↑(Fintype.card G) * ↑A.card
state_after: no goals

tactic: simp [B]
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
⊢ ∀ (i : G × G), i ∈ univ ×ˢ A ↔ ((Equiv.refl G).prodShear fun a => Equiv.addLeft a) i ∈ B
state_after: no goals

tactic: simpa [IsCornerFree, isCorner_iff, B, -exists_and_left, -exists_and_right]
  using corners_theorem ε hε hG B this
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
⊢ ∃ x₁ y₁ x₂ y₂, y₁ - x₁ ∈ A ∧ y₂ - x₁ ∈ A ∧ y₁ - x₂ ∈ A ∧ x₁ + y₂ = x₂ + y₁ ∧ x₁ ≠ x₂
state_after: no goals

tactic: rw [sub_add_sub_comm, add_comm, add_sub_add_comm, add_right_cancel_iff,
  sub_eq_sub_iff_add_eq_add, add_comm, hxy, add_comm]
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
x₁ y₁ x₂ y₂ : G
hx₁y₁ : y₁ - x₁ ∈ A
hx₁y₂ : y₂ - x₁ ∈ A
hx₂y₁ : y₁ - x₂ ∈ A
hxy : x₁ + y₂ = x₂ + y₁
hx₁x₂ : x₁ ≠ x₂
⊢ y₁ - x₂ + (y₂ - x₁) = y₁ - x₁ + (y₁ - x₁)
state_after: no goals

tactic: simpa using this.symm
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A✝ B✝ : Finset (G × G)
a b c d x y : G
n : ℕ
ε✝ ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound ε ≤ Fintype.card G
A : Finset G
hAε : ε * ↑(Fintype.card G) ≤ ↑A.card
hA : ThreeAPFree ↑A
B : Finset (G × G) :=
  filter
    (fun x =>
      match x with
      | (x, y) => y - x ∈ A)
    univ
this✝ : ε * ↑(Fintype.card G) ^ 2 ≤ ↑B.card
x₁ y₁ x₂ y₂ : G
hx₁y₁ : y₁ - x₁ ∈ A
hx₁y₂ : y₂ - x₁ ∈ A
hx₂y₁ : y₁ - x₂ ∈ A
hxy : x₁ + y₂ = x₂ + y₁
hx₁x₂ : x₁ ≠ x₂
this : y₁ - x₂ = y₁ - x₁
⊢ x₁ = x₂
state_after: no goals