File: Mathlib/Algebra/Group/WithOne/Basic.lean

full_name: WithZero.involutiveNeg
code: @[to_additive]
instance involutiveInv [InvolutiveInv α] : InvolutiveInv (WithOne α) 
goal: InvolutiveNeg (WithZero α)

full_name: WithOne.involutiveInv
code: @[to_additive]
instance involutiveInv [InvolutiveInv α] : InvolutiveInv (WithOne α) 
goal: InvolutiveInv (WithOne α)

full_name: WithZero.coeAddHom_apply
code: /-- `WithOne.coe` as a bundled morphism -/
@[to_additive (attr := simps apply) "`WithZero.coe` as a bundled morphism"]
def coeMulHom [Mul α] : α →ₙ* WithOne α 
goal: ∀ (a : α), WithZero.coeAddHom a = ↑a

full_name: WithOne.coeMulHom
code: /-- `WithOne.coe` as a bundled morphism -/
@[to_additive (attr := simps apply) "`WithZero.coe` as a bundled morphism"]
def coeMulHom [Mul α] : α →ₙ* WithOne α 
goal: α →ₙ* WithOne α

full_name: WithOne.coeMulHom_apply
code: /-- `WithOne.coe` as a bundled morphism -/
@[to_additive (attr := simps apply) "`WithZero.coe` as a bundled morphism"]
def coeMulHom [Mul α] : α →ₙ* WithOne α 
goal: ∀ (a : α), WithOne.coeMulHom a = ↑a

full_name: WithZero.coeAddHom
code: /-- `WithOne.coe` as a bundled morphism -/
@[to_additive (attr := simps apply) "`WithZero.coe` as a bundled morphism"]
def coeMulHom [Mul α] : α →ₙ* WithOne α 
goal: AddHom α (WithZero α)

full_name: WithZero.lift
code: /-- Lift a semigroup homomorphism `f` to a bundled monoid homomorphism. -/
@[to_additive "Lift an add semigroup homomorphism `f` to a bundled add monoid homomorphism."]
def lift : (α →ₙ* β) ≃ (WithOne α →* β) 
goal: AddHom α β ≃ (WithZero α →+ β)

full_name: WithOne.lift
code: /-- Lift a semigroup homomorphism `f` to a bundled monoid homomorphism. -/
@[to_additive "Lift an add semigroup homomorphism `f` to a bundled add monoid homomorphism."]
def lift : (α →ₙ* β) ≃ (WithOne α →* β) 
goal: (α →ₙ* β) ≃ (WithOne α →* β)

full_name: WithZero.lift_coe
code: @[to_additive (attr := simp)]
theorem lift_coe (x : α) : lift f x = f x 
goal: (WithZero.lift f) ↑x = f x

full_name: WithOne.lift_coe
code: @[to_additive (attr := simp)]
theorem lift_coe (x : α) : lift f x = f x 
goal: (WithOne.lift f) ↑x = f x

full_name: WithOne.lift_one
code: @[to_additive]
theorem lift_one : lift f 1 = 1 
goal: (WithOne.lift f) 1 = 1

full_name: WithZero.lift_zero
code: @[to_additive]
theorem lift_one : lift f 1 = 1 
goal: (WithZero.lift f) 0 = 0

full_name: WithZero.lift_unique
code: @[to_additive]
theorem lift_unique (f : WithOne α →* β) : f = lift (f.toMulHom.comp coeMulHom) 
goal: f = WithZero.lift ((↑f).comp WithZero.coeAddHom)

full_name: WithOne.lift_unique
code: @[to_additive]
theorem lift_unique (f : WithOne α →* β) : f = lift (f.toMulHom.comp coeMulHom) 
goal: f = WithOne.lift ((↑f).comp WithOne.coeMulHom)

full_name: WithOne.map
code: /-- Given a multiplicative map from `α → β` returns a monoid homomorphism
  from `WithOne α` to `WithOne β` -/
@[to_additive "Given an additive map from `α → β` returns an add monoid homomorphism from
`WithZero α` to `WithZero β`"]
def map (f : α →ₙ* β) : WithOne α →* WithOne β 
goal: WithOne α →* WithOne β

full_name: WithZero.map
code: /-- Given a multiplicative map from `α → β` returns a monoid homomorphism
  from `WithOne α` to `WithOne β` -/
@[to_additive "Given an additive map from `α → β` returns an add monoid homomorphism from
`WithZero α` to `WithZero β`"]
def map (f : α →ₙ* β) : WithOne α →* WithOne β 
goal: WithZero α →+ WithZero β

full_name: WithOne.map_coe
code: @[to_additive (attr := simp)]
theorem map_coe (f : α →ₙ* β) (a : α) : map f (a : WithOne α) = f a 
goal: (WithOne.map f) ↑a = ↑(f a)

full_name: WithZero.map_coe
code: @[to_additive (attr := simp)]
theorem map_coe (f : α →ₙ* β) (a : α) : map f (a : WithOne α) = f a 
goal: (WithZero.map f) ↑a = ↑(f a)

full_name: WithZero.map_id
code: @[to_additive (attr := simp)]
theorem map_id : map (MulHom.id α) = MonoidHom.id (WithOne α) 
goal: WithZero.map (AddHom.id α) = AddMonoidHom.id (WithZero α)

full_name: WithOne.map_id
code: @[to_additive (attr := simp)]
theorem map_id : map (MulHom.id α) = MonoidHom.id (WithOne α) 
goal: WithOne.map (MulHom.id α) = MonoidHom.id (WithOne α)

full_name: WithZero.map_map
code: @[to_additive]
theorem 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: WithOne.map_map
code: @[to_additive]
theorem map_map (f : α →ₙ* β) (g : β →ₙ* γ) (x) : map g (map f x) = map (g.comp f) x 
goal: (WithOne.map g) ((WithOne.map f) x) = (WithOne.map (g.comp f)) x

full_name: WithZero.map_comp
code: @[to_additive (attr := simp)]
theorem 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: WithOne.map_comp
code: @[to_additive (attr := simp)]
theorem map_comp (f : α →ₙ* β) (g : β →ₙ* γ) : map (g.comp f) = (map g).comp (map f) 
goal: WithOne.map (g.comp f) = (WithOne.map g).comp (WithOne.map f)

full_name: AddEquiv.withZeroCongr_apply
code: /-- A version of `Equiv.optionCongr` for `WithOne`. -/
@[to_additive (attr := simps apply) "A version of `Equiv.optionCongr` for `WithZero`."]
def _root_.MulEquiv.withOneCongr (e : α ≃* β) : WithOne α ≃* WithOne β 
goal: e.withZeroCongr a = (WithZero.map e.toAddHom) a

full_name: MulEquiv.withOneCongr_apply
code: /-- A version of `Equiv.optionCongr` for `WithOne`. -/
@[to_additive (attr := simps apply) "A version of `Equiv.optionCongr` for `WithZero`."]
def _root_.MulEquiv.withOneCongr (e : α ≃* β) : WithOne α ≃* WithOne β 
goal: e.withOneCongr a = (WithOne.map e.toMulHom) a

full_name: MulEquiv.withOneCongr
code: /-- A version of `Equiv.optionCongr` for `WithOne`. -/
@[to_additive (attr := simps apply) "A version of `Equiv.optionCongr` for `WithZero`."]
def _root_.MulEquiv.withOneCongr (e : α ≃* β) : WithOne α ≃* WithOne β 
goal: WithOne α ≃* WithOne β

full_name: AddEquiv.withZeroCongr
code: /-- A version of `Equiv.optionCongr` for `WithOne`. -/
@[to_additive (attr := simps apply) "A version of `Equiv.optionCongr` for `WithZero`."]
def _root_.MulEquiv.withOneCongr (e : α ≃* β) : WithOne α ≃* WithOne β 
goal: WithZero α ≃+ WithZero β

full_name: AddEquiv.withZeroCongr_refl
code: @[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_refl : (MulEquiv.refl α).withOneCongr = MulEquiv.refl _ 
goal: (AddEquiv.refl α).withZeroCongr = AddEquiv.refl (WithZero α)

full_name: MulEquiv.withOneCongr_refl
code: @[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_refl : (MulEquiv.refl α).withOneCongr = MulEquiv.refl _ 
goal: (MulEquiv.refl α).withOneCongr = MulEquiv.refl (WithOne α)

full_name: MulEquiv.withOneCongr_symm
code: @[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_symm (e : α ≃* β) :
    e.withOneCongr.symm = e.symm.withOneCongr 
goal: e.withOneCongr.symm = e.symm.withOneCongr

full_name: AddEquiv.withZeroCongr_symm
code: @[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_symm (e : α ≃* β) :
    e.withOneCongr.symm = e.symm.withOneCongr 
goal: e.withZeroCongr.symm = e.symm.withZeroCongr

full_name: AddEquiv.withZeroCongr_trans
code: @[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_trans (e₁ : α ≃* β) (e₂ : β ≃* γ) :
    e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr 
goal: e₁.withZeroCongr.trans e₂.withZeroCongr = (e₁.trans e₂).withZeroCongr

full_name: MulEquiv.withOneCongr_trans
code: @[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_trans (e₁ : α ≃* β) (e₂ : β ≃* γ) :
    e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr 
goal: e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr