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

full_name: NNRat.cast_nonneg
code: lemma NNRat.cast_nonneg (q : ℚ≥0) : 0 ≤ (q : α) 
goal: 0 ≤ ↑q

full_name: nnqsmul_nonneg
code: lemma nnqsmul_nonneg (q : ℚ≥0) (ha : 0 ≤ a) : 0 ≤ q • a 
goal: 0 ≤ q • a

full_name: Nonneg.inv
code: instance inv : Inv { x : α // 0 ≤ x } 
goal: Inv { x // 0 ≤ x }

full_name: Nonneg.coe_inv
code: @[simp, norm_cast]
protected theorem coe_inv (a : { x : α // 0 ≤ x }) : ((a⁻¹ : { x : α // 0 ≤ x }) : α) = (a : α)⁻¹ 
goal: ↑a⁻¹ = (↑a)⁻¹

full_name: Nonneg.inv_mk
code: @[simp]
theorem inv_mk (hx : 0 ≤ x) :
    (⟨x, hx⟩ : { x : α // 0 ≤ x })⁻¹ = ⟨x⁻¹, inv_nonneg (α := α) |>.2 hx⟩ 
goal: ⟨x, hx⟩⁻¹ = ⟨x⁻¹, ⋯⟩

full_name: Nonneg.div
code: instance div : Div { x : α // 0 ≤ x } 
goal: Div { x // 0 ≤ x }

full_name: Nonneg.coe_div
code: @[simp, norm_cast]
protected theorem coe_div (a b : { x : α // 0 ≤ x }) : ((a / b : { x : α // 0 ≤ x }) : α) = a / b 
goal: ↑(a / b) = ↑a / ↑b

full_name: Nonneg.mk_div_mk
code: @[simp]
theorem mk_div_mk (hx : 0 ≤ x) (hy : 0 ≤ y) :
    (⟨x, hx⟩ : { x : α // 0 ≤ x }) / ⟨y, hy⟩ = ⟨x / y, div_nonneg hx hy⟩ 
goal: ⟨x, hx⟩ / ⟨y, hy⟩ = ⟨x / y, ⋯⟩

full_name: Nonneg.zpow
code: instance zpow : Pow { x : α // 0 ≤ x } ℤ 
goal: Pow { x // 0 ≤ x } ℤ

full_name: Nonneg.coe_zpow
code: @[simp, norm_cast]
protected theorem coe_zpow (a : { x : α // 0 ≤ x }) (n : ℤ) :
    ((a ^ n : { x : α // 0 ≤ x }) : α) = (a : α) ^ n 
goal: ↑(a ^ n) = ↑a ^ n

full_name: Nonneg.mk_zpow
code: @[simp]
theorem mk_zpow (hx : 0 ≤ x) (n : ℤ) :
    (⟨x, hx⟩ : { x : α // 0 ≤ x }) ^ n = ⟨x ^ n, zpow_nonneg hx n⟩ 
goal: ⟨x, hx⟩ ^ n = ⟨x ^ n, ⋯⟩

full_name: Nonneg.instNNRatCast
code: instance instNNRatCast : NNRatCast {x : α // 0 ≤ x} 
goal: NNRatCast { x // 0 ≤ x }

full_name: Nonneg.instNNRatSMul
code: instance instNNRatSMul : SMul ℚ≥0 {x : α // 0 ≤ x} 
goal: SMul ℚ≥0 { x // 0 ≤ x }

full_name: Nonneg.coe_nnratCast
code: @[simp, norm_cast] lemma coe_nnratCast (q : ℚ≥0) : (q : {x : α // 0 ≤ x}) = (q : α) 
goal: ↑↑q = ↑q

full_name: Nonneg.mk_nnratCast
code: @[simp] lemma mk_nnratCast (q : ℚ≥0) : (⟨q, q.cast_nonneg⟩ : {x : α // 0 ≤ x}) = q 
goal: ⟨↑q, ⋯⟩ = ↑q

full_name: Nonneg.coe_nnqsmul
code: @[simp, norm_cast] lemma coe_nnqsmul (q : ℚ≥0) (a : {x : α // 0 ≤ x}) :
    ↑(q • a) = (q • a : α) 
goal: ↑(q • a) = q • ↑a

full_name: Nonneg.mk_nnqsmul
code: @[simp] lemma mk_nnqsmul (q : ℚ≥0) (a : α) (ha : 0 ≤ a) :
    (⟨q • a, by rw [NNRat.smul_def]; exact mul_nonneg q.cast_nonneg ha⟩ : {x : α // 0 ≤ x}) =
      q • a 
goal: ↑⟨q • a, ⋯⟩ = q • a

full_name: Nonneg.linearOrderedSemifield
code: instance linearOrderedSemifield : LinearOrderedSemifield { x : α // 0 ≤ x } 
goal: LinearOrderedSemifield { x // 0 ≤ x }

full_name: Nonneg.canonicallyLinearOrderedSemifield
code: instance canonicallyLinearOrderedSemifield [LinearOrderedField α] :
    CanonicallyLinearOrderedSemifield { x : α // 0 ≤ x } 
goal: CanonicallyLinearOrderedSemifield { x // 0 ≤ x }

full_name: Nonneg.linearOrderedCommGroupWithZero
code: instance linearOrderedCommGroupWithZero [LinearOrderedField α] :
    LinearOrderedCommGroupWithZero { x : α // 0 ≤ x } 
goal: LinearOrderedCommGroupWithZero { x // 0 ≤ x }
File: Mathlib/Algebra/Order/Sub/WithTop.lean

full_name: WithTop.sub
code: /-- If `α` has a subtraction and a bottom element, we can extend the subtraction to `WithTop α`, by
setting `x - ⊤ = ⊥` and `⊤ - x = ⊤`. -/
protected def sub : ∀ _ _ : WithTop α, WithTop α
  
goal: WithTop α → WithTop α → WithTop α

full_name: WithTop.instSub
code: instance : Sub (WithTop α) 
goal: Sub (WithTop α)

full_name: WithTop.coe_sub
code: @[simp, norm_cast]
theorem coe_sub {a b : α} : (↑(a - b) : WithTop α) = ↑a - ↑b 
goal: ↑(a - b) = ↑a - ↑b

full_name: WithTop.top_sub_coe
code: @[simp]
theorem top_sub_coe {a : α} : (⊤ : WithTop α) - a = ⊤ 
goal: ⊤ - ↑a = ⊤

full_name: WithTop.sub_top
code: @[simp]
theorem sub_top {a : WithTop α} : a - ⊤ = (⊥ : α) 
goal: a - ⊤ = ↑⊥

full_name: WithTop.sub_eq_top_iff
code: @[simp] theorem sub_eq_top_iff {a b : WithTop α} : a - b = ⊤ ↔ a = ⊤ ∧ b ≠ ⊤ 
goal: a - b = ⊤ ↔ a = ⊤ ∧ b ≠ ⊤

full_name: WithTop.map_sub
code: theorem map_sub [Sub β] [Bot β] {f : α → β} (h : ∀ x y, f (x - y) = f x - f y) (h₀ : f ⊥ = ⊥) :
    ∀ x y : WithTop α, (x - y).map f = x.map f - y.map f
  
goal: WithTop.map f (x - y) = WithTop.map f x - WithTop.map f y

full_name: WithTop.instOrderedSub
code: instance : OrderedSub (WithTop α) 
goal: OrderedSub (WithTop α)
File: Mathlib/Algebra/Order/Sub/Prod.lean

full_name: Prod.orderedSub
code: instance Prod.orderedSub
    [Preorder α] [Add α] [Sub α] [OrderedSub α] [Sub β] [Preorder β] [Add β] [OrderedSub β] :
    OrderedSub (α × β) 
goal: OrderedSub (α × β)

full_name: Pi.orderedSub
code: instance Pi.orderedSub {ι : Type*} {α : ι → Type*}
    [∀ i, Preorder (α i)] [∀ i, Add (α i)] [∀ i, Sub (α i)] [∀ i, OrderedSub (α i)] :
    OrderedSub ((i : ι) → α i) 
goal: OrderedSub ((i : ι) → α i)
File: Mathlib/Algebra/Order/Module/Pointwise.lean

full_name: smul_lowerBounds_subset_lowerBounds_smul_of_nonneg
code: lemma smul_lowerBounds_subset_lowerBounds_smul_of_nonneg (ha : 0 ≤ a) :
    a • lowerBounds s ⊆ lowerBounds (a • s) 
goal: a • lowerBounds s ⊆ lowerBounds (a • s)

full_name: smul_upperBounds_subset_upperBounds_smul_of_nonneg
code: lemma smul_upperBounds_subset_upperBounds_smul_of_nonneg (ha : 0 ≤ a) :
    a • upperBounds s ⊆ upperBounds (a • s) 
goal: a • upperBounds s ⊆ upperBounds (a • s)

full_name: BddBelow.smul_of_nonneg
code: lemma BddBelow.smul_of_nonneg (hs : BddBelow s) (ha : 0 ≤ a) : BddBelow (a • s) 
goal: BddBelow (a • s)

full_name: BddAbove.smul_of_nonneg
code: lemma BddAbove.smul_of_nonneg (hs : BddAbove s) (ha : 0 ≤ a) : BddAbove (a • s) 
goal: BddAbove (a • s)

full_name: lowerBounds_smul_of_pos
code: @[simp] lemma lowerBounds_smul_of_pos (ha : 0 < a) : lowerBounds (a • s) = a • lowerBounds s 
goal: lowerBounds (a • s) = a • lowerBounds s

full_name: upperBounds_smul_of_pos
code: @[simp] lemma upperBounds_smul_of_pos (ha : 0 < a) : upperBounds (a • s) = a • upperBounds s 
goal: upperBounds (a • s) = a • upperBounds s

full_name: bddBelow_smul_iff_of_pos
code: @[simp] lemma bddBelow_smul_iff_of_pos (ha : 0 < a) : BddBelow (a • s) ↔ BddBelow s 
goal: BddBelow (a • s) ↔ BddBelow s

full_name: bddAbove_smul_iff_of_pos
code: @[simp] lemma bddAbove_smul_iff_of_pos (ha : 0 < a) : BddAbove (a • s) ↔ BddAbove s 
goal: BddAbove (a • s) ↔ BddAbove s

full_name: smul_lowerBounds_subset_upperBounds_smul
code: lemma smul_lowerBounds_subset_upperBounds_smul (ha : a ≤ 0) :
    a • lowerBounds s ⊆ upperBounds (a • s) 
goal: a • lowerBounds s ⊆ upperBounds (a • s)

full_name: smul_upperBounds_subset_lowerBounds_smul
code: lemma smul_upperBounds_subset_lowerBounds_smul (ha : a ≤ 0) :
    a • upperBounds s ⊆ lowerBounds (a • s) 
goal: a • upperBounds s ⊆ lowerBounds (a • s)

full_name: BddBelow.smul_of_nonpos
code: lemma BddBelow.smul_of_nonpos (ha : a ≤ 0) (hs : BddBelow s) : BddAbove (a • s) 
goal: BddAbove (a • s)

full_name: BddAbove.smul_of_nonpos
code: lemma BddAbove.smul_of_nonpos (ha : a ≤ 0) (hs : BddAbove s) : BddBelow (a • s) 
goal: BddBelow (a • s)

full_name: lowerBounds_smul_of_neg
code: @[simp] lemma lowerBounds_smul_of_neg (ha : a < 0) : lowerBounds (a • s) = a • upperBounds s 
goal: lowerBounds (a • s) = a • upperBounds s

full_name: upperBounds_smul_of_neg
code: @[simp] lemma upperBounds_smul_of_neg (ha : a < 0) : upperBounds (a • s) = a • lowerBounds s 
goal: upperBounds (a • s) = a • lowerBounds s

full_name: bddBelow_smul_iff_of_neg
code: @[simp] lemma bddBelow_smul_iff_of_neg (ha : a < 0) : BddBelow (a • s) ↔ BddAbove s 
goal: BddBelow (a • s) ↔ BddAbove s

full_name: bddAbove_smul_iff_of_neg
code: @[simp] lemma bddAbove_smul_iff_of_neg (ha : a < 0) : BddAbove (a • s) ↔ BddBelow s 
goal: BddAbove (a • s) ↔ BddBelow s
File: Mathlib/Algebra/Order/Module/Algebra.lean

full_name: algebraMap_mono
code: @[mono] lemma algebraMap_mono : Monotone (algebraMap α β) 
goal: Monotone ⇑(algebraMap α β)

full_name: GCongr.algebraMap_le_algebraMap
code: /-- A version of `algebraMap_mono` for use by `gcongr` since it currently does not preprocess
`Monotone` conclusions. -/
@[gcongr] protected lemma GCongr.algebraMap_le_algebraMap {a₁ a₂ : α} (ha : a₁ ≤ a₂) :
    algebraMap α β a₁ ≤ algebraMap α β a₂ 
goal: (algebraMap α β) a₁ ≤ (algebraMap α β) a₂

full_name: algebraMap_nonneg
code: lemma algebraMap_nonneg (ha : 0 ≤ a) : 0 ≤ algebraMap α β a 
goal: 0 ≤ (algebraMap α β) a

full_name: algebraMap_le_algebraMap
code: @[simp] lemma algebraMap_le_algebraMap : algebraMap α β a₁ ≤ algebraMap α β a₂ ↔ a₁ ≤ a₂ 
goal: (algebraMap α β) a₁ ≤ (algebraMap α β) a₂ ↔ a₁ ≤ a₂

full_name: algebraMap_strictMono
code: @[mono] lemma algebraMap_strictMono : StrictMono (algebraMap α β) 
goal: StrictMono ⇑(algebraMap α β)

full_name: GCongr.algebraMap_lt_algebraMap
code: /-- A version of `algebraMap_strictMono` for use by `gcongr` since it currently does not preprocess
`Monotone` conclusions. -/
@[gcongr] protected lemma GCongr.algebraMap_lt_algebraMap {a₁ a₂ : α} (ha : a₁ < a₂) :
    algebraMap α β a₁ < algebraMap α β a₂ 
goal: (algebraMap α β) a₁ < (algebraMap α β) a₂

full_name: algebraMap_pos
code: lemma algebraMap_pos (ha : 0 < a) : 0 < algebraMap α β a 
goal: 0 < (algebraMap α β) a

full_name: algebraMap_lt_algebraMap
code: @[simp] lemma algebraMap_lt_algebraMap : algebraMap α β a₁ < algebraMap α β a₂ ↔ a₁ < a₂ 
goal: (algebraMap α β) a₁ < (algebraMap α β) a₂ ↔ a₁ < a₂

full_name: Mathlib.Meta.Positivity.evalAlgebraMap
code: /-- Extension for `algebraMap`. -/
@[positivity algebraMap _ _ _]
def evalAlgebraMap : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

full_name: WithTop.orderedAddCommMonoid
code: instance orderedAddCommMonoid [OrderedAddCommMonoid α] : OrderedAddCommMonoid (WithTop α) 
goal: OrderedAddCommMonoid (WithTop α)

full_name: WithTop.canonicallyOrderedAddCommMonoid
code: instance canonicallyOrderedAddCommMonoid [CanonicallyOrderedAddCommMonoid α] :
    CanonicallyOrderedAddCommMonoid (WithTop α) 
goal: CanonicallyOrderedAddCommMonoid (WithTop α)

full_name: WithTop.instCanonicallyLinearOrderedAddCommMonoid
code: instance [CanonicallyLinearOrderedAddCommMonoid α] :
    CanonicallyLinearOrderedAddCommMonoid (WithTop α) 
goal: CanonicallyLinearOrderedAddCommMonoid (WithTop α)

full_name: WithBot.orderedAddCommMonoid
code: instance orderedAddCommMonoid [OrderedAddCommMonoid α] : OrderedAddCommMonoid (WithBot α) 
goal: OrderedAddCommMonoid (WithBot α)

full_name: WithBot.linearOrderedAddCommMonoid
code: instance linearOrderedAddCommMonoid [LinearOrderedAddCommMonoid α] :
    LinearOrderedAddCommMonoid (WithBot α) 
goal: LinearOrderedAddCommMonoid (WithBot α)
File: Mathlib/Algebra/Order/Monoid/ToMulBot.lean

full_name: WithZero.toMulBot
code: /-- Making an additive monoid multiplicative then adding a zero is the same as adding a bottom
element then making it multiplicative. -/
def toMulBot : WithZero (Multiplicative α) ≃* Multiplicative (WithBot α) 
goal: WithZero (Multiplicative α) ≃* Multiplicative (WithBot α)

full_name: WithZero.toMulBot_zero
code: @[simp]
theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplicative.ofAdd ⊥ 
goal: WithZero.toMulBot 0 = Multiplicative.ofAdd ⊥

full_name: WithZero.toMulBot_coe
code: @[simp]
theorem toMulBot_coe (x : Multiplicative α) :
    toMulBot ↑x = Multiplicative.ofAdd (↑(Multiplicative.toAdd x) : WithBot α) 
goal: WithZero.toMulBot ↑x = Multiplicative.ofAdd ↑(Multiplicative.toAdd x)

full_name: WithZero.toMulBot_symm_bot
code: @[simp]
theorem toMulBot_symm_bot : toMulBot.symm (Multiplicative.ofAdd (⊥ : WithBot α)) = 0 
goal: WithZero.toMulBot.symm (Multiplicative.ofAdd ⊥) = 0

full_name: WithZero.toMulBot_coe_ofAdd
code: @[simp]
theorem toMulBot_coe_ofAdd (x : α) :
    toMulBot.symm (Multiplicative.ofAdd (x : WithBot α)) = Multiplicative.ofAdd x 
goal: WithZero.toMulBot.symm (Multiplicative.ofAdd ↑x) = ↑(Multiplicative.ofAdd x)

full_name: WithZero.toMulBot_strictMono
code: theorem toMulBot_strictMono : StrictMono (@toMulBot α _) 
goal: StrictMono ⇑WithZero.toMulBot

full_name: WithZero.toMulBot_le
code: @[simp]
theorem toMulBot_le : toMulBot a ≤ toMulBot b ↔ a ≤ b 
goal: WithZero.toMulBot a ≤ WithZero.toMulBot b ↔ a ≤ b

full_name: WithZero.toMulBot_lt
code: @[simp]
theorem toMulBot_lt : toMulBot a < toMulBot b ↔ a < b 
goal: WithZero.toMulBot a < WithZero.toMulBot b ↔ a < b
File: Mathlib/Algebra/Order/Monoid/NatCast.lean

full_name: lt_add_one
code: lemma lt_add_one [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α]
    [NeZero (1 : α)] [CovariantClass α α (·+·) (·<·)] (a : α) : a < a + 1 
goal: a < a + 1

full_name: lt_one_add
code: lemma lt_one_add [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α]
    [NeZero (1 : α)] [CovariantClass α α (swap (·+·)) (·<·)] (a : α) : a < 1 + a 
goal: a < 1 + a

full_name: zero_le_two
code: lemma zero_le_two [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
    (0 : α) ≤ 2 
goal: 0 ≤ 2

full_name: zero_le_three
code: lemma zero_le_three [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
    (0 : α) ≤ 3 
goal: 0 ≤ 3

full_name: zero_le_four
code: lemma zero_le_four [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
    (0 : α) ≤ 4 
goal: 0 ≤ 4

full_name: one_le_two
code: lemma one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
    (1 : α) ≤ 2 
goal: 1 ≤ 2

full_name: one_le_two'
code: lemma one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (·+·)) (·≤·)] :
    (1 : α) ≤ 2 
goal: 1 ≤ 2

full_name: zero_lt_two
code: /-- See `zero_lt_two'` for a version with the type explicit. -/
@[simp] lemma zero_lt_two : (0 : α) < 2 
goal: 0 < 2

full_name: zero_lt_three
code: /-- See `zero_lt_three'` for a version with the type explicit. -/
@[simp] lemma zero_lt_three : (0 : α) < 3 
goal: 0 < 3

full_name: zero_lt_four
code: /-- See `zero_lt_four'` for a version with the type explicit. -/
@[simp] lemma zero_lt_four : (0 : α) < 4 
goal: 0 < 4

full_name: zero_lt_two'
code: /-- See `zero_lt_two` for a version with the type implicit. -/
lemma zero_lt_two' : (0 : α) < 2 
goal: 0 < 2

full_name: zero_lt_three'
code: /-- See `zero_lt_three` for a version with the type implicit. -/
lemma zero_lt_three' : (0 : α) < 3 
goal: 0 < 3

full_name: zero_lt_four'
code: /-- See `zero_lt_four` for a version with the type implicit. -/
lemma zero_lt_four' : (0 : α) < 4 
goal: 0 < 4

full_name: ZeroLEOneClass.neZero.two
code: instance ZeroLEOneClass.neZero.two : NeZero (2 : α) 
goal: NeZero 2

full_name: ZeroLEOneClass.neZero.three
code: instance ZeroLEOneClass.neZero.three : NeZero (3 : α) 
goal: NeZero 3

full_name: ZeroLEOneClass.neZero.four
code: instance ZeroLEOneClass.neZero.four : NeZero (4 : α) 
goal: NeZero 4

full_name: one_lt_two
code: lemma one_lt_two [CovariantClass α α (·+·) (·<·)] : (1 : α) < 2 
goal: 1 < 2
File: Mathlib/Algebra/Order/Monoid/OrderDual.lean

full_name: OrderDual.orderedAddCommMonoid
code: @[to_additive]
instance orderedCommMonoid [OrderedCommMonoid α] : OrderedCommMonoid αᵒᵈ 
goal: OrderedAddCommMonoid αᵒᵈ

full_name: OrderDual.orderedCommMonoid
code: @[to_additive]
instance orderedCommMonoid [OrderedCommMonoid α] : OrderedCommMonoid αᵒᵈ 
goal: OrderedCommMonoid αᵒᵈ

full_name: OrderDual.OrderedCancelAddCommMonoid.to_contravariantClass
code: @[to_additive OrderDual.OrderedCancelAddCommMonoid.to_contravariantClass]
instance OrderedCancelCommMonoid.to_contravariantClass [OrderedCancelCommMonoid α] :
    ContravariantClass αᵒᵈ αᵒᵈ HMul.hMul LE.le 
goal: ContravariantClass αᵒᵈ αᵒᵈ HAdd.hAdd LE.le

full_name: OrderDual.OrderedCancelCommMonoid.to_contravariantClass
code: @[to_additive OrderDual.OrderedCancelAddCommMonoid.to_contravariantClass]
instance OrderedCancelCommMonoid.to_contravariantClass [OrderedCancelCommMonoid α] :
    ContravariantClass αᵒᵈ αᵒᵈ HMul.hMul LE.le 
goal: ContravariantClass αᵒᵈ αᵒᵈ HMul.hMul LE.le

full_name: OrderDual.orderedCancelCommMonoid
code: @[to_additive]
instance orderedCancelCommMonoid [OrderedCancelCommMonoid α] : OrderedCancelCommMonoid αᵒᵈ 
goal: OrderedCancelCommMonoid αᵒᵈ

full_name: OrderDual.orderedAddCancelCommMonoid
code: @[to_additive]
instance orderedCancelCommMonoid [OrderedCancelCommMonoid α] : OrderedCancelCommMonoid αᵒᵈ 
goal: OrderedCancelAddCommMonoid αᵒᵈ

full_name: OrderDual.linearOrderedCancelCommMonoid
code: @[to_additive]
instance linearOrderedCancelCommMonoid [LinearOrderedCancelCommMonoid α] :
    LinearOrderedCancelCommMonoid αᵒᵈ 
goal: LinearOrderedCancelCommMonoid αᵒᵈ

full_name: OrderDual.linearOrderedAddCancelCommMonoid
code: @[to_additive]
instance linearOrderedCancelCommMonoid [LinearOrderedCancelCommMonoid α] :
    LinearOrderedCancelCommMonoid αᵒᵈ 
goal: LinearOrderedCancelAddCommMonoid αᵒᵈ

full_name: OrderDual.linearOrderedCommMonoid
code: @[to_additive]
instance linearOrderedCommMonoid [LinearOrderedCommMonoid α] : LinearOrderedCommMonoid αᵒᵈ 
goal: LinearOrderedCommMonoid αᵒᵈ

full_name: OrderDual.linearOrderedAddCommMonoid
code: @[to_additive]
instance linearOrderedCommMonoid [LinearOrderedCommMonoid α] : LinearOrderedCommMonoid αᵒᵈ 
goal: LinearOrderedAddCommMonoid αᵒᵈ
File: Mathlib/Algebra/Order/Algebra.lean

full_name: algebraMap_monotone
code: theorem algebraMap_monotone : Monotone (algebraMap R A) 
goal: Monotone ⇑(algebraMap R A)
File: Mathlib/Algebra/Order/Field/Rat.lean

full_name: Rat.instLinearOrderedField
code: instance instLinearOrderedField : LinearOrderedField ℚ 
goal: LinearOrderedField ℚ

full_name: NNRat.coe_inv
code: @[simp, norm_cast] lemma coe_inv (q : ℚ≥0) : ((q⁻¹ : ℚ≥0) : ℚ) = (q : ℚ)⁻¹ 
goal: ↑q⁻¹ = (↑q)⁻¹

full_name: NNRat.coe_div
code: @[simp, norm_cast] lemma coe_div (p q : ℚ≥0) : ((p / q : ℚ≥0) : ℚ) = p / q 
goal: ↑(p / q) = ↑p / ↑q

full_name: NNRat.inv_def
code: lemma inv_def (q : ℚ≥0) : q⁻¹ = divNat q.den q.num 
goal: q⁻¹ = NNRat.divNat q.den q.num

full_name: NNRat.div_def
code: lemma div_def (p q : ℚ≥0) : p / q = divNat (p.num * q.den) (p.den * q.num) 
goal: p / q = NNRat.divNat (p.num * q.den) (p.den * q.num)

full_name: NNRat.num_inv_of_ne_zero
code: lemma num_inv_of_ne_zero {q : ℚ≥0} (hq : q ≠ 0) : q⁻¹.num = q.den 
goal: q⁻¹.num = q.den

full_name: NNRat.den_inv_of_ne_zero
code: lemma den_inv_of_ne_zero {q : ℚ≥0} (hq : q ≠ 0) : q⁻¹.den = q.num 
goal: q⁻¹.den = q.num
File: Mathlib/Algebra/Order/Invertible.lean

full_name: invOf_pos
code: @[simp]
theorem invOf_pos [Invertible a] : 0 < ⅟ a ↔ 0 < a 
goal: 0 < ⅟a ↔ 0 < a

full_name: invOf_nonpos
code: @[simp]
theorem invOf_nonpos [Invertible a] : ⅟ a ≤ 0 ↔ a ≤ 0 
goal: ⅟a ≤ 0 ↔ a ≤ 0

full_name: invOf_nonneg
code: @[simp]
theorem invOf_nonneg [Invertible a] : 0 ≤ ⅟ a ↔ 0 ≤ a 
goal: 0 ≤ ⅟a ↔ 0 ≤ a

full_name: invOf_lt_zero
code: @[simp]
theorem invOf_lt_zero [Invertible a] : ⅟ a < 0 ↔ a < 0 
goal: ⅟a < 0 ↔ a < 0

full_name: invOf_le_one
code: @[simp]
theorem invOf_le_one [Invertible a] (h : 1 ≤ a) : ⅟ a ≤ 1 
goal: ⅟a ≤ 1

full_name: pos_invOf_of_invertible_cast
code: theorem pos_invOf_of_invertible_cast [Nontrivial α] (n : ℕ)
    [Invertible (n : α)] : 0 < ⅟(n : α) 
goal: 0 < ⅟↑n
File: Mathlib/Algebra/Order/Field/Canonical/Basic.lean

full_name: tsub_div
code: theorem tsub_div (a b c : α) : (a - b) / c = a / c - b / c 
goal: (a - b) / c = a / c - b / c
File: Mathlib/Algebra/Order/Field/Canonical/Defs.lean

full_name: CanonicallyLinearOrderedSemifield
code: /-- A canonically linear ordered field is a linear ordered field in which `a ≤ b` iff there exists
`c` with `b = a + c`. -/
class CanonicallyLinearOrderedSemifield (α : Type*) extends CanonicallyOrderedCommSemiring α,
  LinearOrderedSemifield α
goal: Type u_2

full_name: CanonicallyLinearOrderedSemifield.toLinearOrderedCommGroupWithZero
code: instance (priority := 100) CanonicallyLinearOrderedSemifield.toLinearOrderedCommGroupWithZero
    [CanonicallyLinearOrderedSemifield α] : LinearOrderedCommGroupWithZero α 
goal: LinearOrderedCommGroupWithZero α

full_name: CanonicallyLinearOrderedSemifield.toCanonicallyLinearOrderedAddCommMonoid
code: instance (priority := 100) CanonicallyLinearOrderedSemifield.toCanonicallyLinearOrderedAddCommMonoid
    [CanonicallyLinearOrderedSemifield α] : CanonicallyLinearOrderedAddCommMonoid α 
goal: CanonicallyLinearOrderedAddCommMonoid α
File: Mathlib/Algebra/Order/Field/InjSurj.lean

full_name: Function.Injective.linearOrderedSemifield
code: /-- Pullback a `LinearOrderedSemifield` under an injective map. -/
-- See note [reducible non-instances]
abbrev linearOrderedSemifield [LinearOrderedSemifield α] (zero : f 0 = 0) (one : f 1 = 1)
    (add : ∀ x y, f (x + y) = f x + f y) (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)
    (nsmul : ∀ (n : ℕ) (x), f (n • x) = n • f x) (nnqsmul : ∀ (q : ℚ≥0) (x), f (q • x) = q • f x)
    (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n) (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n)
    (natCast : ∀ n : ℕ, f n = n) (nnratCast : ∀ q : ℚ≥0, f q = q)
    (hsup : ∀ x y, f (x ⊔ y) = max (f x) (f y)) (hinf : ∀ x y, f (x ⊓ y) = min (f x) (f y)) :
    LinearOrderedSemifield β 
goal: LinearOrderedSemifield β

full_name: Function.Injective.linearOrderedField
code: /-- Pullback a `LinearOrderedField` under an injective map. -/
-- See note [reducible non-instances]
abbrev linearOrderedField [LinearOrderedField α] (zero : f 0 = 0) (one : f 1 = 1)
    (add : ∀ x y, f (x + y) = f x + f y) (mul : ∀ x y, f (x * y) = f x * f y)
    (neg : ∀ x, f (-x) = -f x) (sub : ∀ 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)
    (nsmul : ∀ (n : ℕ) (x), f (n • x) = n • f x) (zsmul : ∀ (n : ℤ) (x), f (n • x) = n • f x)
    (nnqsmul : ∀ (q : ℚ≥0) (x), f (q • x) = q • f x) (qsmul : ∀ (q : ℚ) (x), f (q • x) = q • f x)
    (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n) (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n)
    (natCast : ∀ n : ℕ, f n = n) (intCast : ∀ n : ℤ, f n = n) (nnratCast : ∀ q : ℚ≥0, f q = q)
    (ratCast : ∀ q : ℚ, f q = q) (hsup : ∀ x y, f (x ⊔ y) = max (f x) (f y))
    (hinf : ∀ x y, f (x ⊓ y) = min (f x) (f y)) : LinearOrderedField β 
goal: LinearOrderedField β
File: Mathlib/Algebra/Order/Field/Unbundled/Basic.lean

full_name: inv_pos
code: @[simp] lemma inv_pos : 0 < a⁻¹ ↔ 0 < a 
goal: 0 < a⁻¹ ↔ 0 < a

full_name: inv_nonneg
code: @[simp] lemma inv_nonneg : 0 ≤ a⁻¹ ↔ 0 ≤ a 
goal: 0 ≤ a⁻¹ ↔ 0 ≤ a

full_name: inv_lt_zero
code: @[simp] lemma inv_lt_zero : a⁻¹ < 0 ↔ a < 0 
goal: a⁻¹ < 0 ↔ a < 0

full_name: inv_nonpos
code: @[simp] lemma inv_nonpos : a⁻¹ ≤ 0 ↔ a ≤ 0 
goal: a⁻¹ ≤ 0 ↔ a ≤ 0

full_name: one_div_pos
code: lemma one_div_pos : 0 < 1 / a ↔ 0 < a 
goal: 0 < 1 / a ↔ 0 < a

full_name: one_div_neg
code: lemma one_div_neg : 1 / a < 0 ↔ a < 0 
goal: 1 / a < 0 ↔ a < 0

full_name: one_div_nonneg
code: lemma one_div_nonneg : 0 ≤ 1 / a ↔ 0 ≤ a 
goal: 0 ≤ 1 / a ↔ 0 ≤ a

full_name: one_div_nonpos
code: lemma one_div_nonpos : 1 / a ≤ 0 ↔ a ≤ 0 
goal: 1 / a ≤ 0 ↔ a ≤ 0

full_name: div_pos
code: lemma div_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a / b 
goal: 0 < a / b

full_name: div_nonneg
code: lemma div_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a / b 
goal: 0 ≤ a / b

full_name: div_nonpos_of_nonpos_of_nonneg
code: lemma div_nonpos_of_nonpos_of_nonneg [MulPosMono α] (ha : a ≤ 0) (hb : 0 ≤ b) : a / b ≤ 0 
goal: a / b ≤ 0

full_name: div_nonpos_of_nonneg_of_nonpos
code: lemma div_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0) : a / b ≤ 0 
goal: a / b ≤ 0

full_name: zpow_nonneg
code: lemma zpow_nonneg [PosMulMono α] (ha : 0 ≤ a) : ∀ n : ℤ, 0 ≤ a ^ n
  
goal: 0 ≤ a ^ n

full_name: zpow_pos_of_pos
code: lemma zpow_pos_of_pos [PosMulStrictMono α] (ha : 0 < a) : ∀ n : ℤ, 0 < a ^ n
  
goal: 0 < a ^ n
File: Mathlib/Algebra/Order/Field/Pi.lean

full_name: Pi.exists_forall_pos_add_lt
code: theorem Pi.exists_forall_pos_add_lt [ExistsAddOfLE α] [Finite ι] {x y : ι → α}
    (h : ∀ i, x i < y i) : ∃ ε, 0 < ε ∧ ∀ i, x i + ε < y i 
goal: ∃ ε, 0 < ε ∧ ∀ (i : ι), x i + ε < y i