File: Mathlib/Algebra/GroupWithZero/WithZero.lean

full_name: WithZero.one
code: instance one : One (WithZero α) 
goal: One (WithZero α)

full_name: WithZero.coe_one
code: @[simp, norm_cast] lemma coe_one : ((1 : α) : WithZero α) = 1 
goal: ↑1 = 1

full_name: WithZero.mulZeroClass
code: instance mulZeroClass : MulZeroClass (WithZero α) 
goal: MulZeroClass (WithZero α)

full_name: WithZero.coe_mul
code: @[simp, norm_cast] lemma coe_mul (a b : α) : (↑(a * b) : WithZero α) = a * b 
goal: ↑(a * b) = ↑a * ↑b

full_name: WithZero.unzero_mul
code: lemma unzero_mul {x y : WithZero α} (hxy : x * y ≠ 0) :
    unzero hxy = unzero (left_ne_zero_of_mul hxy) * unzero (right_ne_zero_of_mul hxy) 
goal: WithZero.unzero hxy = WithZero.unzero ⋯ * WithZero.unzero ⋯

full_name: WithZero.noZeroDivisors
code: instance noZeroDivisors : NoZeroDivisors (WithZero α) 
goal: NoZeroDivisors (WithZero α)

full_name: WithZero.semigroupWithZero
code: instance semigroupWithZero [Semigroup α] : SemigroupWithZero (WithZero α) 
goal: SemigroupWithZero (WithZero α)

full_name: WithZero.commSemigroup
code: instance commSemigroup [CommSemigroup α] : CommSemigroup (WithZero α) 
goal: CommSemigroup (WithZero α)

full_name: WithZero.mulZeroOneClass
code: instance mulZeroOneClass [MulOneClass α] : MulZeroOneClass (WithZero α) 
goal: MulZeroOneClass (WithZero α)

full_name: WithZero.coeMonoidHom
code: /-- Coercion as a monoid hom. -/
@[simps apply]
def coeMonoidHom : α →* WithZero α 
goal: α →* WithZero α

full_name: WithZero.coeMonoidHom_apply
code: /-- Coercion as a monoid hom. -/
@[simps apply]
def coeMonoidHom : α →* WithZero α 
goal: ∀ (a : α), WithZero.coeMonoidHom a = ↑a

full_name: WithZero.monoidWithZeroHom_ext
code: @[ext high]
theorem monoidWithZeroHom_ext ⦃f g : WithZero α →*₀ β⦄
    (h : f.toMonoidHom.comp coeMonoidHom = g.toMonoidHom.comp coeMonoidHom) :
    f = g 
goal: f = g

full_name: WithZero.lift'
code: /-- The (multiplicative) universal property of `WithZero`. -/
@[simps! symm_apply_apply]
noncomputable nonrec def lift' : (α →* β) ≃ (WithZero α →*₀ β) 
goal: (α →* β) ≃ (WithZero α →*₀ β)

full_name: WithZero.lift'_symm_apply_apply
code: /-- The (multiplicative) universal property of `WithZero`. -/
@[simps! symm_apply_apply]
noncomputable nonrec def lift' : (α →* β) ≃ (WithZero α →*₀ β) 
goal: ∀ (a : α), (WithZero.lift'.symm F) a = F ↑a

full_name: WithZero.lift'_zero
code: lemma lift'_zero (f : α →* β) : lift' f (0 : WithZero α) = 0 
goal: (WithZero.lift' f) 0 = 0

full_name: WithZero.lift'_coe
code: @[simp] lemma lift'_coe (f : α →* β) (x : α) : lift' f (x : WithZero α) = f x 
goal: (WithZero.lift' f) ↑x = f x

full_name: WithZero.lift'_unique
code: lemma lift'_unique (f : WithZero α →*₀ β) : f = lift' (f.toMonoidHom.comp coeMonoidHom) 
goal: f = WithZero.lift' ((↑f).comp WithZero.coeMonoidHom)

full_name: WithZero.map'
code: /-- The `MonoidWithZero` homomorphism `WithZero α →* WithZero β` induced by a monoid homomorphism
  `f : α →* β`. -/
noncomputable def map' (f : α →* β) : WithZero α →*₀ WithZero β 
goal: WithZero α →*₀ WithZero β

full_name: WithZero.map'_zero
code: lemma map'_zero (f : α →* β) : map' f 0 = 0 
goal: (WithZero.map' f) 0 = 0

full_name: WithZero.map'_coe
code: @[simp] lemma map'_coe (f : α →* β) (x : α) : map' f (x : WithZero α) = f x 
goal: (WithZero.map' f) ↑x = ↑(f x)

full_name: WithZero.map'_id
code: @[simp]
lemma map'_id : map' (MonoidHom.id β) = MonoidHom.id (WithZero β) 
goal: ↑(WithZero.map' (MonoidHom.id β)) = MonoidHom.id (WithZero β)

full_name: WithZero.map'_map'
code: lemma map'_map'  (f : α →* β) (g : β →* γ) (x) : map' g (map' f x) = map' (g.comp f) x 
goal: (WithZero.map' g) ((WithZero.map' f) x) = (WithZero.map' (g.comp f)) x

full_name: WithZero.map'_comp
code: @[simp]
lemma map'_comp (f : α →* β) (g : β →* γ) : map' (g.comp f) = (map' g).comp (map' f) 
goal: WithZero.map' (g.comp f) = (WithZero.map' g).comp (WithZero.map' f)

full_name: WithZero.pow
code: instance pow : Pow (WithZero α) ℕ 
goal: Pow (WithZero α) ℕ

full_name: WithZero.coe_pow
code: @[simp, norm_cast] lemma coe_pow (a : α) (n : ℕ) : (↑(a ^ n) : WithZero α) = a ^ n 
goal: ↑(a ^ n) = ↑a ^ n

full_name: WithZero.monoidWithZero
code: instance monoidWithZero [Monoid α] : MonoidWithZero (WithZero α) 
goal: MonoidWithZero (WithZero α)

full_name: WithZero.commMonoidWithZero
code: instance commMonoidWithZero [CommMonoid α] : CommMonoidWithZero (WithZero α) 
goal: CommMonoidWithZero (WithZero α)

full_name: WithZero.inv
code: /-- Extend the inverse operation on `α` to `WithZero α` by sending `0` to `0`. -/
instance inv : Inv (WithZero α) 
goal: Inv (WithZero α)

full_name: WithZero.coe_inv
code: @[simp, norm_cast] lemma coe_inv (a : α) : ((a⁻¹ : α) : WithZero α) = (↑a)⁻¹ 
goal: ↑a⁻¹ = (↑a)⁻¹

full_name: WithZero.inv_zero
code: @[simp] protected lemma inv_zero : (0 : WithZero α)⁻¹ = 0 
goal: 0⁻¹ = 0

full_name: WithZero.invOneClass
code: instance invOneClass [InvOneClass α] : InvOneClass (WithZero α) 
goal: InvOneClass (WithZero α)

full_name: WithZero.div
code: instance div : Div (WithZero α) 
goal: Div (WithZero α)

full_name: WithZero.coe_div
code: @[norm_cast] lemma coe_div (a b : α) : ↑(a / b : α) = (a / b : WithZero α) 
goal: ↑(a / b) = ↑a / ↑b

full_name: WithZero.instPowInt
code: instance : Pow (WithZero α) ℤ 
goal: Pow (WithZero α) ℤ

full_name: WithZero.coe_zpow
code: @[simp, norm_cast] lemma coe_zpow (a : α) (n : ℤ) : ↑(a ^ n) = (↑a : WithZero α) ^ n 
goal: ↑(a ^ n) = ↑a ^ n

full_name: WithZero.divInvMonoid
code: instance divInvMonoid [DivInvMonoid α] : DivInvMonoid (WithZero α) 
goal: DivInvMonoid (WithZero α)

full_name: WithZero.divInvOneMonoid
code: instance divInvOneMonoid [DivInvOneMonoid α] : DivInvOneMonoid (WithZero α) 
goal: DivInvOneMonoid (WithZero α)

full_name: WithZero.involutiveInv
code: instance involutiveInv [InvolutiveInv α] : InvolutiveInv (WithZero α) 
goal: InvolutiveInv (WithZero α)

full_name: WithZero.divisionMonoid
code: instance divisionMonoid [DivisionMonoid α] : DivisionMonoid (WithZero α) 
goal: DivisionMonoid (WithZero α)

full_name: WithZero.divisionCommMonoid
code: instance divisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid (WithZero α) 
goal: DivisionCommMonoid (WithZero α)

full_name: WithZero.groupWithZero
code: /-- If `α` is a group then `WithZero α` is a group with zero. -/
instance groupWithZero : GroupWithZero (WithZero α) 
goal: GroupWithZero (WithZero α)

full_name: WithZero.unitsWithZeroEquiv
code: /-- Any group is isomorphic to the units of itself adjoined with `0`. -/
def unitsWithZeroEquiv : (WithZero α)ˣ ≃* α 
goal: (WithZero α)ˣ ≃* α

full_name: WithZero.commGroupWithZero
code: instance commGroupWithZero [CommGroup α] : CommGroupWithZero (WithZero α) 
goal: CommGroupWithZero (WithZero α)

full_name: WithZero.addMonoidWithOne
code: instance addMonoidWithOne [AddMonoidWithOne α] : AddMonoidWithOne (WithZero α) 
goal: AddMonoidWithOne (WithZero α)