ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- threeGPFree_smul_set₀
theorem threeGPFree_smul_set₀ (ha : a ≠ 0) : ThreeGPFree (a • s) ↔ ThreeGPFree s 
Arguments: {α : Type u_2} [CancelCommMonoidWithZero α] [NoZeroDivisors α] {s : Set α} {a : α} (ha : a ≠ 0)
Goal: ThreeGPFree (a • s) ↔ ThreeGPFree s
-- threeAPFree_iff_eq_right
theorem threeAPFree_iff_eq_right {s : Set ℕ} :
    ThreeAPFree s ↔ ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → ∀ ⦃c⦄, c ∈ s → a + c = b + b → a = c 
Arguments: {s : Set ℕ}
Goal: ThreeAPFree s ↔ ∀ ⦃a : ℕ⦄, a ∈ s → ∀ ⦃b : ℕ⦄, b ∈ s → ∀ ⦃c : ℕ⦄, c ∈ s → a + c = b + b → a = c
-- addRothNumber_le
@[to_additive]
theorem mulRothNumber_le : mulRothNumber s ≤ s.card 
Arguments: {α : Type u_2} [DecidableEq α] [AddMonoid α] (s : Finset α)
Goal: addRothNumber s ≤ s.card
-- mulRothNumber_le
@[to_additive]
theorem mulRothNumber_le : mulRothNumber s ≤ s.card 
Arguments: {α : Type u_2} [DecidableEq α] [Monoid α] (s : Finset α)
Goal: mulRothNumber s ≤ s.card
-- addRothNumber_spec
@[to_additive]
theorem mulRothNumber_spec :
    ∃ t ⊆ s, t.card = mulRothNumber s ∧ ThreeGPFree (t : Set α) 
Arguments: {α : Type u_2} [DecidableEq α] [AddMonoid α] (s : Finset α)
Goal: ∃ t ⊆ s, t.card = addRothNumber s ∧ ThreeAPFree ↑t
-- mulRothNumber_spec
@[to_additive]
theorem mulRothNumber_spec :
    ∃ t ⊆ s, t.card = mulRothNumber s ∧ ThreeGPFree (t : Set α) 
Arguments: {α : Type u_2} [DecidableEq α] [Monoid α] (s : Finset α)
Goal: ∃ t ⊆ s, t.card = mulRothNumber s ∧ ThreeGPFree ↑t
-- ThreeAPFree.le_addRothNumber
@[to_additive]
theorem ThreeGPFree.le_mulRothNumber (hs : ThreeGPFree (s : Set α)) (h : s ⊆ t) :
    s.card ≤ mulRothNumber t 
Arguments: {α : Type u_2} [DecidableEq α] [AddMonoid α] {s t : Finset α} (hs : ThreeAPFree ↑s) (h : s ⊆ t)
Goal: s.card ≤ addRothNumber t
-- ThreeGPFree.le_mulRothNumber
@[to_additive]
theorem ThreeGPFree.le_mulRothNumber (hs : ThreeGPFree (s : Set α)) (h : s ⊆ t) :
    s.card ≤ mulRothNumber t 
Arguments: {α : Type u_2} [DecidableEq α] [Monoid α] {s t : Finset α} (hs : ThreeGPFree ↑s) (h : s ⊆ t)
Goal: s.card ≤ mulRothNumber t
-- ThreeAPFree.addRothNumber_eq
@[to_additive]
theorem ThreeGPFree.mulRothNumber_eq (hs : ThreeGPFree (s : Set α)) :
    mulRothNumber s = s.card 
Arguments: {α : Type u_2} [DecidableEq α] [AddMonoid α] {s : Finset α} (hs : ThreeAPFree ↑s)
Goal: addRothNumber s = s.card
-- ThreeGPFree.mulRothNumber_eq
@[to_additive]
theorem ThreeGPFree.mulRothNumber_eq (hs : ThreeGPFree (s : Set α)) :
    mulRothNumber s = s.card 
Arguments: {α : Type u_2} [DecidableEq α] [Monoid α] {s : Finset α} (hs : ThreeGPFree ↑s)
Goal: mulRothNumber s = s.card
-- addRothNumber_empty
@[to_additive (attr := simp)]
theorem mulRothNumber_empty : mulRothNumber (∅ : Finset α) = 0 
Arguments: {α : Type u_2} [DecidableEq α] [AddMonoid α]
Goal: addRothNumber ∅ = 0
-- mulRothNumber_empty
@[to_additive (attr := simp)]
theorem mulRothNumber_empty : mulRothNumber (∅ : Finset α) = 0 
Arguments: {α : Type u_2} [DecidableEq α] [Monoid α]
Goal: mulRothNumber ∅ = 0
-- addRothNumber_singleton
@[to_additive (attr := simp)]
theorem mulRothNumber_singleton (a : α) : mulRothNumber ({a} : Finset α) = 1 
Arguments: {α : Type u_2} [DecidableEq α] [AddMonoid α] (a : α)
Goal: addRothNumber {a} = 1
-- mulRothNumber_singleton
@[to_additive (attr := simp)]
theorem mulRothNumber_singleton (a : α) : mulRothNumber ({a} : Finset α) = 1 
Arguments: {α : Type u_2} [DecidableEq α] [Monoid α] (a : α)
Goal: mulRothNumber {a} = 1
-- mulRothNumber_union_le
@[to_additive]
theorem mulRothNumber_union_le (s t : Finset α) :
    mulRothNumber (s ∪ t) ≤ mulRothNumber s + mulRothNumber t 
Arguments: {α : Type u_2} [DecidableEq α] [Monoid α] (s t : Finset α)
Goal: mulRothNumber (s ∪ t) ≤ mulRothNumber s + mulRothNumber t
-- addRothNumber_union_le
@[to_additive]
theorem mulRothNumber_union_le (s t : Finset α) :
    mulRothNumber (s ∪ t) ≤ mulRothNumber s + mulRothNumber t 
Arguments: {α : Type u_2} [DecidableEq α] [AddMonoid α] (s t : Finset α)
Goal: addRothNumber (s ∪ t) ≤ addRothNumber s + addRothNumber t
-- le_addRothNumber_product
@[to_additive]
theorem le_mulRothNumber_product (s : Finset α) (t : Finset β) :
    mulRothNumber s * mulRothNumber t ≤ mulRothNumber (s ×ˢ t) 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq α] [AddMonoid α] [DecidableEq β] [AddMonoid β] (s : Finset α) (t : Finset β)
Goal: addRothNumber s * addRothNumber t ≤ addRothNumber (s ×ˢ t)
-- le_mulRothNumber_product
@[to_additive]
theorem le_mulRothNumber_product (s : Finset α) (t : Finset β) :
    mulRothNumber s * mulRothNumber t ≤ mulRothNumber (s ×ˢ t) 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq α] [Monoid α] [DecidableEq β] [Monoid β] (s : Finset α) (t : Finset β)
Goal: mulRothNumber s * mulRothNumber t ≤ mulRothNumber (s ×ˢ t)
-- mulRothNumber_lt_of_forall_not_threeGPFree
@[to_additive]
theorem mulRothNumber_lt_of_forall_not_threeGPFree
    (h : ∀ t ∈ powersetCard n s, ¬ThreeGPFree ((t : Finset α) : Set α)) :
    mulRothNumber s < n 
Arguments: {α : Type u_2} [DecidableEq α] [Monoid α] {s : Finset α} {n : ℕ} (h : ∀ t ∈ Finset.powersetCard n s, ¬ThreeGPFree ↑t)
Goal: mulRothNumber s < n
-- addRothNumber_lt_of_forall_not_threeAPFree
@[to_additive]
theorem mulRothNumber_lt_of_forall_not_threeGPFree
    (h : ∀ t ∈ powersetCard n s, ¬ThreeGPFree ((t : Finset α) : Set α)) :
    mulRothNumber s < n 
Arguments: {α : Type u_2} [DecidableEq α] [AddMonoid α] {s : Finset α} {n : ℕ} (h : ∀ t ∈ Finset.powersetCard n s, ¬ThreeAPFree ↑t)
Goal: addRothNumber s < n
-- IsMulFreimanHom.mulRothNumber_mono
@[to_additive "Arithmetic progressions can be pushed forward along bijective 2-Freiman homs."]
lemma IsMulFreimanHom.mulRothNumber_mono (hf : IsMulFreimanHom 2 A B f) (hf' : Set.BijOn f A B) :
    mulRothNumber B ≤ mulRothNumber A 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq α] [CommMonoid α] [CommMonoid β] [DecidableEq β] {A : Finset α} {B : Finset β} {f : α → β} (hf : IsMulFreimanHom 2 (↑A) (↑B) f) (hf' : Set.BijOn f ↑A ↑B)
Goal: mulRothNumber B ≤ mulRothNumber A
-- IsAddFreimanHom.addRothNumber_mono
@[to_additive "Arithmetic progressions can be pushed forward along bijective 2-Freiman homs."]
lemma IsMulFreimanHom.mulRothNumber_mono (hf : IsMulFreimanHom 2 A B f) (hf' : Set.BijOn f A B) :
    mulRothNumber B ≤ mulRothNumber A 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq α] [AddCommMonoid α] [AddCommMonoid β] [DecidableEq β] {A : Finset α} {B : Finset β} {f : α → β} (hf : IsAddFreimanHom 2 (↑A) (↑B) f) (hf' : Set.BijOn f ↑A ↑B)
Goal: addRothNumber B ≤ addRothNumber A
-- IsMulFreimanIso.mulRothNumber_congr
@[to_additive "Arithmetic progressions are preserved under 2-Freiman isos."]
lemma IsMulFreimanIso.mulRothNumber_congr (hf : IsMulFreimanIso 2 A B f) :
    mulRothNumber A = mulRothNumber B 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq α] [CommMonoid α] [CommMonoid β] [DecidableEq β] {A : Finset α} {B : Finset β} {f : α → β} (hf : IsMulFreimanIso 2 (↑A) (↑B) f)
Goal: mulRothNumber A = mulRothNumber B
-- IsAddFreimanIso.addRothNumber_congr
@[to_additive "Arithmetic progressions are preserved under 2-Freiman isos."]
lemma IsMulFreimanIso.mulRothNumber_congr (hf : IsMulFreimanIso 2 A B f) :
    mulRothNumber A = mulRothNumber B 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq α] [AddCommMonoid α] [AddCommMonoid β] [DecidableEq β] {A : Finset α} {B : Finset β} {f : α → β} (hf : IsAddFreimanIso 2 (↑A) (↑B) f)
Goal: addRothNumber A = addRothNumber B
-- addRothNumber_map_add_left
@[to_additive (attr := simp)]
theorem mulRothNumber_map_mul_left :
    mulRothNumber (s.map <| mulLeftEmbedding a) = mulRothNumber s 
Arguments: {α : Type u_2} [DecidableEq α] [AddCancelCommMonoid α] (s : Finset α) (a : α)
Goal: addRothNumber (Finset.map (addLeftEmbedding a) s) = addRothNumber s
-- mulRothNumber_map_mul_left
@[to_additive (attr := simp)]
theorem mulRothNumber_map_mul_left :
    mulRothNumber (s.map <| mulLeftEmbedding a) = mulRothNumber s 
Arguments: {α : Type u_2} [DecidableEq α] [CancelCommMonoid α] (s : Finset α) (a : α)
Goal: mulRothNumber (Finset.map (mulLeftEmbedding a) s) = mulRothNumber s
-- addRothNumber_map_add_right
@[to_additive (attr := simp)]
theorem mulRothNumber_map_mul_right :
    mulRothNumber (s.map <| mulRightEmbedding a) = mulRothNumber s 
Arguments: {α : Type u_2} [DecidableEq α] [AddCancelCommMonoid α] (s : Finset α) (a : α)
Goal: addRothNumber (Finset.map (addRightEmbedding a) s) = addRothNumber s
-- mulRothNumber_map_mul_right
@[to_additive (attr := simp)]
theorem mulRothNumber_map_mul_right :
    mulRothNumber (s.map <| mulRightEmbedding a) = mulRothNumber s 
Arguments: {α : Type u_2} [DecidableEq α] [CancelCommMonoid α] (s : Finset α) (a : α)
Goal: mulRothNumber (Finset.map (mulRightEmbedding a) s) = mulRothNumber s
-- rothNumberNat_def
theorem rothNumberNat_def (n : ℕ) : rothNumberNat n = addRothNumber (range n) 
Arguments: (n : ℕ)
Goal: rothNumberNat n = addRothNumber (Finset.range n)
-- rothNumberNat_le
theorem rothNumberNat_le (N : ℕ) : rothNumberNat N ≤ N 
Arguments: (N : ℕ)
Goal: rothNumberNat N ≤ N
-- rothNumberNat_spec
theorem rothNumberNat_spec (n : ℕ) :
    ∃ t ⊆ range n, t.card = rothNumberNat n ∧ ThreeAPFree (t : Set ℕ) 
Arguments: (n : ℕ)
Goal: ∃ t ⊆ Finset.range n, t.card = rothNumberNat n ∧ ThreeAPFree ↑t
-- ThreeAPFree.le_rothNumberNat
theorem ThreeAPFree.le_rothNumberNat (s : Finset ℕ) (hs : ThreeAPFree (s : Set ℕ))
    (hsn : ∀ x ∈ s, x < n) (hsk : s.card = k) : k ≤ rothNumberNat n 
Arguments: {k n : ℕ} (s : Finset ℕ) (hs : ThreeAPFree ↑s) (hsn : ∀ x ∈ s, x < n) (hsk : s.card = k)
Goal: k ≤ rothNumberNat n
-- rothNumberNat_add_le
theorem rothNumberNat_add_le (M N : ℕ) :
    rothNumberNat (M + N) ≤ rothNumberNat M + rothNumberNat N 
Arguments: (M N : ℕ)
Goal: rothNumberNat (M + N) ≤ rothNumberNat M + rothNumberNat N
-- rothNumberNat_zero
@[simp]
theorem rothNumberNat_zero : rothNumberNat 0 = 0 
Goal: rothNumberNat 0 = 0
-- addRothNumber_Ico
theorem addRothNumber_Ico (a b : ℕ) : addRothNumber (Ico a b) = rothNumberNat (b - a) 
Arguments: (a b : ℕ)
Goal: addRothNumber (Finset.Ico a b) = rothNumberNat (b - a)
-- Fin.addRothNumber_eq_rothNumberNat
lemma Fin.addRothNumber_eq_rothNumberNat (hkn : 2 * k ≤ n) :
    addRothNumber (Iio k : Finset (Fin n.succ)) = rothNumberNat k 
Arguments: {k n : ℕ} (hkn : 2 * k ≤ n)
Goal: addRothNumber (Finset.Iio ↑k) = rothNumberNat k
-- Fin.addRothNumber_le_rothNumberNat
lemma Fin.addRothNumber_le_rothNumberNat (k n : ℕ) (hkn : k ≤ n) :
    addRothNumber (Iio k : Finset (Fin n.succ)) ≤ rothNumberNat k 
Arguments: (k n : ℕ) (hkn : k ≤ n)
Goal: addRothNumber (Finset.Iio ↑k) ≤ rothNumberNat k
-- Mathlib.Tactic.Rify.ratCast_eq
@[rify_simps] lemma ratCast_eq (a b : ℚ) : a = b ↔ (a : ℝ) = (b : ℝ) 
Arguments: (a b : ℚ)
Goal: a = b ↔ ↑a = ↑b
-- Mathlib.Tactic.Rify.ratCast_le
@[rify_simps] lemma ratCast_le (a b : ℚ) : a ≤ b ↔ (a : ℝ) ≤ (b : ℝ) 
Arguments: (a b : ℚ)
Goal: a ≤ b ↔ ↑a ≤ ↑b
-- Mathlib.Tactic.Rify.ratCast_lt
@[rify_simps] lemma ratCast_lt (a b : ℚ) : a < b ↔ (a : ℝ) < (b : ℝ) 
Arguments: (a b : ℚ)
Goal: a < b ↔ ↑a < ↑b
-- Mathlib.Tactic.Rify.ratCast_ne
@[rify_simps] lemma ratCast_ne (a b : ℚ) : a ≠ b ↔ (a : ℝ) ≠ (b : ℝ) 
Arguments: (a b : ℚ)
Goal: a ≠ b ↔ ↑a ≠ ↑b
-- Mathlib.Tactic.Rify.ofNat_rat_real
@[rify_simps] lemma ofNat_rat_real (a : ℕ) [a.AtLeastTwo] :
    ((no_index (OfNat.ofNat a : ℚ)) : ℝ) = (OfNat.ofNat a : ℝ) 
Arguments: (a : ℕ) [a.AtLeastTwo]
Goal: ↑(OfNat.ofNat a) = OfNat.ofNat a
-- Finset.mulEnergy_mono
@[to_additive (attr := gcongr)]
lemma mulEnergy_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : Eₘ[s₁, t₁] ≤ Eₘ[s₂, t₂] 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] {s₁ s₂ t₁ t₂ : Finset α} (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂)
Goal: s₁.mulEnergy t₁ ≤ s₂.mulEnergy t₂
-- Finset.addEnergy_mono
@[to_additive (attr := gcongr)]
lemma mulEnergy_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : Eₘ[s₁, t₁] ≤ Eₘ[s₂, t₂] 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] {s₁ s₂ t₁ t₂ : Finset α} (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂)
Goal: s₁.addEnergy t₁ ≤ s₂.addEnergy t₂
-- Finset.addEnergy_mono_left
@[to_additive] lemma mulEnergy_mono_left (hs : s₁ ⊆ s₂) : Eₘ[s₁, t] ≤ Eₘ[s₂, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] {s₁ s₂ t : Finset α} (hs : s₁ ⊆ s₂)
Goal: s₁.addEnergy t ≤ s₂.addEnergy t
-- Finset.mulEnergy_mono_left
@[to_additive] lemma mulEnergy_mono_left (hs : s₁ ⊆ s₂) : Eₘ[s₁, t] ≤ Eₘ[s₂, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] {s₁ s₂ t : Finset α} (hs : s₁ ⊆ s₂)
Goal: s₁.mulEnergy t ≤ s₂.mulEnergy t
-- Finset.addEnergy_mono_right
@[to_additive] lemma mulEnergy_mono_right (ht : t₁ ⊆ t₂) : Eₘ[s, t₁] ≤ Eₘ[s, t₂] 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] {s t₁ t₂ : Finset α} (ht : t₁ ⊆ t₂)
Goal: s.addEnergy t₁ ≤ s.addEnergy t₂
-- Finset.mulEnergy_mono_right
@[to_additive] lemma mulEnergy_mono_right (ht : t₁ ⊆ t₂) : Eₘ[s, t₁] ≤ Eₘ[s, t₂] 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] {s t₁ t₂ : Finset α} (ht : t₁ ⊆ t₂)
Goal: s.mulEnergy t₁ ≤ s.mulEnergy t₂
-- Finset.le_mulEnergy
@[to_additive] lemma le_mulEnergy : s.card * t.card ≤ Eₘ[s, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] {s t : Finset α}
Goal: s.card * t.card ≤ s.mulEnergy t
-- Finset.le_addEnergy
@[to_additive] lemma le_mulEnergy : s.card * t.card ≤ Eₘ[s, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] {s t : Finset α}
Goal: s.card * t.card ≤ s.addEnergy t
-- Finset.addEnergy_pos
@[to_additive] lemma mulEnergy_pos (hs : s.Nonempty) (ht : t.Nonempty) : 0 < Eₘ[s, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] {s t : Finset α} (hs : s.Nonempty) (ht : t.Nonempty)
Goal: 0 < s.addEnergy t
-- Finset.mulEnergy_pos
@[to_additive] lemma mulEnergy_pos (hs : s.Nonempty) (ht : t.Nonempty) : 0 < Eₘ[s, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] {s t : Finset α} (hs : s.Nonempty) (ht : t.Nonempty)
Goal: 0 < s.mulEnergy t
-- Finset.addEnergy_empty_left
@[to_additive (attr := simp)] lemma mulEnergy_empty_left : Eₘ[∅, t] = 0 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] (t : Finset α)
Goal: ∅.addEnergy t = 0
-- Finset.mulEnergy_empty_left
@[to_additive (attr := simp)] lemma mulEnergy_empty_left : Eₘ[∅, t] = 0 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] (t : Finset α)
Goal: ∅.mulEnergy t = 0
-- Finset.mulEnergy_empty_right
@[to_additive (attr := simp)] lemma mulEnergy_empty_right : Eₘ[s, ∅] = 0 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] (s : Finset α)
Goal: s.mulEnergy ∅ = 0
-- Finset.addEnergy_empty_right
@[to_additive (attr := simp)] lemma mulEnergy_empty_right : Eₘ[s, ∅] = 0 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] (s : Finset α)
Goal: s.addEnergy ∅ = 0
-- Finset.mulEnergy_pos_iff
@[to_additive (attr := simp)] lemma mulEnergy_pos_iff : 0 < Eₘ[s, t] ↔ s.Nonempty ∧ t.Nonempty 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] {s t : Finset α}
Goal: 0 < s.mulEnergy t ↔ s.Nonempty ∧ t.Nonempty
-- Finset.addEnergy_pos_iff
@[to_additive (attr := simp)] lemma mulEnergy_pos_iff : 0 < Eₘ[s, t] ↔ s.Nonempty ∧ t.Nonempty 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] {s t : Finset α}
Goal: 0 < s.addEnergy t ↔ s.Nonempty ∧ t.Nonempty
-- Finset.addEnergy_eq_zero_iff
@[to_additive (attr := simp)] lemma mulEnergy_eq_zero_iff : Eₘ[s, t] = 0 ↔ s = ∅ ∨ t = ∅ 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] {s t : Finset α}
Goal: s.addEnergy t = 0 ↔ s = ∅ ∨ t = ∅
-- Finset.mulEnergy_eq_zero_iff
@[to_additive (attr := simp)] lemma mulEnergy_eq_zero_iff : Eₘ[s, t] = 0 ↔ s = ∅ ∨ t = ∅ 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] {s t : Finset α}
Goal: s.mulEnergy t = 0 ↔ s = ∅ ∨ t = ∅
-- Finset.addEnergy_eq_card_filter
@[to_additive] lemma mulEnergy_eq_card_filter (s t : Finset α) :
    Eₘ[s, t] = (((s ×ˢ t) ×ˢ s ×ˢ t).filter fun ((a, b), c, d) ↦ a * b = c * d).card 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] (s t : Finset α)
Goal: s.addEnergy t =
  (Finset.filter (fun x => Finset.addEnergy_eq_card_filter.match_1 (fun x => Prop) x fun a b c d => a + b = c + d)
      ((s ×ˢ t) ×ˢ s ×ˢ t)).card
-- Finset.mulEnergy_eq_card_filter
@[to_additive] lemma mulEnergy_eq_card_filter (s t : Finset α) :
    Eₘ[s, t] = (((s ×ˢ t) ×ˢ s ×ˢ t).filter fun ((a, b), c, d) ↦ a * b = c * d).card 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] (s t : Finset α)
Goal: s.mulEnergy t =
  (Finset.filter
      (fun x =>
        match x with
        | ((a, b), c, d) => a * b = c * d)
      ((s ×ˢ t) ×ˢ s ×ˢ t)).card
-- Finset.addEnergy_eq_sum_sq'
@[to_additive] lemma mulEnergy_eq_sum_sq' (s t : Finset α) :
    Eₘ[s, t] = ∑ a ∈ s * t, ((s ×ˢ t).filter fun (x, y) ↦ x * y = a).card ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] (s t : Finset α)
Goal: s.addEnergy t =
  ∑ a ∈ s + t,
    (Finset.filter (fun x => Finset.addEnergy_eq_sum_sq'.match_1 (fun x => Prop) x fun x y => x + y = a)
          (s ×ˢ t)).card ^
      2
-- Finset.mulEnergy_eq_sum_sq'
@[to_additive] lemma mulEnergy_eq_sum_sq' (s t : Finset α) :
    Eₘ[s, t] = ∑ a ∈ s * t, ((s ×ˢ t).filter fun (x, y) ↦ x * y = a).card ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] (s t : Finset α)
Goal: s.mulEnergy t =
  ∑ a ∈ s * t,
    (Finset.filter
          (fun x =>
            match x with
            | (x, y) => x * y = a)
          (s ×ˢ t)).card ^
      2
-- Finset.mulEnergy_eq_sum_sq
@[to_additive] lemma mulEnergy_eq_sum_sq [Fintype α] (s t : Finset α) :
    Eₘ[s, t] = ∑ a, ((s ×ˢ t).filter fun (x, y) ↦ x * y = a).card ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] [Fintype α] (s t : Finset α)
Goal: s.mulEnergy t =
  ∑ a : α,
    (Finset.filter
          (fun x =>
            match x with
            | (x, y) => x * y = a)
          (s ×ˢ t)).card ^
      2
-- Finset.addEnergy_eq_sum_sq
@[to_additive] lemma mulEnergy_eq_sum_sq [Fintype α] (s t : Finset α) :
    Eₘ[s, t] = ∑ a, ((s ×ˢ t).filter fun (x, y) ↦ x * y = a).card ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] [Fintype α] (s t : Finset α)
Goal: s.addEnergy t =
  ∑ a : α,
    (Finset.filter (fun x => Finset.addEnergy_eq_sum_sq'.match_1 (fun x => Prop) x fun x y => x + y = a)
          (s ×ˢ t)).card ^
      2
-- Finset.card_sq_le_card_mul_mulEnergy
@[to_additive card_sq_le_card_mul_addEnergy]
lemma card_sq_le_card_mul_mulEnergy (s t u : Finset α) :
    ((s ×ˢ t).filter fun (a, b) ↦ a * b ∈ u).card ^ 2 ≤ u.card * Eₘ[s, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] (s t u : Finset α)
Goal: (Finset.filter
        (fun x =>
          match x with
          | (a, b) => a * b ∈ u)
        (s ×ˢ t)).card ^
    2 ≤
  u.card * s.mulEnergy t
-- Finset.card_sq_le_card_mul_addEnergy
@[to_additive card_sq_le_card_mul_addEnergy]
lemma card_sq_le_card_mul_mulEnergy (s t u : Finset α) :
    ((s ×ˢ t).filter fun (a, b) ↦ a * b ∈ u).card ^ 2 ≤ u.card * Eₘ[s, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] (s t u : Finset α)
Goal: (Finset.filter (fun x => Finset.addEnergy_eq_sum_sq'.match_1 (fun x => Prop) x fun a b => a + b ∈ u) (s ×ˢ t)).card ^
    2 ≤
  u.card * s.addEnergy t
-- Finset.le_card_add_mul_addEnergy
@[to_additive le_card_add_mul_addEnergy] lemma le_card_add_mul_mulEnergy (s t : Finset α) :
    s.card ^ 2 * t.card ^ 2 ≤ (s * t).card * Eₘ[s, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Add α] (s t : Finset α)
Goal: s.card ^ 2 * t.card ^ 2 ≤ (s + t).card * s.addEnergy t
-- Finset.le_card_add_mul_mulEnergy
@[to_additive le_card_add_mul_addEnergy] lemma le_card_add_mul_mulEnergy (s t : Finset α) :
    s.card ^ 2 * t.card ^ 2 ≤ (s * t).card * Eₘ[s, t] 
Arguments: {α : Type u_1} [DecidableEq α] [Mul α] (s t : Finset α)
Goal: s.card ^ 2 * t.card ^ 2 ≤ (s * t).card * s.mulEnergy t
-- Finset.mulEnergy_comm
@[to_additive] lemma mulEnergy_comm (s t : Finset α) : Eₘ[s, t] = Eₘ[t, s] 
Arguments: {α : Type u_1} [DecidableEq α] [CommMonoid α] (s t : Finset α)
Goal: s.mulEnergy t = t.mulEnergy s
-- Finset.addEnergy_comm
@[to_additive] lemma mulEnergy_comm (s t : Finset α) : Eₘ[s, t] = Eₘ[t, s] 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommMonoid α] (s t : Finset α)
Goal: s.addEnergy t = t.addEnergy s
-- Finset.mulEnergy_univ_left
@[to_additive (attr := simp)]
lemma mulEnergy_univ_left : Eₘ[univ, t] = Fintype.card α * t.card ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] [Fintype α] (t : Finset α)
Goal: Finset.univ.mulEnergy t = Fintype.card α * t.card ^ 2
-- Finset.addEnergy_univ_left
@[to_additive (attr := simp)]
lemma mulEnergy_univ_left : Eₘ[univ, t] = Fintype.card α * t.card ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] [Fintype α] (t : Finset α)
Goal: Finset.univ.addEnergy t = Fintype.card α * t.card ^ 2
-- Finset.addEnergy_univ_right
@[to_additive (attr := simp)]
lemma mulEnergy_univ_right : Eₘ[s, univ] = Fintype.card α * s.card ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] [Fintype α] (s : Finset α)
Goal: s.addEnergy Finset.univ = Fintype.card α * s.card ^ 2
-- Finset.mulEnergy_univ_right
@[to_additive (attr := simp)]
lemma mulEnergy_univ_right : Eₘ[s, univ] = Fintype.card α * s.card ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] [Fintype α] (s : Finset α)
Goal: s.mulEnergy Finset.univ = Fintype.card α * s.card ^ 2
-- Finset.ruzsa_triangle_inequality_sub_sub_sub
@[to_additive "**Ruzsa's triangle inequality**. Subtraction version."]
theorem ruzsa_triangle_inequality_div_div_div (A B C : Finset α) :
    (A / C).card * B.card ≤ (A / B).card * (B / C).card 
Arguments: {α : Type u_1} [AddCommGroup α] [DecidableEq α] (A B C : Finset α)
Goal: (A - C).card * B.card ≤ (A - B).card * (B - C).card
-- Finset.ruzsa_triangle_inequality_div_div_div
@[to_additive "**Ruzsa's triangle inequality**. Subtraction version."]
theorem ruzsa_triangle_inequality_div_div_div (A B C : Finset α) :
    (A / C).card * B.card ≤ (A / B).card * (B / C).card 
Arguments: {α : Type u_1} [CommGroup α] [DecidableEq α] (A B C : Finset α)
Goal: (A / C).card * B.card ≤ (A / B).card * (B / C).card
-- Finset.ruzsa_triangle_inequality_div_mul_mul
@[to_additive "**Ruzsa's triangle inequality**. Sub-add-add version."]
theorem ruzsa_triangle_inequality_div_mul_mul (A B C : Finset α) :
    (A / C).card * B.card ≤ (A * B).card * (B * C).card 
Arguments: {α : Type u_1} [CommGroup α] [DecidableEq α] (A B C : Finset α)
Goal: (A / C).card * B.card ≤ (A * B).card * (B * C).card
-- Finset.ruzsa_triangle_inequality_sub_add_add
@[to_additive "**Ruzsa's triangle inequality**. Sub-add-add version."]
theorem ruzsa_triangle_inequality_div_mul_mul (A B C : Finset α) :
    (A / C).card * B.card ≤ (A * B).card * (B * C).card 
Arguments: {α : Type u_1} [AddCommGroup α] [DecidableEq α] (A B C : Finset α)
Goal: (A - C).card * B.card ≤ (A + B).card * (B + C).card
-- Finset.ruzsa_triangle_inequality_add_sub_add
@[to_additive "**Ruzsa's triangle inequality**. Add-sub-add version."]
theorem ruzsa_triangle_inequality_mul_div_mul (A B C : Finset α) :
    (A * C).card * B.card ≤ (A / B).card * (B * C).card 
Arguments: {α : Type u_1} [AddCommGroup α] [DecidableEq α] (A B C : Finset α)
Goal: (A + C).card * B.card ≤ (A - B).card * (B + C).card
-- Finset.ruzsa_triangle_inequality_mul_div_mul
@[to_additive "**Ruzsa's triangle inequality**. Add-sub-add version."]
theorem ruzsa_triangle_inequality_mul_div_mul (A B C : Finset α) :
    (A * C).card * B.card ≤ (A / B).card * (B * C).card 
Arguments: {α : Type u_1} [CommGroup α] [DecidableEq α] (A B C : Finset α)
Goal: (A * C).card * B.card ≤ (A / B).card * (B * C).card
-- Finset.ruzsa_triangle_inequality_add_add_sub
@[to_additive "**Ruzsa's triangle inequality**. Add-add-sub version."]
theorem ruzsa_triangle_inequality_mul_mul_div (A B C : Finset α) :
    (A * C).card * B.card ≤ (A * B).card * (B / C).card 
Arguments: {α : Type u_1} [AddCommGroup α] [DecidableEq α] (A B C : Finset α)
Goal: (A + C).card * B.card ≤ (A + B).card * (B - C).card
-- Finset.ruzsa_triangle_inequality_mul_mul_div
@[to_additive "**Ruzsa's triangle inequality**. Add-add-sub version."]
theorem ruzsa_triangle_inequality_mul_mul_div (A B C : Finset α) :
    (A * C).card * B.card ≤ (A * B).card * (B / C).card 
Arguments: {α : Type u_1} [CommGroup α] [DecidableEq α] (A B C : Finset α)
Goal: (A * C).card * B.card ≤ (A * B).card * (B / C).card