ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- IsAddFreimanIso.sum
@[to_additive]
lemma IsMulFreimanIso.prod (h₁ : IsMulFreimanIso n A₁ B₁ f₁) (h₂ : IsMulFreimanIso n A₂ B₂ f₂) :
    IsMulFreimanIso n (A₁ ×ˢ A₂) (B₁ ×ˢ B₂) (Prod.map f₁ f₂) 
Arguments: {α₁ : Type u_5} {α₂ : Type u_6} {β₁ : Type u_7} {β₂ : Type u_8} [AddCommMonoid α₁] [AddCommMonoid α₂] [AddCommMonoid β₁] [AddCommMonoid β₂] {A₁ : Set α₁} {A₂ : Set α₂} {B₁ : Set β₁} {B₂ : Set β₂} {f₁ : α₁ → β₁} {f₂ : α₂ → β₂} {n : ℕ} (h₁ : IsAddFreimanIso n A₁ B₁ f₁) (h₂ : IsAddFreimanIso n A₂ B₂ f₂)
Goal: IsAddFreimanIso n (A₁ ×ˢ A₂) (B₁ ×ˢ B₂) (Prod.map f₁ f₂)
-- IsMulFreimanIso.prod
@[to_additive]
lemma IsMulFreimanIso.prod (h₁ : IsMulFreimanIso n A₁ B₁ f₁) (h₂ : IsMulFreimanIso n A₂ B₂ f₂) :
    IsMulFreimanIso n (A₁ ×ˢ A₂) (B₁ ×ˢ B₂) (Prod.map f₁ f₂) 
Arguments: {α₁ : Type u_5} {α₂ : Type u_6} {β₁ : Type u_7} {β₂ : Type u_8} [CommMonoid α₁] [CommMonoid α₂] [CommMonoid β₁] [CommMonoid β₂] {A₁ : Set α₁} {A₂ : Set α₂} {B₁ : Set β₁} {B₂ : Set β₂} {f₁ : α₁ → β₁} {f₂ : α₂ → β₂} {n : ℕ} (h₁ : IsMulFreimanIso n A₁ B₁ f₁) (h₂ : IsMulFreimanIso n A₂ B₂ f₂)
Goal: IsMulFreimanIso n (A₁ ×ˢ A₂) (B₁ ×ˢ B₂) (Prod.map f₁ f₂)
-- _private.Mathlib.Combinatorics.Additive.FreimanHom.0.Fin.aux
private lemma aux (hm : m ≠ 0) (hkmn : m * k ≤ n) : k < (n + 1) 
Arguments: {k m n : ℕ} (hm : m ≠ 0) (hkmn : m * k ≤ n)
Goal: k < n + 1
-- Fin.isAddFreimanIso_Iic
lemma isAddFreimanIso_Iic (hm : m ≠ 0) (hkmn : m * k ≤ n) :
    IsAddFreimanIso m (Iic (k : Fin (n + 1))) (Iic k) val 
Arguments: {k m n : ℕ} (hm : m ≠ 0) (hkmn : m * k ≤ n)
Goal: IsAddFreimanIso m (Set.Iic ↑k) (Set.Iic k) Fin.val
-- Fin.isAddFreimanIso_Iio
lemma isAddFreimanIso_Iio (hm : m ≠ 0) (hkmn : m * k ≤ n) :
    IsAddFreimanIso m (Iio (k : Fin (n + 1))) (Iio k) val 
Arguments: {k m n : ℕ} (hm : m ≠ 0) (hkmn : m * k ≤ n)
Goal: IsAddFreimanIso m (Set.Iio ↑k) (Set.Iio k) Fin.val
-- Mathlib.Tactic.CC.iff_eq_of_eq_true_left
theorem iff_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ↔ b) = b 
Arguments: {a b : Prop} (h : a = True)
Goal: (a ↔ b) = b
-- Mathlib.Tactic.CC.iff_eq_of_eq_true_right
theorem iff_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a ↔ b) = a 
Arguments: {a b : Prop} (h : b = True)
Goal: (a ↔ b) = a
-- Mathlib.Tactic.CC.iff_eq_true_of_eq
theorem iff_eq_true_of_eq {a b : Prop} (h : a = b) : (a ↔ b) = True 
Arguments: {a b : Prop} (h : a = b)
Goal: (a ↔ b) = True
-- Mathlib.Tactic.CC.and_eq_of_eq_true_left
theorem and_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ∧ b) = b 
Arguments: {a b : Prop} (h : a = True)
Goal: (a ∧ b) = b
-- Mathlib.Tactic.CC.and_eq_of_eq_true_right
theorem and_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a ∧ b) = a 
Arguments: {a b : Prop} (h : b = True)
Goal: (a ∧ b) = a
-- Mathlib.Tactic.CC.and_eq_of_eq_false_left
theorem and_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a ∧ b) = False 
Arguments: {a b : Prop} (h : a = False)
Goal: (a ∧ b) = False
-- Mathlib.Tactic.CC.and_eq_of_eq_false_right
theorem and_eq_of_eq_false_right {a b : Prop} (h : b = False) : (a ∧ b) = False 
Arguments: {a b : Prop} (h : b = False)
Goal: (a ∧ b) = False
-- Mathlib.Tactic.CC.and_eq_of_eq
theorem and_eq_of_eq {a b : Prop} (h : a = b) : (a ∧ b) = a 
Arguments: {a b : Prop} (h : a = b)
Goal: (a ∧ b) = a
-- Mathlib.Tactic.CC.or_eq_of_eq_true_left
theorem or_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ∨ b) = True 
Arguments: {a b : Prop} (h : a = True)
Goal: (a ∨ b) = True
-- Mathlib.Tactic.CC.or_eq_of_eq_true_right
theorem or_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a ∨ b) = True 
Arguments: {a b : Prop} (h : b = True)
Goal: (a ∨ b) = True
-- Mathlib.Tactic.CC.or_eq_of_eq_false_left
theorem or_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a ∨ b) = b 
Arguments: {a b : Prop} (h : a = False)
Goal: (a ∨ b) = b
-- Mathlib.Tactic.CC.or_eq_of_eq_false_right
theorem or_eq_of_eq_false_right {a b : Prop} (h : b = False) : (a ∨ b) = a 
Arguments: {a b : Prop} (h : b = False)
Goal: (a ∨ b) = a
-- Mathlib.Tactic.CC.or_eq_of_eq
theorem or_eq_of_eq {a b : Prop} (h : a = b) : (a ∨ b) = a 
Arguments: {a b : Prop} (h : a = b)
Goal: (a ∨ b) = a
-- Mathlib.Tactic.CC.imp_eq_of_eq_true_left
theorem imp_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a → b) = b 
Arguments: {a b : Prop} (h : a = True)
Goal: (a → b) = b
-- Mathlib.Tactic.CC.imp_eq_of_eq_true_right
theorem imp_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a → b) = True 
Arguments: {a b : Prop} (h : b = True)
Goal: (a → b) = True
-- Mathlib.Tactic.CC.imp_eq_of_eq_false_left
theorem imp_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a → b) = True 
Arguments: {a b : Prop} (h : a = False)
Goal: (a → b) = True
-- Mathlib.Tactic.CC.imp_eq_of_eq_false_right
theorem imp_eq_of_eq_false_right {a b : Prop} (h : b = False) : (a → b) = Not a 
Arguments: {a b : Prop} (h : b = False)
Goal: (a → b) = ¬a
-- Mathlib.Tactic.CC.not_imp_eq_of_eq_false_right
theorem not_imp_eq_of_eq_false_right {a b : Prop} (h : b = False) : (Not a → b) = a 
Arguments: {a b : Prop} (h : b = False)
Goal: (¬a → b) = a
-- Mathlib.Tactic.CC.imp_eq_true_of_eq
theorem imp_eq_true_of_eq {a b : Prop} (h : a = b) : (a → b) = True 
Arguments: {a b : Prop} (h : a = b)
Goal: (a → b) = True
-- Mathlib.Tactic.CC.not_eq_of_eq_true
theorem not_eq_of_eq_true {a : Prop} (h : a = True) : Not a = False 
Arguments: {a : Prop} (h : a = True)
Goal: (¬a) = False
-- Mathlib.Tactic.CC.not_eq_of_eq_false
theorem not_eq_of_eq_false {a : Prop} (h : a = False) : Not a = True 
Arguments: {a : Prop} (h : a = False)
Goal: (¬a) = True
-- Mathlib.Tactic.CC.false_of_a_eq_not_a
theorem false_of_a_eq_not_a {a : Prop} (h : a = Not a) : False 
Arguments: {a : Prop} (h : a = ¬a)
Goal: False
-- Mathlib.Tactic.CC.if_eq_of_eq_true
theorem if_eq_of_eq_true {c : Prop} [d : Decidable c] {α : Sort u} (t e : α) (h : c = True) :
    @ite α c d t e = t 
Arguments: {c : Prop} [d : Decidable c] {α : Sort u} (t e : α) (h : c = True)
Goal: (if c then t else e) = t
-- Mathlib.Tactic.CC.if_eq_of_eq_false
theorem if_eq_of_eq_false {c : Prop} [d : Decidable c] {α : Sort u} (t e : α) (h : c = False) :
    @ite α c d t e = e 
Arguments: {c : Prop} [d : Decidable c] {α : Sort u} (t e : α) (h : c = False)
Goal: (if c then t else e) = e
-- Mathlib.Tactic.CC.if_eq_of_eq
theorem if_eq_of_eq (c : Prop) [d : Decidable c] {α : Sort u} {t e : α} (h : t = e) :
    @ite α c d t e = t 
Arguments: (c : Prop) [d : Decidable c] {α : Sort u} {t e : α} (h : t = e)
Goal: (if c then t else e) = t
-- Mathlib.Tactic.CC.eq_true_of_and_eq_true_left
theorem eq_true_of_and_eq_true_left {a b : Prop} (h : (a ∧ b) = True) : a = True 
Arguments: {a b : Prop} (h : (a ∧ b) = True)
Goal: a = True
-- Mathlib.Tactic.CC.eq_true_of_and_eq_true_right
theorem eq_true_of_and_eq_true_right {a b : Prop} (h : (a ∧ b) = True) : b = True 
Arguments: {a b : Prop} (h : (a ∧ b) = True)
Goal: b = True
-- Mathlib.Tactic.CC.eq_false_of_or_eq_false_left
theorem eq_false_of_or_eq_false_left {a b : Prop} (h : (a ∨ b) = False) : a = False 
Arguments: {a b : Prop} (h : (a ∨ b) = False)
Goal: a = False
-- Mathlib.Tactic.CC.eq_false_of_or_eq_false_right
theorem eq_false_of_or_eq_false_right {a b : Prop} (h : (a ∨ b) = False) : b = False 
Arguments: {a b : Prop} (h : (a ∨ b) = False)
Goal: b = False
-- Mathlib.Tactic.CC.eq_false_of_not_eq_true
theorem eq_false_of_not_eq_true {a : Prop} (h : Not a = True) : a = False 
Arguments: {a : Prop} (h : (¬a) = True)
Goal: a = False
-- Mathlib.Tactic.CC.eq_true_of_not_eq_false
theorem eq_true_of_not_eq_false {a : Prop} (h : Not a = False) : a = True 
Arguments: {a : Prop} (h : (¬a) = False)
Goal: a = True
-- Mathlib.Tactic.IntervalCases.of_not_lt_left
theorem of_not_lt_left [LinearOrder α] (h : ¬(a:α) < b) (eq : a = a') : b ≤ a' 
Arguments: {α : Type u_1} {a b a' : α} [LinearOrder α] (h : ¬a < b) (eq : a = a')
Goal: b ≤ a'
-- Mathlib.Tactic.IntervalCases.of_not_lt_right
theorem of_not_lt_right [LinearOrder α] (h : ¬(a:α) < b) (eq : b = b') : b' ≤ a 
Arguments: {α : Type u_1} {a b b' : α} [LinearOrder α] (h : ¬a < b) (eq : b = b')
Goal: b' ≤ a
-- Mathlib.Tactic.IntervalCases.of_not_le_left
theorem of_not_le_left [LE α] (h : ¬(a:α) ≤ b) (eq : a = a') : ¬a' ≤ b 
Arguments: {α : Type u_1} {a b a' : α} [LE α] (h : ¬a ≤ b) (eq : a = a')
Goal: ¬a' ≤ b
-- Mathlib.Tactic.IntervalCases.of_not_le_right
theorem of_not_le_right [LE α] (h : ¬(a:α) ≤ b) (eq : b = b') : ¬a ≤ b' 
Arguments: {α : Type u_1} {a b b' : α} [LE α] (h : ¬a ≤ b) (eq : b = b')
Goal: ¬a ≤ b'
-- Mathlib.Tactic.IntervalCases.of_lt_left
theorem of_lt_left [LinearOrder α] (h : (a:α) < b) (eq : a = a') : ¬b ≤ a' 
Arguments: {α : Type u_1} {a b a' : α} [LinearOrder α] (h : a < b) (eq : a = a')
Goal: ¬b ≤ a'
-- Mathlib.Tactic.IntervalCases.of_lt_right
theorem of_lt_right [LinearOrder α] (h : (a:α) < b) (eq : b = b') : ¬b' ≤ a 
Arguments: {α : Type u_1} {a b b' : α} [LinearOrder α] (h : a < b) (eq : b = b')
Goal: ¬b' ≤ a
-- Mathlib.Tactic.IntervalCases.of_le_left
theorem of_le_left [LE α] (h : (a:α) ≤ b) (eq : a = a') : a' ≤ b 
Arguments: {α : Type u_1} {a b a' : α} [LE α] (h : a ≤ b) (eq : a = a')
Goal: a' ≤ b
-- Mathlib.Tactic.IntervalCases.of_le_right
theorem of_le_right [LE α] (h : (a:α) ≤ b) (eq : b = b') : a ≤ b' 
Arguments: {α : Type u_1} {a b b' : α} [LE α] (h : a ≤ b) (eq : b = b')
Goal: a ≤ b'
-- Mathlib.Tactic.IntervalCases.le_of_not_le_of_le
theorem le_of_not_le_of_le {hi n lo : α} [LinearOrder α] (h1 : ¬hi ≤ n) (h2 : hi ≤ lo) :
    (n:α) ≤ lo 
Arguments: {α : Type u_1} {hi n lo : α} [LinearOrder α] (h1 : ¬hi ≤ n) (h2 : hi ≤ lo)
Goal: n ≤ lo
-- Int.add_one_le_of_not_le
theorem _root_.Int.add_one_le_of_not_le {a b : ℤ} (h : ¬b ≤ a) : a + 1 ≤ b 
Arguments: {a b : ℤ} (h : ¬b ≤ a)
Goal: a + 1 ≤ b
-- Int.le_sub_one_of_not_le
theorem _root_.Int.le_sub_one_of_not_le {a b : ℤ} (h : ¬b ≤ a) : a ≤ b - 1 
Arguments: {a b : ℤ} (h : ¬b ≤ a)
Goal: a ≤ b - 1
-- CancelDenoms.mul_subst
theorem mul_subst {α} [CommRing α] {n1 n2 k e1 e2 t1 t2 : α}
    (h1 : n1 * e1 = t1) (h2 : n2 * e2 = t2) (h3 : n1 * n2 = k) : k * (e1 * e2) = t1 * t2 
Arguments: {α : Type u_1} [CommRing α] {n1 n2 k e1 e2 t1 t2 : α} (h1 : n1 * e1 = t1) (h2 : n2 * e2 = t2) (h3 : n1 * n2 = k)
Goal: k * (e1 * e2) = t1 * t2
-- CancelDenoms.div_subst
theorem div_subst {α} [Field α] {n1 n2 k e1 e2 t1 : α}
    (h1 : n1 * e1 = t1) (h2 : n2 / e2 = 1) (h3 : n1 * n2 = k) : k * (e1 / e2) = t1 
Arguments: {α : Type u_1} [Field α] {n1 n2 k e1 e2 t1 : α} (h1 : n1 * e1 = t1) (h2 : n2 / e2 = 1) (h3 : n1 * n2 = k)
Goal: k * (e1 / e2) = t1
-- CancelDenoms.cancel_factors_eq_div
theorem cancel_factors_eq_div {α} [Field α] {n e e' : α}
    (h : n * e = e') (h2 : n ≠ 0) : e = e' / n 
Arguments: {α : Type u_1} [Field α] {n e e' : α} (h : n * e = e') (h2 : n ≠ 0)
Goal: e = e' / n
-- CancelDenoms.add_subst
theorem add_subst {α} [Ring α] {n e1 e2 t1 t2 : α} (h1 : n * e1 = t1) (h2 : n * e2 = t2) :
    n * (e1 + e2) = t1 + t2 
Arguments: {α : Type u_1} [Ring α] {n e1 e2 t1 t2 : α} (h1 : n * e1 = t1) (h2 : n * e2 = t2)
Goal: n * (e1 + e2) = t1 + t2
-- CancelDenoms.sub_subst
theorem sub_subst {α} [Ring α] {n e1 e2 t1 t2 : α} (h1 : n * e1 = t1) (h2 : n * e2 = t2) :
    n * (e1 - e2) = t1 - t2 
Arguments: {α : Type u_1} [Ring α] {n e1 e2 t1 t2 : α} (h1 : n * e1 = t1) (h2 : n * e2 = t2)
Goal: n * (e1 - e2) = t1 - t2
-- CancelDenoms.neg_subst
theorem neg_subst {α} [Ring α] {n e t : α} (h1 : n * e = t) : n * -e = -t 
Arguments: {α : Type u_1} [Ring α] {n e t : α} (h1 : n * e = t)
Goal: n * -e = -t
-- CancelDenoms.pow_subst
theorem pow_subst {α} [CommRing α] {n e1 t1 k l : α} {e2 : ℕ}
    (h1 : n * e1 = t1) (h2 : l * n ^ e2 = k) : k * (e1 ^ e2) = l * t1 ^ e2 
Arguments: {α : Type u_1} [CommRing α] {n e1 t1 k l : α} {e2 : ℕ} (h1 : n * e1 = t1) (h2 : l * n ^ e2 = k)
Goal: k * e1 ^ e2 = l * t1 ^ e2
-- CancelDenoms.inv_subst
theorem inv_subst {α} [Field α] {n k e : α} (h2 : e ≠ 0) (h3 : n * e = k) :
    k * (e ⁻¹) = n 
Arguments: {α : Type u_1} [Field α] {n k e : α} (h2 : e ≠ 0) (h3 : n * e = k)
Goal: k * e⁻¹ = n
-- CancelDenoms.cancel_factors_lt
theorem cancel_factors_lt {α} [LinearOrderedField α] {a b ad bd a' b' gcd : α}
    (ha : ad * a = a') (hb : bd * b = b') (had : 0 < ad) (hbd : 0 < bd) (hgcd : 0 < gcd) :
    (a < b) = (1 / gcd * (bd * a') < 1 / gcd * (ad * b')) 
Arguments: {α : Type u_1} [LinearOrderedField α] {a b ad bd a' b' gcd : α} (ha : ad * a = a') (hb : bd * b = b') (had : 0 < ad) (hbd : 0 < bd) (hgcd : 0 < gcd)
Goal: (a < b) = (1 / gcd * (bd * a') < 1 / gcd * (ad * b'))
-- CancelDenoms.cancel_factors_le
theorem cancel_factors_le {α} [LinearOrderedField α] {a b ad bd a' b' gcd : α}
    (ha : ad * a = a') (hb : bd * b = b') (had : 0 < ad) (hbd : 0 < bd) (hgcd : 0 < gcd) :
    (a ≤ b) = (1 / gcd * (bd * a') ≤ 1 / gcd * (ad * b')) 
Arguments: {α : Type u_1} [LinearOrderedField α] {a b ad bd a' b' gcd : α} (ha : ad * a = a') (hb : bd * b = b') (had : 0 < ad) (hbd : 0 < bd) (hgcd : 0 < gcd)
Goal: (a ≤ b) = (1 / gcd * (bd * a') ≤ 1 / gcd * (ad * b'))
-- CancelDenoms.cancel_factors_eq
theorem cancel_factors_eq {α} [Field α] {a b ad bd a' b' gcd : α} (ha : ad * a = a')
    (hb : bd * b = b') (had : ad ≠ 0) (hbd : bd ≠ 0) (hgcd : gcd ≠ 0) :
    (a = b) = (1 / gcd * (bd * a') = 1 / gcd * (ad * b')) 
Arguments: {α : Type u_1} [Field α] {a b ad bd a' b' gcd : α} (ha : ad * a = a') (hb : bd * b = b') (had : ad ≠ 0) (hbd : bd ≠ 0) (hgcd : gcd ≠ 0)
Goal: (a = b) = (1 / gcd * (bd * a') = 1 / gcd * (ad * b'))
-- CancelDenoms.cancel_factors_ne
theorem cancel_factors_ne {α} [Field α] {a b ad bd a' b' gcd : α} (ha : ad * a = a')
    (hb : bd * b = b') (had : ad ≠ 0) (hbd : bd ≠ 0) (hgcd : gcd ≠ 0) :
    (a ≠ b) = (1 / gcd * (bd * a') ≠ 1 / gcd * (ad * b')) 
Arguments: {α : Type u_1} [Field α] {a b ad bd a' b' gcd : α} (ha : ad * a = a') (hb : bd * b = b') (had : ad ≠ 0) (hbd : bd ≠ 0) (hgcd : gcd ≠ 0)
Goal: (a ≠ b) = (1 / gcd * (bd * a') ≠ 1 / gcd * (ad * b'))
-- CancelDenoms.derive_trans
theorem derive_trans {α} [Mul α] {a b c d : α} (h : a = b) (h' : c * b = d) : c * a = d 
Arguments: {α : Type u_1} [Mul α] {a b c d : α} (h : a = b) (h' : c * b = d)
Goal: c * a = d
-- Mathlib.Tactic.PushNeg.not_not_eq
theorem not_not_eq : (¬ ¬ p) = p 
Arguments: (p : Prop)
Goal: (¬¬p) = p
-- Mathlib.Tactic.PushNeg.not_and_eq
theorem not_and_eq : (¬ (p ∧ q)) = (p → ¬ q) 
Arguments: (p q : Prop)
Goal: (¬(p ∧ q)) = (p → ¬q)
-- Mathlib.Tactic.PushNeg.not_and_or_eq
theorem not_and_or_eq : (¬ (p ∧ q)) = (¬ p ∨ ¬ q) 
Arguments: (p q : Prop)
Goal: (¬(p ∧ q)) = (¬p ∨ ¬q)
-- Mathlib.Tactic.PushNeg.not_or_eq
theorem not_or_eq : (¬ (p ∨ q)) = (¬ p ∧ ¬ q) 
Arguments: (p q : Prop)
Goal: (¬(p ∨ q)) = (¬p ∧ ¬q)
-- Mathlib.Tactic.PushNeg.not_forall_eq
theorem not_forall_eq : (¬ ∀ x, s x) = (∃ x, ¬ s x) 
Arguments: {α : Sort u_1} (s : α → Prop)
Goal: (¬∀ (x : α), s x) = ∃ x, ¬s x
-- Mathlib.Tactic.PushNeg.not_exists_eq
theorem not_exists_eq : (¬ ∃ x, s x) = (∀ x, ¬ s x) 
Arguments: {α : Sort u_1} (s : α → Prop)
Goal: (¬∃ x, s x) = ∀ (x : α), ¬s x
-- Mathlib.Tactic.PushNeg.not_implies_eq
theorem not_implies_eq : (¬ (p → q)) = (p ∧ ¬ q) 
Arguments: (p q : Prop)
Goal: (¬(p → q)) = (p ∧ ¬q)
-- Mathlib.Tactic.PushNeg.not_ne_eq
theorem not_ne_eq (x y : α) : (¬ (x ≠ y)) = (x = y) 
Arguments: {α : Sort u_1} (x y : α)
Goal: (¬x ≠ y) = (x = y)
-- Mathlib.Tactic.PushNeg.not_iff
theorem not_iff : (¬ (p ↔ q)) = ((p ∧ ¬ q) ∨ (¬ p ∧ q)) 
Arguments: (p q : Prop)
Goal: (¬(p ↔ q)) = (p ∧ ¬q ∨ ¬p ∧ q)
-- Mathlib.Tactic.PushNeg.not_le_eq
theorem not_le_eq (a b : β) : (¬ (a ≤ b)) = (b < a) 
Arguments: {β : Type u_2} [LinearOrder β] (a b : β)
Goal: (¬a ≤ b) = (b < a)
-- Mathlib.Tactic.PushNeg.not_lt_eq
theorem not_lt_eq (a b : β) : (¬ (a < b)) = (b ≤ a) 
Arguments: {β : Type u_2} [LinearOrder β] (a b : β)
Goal: (¬a < b) = (b ≤ a)
-- Mathlib.Tactic.PushNeg.not_ge_eq
theorem not_ge_eq (a b : β) : (¬ (a ≥ b)) = (a < b) 
Arguments: {β : Type u_2} [LinearOrder β] (a b : β)
Goal: (¬a ≥ b) = (a < b)
-- Mathlib.Tactic.PushNeg.not_gt_eq
theorem not_gt_eq (a b : β) : (¬ (a > b)) = (a ≤ b) 
Arguments: {β : Type u_2} [LinearOrder β] (a b : β)
Goal: (¬a > b) = (a ≤ b)
-- Mathlib.Tactic.PushNeg.not_nonempty_eq
theorem not_nonempty_eq (s : Set β) : (¬ s.Nonempty) = (s = ∅) 
Arguments: {β : Type u_2} (s : Set β)
Goal: (¬s.Nonempty) = (s = ∅)
-- Mathlib.Tactic.PushNeg.ne_empty_eq_nonempty
theorem ne_empty_eq_nonempty (s : Set β) : (s ≠ ∅) = s.Nonempty 
Arguments: {β : Type u_2} (s : Set β)
Goal: (s ≠ ∅) = s.Nonempty
-- Mathlib.Tactic.PushNeg.empty_ne_eq_nonempty
theorem empty_ne_eq_nonempty (s : Set β) : (∅ ≠ s) = s.Nonempty 
Arguments: {β : Type u_2} (s : Set β)
Goal: (∅ ≠ s) = s.Nonempty
-- threeAPFree_frontier
lemma threeAPFree_frontier {𝕜 E : Type*} [LinearOrderedField 𝕜] [TopologicalSpace E]
    [AddCommMonoid E] [Module 𝕜 E] {s : Set E} (hs₀ : IsClosed s) (hs₁ : StrictConvex 𝕜 s) :
    ThreeAPFree (frontier s) 
Arguments: {𝕜 : Type u_1} {E : Type u_2} [LinearOrderedField 𝕜] [TopologicalSpace E] [AddCommMonoid E] [Module 𝕜 E] {s : Set E} (hs₀ : IsClosed s) (hs₁ : StrictConvex 𝕜 s)
Goal: ThreeAPFree (frontier s)
-- threeAPFree_sphere
lemma threeAPFree_sphere {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [StrictConvexSpace ℝ E] (x : E) (r : ℝ) : ThreeAPFree (sphere x r) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] [StrictConvexSpace ℝ E] (x : E) (r : ℝ)
Goal: ThreeAPFree (Metric.sphere x r)
-- Behrend.mem_box
theorem mem_box : x ∈ box n d ↔ ∀ i, x i < d 
Arguments: {n d : ℕ} {x : Fin n → ℕ}
Goal: x ∈ Behrend.box n d ↔ ∀ (i : Fin n), x i < d
-- Behrend.card_box
@[simp]
theorem card_box : (box n d).card = d ^ n 
Arguments: {n d : ℕ}
Goal: (Behrend.box n d).card = d ^ n
-- Behrend.box_zero
@[simp]
theorem box_zero : box (n + 1) 0 = ∅ 
Arguments: {n : ℕ}
Goal: Behrend.box (n + 1) 0 = ∅
-- Behrend.sphere_zero_subset
theorem sphere_zero_subset : sphere n d 0 ⊆ 0 
Arguments: {n d : ℕ}
Goal: Behrend.sphere n d 0 ⊆ 0
-- Behrend.sphere_zero_right
@[simp]
theorem sphere_zero_right (n k : ℕ) : sphere (n + 1) 0 k = ∅ 
Arguments: (n k : ℕ)
Goal: Behrend.sphere (n + 1) 0 k = ∅
-- Behrend.sphere_subset_box
theorem sphere_subset_box : sphere n d k ⊆ box n d 
Arguments: {n d k : ℕ}
Goal: Behrend.sphere n d k ⊆ Behrend.box n d
-- Behrend.norm_of_mem_sphere
theorem norm_of_mem_sphere {x : Fin n → ℕ} (hx : x ∈ sphere n d k) :
    ‖(WithLp.equiv 2 _).symm ((↑) ∘ x : Fin n → ℝ)‖ = √↑k 
Arguments: {n d k : ℕ} {x : Fin n → ℕ} (hx : x ∈ Behrend.sphere n d k)
Goal: ‖(WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x)‖ = √↑k
-- Behrend.sphere_subset_preimage_metric_sphere
theorem sphere_subset_preimage_metric_sphere : (sphere n d k : Set (Fin n → ℕ)) ⊆
    (fun x : Fin n → ℕ => (WithLp.equiv 2 _).symm ((↑) ∘ x : Fin n → ℝ)) ⁻¹'
      Metric.sphere (0 : PiLp 2 fun _ : Fin n => ℝ) (√↑k) 
Arguments: {n d k : ℕ}
Goal: ↑(Behrend.sphere n d k) ⊆ (fun x => (WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x)) ⁻¹' Metric.sphere 0 √↑k
-- Behrend.map_apply
@[simps]
def map (d : ℕ) : (Fin n → ℕ) →+ ℕ 
Arguments: {n : ℕ} (d : ℕ) (a : Fin n → ℕ)
Goal: (Behrend.map d) a = ∑ i : Fin n, a i * d ^ ↑i
-- Behrend.map_zero
theorem map_zero (d : ℕ) (a : Fin 0 → ℕ) : map d a = 0 
Arguments: (d : ℕ) (a : Fin 0 → ℕ)
Goal: (Behrend.map d) a = 0
-- Behrend.map_succ
theorem map_succ (a : Fin (n + 1) → ℕ) :
    map d a = a 0 + (∑ x : Fin n, a x.succ * d ^ (x : ℕ)) * d 
Arguments: {n d : ℕ} (a : Fin (n + 1) → ℕ)
Goal: (Behrend.map d) a = a 0 + (∑ x : Fin n, a x.succ * d ^ ↑x) * d
-- Behrend.map_succ'
theorem map_succ' (a : Fin (n + 1) → ℕ) : map d a = a 0 + map d (a ∘ Fin.succ) * d 
Arguments: {n d : ℕ} (a : Fin (n + 1) → ℕ)
Goal: (Behrend.map d) a = a 0 + (Behrend.map d) (a ∘ Fin.succ) * d
-- Behrend.map_monotone
theorem map_monotone (d : ℕ) : Monotone (map d : (Fin n → ℕ) → ℕ) 
Arguments: {n : ℕ} (d : ℕ)
Goal: Monotone ⇑(Behrend.map d)
-- Behrend.map_mod
theorem map_mod (a : Fin n.succ → ℕ) : map d a % d = a 0 % d 
Arguments: {n d : ℕ} (a : Fin n.succ → ℕ)
Goal: (Behrend.map d) a % d = a 0 % d
-- Behrend.map_eq_iff
theorem map_eq_iff {x₁ x₂ : Fin n.succ → ℕ} (hx₁ : ∀ i, x₁ i < d) (hx₂ : ∀ i, x₂ i < d) :
    map d x₁ = map d x₂ ↔ x₁ 0 = x₂ 0 ∧ map d (x₁ ∘ Fin.succ) = map d (x₂ ∘ Fin.succ) 
Arguments: {n d : ℕ} {x₁ x₂ : Fin n.succ → ℕ} (hx₁ : ∀ (i : Fin n.succ), x₁ i < d) (hx₂ : ∀ (i : Fin n.succ), x₂ i < d)
Goal: (Behrend.map d) x₁ = (Behrend.map d) x₂ ↔
  x₁ 0 = x₂ 0 ∧ (Behrend.map d) (x₁ ∘ Fin.succ) = (Behrend.map d) (x₂ ∘ Fin.succ)
-- Behrend.map_injOn
theorem map_injOn : {x : Fin n → ℕ | ∀ i, x i < d}.InjOn (map d) 
Arguments: {n d : ℕ} {x : Fin n → ℕ}
Goal: Set.InjOn ⇑(Behrend.map d) {x | ∀ (i : Fin n), x i < d}
-- Behrend.map_le_of_mem_box
theorem map_le_of_mem_box (hx : x ∈ box n d) :
    map (2 * d - 1) x ≤ ∑ i : Fin n, (d - 1) * (2 * d - 1) ^ (i : ℕ) 
Arguments: {n d : ℕ} {x : Fin n → ℕ} (hx : x ∈ Behrend.box n d)
Goal: (Behrend.map (2 * d - 1)) x ≤ ∑ i : Fin n, (d - 1) * (2 * d - 1) ^ ↑i
-- Behrend.threeAPFree_sphere
nonrec theorem threeAPFree_sphere : ThreeAPFree (sphere n d k : Set (Fin n → ℕ)) 
Arguments: {n d k : ℕ}
Goal: ThreeAPFree ↑(Behrend.sphere n d k)
-- Behrend.threeAPFree_image_sphere
theorem threeAPFree_image_sphere :
    ThreeAPFree ((sphere n d k).image (map (2 * d - 1)) : Set ℕ) 
Arguments: {n d k : ℕ} {x : Fin n → ℕ}
Goal: ThreeAPFree ↑(Finset.image (⇑(Behrend.map (2 * d - 1))) (Behrend.sphere n d k))
-- Behrend.sum_sq_le_of_mem_box
theorem sum_sq_le_of_mem_box (hx : x ∈ box n d) : ∑ i : Fin n, x i ^ 2 ≤ n * (d - 1) ^ 2 
Arguments: {n d : ℕ} {x : Fin n → ℕ} (hx : x ∈ Behrend.box n d)
Goal: ∑ i : Fin n, x i ^ 2 ≤ n * (d - 1) ^ 2
-- Behrend.sum_eq
theorem sum_eq : (∑ i : Fin n, d * (2 * d + 1) ^ (i : ℕ)) = ((2 * d + 1) ^ n - 1) / 2 
Arguments: {n d : ℕ}
Goal: ∑ i : Fin n, d * (2 * d + 1) ^ ↑i = ((2 * d + 1) ^ n - 1) / 2
-- Behrend.sum_lt
theorem sum_lt : (∑ i : Fin n, d * (2 * d + 1) ^ (i : ℕ)) < (2 * d + 1) ^ n 
Arguments: {n d : ℕ}
Goal: ∑ i : Fin n, d * (2 * d + 1) ^ ↑i < (2 * d + 1) ^ n
-- Behrend.card_sphere_le_rothNumberNat
theorem card_sphere_le_rothNumberNat (n d k : ℕ) :
    (sphere n d k).card ≤ rothNumberNat ((2 * d - 1) ^ n) 
Arguments: (n d k : ℕ)
Goal: (Behrend.sphere n d k).card ≤ rothNumberNat ((2 * d - 1) ^ n)
-- Behrend.exists_large_sphere_aux
theorem exists_large_sphere_aux (n d : ℕ) : ∃ k ∈ range (n * (d - 1) ^ 2 + 1),
    (↑(d ^ n) / ((n * (d - 1) ^ 2 :) + 1) : ℝ) ≤ (sphere n d k).card 
Arguments: (n d : ℕ)
Goal: ∃ k ∈ Finset.range (n * (d - 1) ^ 2 + 1), ↑(d ^ n) / (↑(n * (d - 1) ^ 2) + 1) ≤ ↑(Behrend.sphere n d k).card
-- Behrend.exists_large_sphere
theorem exists_large_sphere (n d : ℕ) :
    ∃ k, ((d ^ n :) / (n * d ^ 2 :) : ℝ) ≤ (sphere n d k).card 
Arguments: (n d : ℕ)
Goal: ∃ k, ↑(d ^ n) / ↑(n * d ^ 2) ≤ ↑(Behrend.sphere n d k).card
-- Behrend.bound_aux'
theorem bound_aux' (n d : ℕ) : ((d ^ n :) / (n * d ^ 2 :) : ℝ) ≤ rothNumberNat ((2 * d - 1) ^ n) 
Arguments: (n d : ℕ)
Goal: ↑(d ^ n) / ↑(n * d ^ 2) ≤ ↑(rothNumberNat ((2 * d - 1) ^ n))
-- Behrend.bound_aux
theorem bound_aux (hd : d ≠ 0) (hn : 2 ≤ n) :
    (d ^ (n - 2 :) / n : ℝ) ≤ rothNumberNat ((2 * d - 1) ^ n) 
Arguments: {n d : ℕ} (hd : d ≠ 0) (hn : 2 ≤ n)
Goal: ↑d ^ (n - 2) / ↑n ≤ ↑(rothNumberNat ((2 * d - 1) ^ n))
-- Behrend.log_two_mul_two_le_sqrt_log_eight
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ √(log 8) 
Goal: Real.log 2 * 2 ≤ √(Real.log 8)
-- Behrend.two_div_one_sub_two_div_e_le_eight
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 
Goal: 2 / (1 - 2 / rexp 1) ≤ 8
-- Behrend.le_sqrt_log
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ √(log ↑N) 
Arguments: {N : ℕ} (hN : 4096 ≤ N)
Goal: Real.log (2 / (1 - 2 / rexp 1)) * (69 / 50) ≤ √(Real.log ↑N)
-- Behrend.exp_neg_two_mul_le
theorem exp_neg_two_mul_le {x : ℝ} (hx : 0 < x) : exp (-2 * x) < exp (2 - ⌈x⌉₊) / ⌈x⌉₊ 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: rexp (-2 * x) < rexp (2 - ↑⌈x⌉₊) / ↑⌈x⌉₊
-- Behrend.div_lt_floor
theorem div_lt_floor {x : ℝ} (hx : 2 / (1 - 2 / exp 1) ≤ x) : x / exp 1 < (⌊x / 2⌋₊ : ℝ) 
Arguments: {x : ℝ} (hx : 2 / (1 - 2 / rexp 1) ≤ x)
Goal: x / rexp 1 < ↑⌊x / 2⌋₊
-- Behrend.ceil_lt_mul
theorem ceil_lt_mul {x : ℝ} (hx : 50 / 19 ≤ x) : (⌈x⌉₊ : ℝ) < 1.38 * x 
Arguments: {x : ℝ} (hx : 50 / 19 ≤ x)
Goal: ↑⌈x⌉₊ < 1.38 * x
-- Behrend.nValue_pos
theorem nValue_pos (hN : 2 ≤ N) : 0 < nValue N 
Arguments: {N : ℕ} (hN : 2 ≤ N)
Goal: 0 < Behrend.nValue N
-- Behrend.three_le_nValue
theorem three_le_nValue (hN : 64 ≤ N) : 3 ≤ nValue N 
Arguments: {N : ℕ} (hN : 64 ≤ N)
Goal: 3 ≤ Behrend.nValue N