ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Order/Positive/Field.lean

full_name: Positive.Subtype.inv
code: instance Subtype.inv : Inv { x : K // 0 < x } 
goal: Inv { x // 0 < x }

full_name: Positive.coe_inv
code: @[simp]
theorem coe_inv (x : { x : K // 0 < x }) : ↑x⁻¹ = (x⁻¹ : K) 
goal: ↑x⁻¹ = (↑x)⁻¹

full_name: Positive.instPowSubtypeLtOfNatInt_mathlib
code: instance : Pow { x : K // 0 < x } ℤ 
goal: Pow { x // 0 < x } ℤ

full_name: Positive.coe_zpow
code: @[simp]
theorem coe_zpow (x : { x : K // 0 < x }) (n : ℤ) : ↑(x ^ n) = (x : K) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: Positive.instLinearOrderedCommGroupSubtypeLtOfNat
code: instance : LinearOrderedCommGroup { x : K // 0 < x } 
goal: LinearOrderedCommGroup { x // 0 < x }
File: Mathlib/Algebra/Order/EuclideanAbsoluteValue.lean

full_name: «_aux_Mathlib_Algebra_Order_EuclideanAbsoluteValue___macroRules_term_≺__1»
code: @[inherit_doc]
local infixl:50 " ≺ " => EuclideanDomain.r
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Order_EuclideanAbsoluteValue___unexpand_EuclideanDomain_r_1
code: @[inherit_doc]
local infixl:50 " ≺ " => EuclideanDomain.r
goal: Lean.PrettyPrinter.Unexpander

full_name: AbsoluteValue.IsEuclidean.map_lt_map_iff'
code: /-- An absolute value `abv : R → S` is Euclidean if it is compatible with the
`EuclideanDomain` structure on `R`, namely `abv` is strictly monotone with respect to the well
founded relation `≺` on `R`. -/
structure IsEuclidean : Prop where
  /-- The requirement of a Euclidean absolute value
  that `abv` is monotone with respect to `≺` -/
  map_lt_map_iff' : ∀ {x y}, abv x < abv y ↔ x ≺ y
goal: abv x < abv y ↔ x ≺ y

full_name: AbsoluteValue.IsEuclidean
code: /-- An absolute value `abv : R → S` is Euclidean if it is compatible with the
`EuclideanDomain` structure on `R`, namely `abv` is strictly monotone with respect to the well
founded relation `≺` on `R`. -/
structure IsEuclidean : Prop where
  /-- The requirement of a Euclidean absolute value
  that `abv` is monotone with respect to `≺` -/
  map_lt_map_iff' : ∀ {x y}, abv x < abv y ↔ x ≺ y
goal: Prop

full_name: AbsoluteValue.IsEuclidean.map_lt_map_iff
code: theorem map_lt_map_iff {x y : R} (h : abv.IsEuclidean) : abv x < abv y ↔ x ≺ y 
goal: abv x < abv y ↔ x ≺ y

full_name: AbsoluteValue.IsEuclidean.sub_mod_lt
code: theorem sub_mod_lt (h : abv.IsEuclidean) (a : R) {b : R} (hb : b ≠ 0) : abv (a % b) < abv b 
goal: abv (a % b) < abv b

full_name: AbsoluteValue.abs_isEuclidean
code: /-- `abs : ℤ → ℤ` is a Euclidean absolute value -/
protected theorem abs_isEuclidean : IsEuclidean (AbsoluteValue.abs : AbsoluteValue ℤ ℤ) 
goal: AbsoluteValue.abs.IsEuclidean
File: Mathlib/Algebra/Order/Group/Action.lean

full_name: smul_mono_right
code: theorem smul_mono_right [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LE.le]
    (m : M) : Monotone (HSMul.hSMul m : α → α) 
goal: Monotone (HSMul.hSMul m)

full_name: smul_le_smul_left
code: /-- A copy of `smul_mono_right` that is understood by `gcongr`. -/
@[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 
goal: m • a ≤ m • b

full_name: smul_inf_le
code: theorem smul_inf_le [SMul M α] [SemilatticeInf α] [CovariantClass M α HSMul.hSMul LE.le]
    (m : M) (a₁ a₂ : α) : m • (a₁ ⊓ a₂) ≤ m • a₁ ⊓ m • a₂ 
goal: m • (a₁ ⊓ a₂) ≤ m • a₁ ⊓ m • a₂

full_name: smul_iInf_le
code: theorem smul_iInf_le [SMul M α] [CompleteLattice α] [CovariantClass M α HSMul.hSMul LE.le]
    {m : M} {t : ι → α} :
    m • iInf t ≤ ⨅ i, m • t i 
goal: m • iInf t ≤ ⨅ i, m • t i

full_name: smul_strictMono_right
code: theorem smul_strictMono_right [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LT.lt]
    (m : M) : StrictMono (HSMul.hSMul m : α → α) 
goal: StrictMono (HSMul.hSMul m)
File: Mathlib/Algebra/Order/Group/Instances.lean

full_name: OrderDual.orderedCommGroup
code: @[to_additive]
instance OrderDual.orderedCommGroup [OrderedCommGroup α] : OrderedCommGroup αᵒᵈ 
goal: OrderedCommGroup αᵒᵈ

full_name: OrderDual.orderedAddCommGroup
code: @[to_additive]
instance OrderDual.orderedCommGroup [OrderedCommGroup α] : OrderedCommGroup αᵒᵈ 
goal: OrderedAddCommGroup αᵒᵈ

full_name: OrderDual.linearOrderedCommGroup
code: @[to_additive]
instance OrderDual.linearOrderedCommGroup [LinearOrderedCommGroup α] : LinearOrderedCommGroup αᵒᵈ 
goal: LinearOrderedCommGroup αᵒᵈ

full_name: OrderDual.linearOrderedAddCommGroup
code: @[to_additive]
instance OrderDual.linearOrderedCommGroup [LinearOrderedCommGroup α] : LinearOrderedCommGroup αᵒᵈ 
goal: LinearOrderedAddCommGroup αᵒᵈ
File: Mathlib/Algebra/Order/Field/Defs.lean

full_name: LinearOrderedSemifield
code: /-- A linear ordered semifield is a field with a linear order respecting the operations. -/
class LinearOrderedSemifield (α : Type*) extends LinearOrderedCommSemiring α, Semifield α
goal: Type u_2

full_name: LinearOrderedField
code: /-- A linear ordered field is a field with a linear order respecting the operations. -/
class LinearOrderedField (α : Type*) extends LinearOrderedCommRing α, Field α
goal: Type u_2

full_name: LinearOrderedField.toLinearOrderedSemifield
code: instance (priority := 100) LinearOrderedField.toLinearOrderedSemifield [LinearOrderedField α] :
    LinearOrderedSemifield α 
goal: LinearOrderedSemifield α
File: Mathlib/Algebra/Order/Group/Int.lean

full_name: Int.natCast_strictMono
code: theorem natCast_strictMono : StrictMono (· : ℕ → ℤ) 
goal: StrictMono fun x => ↑x

full_name: Int.linearOrderedAddCommGroup
code: instance linearOrderedAddCommGroup : LinearOrderedAddCommGroup ℤ 
goal: LinearOrderedAddCommGroup ℤ

full_name: Int.abs_eq_natAbs
code: theorem abs_eq_natAbs : ∀ a : ℤ, |a| = natAbs a
  
goal: |a| = ↑a.natAbs

full_name: Int.natCast_natAbs
code: @[simp, norm_cast] lemma natCast_natAbs (n : ℤ) : (n.natAbs : ℤ) = |n| 
goal: ↑n.natAbs = |n|

full_name: Int.natAbs_abs
code: theorem natAbs_abs (a : ℤ) : natAbs |a| = natAbs a 
goal: |a|.natAbs = a.natAbs

full_name: Int.sign_mul_abs
code: theorem sign_mul_abs (a : ℤ) : sign a * |a| = a 
goal: a.sign * |a| = a

full_name: Int.natAbs_le_self_sq
code: lemma natAbs_le_self_sq (a : ℤ) : (Int.natAbs a : ℤ) ≤ a ^ 2 
goal: ↑a.natAbs ≤ a ^ 2

full_name: Int.le_self_sq
code: lemma le_self_sq (b : ℤ) : b ≤ b ^ 2 
goal: b ≤ b ^ 2

full_name: Int.abs_natCast
code: @[norm_cast] lemma abs_natCast (n : ℕ) : |(n : ℤ)| = n 
goal: |↑n| = ↑n

full_name: Int.natAbs_sub_pos_iff
code: theorem natAbs_sub_pos_iff {i j : ℤ} : 0 < natAbs (i - j) ↔ i ≠ j 
goal: 0 < (i - j).natAbs ↔ i ≠ j

full_name: Int.natAbs_sub_ne_zero_iff
code: theorem natAbs_sub_ne_zero_iff {i j : ℤ} : natAbs (i - j) ≠ 0 ↔ i ≠ j 
goal: (i - j).natAbs ≠ 0 ↔ i ≠ j

full_name: Int.abs_lt_one_iff
code: @[simp]
theorem abs_lt_one_iff {a : ℤ} : |a| < 1 ↔ a = 0 
goal: |a| < 1 ↔ a = 0

full_name: Int.abs_le_one_iff
code: theorem abs_le_one_iff {a : ℤ} : |a| ≤ 1 ↔ a = 0 ∨ a = 1 ∨ a = -1 
goal: |a| ≤ 1 ↔ a = 0 ∨ a = 1 ∨ a = -1

full_name: Int.one_le_abs
code: theorem one_le_abs {z : ℤ} (h₀ : z ≠ 0) : 1 ≤ |z| 
goal: 1 ≤ |z|

full_name: Int.ediv_eq_zero_of_lt_abs
code: theorem ediv_eq_zero_of_lt_abs {a b : ℤ} (H1 : 0 ≤ a) (H2 : a < |b|) : a / b = 0 
goal: a / b = 0

full_name: Int.emod_abs
code: @[simp]
theorem emod_abs (a b : ℤ) : a % |b| = a % b 
goal: a % |b| = a % b

full_name: Int.emod_lt
code: theorem emod_lt (a : ℤ) {b : ℤ} (H : b ≠ 0) : a % b < |b| 
goal: a % b < |b|

full_name: Int.abs_ediv_le_abs
code: theorem abs_ediv_le_abs : ∀ a b : ℤ, |a / b| ≤ |a| 
goal: |a / b| ≤ |a|

full_name: Int.abs_sign_of_nonzero
code: theorem abs_sign_of_nonzero {z : ℤ} (hz : z ≠ 0) : |z.sign| = 1 
goal: |z.sign| = 1

full_name: Int.sign_eq_ediv_abs
code: protected theorem sign_eq_ediv_abs (a : ℤ) : sign a = a / |a| 
goal: a.sign = a / |a|

full_name: abs_zsmul_eq_zero
code: @[to_additive (attr := simp) abs_zsmul_eq_zero]
lemma zpow_abs_eq_one (a : G) (n : ℤ) : a ^ |n| = 1 ↔ a ^ n = 1 
goal: |n| • a = 0 ↔ n • a = 0

full_name: zpow_abs_eq_one
code: @[to_additive (attr := simp) abs_zsmul_eq_zero]
lemma zpow_abs_eq_one (a : G) (n : ℤ) : a ^ |n| = 1 ↔ a ^ n = 1 
goal: a ^ |n| = 1 ↔ a ^ n = 1
File: Mathlib/Algebra/Order/Group/Units.lean

full_name: Units.orderedCommGroup
code: /-- The units of an ordered commutative monoid form an ordered commutative group. -/
@[to_additive
      "The units of an ordered commutative additive monoid form an ordered commutative
      additive group."]
instance Units.orderedCommGroup [OrderedCommMonoid α] : OrderedCommGroup αˣ 
goal: OrderedCommGroup αˣ

full_name: AddUnits.orderedAddCommGroup
code: /-- The units of an ordered commutative monoid form an ordered commutative group. -/
@[to_additive
      "The units of an ordered commutative additive monoid form an ordered commutative
      additive group."]
instance Units.orderedCommGroup [OrderedCommMonoid α] : OrderedCommGroup αˣ 
goal: OrderedAddCommGroup (AddUnits α)
File: Mathlib/Algebra/Order/Group/DenselyOrdered.lean

full_name: le_of_forall_neg_add_le
code: @[to_additive]
theorem le_of_forall_lt_one_mul_le (h : ∀ ε < 1, a * ε ≤ b) : a ≤ b 
goal: a ≤ b

full_name: le_of_forall_lt_one_mul_le
code: @[to_additive]
theorem le_of_forall_lt_one_mul_le (h : ∀ ε < 1, a * ε ≤ b) : a ≤ b 
goal: a ≤ b

full_name: le_of_forall_pos_sub_le
code: @[to_additive]
theorem le_of_forall_one_lt_div_le (h : ∀ ε : α, 1 < ε → a / ε ≤ b) : a ≤ b 
goal: a ≤ b

full_name: le_of_forall_one_lt_div_le
code: @[to_additive]
theorem le_of_forall_one_lt_div_le (h : ∀ ε : α, 1 < ε → a / ε ≤ b) : a ≤ b 
goal: a ≤ b

full_name: le_iff_forall_one_lt_le_mul
code: @[to_additive]
theorem le_iff_forall_one_lt_le_mul : a ≤ b ↔ ∀ ε, 1 < ε → a ≤ b * ε 
goal: a ≤ b ↔ ∀ (ε : α), 1 < ε → a ≤ b * ε

full_name: le_iff_forall_pos_le_add
code: @[to_additive]
theorem le_iff_forall_one_lt_le_mul : a ≤ b ↔ ∀ ε, 1 < ε → a ≤ b * ε 
goal: a ≤ b ↔ ∀ (ε : α), 0 < ε → a ≤ b + ε

full_name: le_iff_forall_lt_one_mul_le
code: @[to_additive]
theorem le_iff_forall_lt_one_mul_le : a ≤ b ↔ ∀ ε < 1, a * ε ≤ b 
goal: a ≤ b ↔ ∀ (ε : α), ε < 1 → a * ε ≤ b

full_name: le_iff_forall_neg_add_le
code: @[to_additive]
theorem le_iff_forall_lt_one_mul_le : a ≤ b ↔ ∀ ε < 1, a * ε ≤ b 
goal: a ≤ b ↔ ∀ (ε : α), ε < 0 → a + ε ≤ b
File: Mathlib/Algebra/Order/Group/InjSurj.lean

full_name: Function.Injective.orderedCommGroup
code: /-- Pullback an `OrderedCommGroup` under an injective map.
See note [reducible non-instances]. -/
@[to_additive (attr := reducible) "Pullback an `OrderedAddCommGroup` under an injective map."]
def Function.Injective.orderedCommGroup [OrderedCommGroup α] {β : Type*} [One β] [Mul β] [Inv β]
    [Div β] [Pow β ℕ] [Pow β ℤ] (f : β → α) (hf : Function.Injective f) (one : f 1 = 1)
    (mul : ∀ x y, f (x * y) = f x * f y) (inv : ∀ x, f x⁻¹ = (f x)⁻¹)
    (div : ∀ x y, f (x / y) = f x / f y) (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n)
    (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n) : OrderedCommGroup β 
goal: OrderedCommGroup β

full_name: Function.Injective.orderedAddCommGroup
code: /-- Pullback an `OrderedCommGroup` under an injective map.
See note [reducible non-instances]. -/
@[to_additive (attr := reducible) "Pullback an `OrderedAddCommGroup` under an injective map."]
def Function.Injective.orderedCommGroup [OrderedCommGroup α] {β : Type*} [One β] [Mul β] [Inv β]
    [Div β] [Pow β ℕ] [Pow β ℤ] (f : β → α) (hf : Function.Injective f) (one : f 1 = 1)
    (mul : ∀ x y, f (x * y) = f x * f y) (inv : ∀ x, f x⁻¹ = (f x)⁻¹)
    (div : ∀ x y, f (x / y) = f x / f y) (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n)
    (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n) : OrderedCommGroup β 
goal: OrderedAddCommGroup β

full_name: Function.Injective.linearOrderedCommGroup
code: /-- Pullback a `LinearOrderedCommGroup` under an injective map.
See note [reducible non-instances]. -/
@[to_additive (attr := reducible) "Pullback a `LinearOrderedAddCommGroup` under an injective map."]
def Function.Injective.linearOrderedCommGroup [LinearOrderedCommGroup α] {β : Type*} [One β]
    [Mul β] [Inv β] [Div β] [Pow β ℕ] [Pow β ℤ] [Sup β] [Inf β] (f : β → α)
    (hf : Function.Injective f) (one : f 1 = 1) (mul : ∀ x y, f (x * y) = f x * f y)
    (inv : ∀ x, f x⁻¹ = (f x)⁻¹) (div : ∀ x y, f (x / y) = f x / f y)
    (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n) (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n)
    (sup : ∀ x y, f (x ⊔ y) = max (f x) (f y)) (inf : ∀ x y, f (x ⊓ y) = min (f x) (f y)) :
    LinearOrderedCommGroup β 
goal: LinearOrderedCommGroup β

full_name: Function.Injective.linearOrderedAddCommGroup
code: /-- Pullback a `LinearOrderedCommGroup` under an injective map.
See note [reducible non-instances]. -/
@[to_additive (attr := reducible) "Pullback a `LinearOrderedAddCommGroup` under an injective map."]
def Function.Injective.linearOrderedCommGroup [LinearOrderedCommGroup α] {β : Type*} [One β]
    [Mul β] [Inv β] [Div β] [Pow β ℕ] [Pow β ℤ] [Sup β] [Inf β] (f : β → α)
    (hf : Function.Injective f) (one : f 1 = 1) (mul : ∀ x y, f (x * y) = f x * f y)
    (inv : ∀ x, f x⁻¹ = (f x)⁻¹) (div : ∀ x y, f (x / y) = f x / f y)
    (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n) (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n)
    (sup : ∀ x y, f (x ⊔ y) = max (f x) (f y)) (inf : ∀ x y, f (x ⊓ y) = min (f x) (f y)) :
    LinearOrderedCommGroup β 
goal: LinearOrderedAddCommGroup β
File: Mathlib/Algebra/Order/Field/Subfield.lean

full_name: SubfieldClass.toLinearOrderedField
code: /-- A subfield of a `LinearOrderedField` is a `LinearOrderedField`. -/
instance (priority := 75) toLinearOrderedField [LinearOrderedField K]
    [SubfieldClass S K] (s : S) : LinearOrderedField s 
goal: LinearOrderedField ↥s

full_name: Subfield.toLinearOrderedField
code: /-- A subfield of a `LinearOrderedField` is a `LinearOrderedField`. -/
instance toLinearOrderedField [LinearOrderedField K] (s : Subfield K) : LinearOrderedField s 
goal: LinearOrderedField ↥s
File: Mathlib/Algebra/Order/Group/Prod.lean

full_name: Prod.instOrderedCommGroup
code: @[to_additive]
instance [OrderedCommGroup G] [OrderedCommGroup H] : OrderedCommGroup (G × H) 
goal: OrderedCommGroup (G × H)

full_name: Prod.instOrderedAddCommGroup
code: @[to_additive]
instance [OrderedCommGroup G] [OrderedCommGroup H] : OrderedCommGroup (G × H) 
goal: OrderedAddCommGroup (G × H)

full_name: Prod.Lex.orderedCommGroup
code: @[to_additive]
instance orderedCommGroup [OrderedCommGroup G] [OrderedCommGroup H] :
    OrderedCommGroup (G ×ₗ H) 
goal: OrderedCommGroup (Lex (G × H))

full_name: Prod.Lex.orderedAddCommGroup
code: @[to_additive]
instance orderedCommGroup [OrderedCommGroup G] [OrderedCommGroup H] :
    OrderedCommGroup (G ×ₗ H) 
goal: OrderedAddCommGroup (Lex (G × H))

full_name: Prod.Lex.linearOrderedCommGroup
code: @[to_additive]
instance linearOrderedCommGroup [LinearOrderedCommGroup G] [LinearOrderedCommGroup H] :
    LinearOrderedCommGroup (G ×ₗ H) 
goal: LinearOrderedCommGroup (Lex (G × H))

full_name: Prod.Lex.linearOrderedAddCommGroup
code: @[to_additive]
instance linearOrderedCommGroup [LinearOrderedCommGroup G] [LinearOrderedCommGroup H] :
    LinearOrderedCommGroup (G ×ₗ H) 
goal: LinearOrderedAddCommGroup (Lex (G × H))
File: Mathlib/Algebra/Order/Group/Nat.lean

full_name: Nat.instCanonicallyLinearOrderedAddCommMonoid
code: instance instCanonicallyLinearOrderedAddCommMonoid : CanonicallyLinearOrderedAddCommMonoid ℕ 
goal: CanonicallyLinearOrderedAddCommMonoid ℕ

full_name: Nat.instLinearOrderedCommMonoid
code: instance instLinearOrderedCommMonoid : LinearOrderedCommMonoid ℕ 
goal: LinearOrderedCommMonoid ℕ

full_name: Nat.instLinearOrderedCancelAddCommMonoid
code: instance instLinearOrderedCancelAddCommMonoid : LinearOrderedCancelAddCommMonoid ℕ 
goal: LinearOrderedCancelAddCommMonoid ℕ

full_name: Nat.instOrderedSub
code: instance instOrderedSub : OrderedSub ℕ 
goal: OrderedSub ℕ

full_name: Nat.pow_left_strictMono
code: /-- See also `pow_left_strictMonoOn`. -/
protected lemma pow_left_strictMono (hn : n ≠ 0) : StrictMono (· ^ n : ℕ → ℕ) 
goal: StrictMono fun x => x ^ n

full_name: StrictMono.nat_pow
code: lemma _root_.StrictMono.nat_pow [Preorder α] (hn : n ≠ 0) (hf : StrictMono f) :
    StrictMono (f · ^ n) 
goal: StrictMono fun x => f x ^ n
File: Mathlib/Algebra/Order/Group/Bounds.lean

full_name: IsGLB.exists_between_self_add
code: theorem IsGLB.exists_between_self_add (h : IsGLB s a) (hε : 0 < ε) : ∃ b ∈ s, a ≤ b ∧ b < a + ε 
goal: ∃ b ∈ s, a ≤ b ∧ b < a + ε

full_name: IsGLB.exists_between_self_add'
code: theorem IsGLB.exists_between_self_add' (h : IsGLB s a) (h₂ : a ∉ s) (hε : 0 < ε) :
    ∃ b ∈ s, a < b ∧ b < a + ε 
goal: ∃ b ∈ s, a < b ∧ b < a + ε

full_name: IsLUB.exists_between_sub_self
code: theorem IsLUB.exists_between_sub_self (h : IsLUB s a) (hε : 0 < ε) : ∃ b ∈ s, a - ε < b ∧ b ≤ a 
goal: ∃ b ∈ s, a - ε < b ∧ b ≤ a

full_name: IsLUB.exists_between_sub_self'
code: theorem IsLUB.exists_between_sub_self' (h : IsLUB s a) (h₂ : a ∉ s) (hε : 0 < ε) :
    ∃ b ∈ s, a - ε < b ∧ b < a 
goal: ∃ b ∈ s, a - ε < b ∧ b < a
File: Mathlib/Algebra/Order/Group/TypeTags.lean

full_name: Multiplicative.orderedCommGroup
code: instance Multiplicative.orderedCommGroup [OrderedAddCommGroup α] :
    OrderedCommGroup (Multiplicative α) 
goal: OrderedCommGroup (Multiplicative α)

full_name: Additive.orderedAddCommGroup
code: instance Additive.orderedAddCommGroup [OrderedCommGroup α] :
    OrderedAddCommGroup (Additive α) 
goal: OrderedAddCommGroup (Additive α)

full_name: Multiplicative.linearOrderedCommGroup
code: instance Multiplicative.linearOrderedCommGroup [LinearOrderedAddCommGroup α] :
    LinearOrderedCommGroup (Multiplicative α) 
goal: LinearOrderedCommGroup (Multiplicative α)

full_name: Additive.linearOrderedAddCommGroup
code: instance Additive.linearOrderedAddCommGroup [LinearOrderedCommGroup α] :
    LinearOrderedAddCommGroup (Additive α) 
goal: LinearOrderedAddCommGroup (Additive α)
File: Mathlib/Algebra/Order/Ring/Int.lean

full_name: Int.instLinearOrderedCommRing
code: instance instLinearOrderedCommRing : LinearOrderedCommRing ℤ 
goal: LinearOrderedCommRing ℤ

full_name: Int.instOrderedCommRing
code: instance instOrderedCommRing : OrderedCommRing ℤ 
goal: OrderedCommRing ℤ

full_name: Int.instOrderedRing
code: instance instOrderedRing : OrderedRing ℤ 
goal: OrderedRing ℤ

full_name: Int.isCompl_even_odd
code: lemma isCompl_even_odd : IsCompl { n : ℤ | Even n } { n | Odd n } 
goal: IsCompl {n | Even n} {n | Odd n}

full_name: Nat.cast_natAbs
code: lemma _root_.Nat.cast_natAbs {α : Type*} [AddGroupWithOne α] (n : ℤ) : (n.natAbs : α) = |n| 
goal: ↑n.natAbs = ↑|n|

full_name: Int.cast_mul_eq_zsmul_cast
code: /-- Note this holds in marginally more generality than `Int.cast_mul` -/
lemma cast_mul_eq_zsmul_cast {α : Type*} [AddCommGroupWithOne α] :
    ∀ m n : ℤ, ↑(m * n) = m • (n : α) 
goal: ↑(m * n) = m • ↑n

full_name: Int.two_le_iff_pos_of_even
code: lemma two_le_iff_pos_of_even {m : ℤ} (even : Even m) : 2 ≤ m ↔ 0 < m 
goal: 2 ≤ m ↔ 0 < m

full_name: Int.add_two_le_iff_lt_of_even_sub
code: lemma add_two_le_iff_lt_of_even_sub {m n : ℤ} (even : Even (n - m)) : m + 2 ≤ n ↔ m < n 
goal: m + 2 ≤ n ↔ m < n
File: Mathlib/Algebra/Order/Ring/Finset.lean

full_name: Finset.sup_mul_le_mul_sup_of_nonneg
code: theorem sup_mul_le_mul_sup_of_nonneg [OrderBot R] (s : Finset ι) (ha : ∀ i ∈ s, 0 ≤ a i)
    (hb : ∀ i ∈ s, 0 ≤ b i) : s.sup (a * b) ≤ s.sup a * s.sup b 
goal: s.sup (a * b) ≤ s.sup a * s.sup b

full_name: Finset.mul_inf_le_inf_mul_of_nonneg
code: theorem mul_inf_le_inf_mul_of_nonneg [OrderTop R] (s : Finset ι) (ha : ∀ i ∈ s, 0 ≤ a i)
    (hb : ∀ i ∈ s, 0 ≤ b i) : s.inf a * s.inf b ≤ s.inf (a * b) 
goal: s.inf a * s.inf b ≤ s.inf (a * b)

full_name: Finset.sup'_mul_le_mul_sup'_of_nonneg
code: theorem sup'_mul_le_mul_sup'_of_nonneg (s : Finset ι) (H : s.Nonempty) (ha : ∀ i ∈ s, 0 ≤ a i)
    (hb : ∀ i ∈ s, 0 ≤ b i) : s.sup' H (a * b) ≤ s.sup' H a * s.sup' H b 
goal: s.sup' H (a * b) ≤ s.sup' H a * s.sup' H b

full_name: Finset.inf'_mul_le_mul_inf'_of_nonneg
code: theorem inf'_mul_le_mul_inf'_of_nonneg (s : Finset ι) (H : s.Nonempty) (ha : ∀ i ∈ s, 0 ≤ a i)
    (hb : ∀ i ∈ s, 0 ≤ b i) : s.inf' H a * s.inf' H b ≤ s.inf' H (a * b) 
goal: s.inf' H a * s.inf' H b ≤ s.inf' H (a * b)
File: Mathlib/Algebra/Order/Group/PiLex.lean

full_name: Pi.Lex.orderedCancelCommMonoid
code: @[to_additive]
instance orderedCancelCommMonoid [∀ i, OrderedCancelCommMonoid (α i)] :
    OrderedCancelCommMonoid (Lex (∀ i, α i)) 
goal: OrderedCancelCommMonoid (Lex ((i : ι) → α i))

full_name: Pi.Lex.orderedAddCancelCommMonoid
code: @[to_additive]
instance orderedCancelCommMonoid [∀ i, OrderedCancelCommMonoid (α i)] :
    OrderedCancelCommMonoid (Lex (∀ i, α i)) 
goal: OrderedCancelAddCommMonoid (Lex ((i : ι) → α i))

full_name: Pi.Lex.orderedAddCommGroup
code: @[to_additive]
instance orderedCommGroup [∀ i, OrderedCommGroup (α i)] : OrderedCommGroup (Lex (∀ i, α i)) 
goal: OrderedAddCommGroup (Lex ((i : ι) → α i))

full_name: Pi.Lex.orderedCommGroup
code: @[to_additive]
instance orderedCommGroup [∀ i, OrderedCommGroup (α i)] : OrderedCommGroup (Lex (∀ i, α i)) 
goal: OrderedCommGroup (Lex ((i : ι) → α i))

full_name: Pi.Lex.linearOrderedAddCancelCommMonoid
code: @[to_additive]
noncomputable instance linearOrderedCancelCommMonoid [IsWellOrder ι (· < ·)]
    [∀ i, LinearOrderedCancelCommMonoid (α i)] :
    LinearOrderedCancelCommMonoid (Lex (∀ i, α i)) 
goal: LinearOrderedCancelAddCommMonoid (Lex ((i : ι) → α i))

full_name: Pi.Lex.linearOrderedCancelCommMonoid
code: @[to_additive]
noncomputable instance linearOrderedCancelCommMonoid [IsWellOrder ι (· < ·)]
    [∀ i, LinearOrderedCancelCommMonoid (α i)] :
    LinearOrderedCancelCommMonoid (Lex (∀ i, α i)) 
goal: LinearOrderedCancelCommMonoid (Lex ((i : ι) → α i))

full_name: Pi.Lex.linearOrderedCommGroup
code: @[to_additive]
noncomputable instance linearOrderedCommGroup [IsWellOrder ι (· < ·)]
    [∀ i, LinearOrderedCommGroup (α i)] :
    LinearOrderedCommGroup (Lex (∀ i, α i)) 
goal: LinearOrderedCommGroup (Lex ((i : ι) → α i))

full_name: Pi.Lex.linearOrderedAddCommGroup
code: @[to_additive]
noncomputable instance linearOrderedCommGroup [IsWellOrder ι (· < ·)]
    [∀ i, LinearOrderedCommGroup (α i)] :
    LinearOrderedCommGroup (Lex (∀ i, α i)) 
goal: LinearOrderedAddCommGroup (Lex ((i : ι) → α i))