ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AbsoluteValue.sub_le_add
lemma sub_le_add (a b : R) : abv (a - b) ≤ abv a + abv b 
Arguments: {R : Type u_3} {S : Type u_4} [OrderedCommRing S] [Ring R] (abv : AbsoluteValue R S) [NoZeroDivisors S] (a b : R)
Goal: abv (a - b) ≤ abv a + abv b
-- AbsoluteValue.abs_apply
@[simps]
protected def abs : AbsoluteValue S S 
Arguments: {S : Type u_6} [LinearOrderedRing S] (a : S)
Goal: AbsoluteValue.abs a = |a|
-- AbsoluteValue.abs_toFun
@[simps]
protected def abs : AbsoluteValue S S 
Arguments: {S : Type u_6} [LinearOrderedRing S] (a : S)
Goal: AbsoluteValue.abs a = |a|
-- AbsoluteValue.abs_abv_sub_le_abv_sub
theorem abs_abv_sub_le_abv_sub (a b : R) : abs (abv a - abv b) ≤ abv (a - b) 
Arguments: {R : Type u_5} {S : Type u_6} [Ring R] [LinearOrderedCommRing S] (abv : AbsoluteValue R S) (a b : R)
Goal: |abv a - abv b| ≤ abv (a - b)
-- IsAbsoluteValue.abv_eq_zero'
class IsAbsoluteValue {S} [OrderedSemiring S] {R} [Semiring R] (f : R → S) : Prop where
    abv_nonneg' : ∀ x, 0 ≤ f x
    abv_eq_zero' : ∀ {x}, f x = 0 ↔ x = 0
    abv_add' : ∀ x y, f (x + y) ≤ f x + f y
    abv_mul' : ∀ x y, f (x * y) = f x * f y
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] {f : R → S} [self : IsAbsoluteValue f] {x : R}
Goal: f x = 0 ↔ x = 0
-- IsAbsoluteValue.abv_mul'
class IsAbsoluteValue {S} [OrderedSemiring S] {R} [Semiring R] (f : R → S) : Prop where
    abv_nonneg' : ∀ x, 0 ≤ f x
    abv_eq_zero' : ∀ {x}, f x = 0 ↔ x = 0
    abv_add' : ∀ x y, f (x + y) ≤ f x + f y
    abv_mul' : ∀ x y, f (x * y) = f x * f y
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] {f : R → S} [self : IsAbsoluteValue f] (x y : R)
Goal: f (x * y) = f x * f y
-- IsAbsoluteValue.abv_add'
class IsAbsoluteValue {S} [OrderedSemiring S] {R} [Semiring R] (f : R → S) : Prop where
    abv_nonneg' : ∀ x, 0 ≤ f x
    abv_eq_zero' : ∀ {x}, f x = 0 ↔ x = 0
    abv_add' : ∀ x y, f (x + y) ≤ f x + f y
    abv_mul' : ∀ x y, f (x * y) = f x * f y
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] {f : R → S} [self : IsAbsoluteValue f] (x y : R)
Goal: f (x + y) ≤ f x + f y
-- IsAbsoluteValue.abv_nonneg'
class IsAbsoluteValue {S} [OrderedSemiring S] {R} [Semiring R] (f : R → S) : Prop where
    abv_nonneg' : ∀ x, 0 ≤ f x
    abv_eq_zero' : ∀ {x}, f x = 0 ↔ x = 0
    abv_add' : ∀ x y, f (x + y) ≤ f x + f y
    abv_mul' : ∀ x y, f (x * y) = f x * f y
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] {f : R → S} [self : IsAbsoluteValue f] (x : R)
Goal: 0 ≤ f x
-- IsAbsoluteValue.abv_nonneg
lemma abv_nonneg (x) : 0 ≤ abv x 
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv] (x : R)
Goal: 0 ≤ abv x
-- IsAbsoluteValue.abv_eq_zero
lemma abv_eq_zero {x} : abv x = 0 ↔ x = 0 
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv] {x : R}
Goal: abv x = 0 ↔ x = 0
-- IsAbsoluteValue.abv_add
lemma abv_add (x y) : abv (x + y) ≤ abv x + abv y 
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv] (x y : R)
Goal: abv (x + y) ≤ abv x + abv y
-- IsAbsoluteValue.abv_mul
lemma abv_mul (x y) : abv (x * y) = abv x * abv y 
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv] (x y : R)
Goal: abv (x * y) = abv x * abv y
-- IsAbsoluteValue.toAbsoluteValue_toFun
@[simps]
def toAbsoluteValue : AbsoluteValue R S 
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv]
Goal: ∀ (a : R), (IsAbsoluteValue.toAbsoluteValue abv) a = abv a
-- IsAbsoluteValue.toAbsoluteValue_apply
@[simps]
def toAbsoluteValue : AbsoluteValue R S 
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv]
Goal: ∀ (a : R), (IsAbsoluteValue.toAbsoluteValue abv) a = abv a
-- IsAbsoluteValue.abv_zero
theorem abv_zero : abv 0 = 0 
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv]
Goal: abv 0 = 0
-- IsAbsoluteValue.abv_pos
theorem abv_pos {a : R} : 0 < abv a ↔ a ≠ 0 
Arguments: {S : Type u_5} [OrderedSemiring S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv] {a : R}
Goal: 0 < abv a ↔ a ≠ 0
-- IsAbsoluteValue.abv_one
theorem abv_one [Nontrivial R] : abv 1 = 1 
Arguments: {S : Type u_5} [OrderedRing S] {R : Type u_6} [Semiring R] (abv : R → S) [IsAbsoluteValue abv] [IsDomain S] [Nontrivial R]
Goal: abv 1 = 1
-- IsAbsoluteValue.abv_pow
theorem abv_pow [Nontrivial R] (abv : R → S) [IsAbsoluteValue abv] (a : R) (n : ℕ) :
    abv (a ^ n) = abv a ^ n 
Arguments: {S : Type u_5} [OrderedRing S] {R : Type u_6} [Semiring R] [IsDomain S] [Nontrivial R] (abv : R → S) [IsAbsoluteValue abv] (a : R) (n : ℕ)
Goal: abv (a ^ n) = abv a ^ n
-- IsAbsoluteValue.abv_sub_le
theorem abv_sub_le (a b c : R) : abv (a - c) ≤ abv (a - b) + abv (b - c) 
Arguments: {S : Type u_5} [OrderedRing S] {R : Type u_6} [Ring R] (abv : R → S) [IsAbsoluteValue abv] (a b c : R)
Goal: abv (a - c) ≤ abv (a - b) + abv (b - c)
-- IsAbsoluteValue.sub_abv_le_abv_sub
theorem sub_abv_le_abv_sub (a b : R) : abv a - abv b ≤ abv (a - b) 
Arguments: {S : Type u_5} [OrderedRing S] {R : Type u_6} [Ring R] (abv : R → S) [IsAbsoluteValue abv] (a b : R)
Goal: abv a - abv b ≤ abv (a - b)
-- IsAbsoluteValue.abv_neg
theorem abv_neg (a : R) : abv (-a) = abv a 
Arguments: {R : Type u_3} {S : Type u_4} [OrderedCommRing S] [NoZeroDivisors S] [Ring R] (abv : R → S) [IsAbsoluteValue abv] (a : R)
Goal: abv (-a) = abv a
-- IsAbsoluteValue.abv_sub
theorem abv_sub (a b : R) : abv (a - b) = abv (b - a) 
Arguments: {R : Type u_3} {S : Type u_4} [OrderedCommRing S] [NoZeroDivisors S] [Ring R] (abv : R → S) [IsAbsoluteValue abv] (a b : R)
Goal: abv (a - b) = abv (b - a)
-- IsAbsoluteValue.abs_abv_sub_le_abv_sub
theorem abs_abv_sub_le_abv_sub (a b : R) : abs (abv a - abv b) ≤ abv (a - b) 
Arguments: {S : Type u_5} [LinearOrderedCommRing S] {R : Type u_6} [Ring R] (abv : R → S) [IsAbsoluteValue abv] (a b : R)
Goal: |abv a - abv b| ≤ abv (a - b)
-- IsAbsoluteValue.abv_one'
theorem abv_one' : abv 1 = 1 
Arguments: {S : Type u_5} [LinearOrderedSemifield S] {R : Type u_6} [Semiring R] [Nontrivial R] (abv : R → S) [IsAbsoluteValue abv]
Goal: abv 1 = 1
-- IsAbsoluteValue.abv_inv
theorem abv_inv (a : R) : abv a⁻¹ = (abv a)⁻¹ 
Arguments: {S : Type u_5} [LinearOrderedSemifield S] {R : Type u_6} [DivisionSemiring R] (abv : R → S) [IsAbsoluteValue abv] (a : R)
Goal: abv a⁻¹ = (abv a)⁻¹
-- IsAbsoluteValue.abv_div
theorem abv_div (a b : R) : abv (a / b) = abv a / abv b 
Arguments: {S : Type u_5} [LinearOrderedSemifield S] {R : Type u_6} [DivisionSemiring R] (abv : R → S) [IsAbsoluteValue abv] (a b : R)
Goal: abv (a / b) = abv a / abv b
-- smul_mono_right
theorem smul_mono_right [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LE.le]
    (m : M) : Monotone (HSMul.hSMul m : α → α) 
Arguments: {M : Type u_2} {α : Type u_3} [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LE.le] (m : M)
Goal: Monotone (HSMul.hSMul m)
-- smul_le_smul_left
@[gcongr]
theorem smul_le_smul_left [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LE.le]
    (m : M) {a b : α} (h : a ≤ b) :
    m • a ≤ m • b 
Arguments: {M : Type u_2} {α : Type u_3} [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LE.le] (m : M) {a b : α} (h : a ≤ b)
Goal: m • a ≤ m • b
-- smul_inf_le
theorem smul_inf_le [SMul M α] [SemilatticeInf α] [CovariantClass M α HSMul.hSMul LE.le]
    (m : M) (a₁ a₂ : α) : m • (a₁ ⊓ a₂) ≤ m • a₁ ⊓ m • a₂ 
Arguments: {M : Type u_2} {α : Type u_3} [SMul M α] [SemilatticeInf α] [CovariantClass M α HSMul.hSMul LE.le] (m : M) (a₁ a₂ : α)
Goal: m • (a₁ ⊓ a₂) ≤ m • a₁ ⊓ m • a₂
-- smul_iInf_le
theorem smul_iInf_le [SMul M α] [CompleteLattice α] [CovariantClass M α HSMul.hSMul LE.le]
    {m : M} {t : ι → α} :
    m • iInf t ≤ ⨅ i, m • t i 
Arguments: {ι : Sort u_1} {M : Type u_2} {α : Type u_3} [SMul M α] [CompleteLattice α] [CovariantClass M α HSMul.hSMul LE.le] {m : M} {t : ι → α}
Goal: m • iInf t ≤ ⨅ i, m • t i
-- smul_strictMono_right
theorem smul_strictMono_right [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LT.lt]
    (m : M) : StrictMono (HSMul.hSMul m : α → α) 
Arguments: {M : Type u_2} {α : Type u_3} [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LT.lt] (m : M)
Goal: StrictMono (HSMul.hSMul m)
-- Positive.coe_add
@[simp, norm_cast]
theorem coe_add (x y : { x : M // 0 < x }) : ↑(x + y) = (x + y : M) 
Arguments: {M : Type u_1} [AddMonoid M] [Preorder M] [CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (x y : { x // 0 < x })
Goal: ↑(x + y) = ↑x + ↑y
-- Positive.val_mul
@[simp]
theorem val_mul (x y : { x : R // 0 < x }) : ↑(x * y) = (x * y : R) 
Arguments: {R : Type u_2} [StrictOrderedSemiring R] (x y : { x // 0 < x })
Goal: ↑(x * y) = ↑x * ↑y
-- Positive.val_pow
@[simp]
theorem val_pow (x : { x : R // 0 < x }) (n : ℕ) :
    ↑(x ^ n) = (x : R) ^ n 
Arguments: {R : Type u_2} [StrictOrderedSemiring R] (x : { x // 0 < x }) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- Positive.val_one
@[simp]
theorem val_one : ((1 : { x : R // 0 < x }) : R) = 1 
Arguments: {R : Type u_2} [StrictOrderedSemiring R]
Goal: ↑1 = 1
-- Finset.HasAntidiagonal.mem_antidiagonal
class HasAntidiagonal (A : Type*) [AddMonoid A] where
    antidiagonal : A → Finset (A × A)
    mem_antidiagonal {n} {a} : a ∈ antidiagonal n ↔ a.fst + a.snd = n
Arguments: {A : Type u_1} [AddMonoid A] [self : Finset.HasAntidiagonal A] {n : A} {a : A × A}
Goal: a ∈ Finset.antidiagonal n ↔ a.1 + a.2 = n
-- Finset.hasAntidiagonal_congr
lemma hasAntidiagonal_congr (A : Type*) [AddMonoid A]
    [H1 : HasAntidiagonal A] [H2 : HasAntidiagonal A] :
    H1.antidiagonal = H2.antidiagonal 
Arguments: (A : Type u_2) [AddMonoid A] [H1 : Finset.HasAntidiagonal A] [H2 : Finset.HasAntidiagonal A]
Goal: Finset.antidiagonal = Finset.antidiagonal
-- Finset.swap_mem_antidiagonal
theorem swap_mem_antidiagonal [AddCommMonoid A] [HasAntidiagonal A] {n : A} {xy : A × A} :
    xy.swap ∈ antidiagonal n ↔ xy ∈ antidiagonal n 
Arguments: {A : Type u_1} [AddCommMonoid A] [Finset.HasAntidiagonal A] {n : A} {xy : A × A}
Goal: xy.swap ∈ Finset.antidiagonal n ↔ xy ∈ Finset.antidiagonal n
-- Finset.map_prodComm_antidiagonal
@[simp] theorem map_prodComm_antidiagonal [AddCommMonoid A] [HasAntidiagonal A] {n : A} :
    (antidiagonal n).map (Equiv.prodComm A A) = antidiagonal n 
Arguments: {A : Type u_1} [AddCommMonoid A] [Finset.HasAntidiagonal A] {n : A}
Goal: Finset.map (Equiv.prodComm A A).toEmbedding (Finset.antidiagonal n) = Finset.antidiagonal n
-- Finset.map_swap_antidiagonal
@[simp] theorem map_swap_antidiagonal [AddCommMonoid A] [HasAntidiagonal A] {n : A} :
    (antidiagonal n).map ⟨Prod.swap, Prod.swap_injective⟩ = antidiagonal n 
Arguments: {A : Type u_1} [AddCommMonoid A] [Finset.HasAntidiagonal A] {n : A}
Goal: Finset.map { toFun := Prod.swap, inj' := ⋯ } (Finset.antidiagonal n) = Finset.antidiagonal n
-- Finset.antidiagonal_congr
theorem antidiagonal_congr (hp : p ∈ antidiagonal n) (hq : q ∈ antidiagonal n) :
    p = q ↔ p.1 = q.1 
Arguments: {A : Type u_1} [AddCancelMonoid A] [Finset.HasAntidiagonal A] {p q : A × A} {n : A} (hp : p ∈ Finset.antidiagonal n) (hq : q ∈ Finset.antidiagonal n)
Goal: p = q ↔ p.1 = q.1
-- Finset.antidiagonal_subtype_ext
@[ext] theorem antidiagonal_subtype_ext {p q : antidiagonal n} (h : p.val.1 = q.val.1) : p = q 
Arguments: {A : Type u_1} [AddCancelMonoid A] [Finset.HasAntidiagonal A] {n : A} {p q : { x // x ∈ Finset.antidiagonal n }} (h : (↑p).1 = (↑q).1)
Goal: p = q
-- Finset.antidiagonal_congr'
lemma antidiagonal_congr' (hp : p ∈ antidiagonal n) (hq : q ∈ antidiagonal n) :
    p = q ↔ p.2 = q.2 
Arguments: {A : Type u_1} [AddCancelCommMonoid A] [Finset.HasAntidiagonal A] {p q : A × A} {n : A} (hp : p ∈ Finset.antidiagonal n) (hq : q ∈ Finset.antidiagonal n)
Goal: p = q ↔ p.2 = q.2
-- Finset.antidiagonal_zero
@[simp]
theorem antidiagonal_zero : antidiagonal (0 : A) = {(0, 0)} 
Arguments: {A : Type u_1} [CanonicallyOrderedAddCommMonoid A] [Finset.HasAntidiagonal A]
Goal: Finset.antidiagonal 0 = {(0, 0)}
-- Finset.antidiagonal.fst_le
theorem antidiagonal.fst_le {n : A} {kl : A × A} (hlk : kl ∈ antidiagonal n) : kl.1 ≤ n 
Arguments: {A : Type u_1} [CanonicallyOrderedAddCommMonoid A] [Finset.HasAntidiagonal A] {n : A} {kl : A × A} (hlk : kl ∈ Finset.antidiagonal n)
Goal: kl.1 ≤ n
-- Finset.antidiagonal.snd_le
theorem antidiagonal.snd_le {n : A} {kl : A × A} (hlk : kl ∈ antidiagonal n) : kl.2 ≤ n 
Arguments: {A : Type u_1} [CanonicallyOrderedAddCommMonoid A] [Finset.HasAntidiagonal A] {n : A} {kl : A × A} (hlk : kl ∈ Finset.antidiagonal n)
Goal: kl.2 ≤ n
-- Finset.filter_fst_eq_antidiagonal
theorem filter_fst_eq_antidiagonal (n m : A) [DecidablePred (· = m)] [Decidable (m ≤ n)] :
    filter (fun x : A × A ↦ x.fst = m) (antidiagonal n) = if m ≤ n then {(m, n - m)} else ∅ 
Arguments: {A : Type u_1} [CanonicallyOrderedAddCommMonoid A] [Sub A] [OrderedSub A] [ContravariantClass A A (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [Finset.HasAntidiagonal A] (n m : A) [DecidablePred fun x => x = m] [Decidable (m ≤ n)]
Goal: Finset.filter (fun x => x.1 = m) (Finset.antidiagonal n) = if m ≤ n then {(m, n - m)} else ∅
-- Finset.filter_snd_eq_antidiagonal
theorem filter_snd_eq_antidiagonal (n m : A) [DecidablePred (· = m)] [Decidable (m ≤ n)] :
    filter (fun x : A × A ↦ x.snd = m) (antidiagonal n) = if m ≤ n then {(n - m, m)} else ∅ 
Arguments: {A : Type u_1} [CanonicallyOrderedAddCommMonoid A] [Sub A] [OrderedSub A] [ContravariantClass A A (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [Finset.HasAntidiagonal A] (n m : A) [DecidablePred fun x => x = m] [Decidable (m ≤ n)]
Goal: Finset.filter (fun x => x.2 = m) (Finset.antidiagonal n) = if m ≤ n then {(n - m, m)} else ∅
-- Finset.sigmaAntidiagonalEquivProd_apply
@[simps]
def sigmaAntidiagonalEquivProd [AddMonoid A] [HasAntidiagonal A] :
    (Σ n : A, antidiagonal n) ≃ A × A 
Arguments: {A : Type u_1} [AddMonoid A] [Finset.HasAntidiagonal A] (x : (n : A) × { x // x ∈ Finset.antidiagonal n })
Goal: Finset.sigmaAntidiagonalEquivProd x = ↑x.snd
-- Finset.sigmaAntidiagonalEquivProd_symm_apply_fst
@[simps]
def sigmaAntidiagonalEquivProd [AddMonoid A] [HasAntidiagonal A] :
    (Σ n : A, antidiagonal n) ≃ A × A 
Arguments: {A : Type u_1} [AddMonoid A] [Finset.HasAntidiagonal A] (x : A × A)
Goal: (Finset.sigmaAntidiagonalEquivProd.symm x).fst = x.1 + x.2
-- Finset.sigmaAntidiagonalEquivProd_symm_apply_snd_coe
@[simps]
def sigmaAntidiagonalEquivProd [AddMonoid A] [HasAntidiagonal A] :
    (Σ n : A, antidiagonal n) ≃ A × A 
Arguments: {A : Type u_1} [AddMonoid A] [Finset.HasAntidiagonal A] (x : A × A)
Goal: ↑(Finset.sigmaAntidiagonalEquivProd.symm x).snd = x
-- one_lt_zpow'
@[to_additive zsmul_pos] lemma one_lt_zpow' (ha : 1 < a) (hn : 0 < n) : 1 < a ^ n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {n : ℤ} {a : α} (ha : 1 < a) (hn : 0 < n)
Goal: 1 < a ^ n
-- zsmul_pos
@[to_additive zsmul_pos] lemma one_lt_zpow' (ha : 1 < a) (hn : 0 < n) : 1 < a ^ n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {n : ℤ} {a : α} (ha : 0 < a) (hn : 0 < n)
Goal: 0 < n • a
-- zsmul_strictMono_left
@[to_additive zsmul_strictMono_left]
lemma zpow_right_strictMono (ha : 1 < a) : StrictMono fun n : ℤ ↦ a ^ n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {a : α} (ha : 0 < a)
Goal: StrictMono fun n => n • a
-- zpow_right_strictMono
@[to_additive zsmul_strictMono_left]
lemma zpow_right_strictMono (ha : 1 < a) : StrictMono fun n : ℤ ↦ a ^ n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {a : α} (ha : 1 < a)
Goal: StrictMono fun n => a ^ n
-- zsmul_mono_left
@[to_additive zsmul_mono_left]
lemma zpow_mono_right (ha : 1 ≤ a) : Monotone fun n : ℤ ↦ a ^ n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {a : α} (ha : 0 ≤ a)
Goal: Monotone fun n => n • a
-- zpow_mono_right
@[to_additive zsmul_mono_left]
lemma zpow_mono_right (ha : 1 ≤ a) : Monotone fun n : ℤ ↦ a ^ n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {a : α} (ha : 1 ≤ a)
Goal: Monotone fun n => a ^ n
-- zsmul_le_zsmul
@[to_additive (attr := gcongr)]
lemma zpow_le_zpow (ha : 1 ≤ a) (h : m ≤ n) : a ^ m ≤ a ^ n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {m n : ℤ} {a : α} (ha : 0 ≤ a) (h : m ≤ n)
Goal: m • a ≤ n • a
-- zpow_le_zpow
@[to_additive (attr := gcongr)]
lemma zpow_le_zpow (ha : 1 ≤ a) (h : m ≤ n) : a ^ m ≤ a ^ n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {m n : ℤ} {a : α} (ha : 1 ≤ a) (h : m ≤ n)
Goal: a ^ m ≤ a ^ n
-- zpow_lt_zpow
@[to_additive (attr := gcongr)]
lemma zpow_lt_zpow (ha : 1 < a) (h : m < n) : a ^ m < a ^ n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {m n : ℤ} {a : α} (ha : 1 < a) (h : m < n)
Goal: a ^ m < a ^ n
-- zsmul_lt_zsmul
@[to_additive (attr := gcongr)]
lemma zpow_lt_zpow (ha : 1 < a) (h : m < n) : a ^ m < a ^ n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {m n : ℤ} {a : α} (ha : 0 < a) (h : m < n)
Goal: m • a < n • a
-- zsmul_le_zsmul_iff
@[to_additive]
lemma zpow_le_zpow_iff (ha : 1 < a) : a ^ m ≤ a ^ n ↔ m ≤ n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {m n : ℤ} {a : α} (ha : 0 < a)
Goal: m • a ≤ n • a ↔ m ≤ n
-- zpow_le_zpow_iff
@[to_additive]
lemma zpow_le_zpow_iff (ha : 1 < a) : a ^ m ≤ a ^ n ↔ m ≤ n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {m n : ℤ} {a : α} (ha : 1 < a)
Goal: a ^ m ≤ a ^ n ↔ m ≤ n
-- zsmul_lt_zsmul_iff
@[to_additive]
lemma zpow_lt_zpow_iff (ha : 1 < a) : a ^ m < a ^ n ↔ m < n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {m n : ℤ} {a : α} (ha : 0 < a)
Goal: m • a < n • a ↔ m < n
-- zpow_lt_zpow_iff
@[to_additive]
lemma zpow_lt_zpow_iff (ha : 1 < a) : a ^ m < a ^ n ↔ m < n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {m n : ℤ} {a : α} (ha : 1 < a)
Goal: a ^ m < a ^ n ↔ m < n
-- zsmul_strictMono_right
@[to_additive zsmul_strictMono_right]
lemma zpow_strictMono_left (hn : 0 < n) : StrictMono ((· ^ n) : α → α) 
Arguments: (α : Type u_1) [OrderedAddCommGroup α] {n : ℤ} (hn : 0 < n)
Goal: StrictMono fun x => n • x
-- zpow_strictMono_left
@[to_additive zsmul_strictMono_right]
lemma zpow_strictMono_left (hn : 0 < n) : StrictMono ((· ^ n) : α → α) 
Arguments: (α : Type u_1) [OrderedCommGroup α] {n : ℤ} (hn : 0 < n)
Goal: StrictMono fun x => x ^ n
-- zpow_mono_left
@[to_additive zsmul_mono_right]
lemma zpow_mono_left (hn : 0 ≤ n) : Monotone ((· ^ n) : α → α) 
Arguments: (α : Type u_1) [OrderedCommGroup α] {n : ℤ} (hn : 0 ≤ n)
Goal: Monotone fun x => x ^ n
-- zsmul_mono_right
@[to_additive zsmul_mono_right]
lemma zpow_mono_left (hn : 0 ≤ n) : Monotone ((· ^ n) : α → α) 
Arguments: (α : Type u_1) [OrderedAddCommGroup α] {n : ℤ} (hn : 0 ≤ n)
Goal: Monotone fun x => n • x
-- zsmul_le_zsmul'
@[to_additive (attr := gcongr)]
lemma zpow_le_zpow' (hn : 0 ≤ n) (h : a ≤ b) : a ^ n ≤ b ^ n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {n : ℤ} {a b : α} (hn : 0 ≤ n) (h : a ≤ b)
Goal: n • a ≤ n • b
-- zpow_le_zpow'
@[to_additive (attr := gcongr)]
lemma zpow_le_zpow' (hn : 0 ≤ n) (h : a ≤ b) : a ^ n ≤ b ^ n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {n : ℤ} {a b : α} (hn : 0 ≤ n) (h : a ≤ b)
Goal: a ^ n ≤ b ^ n
-- zsmul_lt_zsmul'
@[to_additive (attr := gcongr)]
lemma zpow_lt_zpow' (hn : 0 < n) (h : a < b) : a ^ n < b ^ n 
Arguments: {α : Type u_1} [OrderedAddCommGroup α] {n : ℤ} {a b : α} (hn : 0 < n) (h : a < b)
Goal: n • a < n • b
-- zpow_lt_zpow'
@[to_additive (attr := gcongr)]
lemma zpow_lt_zpow' (hn : 0 < n) (h : a < b) : a ^ n < b ^ n 
Arguments: {α : Type u_1} [OrderedCommGroup α] {n : ℤ} {a b : α} (hn : 0 < n) (h : a < b)
Goal: a ^ n < b ^ n
-- zsmul_le_zsmul_iff'
@[to_additive] lemma zpow_le_zpow_iff' (hn : 0 < n) : a ^ n ≤ b ^ n ↔ a ≤ b 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {n : ℤ} {a b : α} (hn : 0 < n)
Goal: n • a ≤ n • b ↔ a ≤ b
-- zpow_le_zpow_iff'
@[to_additive] lemma zpow_le_zpow_iff' (hn : 0 < n) : a ^ n ≤ b ^ n ↔ a ≤ b 
Arguments: {α : Type u_1} [LinearOrderedCommGroup α] {n : ℤ} {a b : α} (hn : 0 < n)
Goal: a ^ n ≤ b ^ n ↔ a ≤ b
-- zpow_lt_zpow_iff'
@[to_additive] lemma zpow_lt_zpow_iff' (hn : 0 < n) : a ^ n < b ^ n ↔ a < b 
Arguments: {α : Type u_1} [LinearOrderedCommGroup α] {n : ℤ} {a b : α} (hn : 0 < n)
Goal: a ^ n < b ^ n ↔ a < b
-- zsmul_lt_zsmul_iff'
@[to_additive] lemma zpow_lt_zpow_iff' (hn : 0 < n) : a ^ n < b ^ n ↔ a < b 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {n : ℤ} {a b : α} (hn : 0 < n)
Goal: n • a < n • b ↔ a < b
-- zpow_left_injective
@[to_additive zsmul_right_injective
"See also `smul_right_injective`. TODO: provide a `NoZeroSMulDivisors` instance. We can't do
that here because importing that definition would create import cycles."]
lemma zpow_left_injective (hn : n ≠ 0) : Injective ((· ^ n) : α → α) 
Arguments: {α : Type u_1} [LinearOrderedCommGroup α] {n : ℤ} (hn : n ≠ 0)
Goal: Function.Injective fun x => x ^ n
-- zsmul_right_injective
@[to_additive zsmul_right_injective
"See also `smul_right_injective`. TODO: provide a `NoZeroSMulDivisors` instance. We can't do
that here because importing that definition would create import cycles."]
lemma zpow_left_injective (hn : n ≠ 0) : Injective ((· ^ n) : α → α) 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {n : ℤ} (hn : n ≠ 0)
Goal: Function.Injective fun x => n • x
-- zpow_left_inj
@[to_additive zsmul_right_inj]
lemma zpow_left_inj (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b 
Arguments: {α : Type u_1} [LinearOrderedCommGroup α] {n : ℤ} {a b : α} (hn : n ≠ 0)
Goal: a ^ n = b ^ n ↔ a = b
-- zsmul_right_inj
@[to_additive zsmul_right_inj]
lemma zpow_left_inj (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {n : ℤ} {a b : α} (hn : n ≠ 0)
Goal: n • a = n • b ↔ a = b
-- zpow_eq_zpow_iff'
@[to_additive "Alias of `zsmul_right_inj`, for ease of discovery alongside `zsmul_le_zsmul_iff'` and
`zsmul_lt_zsmul_iff'`."]
lemma zpow_eq_zpow_iff' (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b 
Arguments: {α : Type u_1} [LinearOrderedCommGroup α] {n : ℤ} {a b : α} (hn : n ≠ 0)
Goal: a ^ n = b ^ n ↔ a = b
-- zsmul_eq_zsmul_iff'
@[to_additive "Alias of `zsmul_right_inj`, for ease of discovery alongside `zsmul_le_zsmul_iff'` and
`zsmul_lt_zsmul_iff'`."]
lemma zpow_eq_zpow_iff' (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {n : ℤ} {a b : α} (hn : n ≠ 0)
Goal: n • a = n • b ↔ a = b
-- Int.natCast_strictMono
theorem natCast_strictMono : StrictMono (· : ℕ → ℤ) 
Goal: StrictMono fun x => ↑x
-- Int.abs_eq_natAbs
theorem abs_eq_natAbs : ∀ a : ℤ, |a| = natAbs a
  
Arguments: (a : ℤ)
Goal: |a| = ↑a.natAbs
-- Int.natCast_natAbs
@[simp, norm_cast] lemma natCast_natAbs (n : ℤ) : (n.natAbs : ℤ) = |n| 
Arguments: (n : ℤ)
Goal: ↑n.natAbs = |n|
-- Int.natAbs_abs
theorem natAbs_abs (a : ℤ) : natAbs |a| = natAbs a 
Arguments: (a : ℤ)
Goal: |a|.natAbs = a.natAbs
-- Int.sign_mul_abs
theorem sign_mul_abs (a : ℤ) : sign a * |a| = a 
Arguments: (a : ℤ)
Goal: a.sign * |a| = a
-- Int.natAbs_le_self_sq
lemma natAbs_le_self_sq (a : ℤ) : (Int.natAbs a : ℤ) ≤ a ^ 2 
Arguments: (a : ℤ)
Goal: ↑a.natAbs ≤ a ^ 2
-- Int.le_self_sq
lemma le_self_sq (b : ℤ) : b ≤ b ^ 2 
Arguments: (b : ℤ)
Goal: b ≤ b ^ 2
-- Int.abs_natCast
@[norm_cast] lemma abs_natCast (n : ℕ) : |(n : ℤ)| = n 
Arguments: (n : ℕ)
Goal: |↑n| = ↑n
-- Int.natAbs_sub_pos_iff
theorem natAbs_sub_pos_iff {i j : ℤ} : 0 < natAbs (i - j) ↔ i ≠ j 
Arguments: {i j : ℤ}
Goal: 0 < (i - j).natAbs ↔ i ≠ j
-- Int.natAbs_sub_ne_zero_iff
theorem natAbs_sub_ne_zero_iff {i j : ℤ} : natAbs (i - j) ≠ 0 ↔ i ≠ j 
Arguments: {i j : ℤ}
Goal: (i - j).natAbs ≠ 0 ↔ i ≠ j
-- Int.abs_lt_one_iff
@[simp]
theorem abs_lt_one_iff {a : ℤ} : |a| < 1 ↔ a = 0 
Arguments: {a : ℤ}
Goal: |a| < 1 ↔ a = 0
-- Int.abs_le_one_iff
theorem abs_le_one_iff {a : ℤ} : |a| ≤ 1 ↔ a = 0 ∨ a = 1 ∨ a = -1 
Arguments: {a : ℤ}
Goal: |a| ≤ 1 ↔ a = 0 ∨ a = 1 ∨ a = -1
-- Int.one_le_abs
theorem one_le_abs {z : ℤ} (h₀ : z ≠ 0) : 1 ≤ |z| 
Arguments: {z : ℤ} (h₀ : z ≠ 0)
Goal: 1 ≤ |z|
-- Int.ediv_eq_zero_of_lt_abs
theorem ediv_eq_zero_of_lt_abs {a b : ℤ} (H1 : 0 ≤ a) (H2 : a < |b|) : a / b = 0 
Arguments: {a b : ℤ} (H1 : 0 ≤ a) (H2 : a < |b|)
Goal: a / b = 0
-- Int.emod_abs
@[simp]
theorem emod_abs (a b : ℤ) : a % |b| = a % b 
Arguments: (a b : ℤ)
Goal: a % |b| = a % b
-- Int.emod_lt
theorem emod_lt (a : ℤ) {b : ℤ} (H : b ≠ 0) : a % b < |b| 
Arguments: (a : ℤ) {b : ℤ} (H : b ≠ 0)
Goal: a % b < |b|