# Adjoining a zero/one to semigroups and related algebraic structures #

This file contains different results about adjoining an element to an algebraic structure which then behaves like a zero or a one. An example is adjoining a one to a semigroup to obtain a monoid. That this provides an example of an adjunction is proved in Mathlib.Algebra.Category.MonCat.Adjunctions.

Another result says that adjoining to a group an element zero gives a GroupWithZero. For more information about these structures (which are not that standard in informal mathematics, see Mathlib.Algebra.GroupWithZero.Basic)

## Porting notes #

In Lean 3, we use id here and there to get correct types of proofs. This is required because WithOne and WithZero are marked as irreducible at the end of Mathlib.Algebra.Group.WithOne.Defs, so proofs that use Option α instead of WithOne α no longer typecheck. In Lean 4, both types are plain defs, so we don't need these ids.

## TODO #

WithOne.coe_mul and WithZero.coe_mul have inconsistent use of implicit parameters

def WithZero (α : Type u_1) :
Type u_1

Add an extra element 0 to a type

Equations
Instances For
def WithOne (α : Type u_1) :
Type u_1

Add an extra element 1 to a type

Equations
Instances For
instance WithOne.instReprWithZero {α : Type u} [Repr α] :
Repr ()
Equations
• One or more equations did not get rendered due to their size.
abbrev WithZero.instRepr.match_1 {α : Type u_1} (motive : Sort u_2) :
(o : ) → (Unitmotive none)((a : α) → motive (some a))motive o
Equations
Instances For
instance WithZero.instRepr {α : Type u} [Repr α] :
Repr ()
Equations
• One or more equations did not get rendered due to their size.
instance WithOne.instRepr {α : Type u} [Repr α] :
Repr ()
Equations
• One or more equations did not get rendered due to their size.
Equations
Equations
instance WithZero.zero {α : Type u} :
Zero ()
Equations
• WithZero.zero = { zero := none }
instance WithOne.one {α : Type u} :
One ()
Equations
• WithOne.one = { one := none }
Equations
instance WithOne.mul {α : Type u} [Mul α] :
Mul ()
Equations
instance WithZero.neg {α : Type u} [Neg α] :
Neg ()
Equations
• WithZero.neg = { neg := fun (a : ) => Option.map Neg.neg a }
instance WithOne.inv {α : Type u} [Inv α] :
Inv ()
Equations
• WithOne.inv = { inv := fun (a : ) => Option.map Inv.inv a }
instance WithZero.negZeroClass {α : Type u} [Neg α] :
Equations
• WithZero.negZeroClass = let __src := WithZero.zero; let __src_1 := WithZero.neg;
theorem WithZero.negZeroClass.proof_1 {α : Type u_1} [Neg α] :
-0 = -0
instance WithOne.invOneClass {α : Type u} [Inv α] :
Equations
• WithOne.invOneClass = let __src := WithOne.one; let __src_1 := WithOne.inv;
instance WithZero.inhabited {α : Type u} :
Equations
• WithZero.inhabited = { default := 0 }
instance WithOne.inhabited {α : Type u} :
Equations
• WithOne.inhabited = { default := 1 }
instance WithZero.nontrivial {α : Type u} [] :
Equations
• =
instance WithOne.nontrivial {α : Type u} [] :
Equations
• =
def WithZero.coe {α : Type u} :
α

The canonical map from α into WithZero α

Equations
• WithZero.coe = some
Instances For
def WithOne.coe {α : Type u} :
α

The canonical map from α into WithOne α

Equations
• WithOne.coe = some
Instances For
instance WithZero.coeTC {α : Type u} :
CoeTC α ()
Equations
• WithZero.coeTC = { coe := WithZero.coe }
instance WithOne.coeTC {α : Type u} :
CoeTC α ()
Equations
• WithOne.coeTC = { coe := WithOne.coe }
def WithZero.recZeroCoe {α : Type u} {C : Sort u_1} (h₁ : C 0) (h₂ : (a : α) → C a) (n : ) :
C n

Recursor for WithZero using the preferred forms 0 and ↑a.

Equations
Instances For
def WithOne.recOneCoe {α : Type u} {C : Sort u_1} (h₁ : C 1) (h₂ : (a : α) → C a) (n : ) :
C n

Recursor for WithOne using the preferred forms 1 and ↑a.

Equations
Instances For
def WithZero.unzero {α : Type u} {x : } :
x 0α

Deconstruct an x : WithZero α to the underlying value in α, given a proof that x ≠ 0.

Equations
Instances For
abbrev WithZero.unzero.match_1 {α : Type u_1} (motive : (x : ) → x 0Sort u_2) :
(x : ) → (x_1 : x 0) → ((x : α) → (x_2 : x 0) → motive (some x) x_2)motive x x_1
Equations
• One or more equations did not get rendered due to their size.
Instances For
def WithOne.unone {α : Type u} {x : } :
x 1α

Deconstruct an x : WithOne α to the underlying value in α, given a proof that x ≠ 1.

Equations
• = match x✝, x with | some x, x_1 => x
Instances For
@[simp]
theorem WithZero.unzero_coe {α : Type u} {x : α} (hx : x 0) :
= x
@[simp]
theorem WithOne.unone_coe {α : Type u} {x : α} (hx : x 1) :
= x
abbrev WithZero.coe_unzero.match_1 {α : Type u_1} (motive : (x : ) → x 0Prop) :
∀ (x : ) (x_1 : x 0), (∀ (x : α) (x_2 : x 0), motive (some x) x_2)motive x x_1
Equations
• =
Instances For
@[simp]
theorem WithZero.coe_unzero {α : Type u} {x : } (hx : x 0) :
() = x
@[simp]
theorem WithOne.coe_unone {α : Type u} {x : } (hx : x 1) :
() = x
@[simp]
theorem WithZero.coe_ne_zero {α : Type u} {a : α} :
a 0
@[simp]
theorem WithOne.coe_ne_one {α : Type u} {a : α} :
a 1
@[simp]
theorem WithZero.zero_ne_coe {α : Type u} {a : α} :
0 a
@[simp]
theorem WithOne.one_ne_coe {α : Type u} {a : α} :
1 a
theorem WithZero.ne_zero_iff_exists {α : Type u} {x : } :
x 0 ∃ (a : α), a = x
theorem WithOne.ne_one_iff_exists {α : Type u} {x : } :
x 1 ∃ (a : α), a = x
instance WithZero.canLift {α : Type u} :
CanLift () α WithZero.coe fun (a : ) => a 0
Equations
• =
instance WithOne.canLift {α : Type u} :
CanLift () α WithOne.coe fun (a : ) => a 1
Equations
• =
@[simp]
theorem WithZero.coe_inj {α : Type u} {a : α} {b : α} :
a = b a = b
@[simp]
theorem WithOne.coe_inj {α : Type u} {a : α} {b : α} :
a = b a = b
theorem WithZero.cases_on {α : Type u} {P : Prop} (x : ) :
P 0(∀ (a : α), P a)P x
theorem WithOne.cases_on {α : Type u} {P : Prop} (x : ) :
P 1(∀ (a : α), P a)P x
theorem WithZero.addZeroClass.proof_2 {α : Type u_1} [Add α] (a : ) :
Option.liftOrGet (fun (x x_1 : α) => x + x_1) a none = a
Equations
theorem WithZero.addZeroClass.proof_1 {α : Type u_1} [Add α] (a : ) :
Option.liftOrGet (fun (x x_1 : α) => x + x_1) none a = a
instance WithOne.mulOneClass {α : Type u} [Mul α] :
Equations
• WithOne.mulOneClass =
@[simp]
theorem WithZero.coe_add {α : Type u} [Add α] (a : α) (b : α) :
(a + b) = a + b
@[simp]
theorem WithOne.coe_mul {α : Type u} [Mul α] (a : α) (b : α) :
(a * b) = a * b
theorem WithZero.addMonoid.proof_5 {α : Type u_1} [] :
∀ (n : ) (x : ), nsmulRec (n + 1) x = nsmulRec (n + 1) x
abbrev WithZero.addMonoid.match_1 {α : Type u_1} (motive : Prop) :
∀ (a b c : ), (∀ (b c : ), motive none b c)(∀ (a : α) (c : ), motive (some a) none c)(∀ (a b : α), motive (some a) (some b) none)(∀ (a b c : α), motive (some a) (some b) (some c))motive a b c
Equations
• =
Instances For
theorem WithZero.addMonoid.proof_2 {α : Type u_1} [] (a : ) :
0 + a = a
theorem WithZero.addMonoid.proof_4 {α : Type u_1} [] :
∀ (x : ), nsmulRec 0 x = nsmulRec 0 x
theorem WithZero.addMonoid.proof_3 {α : Type u_1} [] (a : ) :
a + 0 = a
theorem WithZero.addMonoid.proof_1 {α : Type u_1} [] (a : ) (b : ) (c : ) :
a + b + c = a + (b + c)
instance WithZero.addMonoid {α : Type u} [] :
Equations
instance WithOne.monoid {α : Type u} [] :
Equations
• WithOne.monoid = let __spread.0 := WithOne.mulOneClass; Monoid.mk npowRec
abbrev WithZero.addCommMonoid.match_1 {α : Type u_1} (motive : Prop) :
∀ (a b : ), (∀ (a b : α), motive (some a) (some b))(∀ (val : α), motive (some val) none)(∀ (val : α), motive none (some val))(Unitmotive none none)motive a b
Equations
• =
Instances For
instance WithZero.addCommMonoid {α : Type u} [] :
Equations