ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddMonoidHom.withBotMap_apply
@[simps (config := .asFn)]
protected def _root_.AddMonoidHom.withBotMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
    (f : M →+ N) : WithBot M →+ WithBot N 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N)
Goal: ⇑f.withBotMap = WithBot.map ⇑f
-- WithBot.le_of_add_le_add_left
protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥)
    (h : a + b ≤ a + c) : b ≤ c 
Arguments: {α : Type u} [Add α] {a b c : WithBot α} [Preorder α] [ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (ha : a ≠ ⊥) (h : a + b ≤ a + c)
Goal: b ≤ c
-- WithBot.le_of_add_le_add_right
protected theorem le_of_add_le_add_right [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (ha : a ≠ ⊥) (h : b + a ≤ c + a) : b ≤ c 
Arguments: {α : Type u} [Add α] {a b c : WithBot α} [Preorder α] [ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (ha : a ≠ ⊥) (h : b + a ≤ c + a)
Goal: b ≤ c
-- WithBot.add_lt_add_left
protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) (h : b < c) :
    a + b < a + c 
Arguments: {α : Type u} [Add α] {a b c : WithBot α} [Preorder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (ha : a ≠ ⊥) (h : b < c)
Goal: a + b < a + c
-- WithBot.add_lt_add_right
protected theorem add_lt_add_right [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥)
    (h : b < c) : b + a < c + a 
Arguments: {α : Type u} [Add α] {a b c : WithBot α} [Preorder α] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] (ha : a ≠ ⊥) (h : b < c)
Goal: b + a < c + a
-- WithBot.add_le_add_iff_left
protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·)]
    [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥) : a + b ≤ a + c ↔ b ≤ c 
Arguments: {α : Type u} [Add α] {a b c : WithBot α} [Preorder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (ha : a ≠ ⊥)
Goal: a + b ≤ a + c ↔ b ≤ c
-- WithBot.add_le_add_iff_right
protected theorem add_le_add_iff_right [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
    [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊥) : b + a ≤ c + a ↔ b ≤ c 
Arguments: {α : Type u} [Add α] {a b c : WithBot α} [Preorder α] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (ha : a ≠ ⊥)
Goal: b + a ≤ c + a ↔ b ≤ c
-- WithBot.add_lt_add_iff_left
protected theorem add_lt_add_iff_left [CovariantClass α α (· + ·) (· < ·)]
    [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) : a + b < a + c ↔ b < c 
Arguments: {α : Type u} [Add α] {a b c : WithBot α} [Preorder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (ha : a ≠ ⊥)
Goal: a + b < a + c ↔ b < c
-- WithBot.add_lt_add_iff_right
protected theorem add_lt_add_iff_right [CovariantClass α α (swap (· + ·)) (· < ·)]
    [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥) : b + a < c + a ↔ b < c 
Arguments: {α : Type u} [Add α] {a b c : WithBot α} [Preorder α] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] [ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] (ha : a ≠ ⊥)
Goal: b + a < c + a ↔ b < c
-- WithBot.add_lt_add_of_le_of_lt
protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < ·)]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d) :
    a + c < b + d 
Arguments: {α : Type u} [Add α] {a b c d : WithBot α} [Preorder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d)
Goal: a + c < b + d
-- WithBot.add_lt_add_of_lt_of_le
protected theorem add_lt_add_of_lt_of_le [CovariantClass α α (· + ·) (· ≤ ·)]
    [CovariantClass α α (swap (· + ·)) (· < ·)] (hd : d ≠ ⊥) (hab : a < b) (hcd : c ≤ d) :
    a + c < b + d 
Arguments: {α : Type u} [Add α] {a b c d : WithBot α} [Preorder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] (hd : d ≠ ⊥) (hab : a < b) (hcd : c ≤ d)
Goal: a + c < b + d
-- tsub_div
theorem tsub_div (a b c : α) : (a - b) / c = a / c - b / c 
Arguments: {α : Type u_1} [CanonicallyLinearOrderedSemifield α] [Sub α] [OrderedSub α] (a b c : α)
Goal: (a - b) / c = a / c - b / c
-- inv_pos
@[simp] lemma inv_pos : 0 < a⁻¹ ↔ 0 < a 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α}
Goal: 0 < a⁻¹ ↔ 0 < a
-- inv_nonneg
@[simp] lemma inv_nonneg : 0 ≤ a⁻¹ ↔ 0 ≤ a 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α}
Goal: 0 ≤ a⁻¹ ↔ 0 ≤ a
-- inv_lt_zero
@[simp] lemma inv_lt_zero : a⁻¹ < 0 ↔ a < 0 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α}
Goal: a⁻¹ < 0 ↔ a < 0
-- inv_nonpos
@[simp] lemma inv_nonpos : a⁻¹ ≤ 0 ↔ a ≤ 0 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α}
Goal: a⁻¹ ≤ 0 ↔ a ≤ 0
-- one_div_pos
lemma one_div_pos : 0 < 1 / a ↔ 0 < a 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α}
Goal: 0 < 1 / a ↔ 0 < a
-- one_div_neg
lemma one_div_neg : 1 / a < 0 ↔ a < 0 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α}
Goal: 1 / a < 0 ↔ a < 0
-- one_div_nonneg
lemma one_div_nonneg : 0 ≤ 1 / a ↔ 0 ≤ a 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α}
Goal: 0 ≤ 1 / a ↔ 0 ≤ a
-- one_div_nonpos
lemma one_div_nonpos : 1 / a ≤ 0 ↔ a ≤ 0 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α}
Goal: 1 / a ≤ 0 ↔ a ≤ 0
-- div_pos
lemma div_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a / b 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a b : α} [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b)
Goal: 0 < a / b
-- div_nonneg
lemma div_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a / b 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a b : α} [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b)
Goal: 0 ≤ a / b
-- div_nonpos_of_nonpos_of_nonneg
lemma div_nonpos_of_nonpos_of_nonneg [MulPosMono α] (ha : a ≤ 0) (hb : 0 ≤ b) : a / b ≤ 0 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a b : α} [MulPosMono α] (ha : a ≤ 0) (hb : 0 ≤ b)
Goal: a / b ≤ 0
-- div_nonpos_of_nonneg_of_nonpos
lemma div_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0) : a / b ≤ 0 
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a b : α} [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0)
Goal: a / b ≤ 0
-- zpow_nonneg
lemma zpow_nonneg [PosMulMono α] (ha : 0 ≤ a) : ∀ n : ℤ, 0 ≤ a ^ n
  
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α} [PosMulMono α] (ha : 0 ≤ a) (n : ℤ)
Goal: 0 ≤ a ^ n
-- zpow_pos_of_pos
lemma zpow_pos_of_pos [PosMulStrictMono α] (ha : 0 < a) : ∀ n : ℤ, 0 < a ^ n
  
Arguments: {α : Type u_1} [Semifield α] [LinearOrder α] [PosMulReflectLT α] [ZeroLEOneClass α] {a : α} [PosMulStrictMono α] (ha : 0 < a) (n : ℤ)
Goal: 0 < a ^ n
-- Pi.exists_forall_pos_add_lt
theorem Pi.exists_forall_pos_add_lt [ExistsAddOfLE α] [Finite ι] {x y : ι → α}
    (h : ∀ i, x i < y i) : ∃ ε, 0 < ε ∧ ∀ i, x i + ε < y i 
Arguments: {α : Type u_1} {ι : Type u_2} [LinearOrderedCancelAddCommMonoid α] [Nontrivial α] [DenselyOrdered α] [ExistsAddOfLE α] [Finite ι] {x y : ι → α} (h : ∀ (i : ι), x i < y i)
Goal: ∃ ε, 0 < ε ∧ ∀ (i : ι), x i + ε < y i
-- Positive.coe_inv
@[simp]
theorem coe_inv (x : { x : K // 0 < x }) : ↑x⁻¹ = (x⁻¹ : K) 
Arguments: {K : Type u_1} [LinearOrderedField K] (x : { x // 0 < x })
Goal: ↑x⁻¹ = (↑x)⁻¹
-- Positive.coe_zpow
@[simp]
theorem coe_zpow (x : { x : K // 0 < x }) (n : ℤ) : ↑(x ^ n) = (x : K) ^ n 
Arguments: {K : Type u_1} [LinearOrderedField K] (x : { x // 0 < x }) (n : ℤ)
Goal: ↑(x ^ n) = ↑x ^ n
-- IsOrderedVAdd.vadd_le_vadd_right
class IsOrderedVAdd (G P : Type*) [LE G] [LE P] [VAdd G P] : Prop where
  protected vadd_le_vadd_left : ∀ a b : P, a ≤ b → ∀ c : G, c +ᵥ a ≤ c +ᵥ b
  protected vadd_le_vadd_right : ∀ c d : G, c ≤ d → ∀ a : P, c +ᵥ a ≤ d +ᵥ a
Arguments: {G : Type u_3} {P : Type u_4} [LE G] [LE P] [VAdd G P] [self : IsOrderedVAdd G P] (c d : G)
Goal: c ≤ d → ∀ (a : P), c +ᵥ a ≤ d +ᵥ a
-- IsOrderedVAdd.vadd_le_vadd_left
class IsOrderedVAdd (G P : Type*) [LE G] [LE P] [VAdd G P] : Prop where
  protected vadd_le_vadd_left : ∀ a b : P, a ≤ b → ∀ c : G, c +ᵥ a ≤ c +ᵥ b
  protected vadd_le_vadd_right : ∀ c d : G, c ≤ d → ∀ a : P, c +ᵥ a ≤ d +ᵥ a
Arguments: {G : Type u_3} {P : Type u_4} [LE G] [LE P] [VAdd G P] [self : IsOrderedVAdd G P] (a b : P)
Goal: a ≤ b → ∀ (c : G), c +ᵥ a ≤ c +ᵥ b
-- IsOrderedSMul.smul_le_smul_left
@[to_additive]
class IsOrderedSMul (G P : Type*) [LE G] [LE P] [SMul G P] : Prop where
  protected smul_le_smul_left : ∀ a b : P, a ≤ b → ∀ c : G, c • a ≤ c • b
  protected smul_le_smul_right : ∀ c d : G, c ≤ d → ∀ a : P, c • a ≤ d • a
Arguments: {G : Type u_3} {P : Type u_4} [LE G] [LE P] [SMul G P] [self : IsOrderedSMul G P] (a b : P)
Goal: a ≤ b → ∀ (c : G), c • a ≤ c • b
-- IsOrderedSMul.smul_le_smul_right
@[to_additive]
class IsOrderedSMul (G P : Type*) [LE G] [LE P] [SMul G P] : Prop where
  protected smul_le_smul_left : ∀ a b : P, a ≤ b → ∀ c : G, c • a ≤ c • b
  protected smul_le_smul_right : ∀ c d : G, c ≤ d → ∀ a : P, c • a ≤ d • a
Arguments: {G : Type u_3} {P : Type u_4} [LE G] [LE P] [SMul G P] [self : IsOrderedSMul G P] (c d : G)
Goal: c ≤ d → ∀ (a : P), c • a ≤ d • a
-- IsOrderedVAdd.vadd_le_vadd
@[to_additive]
theorem IsOrderedSMul.smul_le_smul [Preorder G] [Preorder P] [SMul G P] [IsOrderedSMul G P]
    {a b : G} {c d : P} (hab : a ≤ b) (hcd : c ≤ d) : a • c ≤ b • d 
Arguments: {G : Type u_1} {P : Type u_2} [Preorder G] [Preorder P] [VAdd G P] [IsOrderedVAdd G P] {a b : G} {c d : P} (hab : a ≤ b) (hcd : c ≤ d)
Goal: a +ᵥ c ≤ b +ᵥ d
-- IsOrderedSMul.smul_le_smul
@[to_additive]
theorem IsOrderedSMul.smul_le_smul [Preorder G] [Preorder P] [SMul G P] [IsOrderedSMul G P]
    {a b : G} {c d : P} (hab : a ≤ b) (hcd : c ≤ d) : a • c ≤ b • d 
Arguments: {G : Type u_1} {P : Type u_2} [Preorder G] [Preorder P] [SMul G P] [IsOrderedSMul G P] {a b : G} {c d : P} (hab : a ≤ b) (hcd : c ≤ d)
Goal: a • c ≤ b • d
-- Monotone.vadd
@[to_additive]
theorem Monotone.smul {γ : Type*} [Preorder G] [Preorder P] [Preorder γ] [SMul G P]
    [IsOrderedSMul G P] {f : γ → G} {g : γ → P} (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x • g x 
Arguments: {G : Type u_1} {P : Type u_2} {γ : Type u_3} [Preorder G] [Preorder P] [Preorder γ] [VAdd G P] [IsOrderedVAdd G P] {f : γ → G} {g : γ → P} (hf : Monotone f) (hg : Monotone g)
Goal: Monotone fun x => f x +ᵥ g x
-- Monotone.smul
@[to_additive]
theorem Monotone.smul {γ : Type*} [Preorder G] [Preorder P] [Preorder γ] [SMul G P]
    [IsOrderedSMul G P] {f : γ → G} {g : γ → P} (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x • g x 
Arguments: {G : Type u_1} {P : Type u_2} {γ : Type u_3} [Preorder G] [Preorder P] [Preorder γ] [SMul G P] [IsOrderedSMul G P] {f : γ → G} {g : γ → P} (hf : Monotone f) (hg : Monotone g)
Goal: Monotone fun x => f x • g x
-- IsCancelVAdd.left_cancel
class IsCancelVAdd (G P : Type*) [VAdd G P] : Prop where
  protected left_cancel : ∀ (a : G) (b c : P), a +ᵥ b = a +ᵥ c → b = c
  protected right_cancel : ∀ (a b : G) (c : P), a +ᵥ c = b +ᵥ c → a = b
Arguments: {G : Type u_3} {P : Type u_4} [VAdd G P] [self : IsCancelVAdd G P] (a : G) (b c : P)
Goal: a +ᵥ b = a +ᵥ c → b = c
-- IsCancelVAdd.right_cancel
class IsCancelVAdd (G P : Type*) [VAdd G P] : Prop where
  protected left_cancel : ∀ (a : G) (b c : P), a +ᵥ b = a +ᵥ c → b = c
  protected right_cancel : ∀ (a b : G) (c : P), a +ᵥ c = b +ᵥ c → a = b
Arguments: {G : Type u_3} {P : Type u_4} [VAdd G P] [self : IsCancelVAdd G P] (a b : G) (c : P)
Goal: a +ᵥ c = b +ᵥ c → a = b
-- IsCancelSMul.left_cancel
@[to_additive]
class IsCancelSMul (G P : Type*) [SMul G P] : Prop where
  protected left_cancel : ∀ (a : G) (b c : P), a • b = a • c → b = c
  protected right_cancel : ∀ (a b : G) (c : P), a • c = b • c → a = b
Arguments: {G : Type u_3} {P : Type u_4} [SMul G P] [self : IsCancelSMul G P] (a : G) (b c : P)
Goal: a • b = a • c → b = c
-- IsCancelSMul.right_cancel
@[to_additive]
class IsCancelSMul (G P : Type*) [SMul G P] : Prop where
  protected left_cancel : ∀ (a : G) (b c : P), a • b = a • c → b = c
  protected right_cancel : ∀ (a b : G) (c : P), a • c = b • c → a = b
Arguments: {G : Type u_3} {P : Type u_4} [SMul G P] [self : IsCancelSMul G P] (a b : G) (c : P)
Goal: a • c = b • c → a = b
-- IsOrderedCancelVAdd.le_of_vadd_le_vadd_right
class IsOrderedCancelVAdd (G P : Type*) [LE G] [LE P] [VAdd G P] extends
    IsOrderedVAdd G P : Prop where
  protected le_of_vadd_le_vadd_left : ∀ (a : G) (b c : P), a +ᵥ b ≤ a +ᵥ c → b ≤ c
  protected le_of_vadd_le_vadd_right : ∀ (a b : G) (c : P), a +ᵥ c ≤ b +ᵥ c → a ≤ b
Arguments: {G : Type u_3} {P : Type u_4} [LE G] [LE P] [VAdd G P] [self : IsOrderedCancelVAdd G P] (a b : G) (c : P)
Goal: a +ᵥ c ≤ b +ᵥ c → a ≤ b
-- IsOrderedCancelVAdd.le_of_vadd_le_vadd_left
class IsOrderedCancelVAdd (G P : Type*) [LE G] [LE P] [VAdd G P] extends
    IsOrderedVAdd G P : Prop where
  protected le_of_vadd_le_vadd_left : ∀ (a : G) (b c : P), a +ᵥ b ≤ a +ᵥ c → b ≤ c
  protected le_of_vadd_le_vadd_right : ∀ (a b : G) (c : P), a +ᵥ c ≤ b +ᵥ c → a ≤ b
Arguments: {G : Type u_3} {P : Type u_4} [LE G] [LE P] [VAdd G P] [self : IsOrderedCancelVAdd G P] (a : G) (b c : P)
Goal: a +ᵥ b ≤ a +ᵥ c → b ≤ c
-- IsOrderedCancelSMul.le_of_smul_le_smul_right
@[to_additive]
class IsOrderedCancelSMul (G P : Type*) [LE G] [LE P] [SMul G P] extends
    IsOrderedSMul G P : Prop where
  protected le_of_smul_le_smul_left : ∀ (a : G) (b c : P), a • b ≤ a • c → b ≤ c
  protected le_of_smul_le_smul_right : ∀ (a b : G) (c : P), a • c ≤ b • c → a ≤ b
Arguments: {G : Type u_3} {P : Type u_4} [LE G] [LE P] [SMul G P] [self : IsOrderedCancelSMul G P] (a b : G) (c : P)
Goal: a • c ≤ b • c → a ≤ b
-- IsOrderedCancelSMul.le_of_smul_le_smul_left
@[to_additive]
class IsOrderedCancelSMul (G P : Type*) [LE G] [LE P] [SMul G P] extends
    IsOrderedSMul G P : Prop where
  protected le_of_smul_le_smul_left : ∀ (a : G) (b c : P), a • b ≤ a • c → b ≤ c
  protected le_of_smul_le_smul_right : ∀ (a b : G) (c : P), a • c ≤ b • c → a ≤ b
Arguments: {G : Type u_3} {P : Type u_4} [LE G] [LE P] [SMul G P] [self : IsOrderedCancelSMul G P] (a : G) (b c : P)
Goal: a • b ≤ a • c → b ≤ c
-- VAdd.vadd_lt_vadd_of_le_of_lt
@[to_additive]
theorem smul_lt_smul_of_le_of_lt [LE G] [Preorder P] [SMul G P] [IsOrderedCancelSMul G P]
    {a b : G} {c d : P} (h₁ : a ≤ b) (h₂ : c < d) :
  a • c < b • d 
Arguments: {G : Type u_1} {P : Type u_2} [LE G] [Preorder P] [VAdd G P] [IsOrderedCancelVAdd G P] {a b : G} {c d : P} (h₁ : a ≤ b) (h₂ : c < d)
Goal: a +ᵥ c < b +ᵥ d
-- SMul.smul_lt_smul_of_le_of_lt
@[to_additive]
theorem smul_lt_smul_of_le_of_lt [LE G] [Preorder P] [SMul G P] [IsOrderedCancelSMul G P]
    {a b : G} {c d : P} (h₁ : a ≤ b) (h₂ : c < d) :
  a • c < b • d 
Arguments: {G : Type u_1} {P : Type u_2} [LE G] [Preorder P] [SMul G P] [IsOrderedCancelSMul G P] {a b : G} {c d : P} (h₁ : a ≤ b) (h₂ : c < d)
Goal: a • c < b • d
-- SMul.smul_lt_smul_of_lt_of_le
@[to_additive]
theorem smul_lt_smul_of_lt_of_le [Preorder G] [Preorder P] [SMul G P] [IsOrderedCancelSMul G P]
    {a b : G} {c d : P} (h₁ : a < b) (h₂ : c ≤ d) : a • c < b • d 
Arguments: {G : Type u_1} {P : Type u_2} [Preorder G] [Preorder P] [SMul G P] [IsOrderedCancelSMul G P] {a b : G} {c d : P} (h₁ : a < b) (h₂ : c ≤ d)
Goal: a • c < b • d
-- VAdd.vadd_lt_vadd_of_lt_of_le
@[to_additive]
theorem smul_lt_smul_of_lt_of_le [Preorder G] [Preorder P] [SMul G P] [IsOrderedCancelSMul G P]
    {a b : G} {c d : P} (h₁ : a < b) (h₂ : c ≤ d) : a • c < b • d 
Arguments: {G : Type u_1} {P : Type u_2} [Preorder G] [Preorder P] [VAdd G P] [IsOrderedCancelVAdd G P] {a b : G} {c d : P} (h₁ : a < b) (h₂ : c ≤ d)
Goal: a +ᵥ c < b +ᵥ d
-- AbsoluteValue.IsEuclidean.map_lt_map_iff'
structure IsEuclidean : Prop where
    map_lt_map_iff' : ∀ {x y}, abv x < abv y ↔ x ≺ y
Arguments: {R : Type u_1} {S : Type u_2} [EuclideanDomain R] [OrderedSemiring S] {abv : AbsoluteValue R S} (self : abv.IsEuclidean) {x y : R}
Goal: abv x < abv y ↔ x ≺ y
-- AbsoluteValue.IsEuclidean.map_lt_map_iff
theorem map_lt_map_iff {x y : R} (h : abv.IsEuclidean) : abv x < abv y ↔ x ≺ y 
Arguments: {R : Type u_1} {S : Type u_2} [EuclideanDomain R] [OrderedSemiring S] {abv : AbsoluteValue R S} {x y : R} (h : abv.IsEuclidean)
Goal: abv x < abv y ↔ x ≺ y
-- AbsoluteValue.IsEuclidean.sub_mod_lt
theorem sub_mod_lt (h : abv.IsEuclidean) (a : R) {b : R} (hb : b ≠ 0) : abv (a % b) < abv b 
Arguments: {R : Type u_1} {S : Type u_2} [EuclideanDomain R] [OrderedSemiring S] {abv : AbsoluteValue R S} (h : abv.IsEuclidean) (a : R) {b : R} (hb : b ≠ 0)
Goal: abv (a % b) < abv b
-- AbsoluteValue.abs_isEuclidean
protected theorem abs_isEuclidean : IsEuclidean (AbsoluteValue.abs : AbsoluteValue ℤ ℤ) 
Goal: AbsoluteValue.abs.IsEuclidean
-- AbsoluteValue.eq_zero'
structure AbsoluteValue (R S : Type*) [Semiring R] [OrderedSemiring S] extends R →ₙ* S where
    nonneg' : ∀ x, 0 ≤ toFun x
    eq_zero' : ∀ x, toFun x = 0 ↔ x = 0
    add_le' : ∀ x y, toFun (x + y) ≤ toFun x + toFun y
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (self : AbsoluteValue R S) (x : R)
Goal: self.toFun x = 0 ↔ x = 0
-- AbsoluteValue.add_le'
structure AbsoluteValue (R S : Type*) [Semiring R] [OrderedSemiring S] extends R →ₙ* S where
    nonneg' : ∀ x, 0 ≤ toFun x
    eq_zero' : ∀ x, toFun x = 0 ↔ x = 0
    add_le' : ∀ x y, toFun (x + y) ≤ toFun x + toFun y
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (self : AbsoluteValue R S) (x y : R)
Goal: self.toFun (x + y) ≤ self.toFun x + self.toFun y
-- AbsoluteValue.nonneg'
structure AbsoluteValue (R S : Type*) [Semiring R] [OrderedSemiring S] extends R →ₙ* S where
    nonneg' : ∀ x, 0 ≤ toFun x
    eq_zero' : ∀ x, toFun x = 0 ↔ x = 0
    add_le' : ∀ x y, toFun (x + y) ≤ toFun x + toFun y
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (self : AbsoluteValue R S) (x : R)
Goal: 0 ≤ self.toFun x
-- AbsoluteValue.coe_mk
@[simp]
theorem coe_mk (f : R →ₙ* S) {h₁ h₂ h₃} : (AbsoluteValue.mk f h₁ h₂ h₃ : R → S) = f 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (f : R →ₙ* S) {h₁ : ∀ (x : R), 0 ≤ f.toFun x} {h₂ : ∀ (x : R), f.toFun x = 0 ↔ x = 0} {h₃ : ∀ (x y : R), f.toFun (x + y) ≤ f.toFun x + f.toFun y}
Goal: ⇑{ toMulHom := f, nonneg' := h₁, eq_zero' := h₂, add_le' := h₃ } = ⇑f
-- AbsoluteValue.ext
@[ext]
theorem ext ⦃f g : AbsoluteValue R S⦄ : (∀ x, f x = g x) → f = g 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] ⦃f g : AbsoluteValue R S⦄
Goal: (∀ (x : R), f x = g x) → f = g
-- AbsoluteValue.coe_toMulHom
@[simp]
theorem coe_toMulHom : ⇑abv.toMulHom = abv 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S)
Goal: ⇑abv.toMulHom = ⇑abv
-- AbsoluteValue.nonneg
protected theorem nonneg (x : R) : 0 ≤ abv x 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) (x : R)
Goal: 0 ≤ abv x
-- AbsoluteValue.eq_zero
@[simp]
protected theorem eq_zero {x : R} : abv x = 0 ↔ x = 0 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) {x : R}
Goal: abv x = 0 ↔ x = 0
-- AbsoluteValue.add_le
protected theorem add_le (x y : R) : abv (x + y) ≤ abv x + abv y 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) (x y : R)
Goal: abv (x + y) ≤ abv x + abv y
-- AbsoluteValue.map_mul
protected theorem map_mul (x y : R) : abv (x * y) = abv x * abv y 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) (x y : R)
Goal: abv (x * y) = abv x * abv y
-- AbsoluteValue.ne_zero_iff
protected theorem ne_zero_iff {x : R} : abv x ≠ 0 ↔ x ≠ 0 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) {x : R}
Goal: abv x ≠ 0 ↔ x ≠ 0
-- AbsoluteValue.pos
protected theorem pos {x : R} (hx : x ≠ 0) : 0 < abv x 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) {x : R} (hx : x ≠ 0)
Goal: 0 < abv x
-- AbsoluteValue.pos_iff
@[simp]
protected theorem pos_iff {x : R} : 0 < abv x ↔ x ≠ 0 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) {x : R}
Goal: 0 < abv x ↔ x ≠ 0
-- AbsoluteValue.ne_zero
protected theorem ne_zero {x : R} (hx : x ≠ 0) : abv x ≠ 0 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) {x : R} (hx : x ≠ 0)
Goal: abv x ≠ 0
-- AbsoluteValue.map_one_of_isLeftRegular
theorem map_one_of_isLeftRegular (h : IsLeftRegular (abv 1)) : abv 1 = 1 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S) (h : IsLeftRegular (abv 1))
Goal: abv 1 = 1
-- AbsoluteValue.map_zero
protected theorem map_zero : abv 0 = 0 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedSemiring S] (abv : AbsoluteValue R S)
Goal: abv 0 = 0
-- AbsoluteValue.sub_le
protected theorem sub_le (a b c : R) : abv (a - c) ≤ abv (a - b) + abv (b - c) 
Arguments: {R : Type u_5} {S : Type u_6} [Ring R] [OrderedSemiring S] (abv : AbsoluteValue R S) (a b c : R)
Goal: abv (a - c) ≤ abv (a - b) + abv (b - c)
-- AbsoluteValue.map_sub_eq_zero_iff
@[simp high] -- Porting note: added `high` to apply it before `AbsoluteValue.eq_zero`
theorem map_sub_eq_zero_iff (a b : R) : abv (a - b) = 0 ↔ a = b 
Arguments: {R : Type u_5} {S : Type u_6} [Ring R] [OrderedSemiring S] (abv : AbsoluteValue R S) (a b : R)
Goal: abv (a - b) = 0 ↔ a = b
-- AbsoluteValue.map_one
protected theorem map_one : abv 1 = 1 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedRing S] (abv : AbsoluteValue R S) [IsDomain S] [Nontrivial R]
Goal: abv 1 = 1
-- AbsoluteValue.coe_toMonoidWithZeroHom
@[simp]
theorem coe_toMonoidWithZeroHom : ⇑abv.toMonoidWithZeroHom = abv 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedRing S] (abv : AbsoluteValue R S) [IsDomain S] [Nontrivial R]
Goal: ⇑abv.toMonoidWithZeroHom = ⇑abv
-- AbsoluteValue.coe_toMonoidHom
@[simp]
theorem coe_toMonoidHom : ⇑abv.toMonoidHom = abv 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedRing S] (abv : AbsoluteValue R S) [IsDomain S] [Nontrivial R]
Goal: ⇑abv.toMonoidHom = ⇑abv
-- AbsoluteValue.map_pow
protected theorem map_pow (a : R) (n : ℕ) : abv (a ^ n) = abv a ^ n 
Arguments: {R : Type u_5} {S : Type u_6} [Semiring R] [OrderedRing S] (abv : AbsoluteValue R S) [IsDomain S] [Nontrivial R] (a : R) (n : ℕ)
Goal: abv (a ^ n) = abv a ^ n
-- AbsoluteValue.le_sub
protected theorem le_sub (a b : R) : abv a - abv b ≤ abv (a - b) 
Arguments: {R : Type u_5} {S : Type u_6} [Ring R] [OrderedRing S] (abv : AbsoluteValue R S) (a b : R)
Goal: abv a - abv b ≤ abv (a - b)
-- AbsoluteValue.map_neg
@[simp]
protected theorem map_neg (a : R) : abv (-a) = abv a 
Arguments: {R : Type u_3} {S : Type u_4} [OrderedCommRing S] [Ring R] (abv : AbsoluteValue R S) [NoZeroDivisors S] (a : R)
Goal: abv (-a) = abv a
-- AbsoluteValue.map_sub
protected theorem map_sub (a b : R) : abv (a - b) = abv (b - a) 
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 (b - a)
-- AbsoluteValue.le_add
protected theorem le_add (a b : R) : abv a - abv b ≤ abv (a + 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 - abv b ≤ abv (a + b)