File: Mathlib/Algebra/Order/Positive/Ring.lean

full_name: Positive.instAddSubtypeLtOfNat_mathlib
code: instance : Add { x : M // 0 < x } 
goal: Add { x // 0 < x }

full_name: Positive.coe_add
code: @[simp, norm_cast]
theorem coe_add (x y : { x : M // 0 < x }) : ↑(x + y) = (x + y : M) 
goal: ↑(x + y) = ↑x + ↑y

full_name: Positive.addSemigroup
code: instance addSemigroup : AddSemigroup { x : M // 0 < x } 
goal: AddSemigroup { x // 0 < x }

full_name: Positive.addCommSemigroup
code: instance addCommSemigroup {M : Type*} [AddCommMonoid M] [Preorder M]
    [CovariantClass M M (· + ·) (· < ·)] : AddCommSemigroup { x : M // 0 < x } 
goal: AddCommSemigroup { x // 0 < x }

full_name: Positive.addLeftCancelSemigroup
code: instance addLeftCancelSemigroup {M : Type*} [AddLeftCancelMonoid M] [Preorder M]
    [CovariantClass M M (· + ·) (· < ·)] : AddLeftCancelSemigroup { x : M // 0 < x } 
goal: AddLeftCancelSemigroup { x // 0 < x }

full_name: Positive.addRightCancelSemigroup
code: instance addRightCancelSemigroup {M : Type*} [AddRightCancelMonoid M] [Preorder M]
    [CovariantClass M M (· + ·) (· < ·)] : AddRightCancelSemigroup { x : M // 0 < x } 
goal: AddRightCancelSemigroup { x // 0 < x }

full_name: Positive.covariantClass_add_lt
code: instance covariantClass_add_lt :
    CovariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· < ·) 
goal: CovariantClass { x // 0 < x } { x // 0 < x } (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Positive.covariantClass_swap_add_lt
code: instance covariantClass_swap_add_lt [CovariantClass M M (swap (· + ·)) (· < ·)] :
    CovariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· < ·) 
goal: CovariantClass { x // 0 < x } { x // 0 < x } (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Positive.contravariantClass_add_lt
code: instance contravariantClass_add_lt [ContravariantClass M M (· + ·) (· < ·)] :
    ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· < ·) 
goal: ContravariantClass { x // 0 < x } { x // 0 < x } (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Positive.contravariantClass_swap_add_lt
code: instance contravariantClass_swap_add_lt [ContravariantClass M M (swap (· + ·)) (· < ·)] :
    ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· < ·) 
goal: ContravariantClass { x // 0 < x } { x // 0 < x } (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Positive.contravariantClass_add_le
code: instance contravariantClass_add_le [ContravariantClass M M (· + ·) (· ≤ ·)] :
    ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· ≤ ·) 
goal: ContravariantClass { x // 0 < x } { x // 0 < x } (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Positive.contravariantClass_swap_add_le
code: instance contravariantClass_swap_add_le [ContravariantClass M M (swap (· + ·)) (· ≤ ·)] :
    ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· ≤ ·) 
goal: ContravariantClass { x // 0 < x } { x // 0 < x } (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Positive.covariantClass_add_le
code: instance covariantClass_add_le [AddMonoid M] [PartialOrder M]
    [CovariantClass M M (· + ·) (· < ·)] :
    CovariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· ≤ ·) 
goal: CovariantClass { x // 0 < x } { x // 0 < x } (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Positive.instMulSubtypeLtOfNat_mathlib
code: instance : Mul { x : R // 0 < x } 
goal: Mul { x // 0 < x }

full_name: Positive.val_mul
code: @[simp]
theorem val_mul (x y : { x : R // 0 < x }) : ↑(x * y) = (x * y : R) 
goal: ↑(x * y) = ↑x * ↑y

full_name: Positive.instPowSubtypeLtOfNatNat_mathlib
code: instance : Pow { x : R // 0 < x } ℕ 
goal: Pow { x // 0 < x } ℕ

full_name: Positive.val_pow
code: @[simp]
theorem val_pow (x : { x : R // 0 < x }) (n : ℕ) :
    ↑(x ^ n) = (x : R) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: Positive.instSemigroupSubtypeLtOfNat
code: instance : Semigroup { x : R // 0 < x } 
goal: Semigroup { x // 0 < x }

full_name: Positive.instDistribSubtypeLtOfNat
code: instance : Distrib { x : R // 0 < x } 
goal: Distrib { x // 0 < x }

full_name: Positive.instOneSubtypeLtOfNat
code: instance : One { x : R // 0 < x } 
goal: One { x // 0 < x }

full_name: Positive.val_one
code: @[simp]
theorem val_one : ((1 : { x : R // 0 < x }) : R) = 1 
goal: ↑1 = 1

full_name: Positive.instMonoidSubtypeLtOfNat
code: instance : Monoid { x : R // 0 < x } 
goal: Monoid { x // 0 < x }

full_name: Positive.orderedCommMonoid
code: instance orderedCommMonoid [StrictOrderedCommSemiring R] :
    OrderedCommMonoid { x : R // 0 < x } 
goal: OrderedCommMonoid { x // 0 < x }

full_name: Positive.linearOrderedCancelCommMonoid
code: /-- If `R` is a nontrivial linear ordered commutative semiring, then `{x : R // 0 < x}` is a linear
ordered cancellative commutative monoid. -/
instance linearOrderedCancelCommMonoid [LinearOrderedCommSemiring R] :
    LinearOrderedCancelCommMonoid { x : R // 0 < x } 
goal: LinearOrderedCancelCommMonoid { x // 0 < x }