ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Polynomial/SpecificDegree.lean

full_name: Polynomial.Monic.irreducible_iff_roots_eq_zero_of_degree_le_three
code: /-- A polynomial of degree 2 or 3 is irreducible iff it doesn't have roots. -/
theorem Monic.irreducible_iff_roots_eq_zero_of_degree_le_three {p : R[X]} (hp : p.Monic)
    (hp2 : 2 ≤ p.natDegree) (hp3 : p.natDegree ≤ 3) : Irreducible p ↔ p.roots = 0 
goal: Irreducible p ↔ p.roots = 0

full_name: Polynomial.irreducible_iff_roots_eq_zero_of_degree_le_three
code: /-- A polynomial of degree 2 or 3 is irreducible iff it doesn't have roots. -/
theorem irreducible_iff_roots_eq_zero_of_degree_le_three
    {p : K[X]} (hp2 : 2 ≤ p.natDegree) (hp3 : p.natDegree ≤ 3) : Irreducible p ↔ p.roots = 0 
goal: Irreducible p ↔ p.roots = 0
File: Mathlib/Algebra/Polynomial/Induction.lean

full_name: Polynomial.induction_on
code: @[elab_as_elim]
protected theorem induction_on {M : R[X] → Prop} (p : R[X]) (h_C : ∀ a, M (C a))
    (h_add : ∀ p q, M p → M q → M (p + q))
    (h_monomial : ∀ (n : ℕ) (a : R), M (C a * X ^ n) → M (C a * X ^ (n + 1))) : M p 
goal: M p

full_name: Polynomial.induction_on'
code: /-- To prove something about polynomials,
it suffices to show the condition is closed under taking sums,
and it holds for monomials.
-/
@[elab_as_elim]
protected theorem induction_on' {M : R[X] → Prop} (p : R[X]) (h_add : ∀ p q, M p → M q → M (p + q))
    (h_monomial : ∀ (n : ℕ) (a : R), M (monomial n a)) : M p 
goal: M p

full_name: Polynomial.span_le_of_C_coeff_mem
code: /-- If the coefficients of a polynomial belong to an ideal, then that ideal contains
the ideal spanned by the coefficients of the polynomial. -/
theorem span_le_of_C_coeff_mem (cf : ∀ i : ℕ, C (f.coeff i) ∈ I) :
    Ideal.span { g | ∃ i, g = C (f.coeff i) } ≤ I 
goal: Ideal.span {g | ∃ i, g = Polynomial.C (f.coeff i)} ≤ I

full_name: Polynomial.mem_span_C_coeff
code: theorem mem_span_C_coeff : f ∈ Ideal.span { g : R[X] | ∃ i : ℕ, g = C (coeff f i) } 
goal: f ∈ Ideal.span {g | ∃ i, g = Polynomial.C (f.coeff i)}

full_name: Polynomial.exists_C_coeff_not_mem
code: theorem exists_C_coeff_not_mem : f ∉ I → ∃ i : ℕ, C (coeff f i) ∉ I 
goal: f ∉ I → ∃ i, Polynomial.C (f.coeff i) ∉ I
File: Mathlib/Algebra/Polynomial/CancelLeads.lean

full_name: Polynomial.cancelLeads
code: /-- `cancelLeads p q` is formed by multiplying `p` and `q` by monomials so that they
  have the same leading term, and then subtracting. -/
def cancelLeads : R[X] 
goal: Polynomial R

full_name: Polynomial.neg_cancelLeads
code: @[simp]
theorem neg_cancelLeads : -p.cancelLeads q = q.cancelLeads p 
goal: -p.cancelLeads q = q.cancelLeads p

full_name: Polynomial.natDegree_cancelLeads_lt_of_natDegree_le_natDegree_of_comm
code: theorem natDegree_cancelLeads_lt_of_natDegree_le_natDegree_of_comm
    (comm : p.leadingCoeff * q.leadingCoeff = q.leadingCoeff * p.leadingCoeff)
    (h : p.natDegree ≤ q.natDegree) (hq : 0 < q.natDegree) :
    (p.cancelLeads q).natDegree < q.natDegree 
goal: (p.cancelLeads q).natDegree < q.natDegree

full_name: Polynomial.dvd_cancelLeads_of_dvd_of_dvd
code: theorem dvd_cancelLeads_of_dvd_of_dvd {r : R[X]} (pq : p ∣ q) (pr : p ∣ r) : p ∣ q.cancelLeads r 
goal: p ∣ q.cancelLeads r

full_name: Polynomial.natDegree_cancelLeads_lt_of_natDegree_le_natDegree
code: theorem natDegree_cancelLeads_lt_of_natDegree_le_natDegree (h : p.natDegree ≤ q.natDegree)
    (hq : 0 < q.natDegree) : (p.cancelLeads q).natDegree < q.natDegree 
goal: (p.cancelLeads q).natDegree < q.natDegree
File: Mathlib/Algebra/Polynomial/GroupRingAction.lean

full_name: Polynomial.smul_eq_map
code: theorem smul_eq_map [MulSemiringAction M R] (m : M) :
    HSMul.hSMul m = map (MulSemiringAction.toRingHom M R m) 
goal: HSMul.hSMul m = Polynomial.map (MulSemiringAction.toRingHom M R m)

full_name: Polynomial.instMulSemiringAction
code: noncomputable instance [MulSemiringAction M R] : MulSemiringAction M R[X] 
goal: MulSemiringAction M R[X]

full_name: Polynomial.smul_X
code: @[simp]
theorem smul_X (m : M) : (m • X : R[X]) = X 
goal: m • Polynomial.X = Polynomial.X

full_name: Polynomial.smul_eval_smul
code: theorem smul_eval_smul (m : M) (f : S[X]) (x : S) : (m • f).eval (m • x) = m • f.eval x 
goal: Polynomial.eval (m • x) (m • f) = m • Polynomial.eval x f

full_name: Polynomial.eval_smul'
code: theorem eval_smul' [MulSemiringAction G S] (g : G) (f : S[X]) (x : S) :
    f.eval (g • x) = g • (g⁻¹ • f).eval x 
goal: Polynomial.eval (g • x) f = g • Polynomial.eval x (g⁻¹ • f)

full_name: Polynomial.smul_eval
code: theorem smul_eval [MulSemiringAction G S] (g : G) (f : S[X]) (x : S) :
    (g • f).eval x = g • f.eval (g⁻¹ • x) 
goal: Polynomial.eval x (g • f) = g • Polynomial.eval (g⁻¹ • x) f

full_name: prodXSubSMul
code: /-- the product of `(X - g • x)` over distinct `g • x`. -/
noncomputable def prodXSubSMul (x : R) : R[X] 
goal: R[X]

full_name: prodXSubSMul.monic
code: theorem prodXSubSMul.monic (x : R) : (prodXSubSMul G R x).Monic 
goal: (prodXSubSMul G R x).Monic

full_name: prodXSubSMul.eval
code: theorem prodXSubSMul.eval (x : R) : (prodXSubSMul G R x).eval x = 0 
goal: Polynomial.eval x (prodXSubSMul G R x) = 0

full_name: prodXSubSMul.smul
code: theorem prodXSubSMul.smul (x : R) (g : G) : g • prodXSubSMul G R x = prodXSubSMul G R x 
goal: g • prodXSubSMul G R x = prodXSubSMul G R x

full_name: prodXSubSMul.coeff
code: theorem prodXSubSMul.coeff (x : R) (g : G) (n : ℕ) :
    g • (prodXSubSMul G R x).coeff n = (prodXSubSMul G R x).coeff n 
goal: g • (prodXSubSMul G R x).coeff n = (prodXSubSMul G R x).coeff n

full_name: MulSemiringActionHom.polynomial
code: /-- An equivariant map induces an equivariant map on polynomials. -/
protected noncomputable def polynomial (g : P →+*[M] Q) : P[X] →+*[M] Q[X] 
goal: P[X] →+*[M] Q[X]

full_name: MulSemiringActionHom.coe_polynomial
code: @[simp]
theorem coe_polynomial (g : P →+*[M] Q) : (g.polynomial : P[X] → Q[X]) = map g 
goal: ⇑g.polynomial = Polynomial.map ↑g
File: Mathlib/Algebra/AlgebraicCard.lean

full_name: Algebraic.infinite_of_charZero
code: theorem infinite_of_charZero (R A : Type*) [CommRing R] [IsDomain R] [Ring A] [Algebra R A]
    [CharZero A] : { x : A | IsAlgebraic R x }.Infinite 
goal: {x | IsAlgebraic R x}.Infinite

full_name: Algebraic.aleph0_le_cardinal_mk_of_charZero
code: theorem aleph0_le_cardinal_mk_of_charZero (R A : Type*) [CommRing R] [IsDomain R] [Ring A]
    [Algebra R A] [CharZero A] : ℵ₀ ≤ #{ x : A // IsAlgebraic R x } 
goal: ℵ₀ ≤ #{ x // IsAlgebraic R x }

full_name: Algebraic.cardinal_mk_lift_le_mul
code: theorem cardinal_mk_lift_le_mul :
    Cardinal.lift.{u} #{ x : A // IsAlgebraic R x } ≤ Cardinal.lift.{v} #R[X] * ℵ₀ 
goal: Cardinal.lift.{u, v} #{ x // IsAlgebraic R x } ≤ Cardinal.lift.{v, u} #R[X] * ℵ₀

full_name: Algebraic.cardinal_mk_lift_le_max
code: theorem cardinal_mk_lift_le_max :
    Cardinal.lift.{u} #{ x : A // IsAlgebraic R x } ≤ max (Cardinal.lift.{v} #R) ℵ₀ 
goal: Cardinal.lift.{u, v} #{ x // IsAlgebraic R x } ≤ max (Cardinal.lift.{v, u} #R) ℵ₀

full_name: Algebraic.cardinal_mk_lift_of_infinite
code: @[simp]
theorem cardinal_mk_lift_of_infinite [Infinite R] :
    Cardinal.lift.{u} #{ x : A // IsAlgebraic R x } = Cardinal.lift.{v} #R 
goal: Cardinal.lift.{u, v} #{ x // IsAlgebraic R x } = Cardinal.lift.{v, u} #R

full_name: Algebraic.countable
code: @[simp]
protected theorem countable : Set.Countable { x : A | IsAlgebraic R x } 
goal: {x | IsAlgebraic R x}.Countable

full_name: Algebraic.cardinal_mk_of_countable_of_charZero
code: @[simp]
theorem cardinal_mk_of_countable_of_charZero [CharZero A] [IsDomain R] :
    #{ x : A // IsAlgebraic R x } = ℵ₀ 
goal: #{ x // IsAlgebraic R x } = ℵ₀

full_name: Algebraic.cardinal_mk_le_mul
code: theorem cardinal_mk_le_mul : #{ x : A // IsAlgebraic R x } ≤ #R[X] * ℵ₀ 
goal: #{ x // IsAlgebraic R x } ≤ #R[X] * ℵ₀

full_name: Algebraic.cardinal_mk_le_max
code: theorem cardinal_mk_le_max : #{ x : A // IsAlgebraic R x } ≤ max #R ℵ₀ 
goal: #{ x // IsAlgebraic R x } ≤ max #R ℵ₀

full_name: Algebraic.cardinal_mk_of_infinite
code: @[simp]
theorem cardinal_mk_of_infinite [Infinite R] : #{ x : A // IsAlgebraic R x } = #R 
goal: #{ x // IsAlgebraic R x } = #R
File: Mathlib/Algebra/Order/Sum.lean

full_name: Sum.one_le_elim_iff
code: @[to_additive]
lemma one_le_elim_iff : 1 ≤ Sum.elim v₁ v₂ ↔ 1 ≤ v₁ ∧ 1 ≤ v₂ 
goal: 1 ≤ Sum.elim v₁ v₂ ↔ 1 ≤ v₁ ∧ 1 ≤ v₂

full_name: Sum.nonneg_elim_iff
code: @[to_additive]
lemma one_le_elim_iff : 1 ≤ Sum.elim v₁ v₂ ↔ 1 ≤ v₁ ∧ 1 ≤ v₂ 
goal: 0 ≤ Sum.elim v₁ v₂ ↔ 0 ≤ v₁ ∧ 0 ≤ v₂

full_name: Sum.elim_le_one_iff
code: @[to_additive]
lemma elim_le_one_iff : Sum.elim v₁ v₂ ≤ 1 ↔ v₁ ≤ 1 ∧ v₂ ≤ 1 
goal: Sum.elim v₁ v₂ ≤ 1 ↔ v₁ ≤ 1 ∧ v₂ ≤ 1

full_name: Sum.elim_nonpos_iff
code: @[to_additive]
lemma elim_le_one_iff : Sum.elim v₁ v₂ ≤ 1 ↔ v₁ ≤ 1 ∧ v₂ ≤ 1 
goal: Sum.elim v₁ v₂ ≤ 0 ↔ v₁ ≤ 0 ∧ v₂ ≤ 0
File: Mathlib/Algebra/Order/ZeroLEOne.lean

full_name: ZeroLEOneClass.zero_le_one
code: /-- Typeclass for expressing that the `0` of a type is less or equal to its `1`. -/
class ZeroLEOneClass (α : Type*) [Zero α] [One α] [LE α] : Prop where
  /-- Zero is less than or equal to one. -/
  zero_le_one : (0 : α) ≤ 1
goal: 0 ≤ 1

full_name: ZeroLEOneClass
code: /-- Typeclass for expressing that the `0` of a type is less or equal to its `1`. -/
class ZeroLEOneClass (α : Type*) [Zero α] [One α] [LE α] : Prop where
  /-- Zero is less than or equal to one. -/
  zero_le_one : (0 : α) ≤ 1
goal: Prop

full_name: zero_le_one
code: /-- `zero_le_one` with the type argument implicit. -/
@[simp] lemma zero_le_one [Zero α] [One α] [LE α] [ZeroLEOneClass α] : (0 : α) ≤ 1 
goal: 0 ≤ 1

full_name: zero_le_one'
code: /-- `zero_le_one` with the type argument explicit. -/
lemma zero_le_one' (α) [Zero α] [One α] [LE α] [ZeroLEOneClass α] : (0 : α) ≤ 1 
goal: 0 ≤ 1

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

full_name: zero_lt_one'
code: /-- See `zero_lt_one` for a version with the type implicit. -/
lemma zero_lt_one' : (0 : α) < 1 
goal: 0 < 1
File: Mathlib/Algebra/QuadraticDiscriminant.lean

full_name: discrim
code: /-- Discriminant of a quadratic -/
def discrim [Ring R] (a b c : R) : R 
goal: R

full_name: discrim_neg
code: @[simp] lemma discrim_neg [Ring R] (a b c : R) : discrim (-a) (-b) (-c) = discrim a b c 
goal: discrim (-a) (-b) (-c) = discrim a b c

full_name: discrim_eq_sq_of_quadratic_eq_zero
code: lemma discrim_eq_sq_of_quadratic_eq_zero {x : R} (h : a * x * x + b * x + c = 0) :
    discrim a b c = (2 * a * x + b) ^ 2 
goal: discrim a b c = (2 * a * x + b) ^ 2

full_name: quadratic_eq_zero_iff_discrim_eq_sq
code: /-- A quadratic has roots if and only if its discriminant equals some square.
-/
theorem quadratic_eq_zero_iff_discrim_eq_sq [NeZero (2 : R)] [NoZeroDivisors R]
    (ha : a ≠ 0) (x : R) :
    a * x * x + b * x + c = 0 ↔ discrim a b c = (2 * a * x + b) ^ 2 
goal: a * x * x + b * x + c = 0 ↔ discrim a b c = (2 * a * x + b) ^ 2

full_name: quadratic_ne_zero_of_discrim_ne_sq
code: /-- A quadratic has no root if its discriminant has no square root. -/
theorem quadratic_ne_zero_of_discrim_ne_sq (h : ∀ s : R, discrim a b c ≠ s^2) (x : R) :
    a * x * x + b * x + c ≠ 0 
goal: a * x * x + b * x + c ≠ 0

full_name: quadratic_eq_zero_iff
code: /-- Roots of a quadratic equation. -/
theorem quadratic_eq_zero_iff (ha : a ≠ 0) {s : K} (h : discrim a b c = s * s) (x : K) :
    a * x * x + b * x + c = 0 ↔ x = (-b + s) / (2 * a) ∨ x = (-b - s) / (2 * a) 
goal: a * x * x + b * x + c = 0 ↔ x = (-b + s) / (2 * a) ∨ x = (-b - s) / (2 * a)

full_name: exists_quadratic_eq_zero
code: /-- A quadratic has roots if its discriminant has square roots -/
theorem exists_quadratic_eq_zero (ha : a ≠ 0) (h : ∃ s, discrim a b c = s * s) :
    ∃ x, a * x * x + b * x + c = 0 
goal: ∃ x, a * x * x + b * x + c = 0

full_name: quadratic_eq_zero_iff_of_discrim_eq_zero
code: /-- Root of a quadratic when its discriminant equals zero -/
theorem quadratic_eq_zero_iff_of_discrim_eq_zero (ha : a ≠ 0) (h : discrim a b c = 0) (x : K) :
    a * x * x + b * x + c = 0 ↔ x = -b / (2 * a) 
goal: a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)

full_name: discrim_le_zero
code: /-- If a polynomial of degree 2 is always nonnegative, then its discriminant is nonpositive -/
theorem discrim_le_zero (h : ∀ x : K, 0 ≤ a * x * x + b * x + c) : discrim a b c ≤ 0 
goal: discrim a b c ≤ 0

full_name: discrim_le_zero_of_nonpos
code: lemma discrim_le_zero_of_nonpos (h : ∀ x : K, a * x * x + b * x + c ≤ 0) : discrim a b c ≤ 0 
goal: discrim a b c ≤ 0

full_name: discrim_lt_zero
code: /-- If a polynomial of degree 2 is always positive, then its discriminant is negative,
at least when the coefficient of the quadratic term is nonzero.
-/
theorem discrim_lt_zero (ha : a ≠ 0) (h : ∀ x : K, 0 < a * x * x + b * x + c) :
    discrim a b c < 0 
goal: discrim a b c < 0

full_name: discrim_lt_zero_of_neg
code: lemma discrim_lt_zero_of_neg (ha : a ≠ 0) (h : ∀ x : K, a * x * x + b * x + c < 0) :
    discrim a b c < 0 
goal: discrim a b c < 0
File: Mathlib/Algebra/Order/GroupWithZero/Synonym.lean

full_name: instMulZeroClassOrderDual
code: instance [h : MulZeroClass α] : MulZeroClass αᵒᵈ 
goal: MulZeroClass αᵒᵈ

full_name: instMulZeroOneClassOrderDual
code: instance [h : MulZeroOneClass α] : MulZeroOneClass αᵒᵈ 
goal: MulZeroOneClass αᵒᵈ

full_name: instNoZeroDivisorsOrderDual
code: instance [Mul α] [Zero α] [h : NoZeroDivisors α] : NoZeroDivisors αᵒᵈ 
goal: NoZeroDivisors αᵒᵈ

full_name: instSemigroupWithZeroOrderDual
code: instance [h : SemigroupWithZero α] : SemigroupWithZero αᵒᵈ 
goal: SemigroupWithZero αᵒᵈ

full_name: instMonoidWithZeroOrderDual
code: instance [h : MonoidWithZero α] : MonoidWithZero αᵒᵈ 
goal: MonoidWithZero αᵒᵈ

full_name: instCancelMonoidWithZeroOrderDual
code: instance [h : CancelMonoidWithZero α] : CancelMonoidWithZero αᵒᵈ 
goal: CancelMonoidWithZero αᵒᵈ

full_name: instCommMonoidWithZeroOrderDual
code: instance [h : CommMonoidWithZero α] : CommMonoidWithZero αᵒᵈ 
goal: CommMonoidWithZero αᵒᵈ

full_name: instCancelCommMonoidWithZeroOrderDual
code: instance [h : CancelCommMonoidWithZero α] : CancelCommMonoidWithZero αᵒᵈ 
goal: CancelCommMonoidWithZero αᵒᵈ

full_name: instGroupWithZeroOrderDual
code: instance [h : GroupWithZero α] : GroupWithZero αᵒᵈ 
goal: GroupWithZero αᵒᵈ

full_name: instCommGroupWithZeroOrderDual
code: instance [h : CommGroupWithZero α] : CommGroupWithZero αᵒᵈ 
goal: CommGroupWithZero αᵒᵈ

full_name: instMulZeroClassLex
code: instance [h : MulZeroClass α] : MulZeroClass (Lex α) 
goal: MulZeroClass (Lex α)

full_name: instMulZeroOneClassLex
code: instance [h : MulZeroOneClass α] : MulZeroOneClass (Lex α) 
goal: MulZeroOneClass (Lex α)

full_name: instNoZeroDivisorsLex
code: instance [Mul α] [Zero α] [h : NoZeroDivisors α] : NoZeroDivisors (Lex α) 
goal: NoZeroDivisors (Lex α)

full_name: instSemigroupWithZeroLex
code: instance [h : SemigroupWithZero α] : SemigroupWithZero (Lex α) 
goal: SemigroupWithZero (Lex α)

full_name: instMonoidWithZeroLex
code: instance [h : MonoidWithZero α] : MonoidWithZero (Lex α) 
goal: MonoidWithZero (Lex α)

full_name: instCancelMonoidWithZeroLex
code: instance [h : CancelMonoidWithZero α] : CancelMonoidWithZero (Lex α) 
goal: CancelMonoidWithZero (Lex α)

full_name: instCommMonoidWithZeroLex
code: instance [h : CommMonoidWithZero α] : CommMonoidWithZero (Lex α) 
goal: CommMonoidWithZero (Lex α)

full_name: instCancelCommMonoidWithZeroLex
code: instance [h : CancelCommMonoidWithZero α] : CancelCommMonoidWithZero (Lex α) 
goal: CancelCommMonoidWithZero (Lex α)

full_name: instGroupWithZeroLex
code: instance [h : GroupWithZero α] : GroupWithZero (Lex α) 
goal: GroupWithZero (Lex α)

full_name: instCommGroupWithZeroLex
code: instance [h : CommGroupWithZero α] : CommGroupWithZero (Lex α) 
goal: CommGroupWithZero (Lex α)
File: Mathlib/Algebra/Order/GroupWithZero/WithZero.lean

full_name: instPosMulStrictMonoWithZeroOfCovariantClassHMulLt
code: instance {α : Type*} [Mul α] [Preorder α] [CovariantClass α α (· * ·) (· < ·)] :
    PosMulStrictMono (WithZero α) 
goal: PosMulStrictMono (WithZero α)

full_name: instMulPosStrictMonoWithZeroOfCovariantClassSwapHMulLt
code: instance {α : Type*} [Mul α] [Preorder α] [CovariantClass α α (swap (· * ·)) (· < ·)] :
    MulPosStrictMono (WithZero α) 
goal: MulPosStrictMono (WithZero α)

full_name: instPosMulMonoWithZeroOfCovariantClassHMulLe
code: instance {α : Type*} [Mul α] [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)] :
    PosMulMono (WithZero α) 
goal: PosMulMono (WithZero α)

full_name: instMulPosMonoWithZeroOfCovariantClassSwapHMulLe
code: instance {α : Type*} [Mul α] [Preorder α] [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
    MulPosMono (WithZero α) 
goal: MulPosMono (WithZero α)
File: Mathlib/Algebra/Order/Floor/Prime.lean

full_name: FloorRing.exists_prime_mul_pow_lt_factorial
code: theorem exists_prime_mul_pow_lt_factorial [LinearOrderedRing K] [FloorRing K] (n : ℕ) (a c : K) :
    ∃ p > n, p.Prime ∧ a * c ^ p < (p - 1)! 
goal: ∃ p > n, Nat.Prime p ∧ a * c ^ p < ↑(p - 1).factorial

full_name: FloorRing.exists_prime_mul_pow_div_factorial_lt_one
code: theorem exists_prime_mul_pow_div_factorial_lt_one [LinearOrderedField K] [FloorRing K]
    (n : ℕ) (a c : K) :
    ∃ p > n, p.Prime ∧ a * c ^ p / (p - 1)! < 1 
goal: ∃ p > n, Nat.Prime p ∧ a * c ^ p / ↑(p - 1).factorial < 1
File: Mathlib/Algebra/Order/Nonneg/Floor.lean

full_name: Nonneg.floorSemiring
code: instance floorSemiring [OrderedSemiring α] [FloorSemiring α] :
    FloorSemiring { r : α // 0 ≤ r } 
goal: FloorSemiring { r // 0 ≤ r }

full_name: Nonneg.nat_floor_coe
code: @[norm_cast]
theorem nat_floor_coe [OrderedSemiring α] [FloorSemiring α] (a : { r : α // 0 ≤ r }) :
    ⌊(a : α)⌋₊ = ⌊a⌋₊ 
goal: ⌊↑a⌋₊ = ⌊a⌋₊

full_name: Nonneg.nat_ceil_coe
code: @[norm_cast]
theorem nat_ceil_coe [OrderedSemiring α] [FloorSemiring α] (a : { r : α // 0 ≤ r }) :
    ⌈(a : α)⌉₊ = ⌈a⌉₊ 
goal: ⌈↑a⌉₊ = ⌈a⌉₊
File: Mathlib/Algebra/Order/Nonneg/Module.lean

full_name: «_aux_Mathlib_Algebra_Order_Nonneg_Module___macroRules_term𝕜≥0_1»
code: local notation3 "𝕜≥0" => {c : 𝕜 // 0 ≤ c}
goal: Lean.Macro

full_name: Nonneg.instSMul
code: instance instSMul : SMul 𝕜≥0 𝕜' 
goal: SMul 𝕜≥0 𝕜'

full_name: Nonneg.coe_smul
code: @[simp, norm_cast]
lemma coe_smul (a : 𝕜≥0) (x : 𝕜') : (a : 𝕜) • x = a • x 
goal: ↑a • x = a • x

full_name: Nonneg.mk_smul
code: @[simp]
lemma mk_smul (a) (ha) (x : 𝕜') : (⟨a, ha⟩ : 𝕜≥0) • x = a • x 
goal: ⟨a, ha⟩ • x = a • x

full_name: Nonneg.instIsScalarTower
code: instance instIsScalarTower : IsScalarTower 𝕜≥0 𝕜' E 
goal: IsScalarTower 𝕜≥0 𝕜' E

full_name: Nonneg.instSMulWithZero
code: instance instSMulWithZero : SMulWithZero 𝕜≥0 𝕜' 
goal: SMulWithZero 𝕜≥0 𝕜'

full_name: Nonneg.instOrderedSMul
code: instance instOrderedSMul : OrderedSMul 𝕜≥0 E 
goal: OrderedSMul 𝕜≥0 E

full_name: Nonneg.instModule
code: /-- A module over an ordered semiring is also a module over just the non-negative scalars. -/
instance instModule : Module 𝕜≥0 E 
goal: Module 𝕜≥0 E
File: Mathlib/Algebra/Order/Module/Rat.lean

full_name: abs_nnqsmul
code: @[simp] lemma abs_nnqsmul [DistribMulAction ℚ≥0 α] [PosSMulMono ℚ≥0 α] (q : ℚ≥0) (a : α) :
    |q • a| = q • |a| 
goal: |q • a| = q • |a|

full_name: abs_qsmul
code: @[simp] lemma abs_qsmul [Module ℚ α] [PosSMulMono ℚ α] (q : ℚ) (a : α) :
    |q • a| = |q| • |a| 
goal: |q • a| = |q| • |a|

full_name: LinearOrderedSemifield.toPosSMulStrictMono_rat
code: instance LinearOrderedSemifield.toPosSMulStrictMono_rat : PosSMulStrictMono ℚ≥0 α 
goal: PosSMulStrictMono ℚ≥0 α

full_name: LinearOrderedField.toPosSMulStrictMono_rat
code: instance LinearOrderedField.toPosSMulStrictMono_rat : PosSMulStrictMono ℚ α 
goal: PosSMulStrictMono ℚ α
File: Mathlib/Algebra/Order/Sub/Basic.lean

full_name: AddHom.le_map_tsub
code: theorem AddHom.le_map_tsub [Preorder β] [Add β] [Sub β] [OrderedSub β] (f : AddHom α β)
    (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) 
goal: f a - f b ≤ f (a - b)

full_name: le_mul_tsub
code: theorem le_mul_tsub {R : Type*} [Distrib R] [Preorder R] [Sub R] [OrderedSub R]
    [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * b - a * c ≤ a * (b - c) 
goal: a * b - a * c ≤ a * (b - c)

full_name: le_tsub_mul
code: theorem le_tsub_mul {R : Type*} [CommSemiring R] [Preorder R] [Sub R] [OrderedSub R]
    [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * c - b * c ≤ (a - b) * c 
goal: a * c - b * c ≤ (a - b) * c

full_name: OrderIso.map_tsub
code: /-- An order isomorphism between types with ordered subtraction preserves subtraction provided that
it preserves addition. -/
theorem OrderIso.map_tsub {M N : Type*} [Preorder M] [Add M] [Sub M] [OrderedSub M]
    [PartialOrder N] [Add N] [Sub N] [OrderedSub N] (e : M ≃o N)
    (h_add : ∀ a b, e (a + b) = e a + e b) (a b : M) : e (a - b) = e a - e b 
goal: e (a - b) = e a - e b

full_name: AddMonoidHom.le_map_tsub
code: theorem AddMonoidHom.le_map_tsub [Preorder β] [AddCommMonoid β] [Sub β] [OrderedSub β] (f : α →+ β)
    (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b) 
goal: f a - f b ≤ f (a - b)
File: Mathlib/Algebra/Order/Nonneg/Ring.lean

full_name: Nonneg.orderedAddCommMonoid
code: instance orderedAddCommMonoid [OrderedAddCommMonoid α] : OrderedAddCommMonoid { x : α // 0 ≤ x } 
goal: OrderedAddCommMonoid { x // 0 ≤ x }

full_name: Nonneg.linearOrderedAddCommMonoid
code: instance linearOrderedAddCommMonoid [LinearOrderedAddCommMonoid α] :
    LinearOrderedAddCommMonoid { x : α // 0 ≤ x } 
goal: LinearOrderedAddCommMonoid { x // 0 ≤ x }

full_name: Nonneg.orderedCancelAddCommMonoid
code: instance orderedCancelAddCommMonoid [OrderedCancelAddCommMonoid α] :
    OrderedCancelAddCommMonoid { x : α // 0 ≤ x } 
goal: OrderedCancelAddCommMonoid { x // 0 ≤ x }

full_name: Nonneg.linearOrderedCancelAddCommMonoid
code: instance linearOrderedCancelAddCommMonoid [LinearOrderedCancelAddCommMonoid α] :
    LinearOrderedCancelAddCommMonoid { x : α // 0 ≤ x } 
goal: LinearOrderedCancelAddCommMonoid { x // 0 ≤ x }

full_name: Nonneg.orderedSemiring
code: instance orderedSemiring [OrderedSemiring α] : OrderedSemiring { x : α // 0 ≤ x } 
goal: OrderedSemiring { x // 0 ≤ x }

full_name: Nonneg.strictOrderedSemiring
code: instance strictOrderedSemiring [StrictOrderedSemiring α] :
    StrictOrderedSemiring { x : α // 0 ≤ x } 
goal: StrictOrderedSemiring { x // 0 ≤ x }

full_name: Nonneg.orderedCommSemiring
code: instance orderedCommSemiring [OrderedCommSemiring α] : OrderedCommSemiring { x : α // 0 ≤ x } 
goal: OrderedCommSemiring { x // 0 ≤ x }

full_name: Nonneg.strictOrderedCommSemiring
code: instance strictOrderedCommSemiring [StrictOrderedCommSemiring α] :
    StrictOrderedCommSemiring { x : α // 0 ≤ x } 
goal: StrictOrderedCommSemiring { x // 0 ≤ x }

full_name: Nonneg.nontrivial
code: instance nontrivial [LinearOrderedSemiring α] : Nontrivial { x : α // 0 ≤ x } 
goal: Nontrivial { x // 0 ≤ x }

full_name: Nonneg.linearOrderedSemiring
code: instance linearOrderedSemiring [LinearOrderedSemiring α] :
    LinearOrderedSemiring { x : α // 0 ≤ x } 
goal: LinearOrderedSemiring { x // 0 ≤ x }

full_name: Nonneg.linearOrderedCommMonoidWithZero
code: instance linearOrderedCommMonoidWithZero [LinearOrderedCommRing α] :
    LinearOrderedCommMonoidWithZero { x : α // 0 ≤ x } 
goal: LinearOrderedCommMonoidWithZero { x // 0 ≤ x }

full_name: Nonneg.canonicallyOrderedAddCommMonoid
code: instance canonicallyOrderedAddCommMonoid [OrderedRing α] :
    CanonicallyOrderedAddCommMonoid { x : α // 0 ≤ x } 
goal: CanonicallyOrderedAddCommMonoid { x // 0 ≤ x }

full_name: Nonneg.canonicallyOrderedCommSemiring
code: instance canonicallyOrderedCommSemiring [OrderedCommRing α] [NoZeroDivisors α] :
    CanonicallyOrderedCommSemiring { x : α // 0 ≤ x } 
goal: CanonicallyOrderedCommSemiring { x // 0 ≤ x }

full_name: Nonneg.canonicallyLinearOrderedAddCommMonoid
code: instance canonicallyLinearOrderedAddCommMonoid [LinearOrderedRing α] :
    CanonicallyLinearOrderedAddCommMonoid { x : α // 0 ≤ x } 
goal: CanonicallyLinearOrderedAddCommMonoid { x // 0 ≤ x }

full_name: Nonneg.orderedSub
code: instance orderedSub [LinearOrderedRing α] : OrderedSub { x : α // 0 ≤ x } 
goal: OrderedSub { x // 0 ≤ x }